java--Hibernate关联映射

hibernate 程序执行流程

集合映射

User.java

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>();



public Map<String, String> getAddressMap() {
    return addressMap;
}
public void setAddressMap(Map<String, String> addressMap) {
    this.addressMap = addressMap;
}
public List<String> getAddressList() {
    return addressList;
}
public void setAddressList(List<String> addressList) {
    this.addressList = addressList;
}
public int getUserId() {
    return userId;
}
public void setUserId(int userId) {
    this.userId = userId;
}
public String getUserName() {
    return userName;
}
public void setUserName(String userName) {
    this.userName = userName;
}
public Set<String> getAddress() {
    return address;
}
public void setAddress(Set<String> address) {
    this.address = address;
}


}

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>

App.java

public class App {

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();
}

// 保存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);

    // 用户对象  --  Map
    user.getAddressMap().put("A0001", "广州");
    user.getAddressMap().put("A0002", "深圳");

    // 保存
    session.save(user);

    session.getTransaction().commit();
    session.close();
}


// 获取
@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();
}
}

关联映射

多对一映射与一对多

public class Dept {

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

public class Employee {

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

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.  集合元素的类型

     -->
     <set name="emps">   <!-- table="t_employee" -->
         <key column="dept_id"></key>
         <one-to-many class="Employee"/>
     </set>


</class>


</hibernate-mapping>

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>

测试

public class App {

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();
    /*
     *  结果
     *  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();
    /*
     *  结果
     *  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
     */
}

}

总结

在一对多与多对一的关联关系中，保存数据最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！

配置一对多与多对一，这种叫“双向关联”
只配置一对多， 叫“单项一对多”
只配置多对一， 叫“单项多对一”

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

查询

public class App2_get {

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

@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();
}

}

Inverse属性

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

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

维护关联关系中，是否设置inverse属性：

1. 保存数据 
    有影响。
   如果设置控制反转,即inverse=true, 然后通过部门方维护关联关系。在保存部门的时候，同时保存员工， 数据会保存，但关联关系不会维护。即外键字段为NULL
2. 获取数据

    无影响。

3. 解除关联关系？
    有影响。
    inverse=false，  可以解除关联
inverse=true，  当前方(部门)没有控制权，不能解除关联关系
(不会生成update语句,也不会报错)
    4. 删除数据对关联关系的影响？
    有影响。
    inverse=false, 有控制权， 可以删除。先清空外键引用，再删除数据。
    inverse=true,  没有控制权: 如果删除的记录有被外键引用，会报错，违反主外键引用约束！  如果删除的记录没有被引用，可以直接删除。

示例

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();
}

@Test
public void bak() {
    Session session = sf.openSession();
    session.beginTransaction();

    session.getTransaction().commit();
    session.close();
}

}

cascade 属性

cascade 表示级联操作 【可以设置到一的一方或多的一方】

none          不级联操作， 默认值
save-update     级联保存或更新
delete        级联删除
save-update,delete    级联保存、更新、删除
all                 同上。级联保存、更新、删除

示例

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();
}


@Test
public void bak() {
    Session session = sf.openSession();
    session.beginTransaction();

    session.getTransaction().commit();
    session.close();
}


}

多对多映射

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

/**
 * 项目
 * 
 * @author Jie.Yuan
 * 
 */
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">
        <key column="prjId"></key>
        <many-to-many column="did" class="Developer"></many-to-many>
     </set>

</class>


</hibernate-mapping>

示例

public class App1_save {

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

// 1. 多对多，保存  【只能通过一方维护另外一方，不能重复维护！】
@Test
public void save() {
    Session session = sf.openSession();
    session.beginTransaction();

    /*
     * 模拟数据： 
        电商系统（曹吉，王春）
        OA系统（王春，老张）
     */
    // 创建项目对象
    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(dev_cj);
//      session.save(dev_wc);
//      session.save(dev_lz);

    session.save(prj_ds);
    session.save(prj_oa);   // 必须要设置级联保存 

    session.getTransaction().commit();
    session.close();
}



@Test
public void bak() {

    Session session = sf.openSession();
    session.beginTransaction();

    session.getTransaction().commit();
    session.close();
}

}

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>

维护关联关系

设置inverse属性，在多对多种维护关联关系的影响？

1） 保存数据
有影响。
     inverse=false ，有控制权，可以维护关联关系； 保存数据的时候会把对象关系插入中间表；
    inverse=true,  没有控制权， 不会往中间表插入数据。
2） 获取数据
    无。

3） 解除关系
    // 有影响。
    // inverse=false ,有控制权， 解除关系就是删除中间表的数据。
    // inverse=true, 没有控制权，不能解除关系。
4） 删除数据
    有影响。
    // inverse=false, 有控制权。 先删除中间表数据，再删除自身。
    // inverse=true, 没有控制权。 如果删除的数据有被引用，会报错！ 否则，才可以删除

示例

public class App2_inverse {

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

// 多对多
//1. 设置inverse属性，对保存数据影响?
// 有影响。
// inverse=false ，有控制权，可以维护关联关系； 保存数据的时候会把对象关系插入中间表；
// inverse=true,  没有控制权， 不会往中间表插入数据。
@Test
public void save() {
    Session session = sf.openSession();
    session.beginTransaction();

    /*
     * 模拟数据： 
        电商系统（曹吉，王春）
        OA系统（王春，老张）
     */
    // 创建项目对象
    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(dev_cj);
//      session.save(dev_wc);
//      session.save(dev_lz);

    session.save(prj_ds);
    session.save(prj_oa);   // 必须要设置级联保存 

    session.getTransaction().commit();
    session.close();
}

//2 .设置inverse属性， 对获取数据影响？  无
@Test
public void get() {

    Session session = sf.openSession();
    session.beginTransaction();

    Project prj = (Project) session.get(Project.class, 1);
    System.out.println(prj.getPrj_name());
    System.out.println(prj.getDevelopers());


    session.getTransaction().commit();
    session.close();
}

//3. 设置inverse属性， 对解除关系影响？
// 有影响。
// inverse=false ,有控制权， 解除关系就是删除中间表的数据。
// inverse=true, 没有控制权，不能解除关系。
@Test
public void removeRelation() {

    Session session = sf.openSession();
    session.beginTransaction();

    Project prj = (Project) session.get(Project.class, 7);
    prj.getDevelopers().clear();

    session.getTransaction().commit();
    session.close();
}



//3. 设置inverse属性，对删除数据的影响?
// inverse=false, 有控制权。 先删除中间表数据，再删除自身。
// inverse=true, 没有控制权。 如果删除的数据有被引用，会报错！ 否则，才可以删除
@Test
public void deleteData() {

    Session session = sf.openSession();
    session.beginTransaction();

    Project prj = (Project) session.get(Project.class, 1);
    session.delete(prj);

    session.getTransaction().commit();
    session.close();
}

}