Java进阶学习第二十天（Hibernate框架：集合映射、关联映射、对象的状态、一级缓存、懒加载、一对一映射、组件映射、继承映射）

一、集合映射

需求：用户网上购物填写地址（一对多）
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>();//简单了解
}

2、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>

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

二、关联映射

1、多对一映射与一对多映射
① 需求：部门与员工
② 设计数据库
③ 设计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();
	}
	
	// 【推荐】 保存， 部员方 【多对一方法操作】
	@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();
	}

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

⑦ 总结：在一对多与多对一的关联关系中，保存数据最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！
◆ 配置一对多与多对一，这种叫“双向关联”
◆ 只配置一对多，叫“单项一对多”
◆ 只配置多对一，叫“单项多对一”（很多时候）
注意：配置了哪一方，哪一方才有维护关联关系的权限！

2、Inverse属性：是在维护关联关系的时候起作用的（控制反转）
表示控制权是否转移(在一的一方起作用)
① Inverse = false：不反转，当前方有控制权（默认值）
② Inverse = true：控制反转，当前方没有控制权
③ 维护关联关系中，是否设置inverse属性：
◆ 保存数据：有影响
如果设置控制反转，即inverse=true，然后通过部门方维护关联关系。在保存部门的时候，同时保存员工，数据会保存，但关联关系不会维护，即外键字段为NULL
◆ 获取数据：无影响
◆ 解除关联关系：有影响
inverse=false，可以解除关联
inverse=true，当前方(部门)没有控制权，不能解除关联关系
(不会生成update语句,也不会报错)
◆ 删除数据：有影响
inverse=false, 有控制权，可以删除。先清空外键引用，再删除数据。
inverse=true, 没有控制权，如果删除的记录有被外键引用，会报错，违反主外键引用约束。如果删除的记录没有被引用，可以直接删除。

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

4、Hibernate常见面试题： inverse与cascade区别？（互不影响）

5、多对多映射
① 需求：项目与开发员工（一个开发人员可参与多个项目）
② 设计数据库
③ 设计javabean封装

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

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>

⑥ 测试

public class App_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();
		// 创建项目对象
		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();
	}
}

⑦ 维护关联关系
设置inverse属性，在多对多种维护关联关系的影响？
◆ 保存数据：有影响
inverse=false，有控制权，可以维护关联关系，保存数据的时候会把对象关系插入中间表；
inverse=true, 没有控制权，不会往中间表插入数据。
◆ 获取数据：无影响
◆ 解除关系：有影响
inverse=false，有控制权，解除关系就是删除中间表的数据。
inverse=true，没有控制权，不能解除关系。
◆ 删除数据：有影响
inverse=false，有控制权，先删除中间表数据，再删除自身。
inverse=true，没有控制权，如果删除的数据有被引用，会报错！否则，才可以删除。

三、对象的状态

Hibernate中对象的状态：临时/瞬时状态、持久化状态、游离状态。
1、临时状态
特点：
① 直接new出来的对象
② 不处于session的管理
③ 数据库中没有对象的记录
2、持久化状态
当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!
特点：
① 处于session的管理
② 数据库中有对应的记录
3、游离状态
特点：
① 不处于session的管理
② 数据库中有对应的记录
③ Session关闭后，对象的状态

四、一级缓存

1、为什么要用缓存？
目的：减少对数据库的访问次数，从而提升hibernate的执行效率！

2、Hibernate中缓存分类：
① 一级缓存
② 二级缓存

3、概念
① Hibenate中一级缓存，也叫做session的缓存，它可以在session范围内减少数据库的访问次数！只在session范围有效！ Session关闭，一级缓存失效！
② 当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候，都会把对象放入session的缓存中。
③ Session的缓存由hibernate维护，用户不能操作缓存内容，如果想操作缓存内容，必须通过hibernate提供的evit/clear方法操作。

4、特点：
① 只在(当前)session范围有效，作用时间短，效果不是特别明显！
② 在短时间内多次操作数据库，效果比较明显！

5、缓存相关几个方法的作用
① session.flush(); 让一级缓存与数据库同步
② session.evict(arg0); 清空一级缓存中指定的对象
③ session.clear(); 清空一级缓存中缓存的所有对象

6、在什么情况用上面方法？
批量操作使用使用：
Session.flush(); // 先与数据库同步
Session.clear(); // 再清空一级缓存内容

7、面试题
① 面试题1：不同的session是否会共享缓存数据?
答：不会。

@Test
	public void sessionTest() throws Exception {
		Session session1 = sf.openSession();
		session1.beginTransaction();
		Session session2 = sf.openSession();
		session2.beginTransaction();
		// user放入session1的缓存区
		User user = (User) session1.get(User.class, 1);
		// user放入session2的缓存区
		session2.update(user);
		// 修改对象
		user.setUserName("New Name");  // 2条update
		session1.getTransaction().commit();  // session1.flush();
		session1.close();
		session2.getTransaction().commit();  // session2.flush();
		session2.close();
	}

如果生成2条update sql，说明不同的session使用不同的缓存区，不能共享。
② 面试题2： list与iterator查询的区别？
◆ list：一次把所有的记录都查询出来，会放入缓存，但不会从缓存中获取数据
◆ Iterator：N+1查询； N表示所有的记录总数，即会先发送一条语句查询所有记录的主键（1），再根据每一个主键再去数据库查询（N）！会放入缓存，也会从缓存中取数据！

public class App_list_iterator {
	private static SessionFactory sf;
	static {
		sf = new Configuration()
			.configure()
			.addClass(User.class)   // 测试时候使用
			.buildSessionFactory();
	}
	/**
	 * list与iterator区别
	 * 1. list 方法
	 * 2. iterator 方法
	 * 3. 缓存
	 * @throws Exception
	 */
	//1.  list 方法
	@Test
	public void list() throws Exception {
		Session session = sf.openSession();
		session.beginTransaction();
		// HQL查询
		Query q = session.createQuery("from User ");
		// list()方法
		List<User> list = q.list();
		for (int i=0; i<list.size(); i++){
			System.out.println(list.get(i));
		}
		session.getTransaction().commit();  
		session.close();
	}
	
	//2. iterator 方法
	@Test
	public void iterator() throws Exception {
		Session session = sf.openSession();
		session.beginTransaction();
		// HQL查询
		Query q = session.createQuery("from User ");
		// iterator()方法
		Iterator<User> it = q.iterate();
		while(it.hasNext()){
			// 得到当前迭代的每一个对象
			User user = it.next();
			System.out.println(user);
		}
		session.getTransaction().commit();  
		session.close();
	}
	
	//3. 缓存
	@Test
	public void cache() throws Exception {
		Session session = sf.openSession();
		session.beginTransaction();
		/**************执行2次list*****************
		Query q = session.createQuery("from User");
		List<User> list = q.list();      // 【会放入？】
		for (int i=0; i<list.size(); i++){
			System.out.println(list.get(i));
		}
		System.out.println("=========list===========");
		list = q.list();				// 【会取出?】
		for (int i=0; i<list.size(); i++){
			System.out.println(list.get(i));
		}
		
		/**************执行2次iteator******************/
		Query q = session.createQuery("from User ");
		Iterator<User> it = q.iterate();		// 【放入缓存】
		while(it.hasNext()){
			User user = it.next();
			System.out.println(user);
		}
		System.out.println("==========iterate===========");
		it = q.iterate();						// 【也会从缓存中取】
		while(it.hasNext()){
			User user = it.next();
			System.out.println(user);
		}
		session.getTransaction().commit();  
		session.close();
	}
	
	// 测试list方法是否会放入缓存和是否从缓存中取出
	@Test
	public void list_iterator() throws Exception {
		Session session = sf.openSession();
		session.beginTransaction();
		// 得到Query接口的引用
		Query q = session.createQuery("from User ");
		// 先list  【得出结果：会放入缓存，但不会从缓存中获取数据】
		List<User> list = q.list(); 
		for (int i=0; i<list.size(); i++){
			System.out.println(list.get(i));
		}
		// 再iteraotr  (会从缓存中取)
		Iterator<User> it = q.iterate();
		while(it.hasNext()){
			User user = it.next();
			System.out.println(user);
		}
		session.getTransaction().commit();  
		session.close();
	}
}

五、懒加载

1、面试题： get、load方法区别？
get：及时加载，只要调用get方法立刻向数据库查询
load：默认使用懒加载，当用到数据的时候才向数据库查询。

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

	//1. 主键查询，及区别
	@Test
	public void get_load() {
		Session session = sf.openSession();
		session.beginTransaction();
		Dept dept = new Dept();
		// get： 及时查询
//		dept = (Dept) session.get(Dept.class, 9);
//		System.out.println(dept.getDeptName());
		// load，默认懒加载， 及在使用数据的时候，才向数据库发送查询的sql语句！
		dept = (Dept)session.load(Dept.class, 9);
		// 方式1： 先使用一下数据
		//dept.getDeptName();
		// 方式2：强迫代理对象初始化
		Hibernate.initialize(dept);
		// 方式3：关闭懒加载
		session.getTransaction().commit();
		session.close();
		// 在这里使用
		System.out.println(dept.getDeptName());
	}

	//1. 主键查询，及区别
	@Test
	public void set() {
		Session session = sf.openSession();
		session.beginTransaction();
		Dept dept = (Dept) session.get(Dept.class, 10);
		System.out.println(dept.getDeptName());
		System.out.println("------");
		System.out.println(dept.getEmps().isEmpty());  //  发送SQL
		session.getTransaction().commit();
		session.close();
	}	
}

2、懒加载：(lazy)
① 概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。
② 目的：提供程序执行效率！
③ lazy 值
◆ true：使用懒加载
◆ false：关闭懒加载
◆ extra：（在集合数据懒加载时候提升效率）在真正使用数据的时候才向数据库发送查询的sql；如果调用集合的size()/isEmpty()方法，只是统计，不真正查询数据！

3、懒加载异常
① Session关闭后，不能使用懒加载数据！
② 如果session关闭后，使用懒加载数据报错：
org.hibernate.LazyInitializationException: could not initialize proxy - no Session
③ 如何解决session关闭后不能使用懒加载数据的问题？
◆ 方式1：先使用一下数据：dept.getDeptName();
◆ 方式2：强迫代理对象初始化：Hibernate.initialize(dept);
◆ 方式3：关闭懒加载：设置lazy=false;
◆ 方式4：在使用数据之后，再关闭session！

六、一对一映射、组件映射、继承映射

1、一对一映射
① 需求：用户与身份证信息
② 设计数据库
③ 设计javabean封装
◆ 基于外键的映射

public class IdCard {
	// 身份证号(主键)
	private String cardNum;// 对象唯一表示(Object Identified, OID)
	private String place; //  身份证地址
	// 身份证与用户，一对一的关系
	private User user;
}

public class User {
	private int userId;
	private String userName;
	// 用户与身份证信息， 一对一关系
	private IdCard idCard;
}

<?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_one2one">
	<class name="IdCard" table="t_IdCard">
		<id name="cardNum">
			<generator class="assigned"></generator>
		</id>	
		<property name="place" length="20"></property>
		<!-- 
			一对一映射，有外键方
			unique="true"   给外键字段添加唯一约束
		 -->
		 <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
	</class>
</hibernate-mapping>

<?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_one2one">
	<class name="User" table="t_user">
		<id name="userId">
			<generator class=" native"></generator>
		</id>	
		<property name="userName" length="20"></property>
		<!-- 
			一对一映射： 没有外键方
		 -->
		 <one-to-one name="idCard" class="IdCard"></one-to-one>
	</class>
</hibernate-mapping>

◆ 基于主键的映射

public class IdCard {
	private int user_id;
	// 身份证号
	private String cardNum;
	private String place; //  身份证地址
	// 身份证与用户，一对一的关系
	private User user;
}

<?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_one2one2">
	<class name="IdCard" table="t_IdCard">
		<id name="user_id">
			<!-- 
				id 节点指定的是主键映射, 即user_id是主键
				主键生成方式： foreign  即把别的表的主键作为当前表的主键；
						property (关键字不能修改)指定引用的对象     对象的全名 cn..User、  对象映射 cn.User.hbm.xml、   table(id)
			 -->
			<generator class="foreign">
				<param name="property">user</param>
			</generator>
		</id>	
		<property name="cardNum" length="20"></property>
		<property name="place" length="20"></property>
		<!-- 
			一对一映射，有外键方
			（基于主键的映射）
			 constrained="true"  指定在主键上添加外键约束
		 -->
		<one-to-one name="user" class="User" constrained="true"  cascade="save-update"></one-to-one>		
	</class>
</hibernate-mapping>

2、类的关系
① 组合关系：一个类中包含了另外一个类，这2个类中就是组合关系。
需求：汽车与车轮
② 继承关系：一个类继承另外一个类，这2个类中就是继承关系。
需求：动物与狗

3、组件映射：组件类和被包含的组件类是要共同映射到一张表
① 需求：汽车与车轮
② 设计数据库
③ 设计javabean封装

public class Car {
	private int id;
	private String name;
	// 车轮
	private Wheel wheel;
}

public class Wheel {
	private int count;
	private int size;
}

<hibernate-mapping package="cn.itcast.d_component">
	<class name="Car" table="t_car">
		<id name="id">
			<generator class="native"></generator>
		</id>	
		<property name="name" length="20"></property>
		<!-- 组件映射 -->
		<component name="wheel">
			<property name="size"></property>
			<property name="count"></property>
		</component>				 
	</class>
</hibernate-mapping>

4、继承映射
① 需求：动物与狗
② 设计数据库
③ 设计javabean封装
◆ 简单继承映射：有多少个子类，写多少个映射文件！

public abstract class Animal {
	private int id;
	private String name;
}

public class Cat extends Animal{
	// 抓老鼠
	private String catchMouse;
	public String getCatchMouse() {
		return catchMouse;
	}

	public void setCatchMouse(String catchMouse) {
		this.catchMouse = catchMouse;
	}
}

public class Monkey extends Animal{
	// 吃香蕉
	private String eatBanana;
}

<hibernate-mapping package="cn.itcast.e_extends1">
	<class name="Cat" table="t_Cat">
		<!-- 简单继承映射： 父类属性直接写 -->
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		<property name="catchMouse"></property>					 
	</class>
</hibernate-mapping>

@Test
	public void getSave() {
		Session session = sf.openSession();
		session.beginTransaction();
		// 保存
//		Cat cat = new Cat();
//		cat.setName("大花猫");
//		cat.setCatchMouse("抓小老鼠");
//		session.save(cat);
	
		// 获取时候注意：当写hql查询的使用，通过父类查询必须写上类的全名
		Query q = session.createQuery("from cn.itcast.e_extends1.Animal");
		List<Animal> list = q.list();
		System.out.println(list);
		session.getTransaction().commit();
		session.close();	
}

◆ 继承映射：【不推荐】所有子类映射到一张表（一张表的情况）
使用情况：子类教多，且子类较为简单，即只有个别属性！
◇ 好处：因为使用一个映射文件，减少了映射文件的个数。
◇ 缺点：不符合数据库设计原则

<?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.e_extends2">
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 指定鉴别器字段(区分不同的子类) -->
		<discriminator column="type_"></discriminator>
		<property name="name"></property>
		
		<!-- 
			子类：猫
				每个子类都用subclass节点映射
				注意：一定要指定鉴别器字段，否则报错！
				鉴别器字段：作用是在数据库中区别每一个子类的信息， 就是一个列
			discriminator-value="cat_"
				指定鉴别器字段,即type_字段的值
				如果不指定，默认为当前子类的全名
		 -->
		 <subclass name="Cat" discriminator-value="cat_">
		 	<property name="catchMouse"></property>
		 </subclass>
		 
		 <!-- 
		 	子类：猴子
		  -->
		  <subclass name="Monkey" discriminator-value="monkey_">
		  	<property name="eatBanana"></property>
		  </subclass>
	</class>
</hibernate-mapping>

◆ 继承映射：所有子类映射到一张表（父类一张表+子类N张表的情况）

<hibernate-mapping package="cn.itcast.e_extends3">
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		
		<!-- 
			子类：猫  t_cat
			key 指定_cat表的外键字段
		-->
		<joined-subclass name="Cat" table="t_cat">
			<key column="t_animal_id"></key>
			<property name="catchMouse"></property>
		</joined-subclass>
		
		<!-- 子类：猴子  t_monkey -->
		<joined-subclass name="Monkey" table="t_monkey">
			<key column="t_animal_id"></key>
			<property name="eatBanana"></property>
		</joined-subclass>	
	</class>
</hibernate-mapping>

总结：一个映射文件存储所有的子类，子类父类都对应表；
缺点：表结构比较复杂，插入一条子类信息，需要用2条sql：往父类插入、往子类插入！
◆ 继承映射：【推荐】每个子类映射一张表，父类不对应表（子类N张表的情况）

<hibernate-mapping package="cn.itcast.e_extends4">
	<!-- 
		 abstract="true"  指定实体类对象不对应表，即在数据库段不生成表
	 -->
	<class name="Animal" abstract="true">
		<!-- 如果用union-subclass节点，主键生成策略不能为自增长！ -->
		<id name="id">
			<generator class="uuid"></generator>
		</id>
		<property name="name"></property>
		
		<!-- 
			子类：猫  t_cat
			union-subclass  
				table 指定为表名, 表的主键即为id列
		-->
		<union-subclass name="Cat" table="t_cat">
			<property name="catchMouse"></property>
		</union-subclass>
		
		<!-- 子类：猴子  t_monkey -->
		<union-subclass name="Monkey" table="t_monkey">
			<property name="eatBanana"></property>
		</union-subclass>
	</class>
</hibernate-mapping>

注意：主键不能是自增长！