Hibernate - 2

Hibernate 关联关系映射

实现类：

/**
 * @author: RookieWangZhiWei
 * @date:2018-3-8 上午9:06:03
 * @version :
 * 
 */
public class Customer {
	private Integer id;
	private String name;
	//在1 的一方,表达持有多的一方的引用=>使用集合
	private Set<Order> orders = new HashSet<Order>();
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}
	
	
}

/**
 * @author: RookieWangZhiWei
 * @date:2018-3-8 上午9:07:18
 * @version :
 * 
 */
public class Order {
	private Integer id;
	private String name;
	
	private Customer customer;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
	
	
}

配置文件：

Customer.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package="two" >
 	<class name="Customer" table="t_customer"  >
		<id name="id" column="id"    >
			<generator class="native"></generator>
		</id> 	
		<property name="name" column="name" type="string" ></property>
 		
 		<!-- 表达一对多关系中的集合
 			name:集合的属性名称
 			inverse: 是否将关系的维护反转给对方. 默认值: false
 				   true: 在Customer 中 放弃维护外键关系
 				   
 			cascade :级联操作
 				save-update：级联保存,级联修改. 保存A时,同时保存B. 
				delete：删除A，同时删除B，AB都不存在
				delete-orphan：孤儿删除，解除关系，同时将B删除，A存在的。
				如果需要配置多项，使用逗号分隔。<set cascade="save-update,delete">
				
				all : save-update 和 delete 整合
				all-delete-orphan : 三个整合
 				
 		 -->
 		<set name="orders" inverse="false" cascade="all-delete-orphan"  >
 			<!--
 				key 用来描述外键
 				column : 外键的值
 			  -->
 			<key column="cid" ></key>
 			<!-- one-to-many 表达, Customer 与orders 的关系是一对多
 				class: 表达关联的另一方的完整类名
 			 -->
 			<one-to-many class="Order" />
 		</set>
 	</class>
 </hibernate-mapping>

Order.hbm.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package="two" >
 	<class name="Order" table="t_order"  >
		<id name="id" column="id"    >
			<generator class="native"></generator>
		</id> 	
		<property name="name" column="name" type="string" ></property>
 		
 		<!-- 表达多对一关系 
 			name: 引用的属性名称
 			column: 外键的列名
 			class: 我引用的Order的完整类名
 		-->
 		<many-to-one name="customer" column="cid" class="Customer"   ></many-to-one>
 	</class>
 </hibernate-mapping>

多对多

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package = "three">
 	<class name = "Student" table = "t_student">
 		<id name = "sid" column = "sid">
 			<generator class = "native"></generator>
 		</id>
 		
 		<property name = "sname" colume = "sname"></property>
 		<!-- 多对多关系 -->
		<!-- 
			set 表达集合
				name: 集合的属性名
				table:多对多中间表的表名
			key 表达外键
				column:引用我的外键名
			many-to-many 表达多对多
				class : 集合引用方的类型
				column:对方在中间表的外键名
		 -->
 		<set name = "courses" table = "stu_cour" inverse="false" cascade="save-update">
 			<key column = "sno"></key>
 			<many-to-many class = "Course" column = "t_course"></many-to-many>
 		</set>
 	</class>
 
 </hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping package = "three">
 	<class name = "Course" table = "t_course">
 		<id name = "cid" column = "cid">
 			<generator class = "native"></generator>
 		</id>
 		
 		<property name = "cname" column = "cname"></property>
 		
 		<set name = "students" table = "stu_cour" inverse="true">
 			<key column = "cno"></key>
 			<many-to-many class = "Student" column = "sno"></many-to-many>
 		</set>
 	</class>
 
 </hibernate-mapping>

抓取策略

1.检索方式

立即检索：立即查询，在执行查询语句时，立即查询所有的数据

延迟检索：延迟查询，在执行查询语句之后，在需要时在查询（懒加载）

2.类级别检索

get:立即检索，get方法一执行，立即查询所有字段的数据

load：延迟检索，默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询 。 Customer.hbm.xml <class  lazy="true |false">

              lazy默认值true，表示延迟检索，如果设置false表示立即检索。

3.关联级别检索

3.1一对多或多对多

l  容器<set> 提供两个属性：fetch、lazy

       fetch：确定使用sql格式

       lazy：关联对象是否延迟。

l  fetch：join、select、subselect

       join：底层使用迫切左外连接

       select：使用多个select语句（默认值）

       subselect：使用子查询

l  lazy：false、true、extra

       false：立即

       true：延迟（默认值）

       extra：极其懒惰

l  fetch="join"

lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

 fetch="select"

l  当前对象 和 关联对象 使用多条select语句查询。

l  lazy="false" , 立即，先查询客户select，立即查询订单select

l  lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

l  lazy="extra"，极其懒惰（延迟），先查询客户select， 如果只需要订单数，使用聚合函数（不查询详情）

1.1.1.1 fetch="subselect"

l  将使用子查询。注意：必须使用Query否则看不到效果。

l  lazy= 同上

3.2多对一

l  <many-to-one fetch="" lazy="">  (<one-to-one>)

l  fetch取值：join、select

       join：底层使用迫切左外连接

       select：多条select语句

l  lazy取值：false、proxy、no-proxy

       false：立即

       proxy：采用关联对象 类级别检索的策略。

              订单 关联 客户 （多对一）

              订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false">

              订单 延迟获得 客户，需要在客户Customer.hbm.xml <classlazy="true">

1.1.1.1 fetch="join"

l  fecth="join" select语句使用左外连接，此时lazy无效。

1.1.1.1 fetch="select"

l  将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。