目的：
联系关系映射(hibernate映射)
1. 鸠合映射
2. 一对多与多对一映射 (重点)
3. 多对多映射
4. inverse/lazy/cascade
1. 鸠合映射
开辟流程：
需求剖析/数据库设计、项目设计/ 编码/测试/实施布置上线/验收
需求:
用户购置， 填写地址！
数据库：
代码：
|
// 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>();
} |
|
<?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 @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(); } |
问题：
鸠合映射，映射的鸠合元素，都是通俗的类型， 可否为对象类型？
2. 联系关系映射
需求1：
部分与员工
一个部分有多个员工; 【一对多】
多个员工，属于一个部分 【多对一】
需求2：
项目与开辟员工
一个项目，有多个开辟人员！
一个开辟人员，介入多个项目！ 【多对多】
多对一映射与一对多
代码
需求：员工与部分
数据库：
设计javabean封装：
映射：
|
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的执行效率！
设置装备摆设一对多与多对一，这种叫“双向联系关系”
只设置装备摆设一对多， 叫“单项一对多”
只设置装备摆设多对一， 叫“单项多对一”
留意：
设置装备摆设了哪一方，哪一刚刚有维护联系关系关系的权限！
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 同上。级联留存、更新、删除
hibernate常晤面试题： inverse与cascade区别？
多对多映射
需求：项目与开辟人员
Project Developer
电商系统
曹吉
王春
OA系统
王春
老张
数据库
代码
|
/** * 开辟人员 * * @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>
|
|
|
|
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, 没有节制权。 假如删除的数据有被引用，会报错！ 不然，才可以删除
原创文章，作者：Maggie-Hunter，如若转载，请注明出处：https://blog.ytso.com/11702.html