我的见解之hibernate（十）

映射双向n-1关系：

举个简单的例子，顾客和订单的关系，一个顾客可以拥有多个订单，而多个订单可以同时属于一个顾客，这就是双向n-1关系，

在Customer一端，需要持有装载着Order集合的引用

/*
	 * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取
	 * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的
	 * 集合实现.  如果我们改为  private HashSet<Order> orders = new HashSet<>();就会报错
	 * 2. 需要把集合进行初始化, 可以防止发生空指针异常
	 */
	private Set<Order> orders = new HashSet<>();

在Order一端，需要持有Customer的引用

private Customer customer;

get和set方法就不说了，这是一定要有的

在Order.hbm.xml文件中

<!-- 
			映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
			name: 多这一端关联的一那一端的属性的名字
			class: 一那一端的属性对应的类名
			column: 一那一端在多的一端对应的数据表中的外键的名字
		-->
		<many-to-one name="customer" class="com.jiangtao.model.Customer" column="CUSTOMER_ID"></many-to-one>

在Customer.hbm.xml文件中

<!-- 映射 1 对多的那个集合属性 -->
        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">
        	<!-- 执行多的表中的外键列的名字 -->
        	<key column="CUSTOMER_ID"></key>
        	<!-- 指定映射类型 -->
        	<one-to-many class="com.jiangtao.model.Order"/>
        </set>

@Test
	public void testMany2OneSave(){
		Customer customer = new Customer();
		customer.setCustomerName("AA");
		
		Order order1 = new Order();
		order1.setOrderName("ORDER-1");
		Order order2 = new Order();
		order2.setOrderName("ORDER-2");
		
		//设定关联关系
		order1.setCustomer(customer);
		order2.setCustomer(customer);
		customer.getOrders().add(order1);
		customer.getOrders().add(order2);
		
		/**
		         执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT, 2 条 UPDATE
			因为 1 的一端和 n 的一端都维护关联关系. 所以会多出 UPDATE
			可以在 1 的一端的 set 节点指定 inverse=true, 来使 1 的一端放弃维护关联关系!
			建议设定 set 的 inverse=true, 建议先插入 1 的一端, 后插入多的一端
			好处是不会多出 UPDATE 语句 只有三条insert语句
		*/
		session.save(customer);
		session.save(order1);
		session.save(order2);
		
//		先插入 Order, 再插入 Cusomer, 3 条 INSERT, 4 条 UPDATE
//		session.save(order1);
//		session.save(order2);
//		session.save(customer);
	}

@Test
	public void testMany2OneGet(){
		/**
		 * 1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的
		 * 1 的那一端的对象!
		 * 我们在多的一端的也就是order.hbm.xml文件中<many-to-one lazy="false"/>
		 * 则可以直接返回多一段的对象，而不是一个代理对象
		 */
		Order order = (Order) session.get(Order.class, 2);
		System.out.println(order.getOrderName()); 
		System.out.println(order.getCustomer().getClass().getName());
		//session.close();如果此时关闭会发生懒加载异常
		//2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句. 
		Customer customer = order.getCustomer();
		System.out.println(customer.getCustomerName()); 
		//3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, 
		//若此时 session 已被关闭, 则默认情况下
		//会发生 LazyInitializationException 异常
		//4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!
	}

	@Test
	public void testOne2ManyGet(){
		//1. 对 n 的一端的集合使用延迟加载
		Customer customer = (Customer) session.get(Customer.class, 7);
		System.out.println(customer.getCustomerName()); 
		//2. 返回的多的一端的集合时 Hibernate 内置的集合类型. 
		//该类型具有延迟加载和存放代理对象的功能. 
		System.out.println(customer.getOrders().getClass()); 
		//session.close();
		//3. 可能会抛出 LazyInitializationException 异常 
		System.out.println(customer.getOrders().size()); 
		//4. 再需要使用集合中元素的时候进行初始化. 
	}

@Test
	public void testDelete(){
		//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
		Customer customer = (Customer) session.get(Customer.class, 1);
		session.delete(customer); 
	}

映射1-1关系：

①基于外键映射的1-1：

部门和部门经理

Department.hbm.xml

<!-- 使用 many-to-one 的方式来映射 1-1 关联关系 -->
		<many-to-one name="mgr" class="com.jiangtao.hibernate.one2one.foreign.Manager" 
			column="MGR_ID" unique="true">  unique:限制是唯一约束
		</many-to-one>

Manager.hbm.xml

 <!-- 映射 1-1 的关联关系: 在对应的数据表中已经有外键了, 当前持久化类使用 one-to-one 进行映射 -->
        <!-- 
        	没有外键的一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段
         -->
        <one-to-one name="dept" 
        	class="com.jiangtao.hibernate.one2one.foreign.Department"
        	property-ref="mgr"></one-to-one>
如果不用property-ref 那么发送的sql语句连接条件不对<span style="color:#FF6666;"><span style="color:#330033;"></span></span><pre name="code" class="java"><pre name="code" class="java">dept.dept_id = mgr.manager_id

加上之后

查询 Manager 对象的连接条件是 dept.manager_id = mgr.manager_id

 默认情况下对关联属性使用懒加载

@Test
	public void testGet(){
		//1. 默认情况下对关联属性使用懒加载
		Department dept = (Department) session.get(Department.class, 1);
		System.out.println(dept.getDeptName()); 
		
		//2. 所以会出现懒加载异常的问题. 
//		session.close();
//		Manager mgr = dept.getMgr();
//		System.out.println(mgr.getClass()); 
//		System.out.println(mgr.getMgrName()); 
		
		//3. 查询 Manager 对象的连接条件应该是 dept.manager_id = mgr.manager_id
		//而不应该是 dept.dept_id = mgr.manager_id
		Manager mgr = dept.getMgr();
		System.out.println(mgr.getMgrName()); 	
	}

在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象

@Test
	public void testGet2(){
		//在查询没有外键的实体对象时, 使用的左外连接查询, 一并查询出其关联的对象
		//并已经进行初始化. 
		Manager mgr = (Manager) session.get(Manager.class, 1);
		System.out.println(mgr.getMgrName()); 
		System.out.println(mgr.getDept().getDeptName()); 
	}

②基于主键的1-1：

Department.hbm.xml

 <id name="deptId" type="java.lang.Integer">
            <column name="DEPT_ID" />
            <!-- 使用外键的方式来生成当前的主键 -->
            <generator class="foreign">
            	<!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->
            	<param name="property">mgr</param>
            </generator>
        </id>

<!--  
		采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,
		其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束
		-->
		<one-to-one name="mgr" class="Manager" constrained="true"/>

Manager.hbm.xml

 <one-to-one name="dept" 
        	class="com.atguigu.hibernate.one2one.primary.Department">
</one-to-one>

双向n-n：需要使用中间表，减少冗余字段

Category.hbm.xml

 <!-- table: 指定中间表 -->
        <set name="items" table="CATEGORIES_ITEMS">
            <key>
                <column name="C_ID" />
            </key>
            <!-- 使用 many-to-many 指定多对多的关联关系. column 执行 Set 集合中的持久化类在中间表的外键列的名称  -->
            <many-to-many class="Item" column="I_ID"></many-to-many>
        </set>

Item.hbm.xml

<set name="categories" table="CATEGORIES_ITEMS" inverse="true">
        	<key column="I_ID"></key>
        	<many-to-many class="com.atguigu.hibernate.n2n.Category" column="C_ID"></many-to-many>
        </set>