Hibernate构架( 二）映射

作者: Acamy丶 | 来源:发表于2017-06-12 20:05 被阅读5次

1.集合映射

Hibernate集合映射里面有set,list,map，具体的用法可以参见如下例

需求：一个用户对应多个地址
User.java

// javabean设计
public class User {
    private int userId;
    private String userName;
    // 一个用户，对应的多个地址
    private Set<String> address;
    private List<String> addressList = new ArrayList<String>(); 
    //private String[] addressArray; // 映射方式和list一样     <array name=""></array>
    private Map<String,String> addressMap = new HashMap<String, String>();
// get,set省略...
}

User.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.a_collection">
    
    <class name="User" table="t_user">
        <id name="userId" column="id">
            <generator class="native"></generator>
        </id>   
        <property name="userName"></property>
        
        <!-- 
            set集合属性的映射
                name 指定要映射的set集合的属性
                table 集合属性要映射到的表
                key  指定集合表(t_address)的外键字段
                element 指定集合表的其他字段
                    type 元素类型，一定要指定
         -->
         <set name="address" table="t_address">
            <key column="uid"></key>
            <element column="address" type="string"></element>
         </set>
         
         <!-- 
            list集合映射
                list-index  指定的是排序列的名称 (因为要保证list集合的有序)
          -->
          <list name="addressList" table="t_addressList">
              <key column="uid"></key>
              <list-index column="idx"></list-index>
              <element column="address" type="string"></element>
          </list>
          
          <!-- 
            map集合的映射
                key  指定外键字段
                map-key 指定map的key 
                element  指定map的value
           -->
          <map name="addressMap" table="t_addressMap">
            <key column="uid"></key>
            <map-key column="shortName" type="string" ></map-key>
            <element column="address" type="string" ></element>
          </map>             
    </class>
</hibernate-mapping>

set测试

private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(User.class)   // 测试时候使用
            .buildSessionFactory();
    }

    // 保存set
    @Test
    public void testSaveSet() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        
        //-- 保存
        Set<String> addressSet = new HashSet<String>();
        addressSet.add("广州");
        addressSet.add("深圳");
        // 用户对象
        User user = new User();
        user.setUserName("Jack");
        user.setAddress(addressSet);
        
        // 保存
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }

效果如下：

Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_address (uid, address) values (?, ?)
Hibernate: insert into t_address (uid, address) values (?, ?)

list测试

// 保存list/map
    @Test
    public void testSaveList() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        User user = new User();
        user.setUserName("Tom");
        // 用户对象  --  list
        user.getAddressList().add("广州");
        user.getAddressList().add("深圳");
        // 保存
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }

效果如下：

Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_addressList (uid, idx, address) values (?, ?, ?)
Hibernate: insert into t_addressList (uid, idx, address) values (?, ?, ?)

map测试

@Test
    public void testSaveMap() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        User user = new User();
        user.setUserName("Tom");
        
        // 用户对象  --  Map
        user.getAddressMap().put("A0001", "广州");
        user.getAddressMap().put("A0002", "深圳");
        
        // 保存
        session.save(user);
        
        session.getTransaction().commit();
        session.close();
    }

效果如下：

Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_addressMap (uid, shortName, address) values (?, ?, ?)
Hibernate: insert into t_addressMap (uid, shortName, address) values (?, ?, ?)

获取数据测试

    @Test
    public void testGet() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 获取
        User user = (User) session.get(User.class, 3); // 及时加载
        System.out.println(user.getUserId());
        System.out.println(user.getUserName());
        
        // 当查询用户，同时可以获取用户关联的list集合的数据 (因为有正确映射)
        // 当使用到集合数据的使用，才向数据库发送执行的sql语句  (懒加载)
        System.out.println(user.getAddressList());
        
        session.getTransaction().commit();
        session.close();
    }

效果如下：

Hibernate: select user0_.id as id0_0_, user0_.userName as userName0_0_ from t_user user0_ where user0_.id=?
3
Tom
Hibernate: select addresslis0_.uid as uid0_0_, addresslis0_.address as address0_, addresslis0_.idx as idx0_ from t_addressList addresslis0_ where addresslis0_.uid=?
[广州, 深圳]

2.关联映射

2.1 一对多与多对一

需求1：部门与员工
一个部门有多个员工; 【一对多】
多个员工，属于一个部门【多对一】

Employee.java

public class Employee {
    private int empId;
    private String empName;
    private double salary;
    // 【多对一】员工与部门
    private Dept dept;
}

Employee.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.b_one2Many">
    
    <class name="Employee" table="t_employee">
        <id name="empId">
            <generator class="native"></generator>
        </id>   
        <property name="empName" length="20"></property>
        <property name="salary" type="double"></property>
        
        <!-- 
            多对一映射配置
            Employee 映射关键点：
            1.  映射的部门属性  ：  dept
            2.  映射的部门属性，对应的外键字段: dept_id
            3.  部门的类型
         -->
         <many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>
         
    </class>
    

</hibernate-mapping>

Dept.java

public class Dept {
    private int deptId;
    private String deptName;
    // 【一对多】 部门对应的多个员工
    private Set<Employee> emps = new HashSet<Employee>();
}

Dept.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.b_one2Many">
    
    <class name="Dept" table="t_dept">
        <id name="deptId">
            <generator class="native"></generator>
        </id>   
        <property name="deptName" length="20"></property>
        
        <!-- 
            一对多关联映射配置  （通过部门管理到员工）
            Dept 映射关键点：
            1.  指定 映射的集合属性： "emps"
            2.  集合属性对应的集合表： "t_employee"
            3.  集合表的外键字段   "t_employee. dept_id"
            4.  集合元素的类型
            
            inverse=false  set集合映射的默认值； 表示有控制权
         -->
         <set name="emps" cascade="save-update,delete" table="t_employee" inverse="true">   <!-- table="t_employee" -->
             <key column="dept_id"></key>
             <one-to-many class="Employee"/>
         </set>          
    </class>    
</hibernate-mapping>

测试

保存：

public class App1_save {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Dept.class)   
            .addClass(Employee.class)   // 测试时候使用
            .buildSessionFactory();
    }

    // 保存， 部门方 【一的一方法操作】
    @Test
    public void save() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 部门对象
        Dept dept = new Dept();
        dept.setDeptName("应用开发部");
        // 员工对象
        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");
        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");
        // 关系
        dept.getEmps().add(emp_zs);
        dept.getEmps().add(emp_ls);

        // 保存
        session.save(emp_zs);
        session.save(emp_ls);
        session.save(dept); // 保存部门，部门下所有的员工  
        
        session.getTransaction().commit();
        session.close();
        /*
         *  结果  当Dept.hbm.xml里的inverse属性为false时
         *  Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
            Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
            Hibernate: insert into t_dept (deptName) values (?)
            Hibernate: update t_employee set deptId=? where empId=?    维护员工引用的部门的id
            Hibernate: update t_employee set deptId=? where empId=?
         */
    }
    // 【推荐】 保存， 部员方 【多的一方法操作】
    @Test
    public void save2() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 部门对象
        Dept dept = new Dept();
        dept.setDeptName("综合部");
        // 员工对象
        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");
        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");
        // 关系
        emp_zs.setDept(dept);
        emp_ls.setDept(dept);
        
        
        // 保存
        session.save(dept); // 先保存一的方法
        session.save(emp_zs);
        session.save(emp_ls);// 再保存多的一方，关系回自动维护(映射配置完)
        
        session.getTransaction().commit();
        session.close();
        /*
         *  结果 当Dept.hbm.xml里的inverse属性为true时此方式和上面无差别
         *  Hibernate: insert into t_dept (deptName) values (?)
            Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
            Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
            少生成2条update  sql
         */
    }
    
}

获取：

@Test
    public void get() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 通过部门方，获取另外一方
//      Dept dept = (Dept) session.get(Dept.class, 1);
//      System.out.println(dept.getDeptName());
//      System.out.println(dept.getEmps());// 懒加载
        
        
        // 通过员工房，获取另外一方
        Employee emp = (Employee) session.get(Employee.class, 1);
        System.out.println(emp.getEmpName());
        System.out.println(emp.getDept().getDeptName());
        
        
        session.getTransaction().commit();
        session.close();
    }

控制反转：

package cn.itcast.b_one2Many;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;

import cn.itcast.a_collection.User;

public class App3_inverse {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Dept.class)   
            .addClass(Employee.class)   // 测试时候使用
            .buildSessionFactory();
    }

    // 1. 保存数据 
    @Test
    public void save() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 部门对象
        Dept dept = new Dept();
        dept.setDeptName("应用开发部");
        // 员工对象
        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");
        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");
        // 关系
        dept.getEmps().add(emp_zs);
        dept.getEmps().add(emp_ls);  // inverse=true,  不会设置关联。
                                    //                 此时的关联应该通过员工方维护。
        

        // 保存
        session.save(emp_zs);
        session.save(emp_ls);
        session.save(dept); // 保存部门，部门下所有的员工  
        
        session.getTransaction().commit();
        session.close();
    }
    
    //2. 是否设置inverse，对获取数据的影响？   无.
    @Test
    public void get() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Dept dept = (Dept) session.get(Dept.class, 1);
        System.out.println(dept.getDeptName());
        System.out.println(dept.getEmps());
        
        session.getTransaction().commit();
        session.close();
    }
    
    // 3. 是否设置inverse，对解除关联关系影响？
    // inverse=false，  可以解除关联
    // inverse=true，  当前方(部门)没有控制权，不能解除关联关系(不会生成update语句,也不会报错)
    // 
    @Test
    public void removeRelation() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 获取部门
        Dept dept = (Dept) session.get(Dept.class, 2);
        // 解除关系
        dept.getEmps().clear();
        
        session.getTransaction().commit();
        session.close();
    }
    
    
    //3. 是否设置inverse属性，在删除数据中对关联关系的影响?
    // inverse=false, 有控制权， 可以删除。先清空外键引用，再删除数据。
    // inverse=true,  没有控制权: 如果删除的记录有被外键引用，会报错，违反主外键引用约束！
    //                           如果删除的记录没有被引用，可以直接删除。
    @Test
    public void deleteData() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 查询部门
        Dept dept = (Dept) session.get(Dept.class, 8);
        session.delete(dept);
        
        
        session.getTransaction().commit();
        session.close();
    }
}

级联删除：

public class App4_cascade {
    
    private static SessionFactory sf;
    static {
        sf = new Configuration()
            .configure()
            .addClass(Dept.class)   
            .addClass(Employee.class)   // 测试时候使用
            .buildSessionFactory();
    }

    // 级联保存
    @Test
    public void save() {
        
        Session session = sf.openSession();
        session.beginTransaction();
        
        // 部门对象
        Dept dept = new Dept();
        dept.setDeptName("财务部");
        // 员工对象
        Employee emp_zs = new Employee();
        emp_zs.setEmpName("张三");
        Employee emp_ls = new Employee();
        emp_ls.setEmpName("李四");
        // 关系
        dept.getEmps().add(emp_zs);
        dept.getEmps().add(emp_ls);  
        
        // 保存
//      session.save(emp_zs);
//      session.save(emp_ls);
        session.save(dept); // 需要设置级联保存； 保存部门，部门下所有的员工  
        
        session.getTransaction().commit();
        session.close();
    }

    // 级联删除
    @Test
    public void delete() {
        Session session = sf.openSession();
        session.beginTransaction();
        
        Dept dept = (Dept) session.get(Dept.class,7);
        session.delete(dept); // 级联删除
        
        session.getTransaction().commit();
        session.close();
    }   
}

总结：
  在一对多与多对一的关联关系中，保存数据最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！
    
配置一对多与多对一，这种叫“双向关联”
只配置一对多，           叫“单项一对多”
只配置多对一，           叫“单项多对一”

注意：
    配置了哪一方，哪一方才有维护关联关系的权限！

Inverse属性
Inverse属性，是在维护关联关系的时候起作用的。
       表示控制权是否转移。(在一的一方起作用)

Inverse , 控制反转。
Inverse = false  不反转；   当前方有控制权
        True  控制反转； 当前方没有控制权

维护关联关系中，是否设置inverse属性：
    1. 保存数据 
        有影响。
       如果设置控制反转,即inverse=true, 然后通过部门方维护关联关系。在保存部门的时候，同时保存员工， 数据会保存，但关联关系不会维护。即外键字段为NULL
         
    2. 获取数据
        无。
    3. 解除关联关系？
        有影响。
        inverse=false，  可以解除关联
inverse=true，  当前方(部门)没有控制权，不能解除关联关系
(不会生成update语句,也不会报错)
    4. 删除数据对关联关系的影响？
        有影响。
        inverse=false, 有控制权， 可以删除。先清空外键引用，再删除数据。
        inverse=true,  没有控制权: 如果删除的记录有被外键引用，会报错，违反主外键引用约束！  如果删除的记录没有被引用，可以直接删除。

cascade 属性
cascade  表示级联操作  【可以设置到一的一方或多的一方】
    none          不级联操作， 默认值
    save-update     级联保存或更新
    delete        级联删除
    save-update,delete    级联保存、更新、删除
    all

注意：inverse表示的是对象和关系之间的联系，面cascade表示的是对象与对象之间的关系，二者区别参考链接：
一对多（多对一）关系中的inverse和cascade属性

2.2 多对多

项目与开发员工
一个项目，有多个开发人员！
一个开发人员，参与多个项目！【多对多】

Developer.java

public class Developer {
    private int d_id;
    private String d_name;
    // 开发人员，参数的多个项目
    private Set<Project> projects = new HashSet<Project>();
}

Developer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.c_many2many">
    
    <class name="Developer" table="t_developer">
        <id name="d_id">
            <generator class="native"></generator>
        </id>   
        <property name="d_name" length="20"></property>
        
        <!-- 
            多对多映射配置： 员工方
                name  指定映射的集合属性
                table 集合属性对应的中间表
                key   指定中间表的外键字段(引用当前表t_developer主键的外键字段)
                many-to-many
                    column 指定外键字段对应的项目字段
                    class  集合元素的类型
         -->
        <set name="projects" table="t_relation">
            <key column="did"></key>
            <many-to-many column="prjId" class="Project"></many-to-many>
        </set>           
    </class>
</hibernate-mapping>

** Project .java**

public class Project {
    private int prj_id;
    private String prj_name;
    // 项目下的多个员工
    private Set<Developer> developers = new HashSet<Developer>();
}

Project.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.c_many2many">
    
    <class name="Project" table="t_project">
        <id name="prj_id">
            <generator class="native"></generator>
        </id>   
        <property name="prj_name" length="20"></property>
        <!-- 
            多对多映射:
            1.  映射的集合属性： “developers”
            2.  集合属性，对应的中间表： “t_relation”
            3. 外键字段:  prjId
            4. 外键字段，对应的中间表字段:  did
            5.   集合属性元素的类型
         -->
         <set name="developers" table="t_relation" cascade="save-update" inverse="false">
            <key column="prjId"></key>
            <many-to-many column="did" class="Developer"></many-to-many>
         </set>      
    </class>    
</hibernate-mapping>

测试

Project prj_ds = new Project();
        prj_ds.setPrj_name("电商系统");
        Project prj_oa = new Project();
        prj_oa.setPrj_name("OA系统");
        
        // 创建员工对象
        Developer dev_cj = new Developer();
        dev_cj.setD_name("曹吉");
        Developer dev_wc = new Developer();
        dev_wc.setD_name("王春");
        Developer dev_lz = new Developer();
        dev_lz.setD_name("老张");
        // 关系 【项目方】
        prj_ds.getDevelopers().add(dev_cj);
        prj_ds.getDevelopers().add(dev_wc); // 电商系统（曹吉，王春）
        prj_oa.getDevelopers().add(dev_wc);
        prj_oa.getDevelopers().add(dev_lz); // OA系统（王春，老张）
        
        
        // 保存
        session.save(prj_ds);
        session.save(prj_oa);   // 必须要设置级联保存 ,且Project.hbm.xml 里的inverse属性为false

效果如下：插入了两个项目，三个开发者，四条记录

Hibernate: insert into t_project (prj_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_project (prj_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)

Hibernate构架( 二）映射

1.集合映射

2.关联映射

2.1 一对多与多对一

测试

2.2 多对多

测试

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JAVA基础知识

Hibernate构架( 二） 映射

1.集合映射

2.关联映射

2.1 一对多与多对一

测试

2.2 多对多

测试

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

JAVA基础知识

Hibernate构架( 二）映射