Hibernate-day03

双向的many2one/one2many

双向many2one/one2many的问题:
一定有额外的SQL发出;
在数据库里面,外键表示many2one或者one2many的关系,外键是没有方向的;但是在面向对象里面,关系有方向,所以两个方向都要去管理这个外键,造成的额外的SQL(这些多余的SQL都是ONE方想去管理many方造成的);

我们既想保留对象中的双向的关系;又想减少额外的SQL,所以需要像下图一样配置映射文件

对象的删除:

1,many方都可以直接删除;
2,删除one方:
　　1）,inverse="false":可以正常删除;
　　　　Hibernate: update Employee set DEPT_ID=null where DEPT_ID=?

　　　　Hibernate: delete from Department where id=?
　　2）,inverse="true":不能正常删除:
　　外键约束错误;

选择:
1,90%的情况,使用单向的many2one;(删除使用HQL;)
2,9%的情况使用双向的many2one/one2many:
　　1）,自连接(树状结构;);
　　2）,组合关系;
3,1%的情况使用单向的one2many;(使用两个one2many来实现many2many)

hibernate中的集合:
1,在hibernate中,集合只能使用接口
2,集合的使用;
　　1）,Set:代表集合中的对象不能重复;集合中的对象没有顺序;对于Set集合,只能使用<set>元素来映射;
　　2）,List:集合中的对象可以重复,集合中的对象是有顺序的;　　

    	 <list name="ems" inverse="true">
    	 	<key column="Dept_ID"/>
    	 	<list-index column="SEQ"/>
    	 	<one-to-many class="Employee"/>
    	 </list> 

　　　　1）,要让one方知道many方的顺序,必须在many方的表中添加一列用来保存顺序;
　　　　2）,这个顺序只有one方知道,所以,这个列应该由one方来维护;
　　　　3）,在<list>元素中添加<list-index>来映射这个列;
　　　　4）,不管list的inverse=true,总要发送额外的SQL去维护这个many方的顺序;
　　3）,第二种映射List的方式:
　　　　1）,如果只是想把List作为一个集合,而不让hibernate来帮我们维护顺序,就可以是用<bag>
　　　　2）,bag元素不关心one中many方的顺序;

    	 <bag name="ems" inverse="true">
    	 	<key column="Dept_ID"/>
    	 	<one-to-many class="Employee"/>
    	 </bag>

3,选择:
　　1）,确定集合中的对象是否能重复;
　　2）,如果使用List,尽量使用bag来映射;
　　3）,如果必须要让many方有顺序;在many方中添加一个表示顺序的属性,

1,在many方添加一个顺序的属性,并且在映射文件中设置

public class Emloyee{
        private Long id;
	private String name;
	private Department dept;
	private Integer sequence;
	//省略get/set
}

    <class name="Employee" table="employee">
		<id	name="id" column="id">
			<generator class="native"/>
		</id>
		<property name="name" column="name"/>
		<property name="sequence" column="sequence"/>
		<many-to-one name="dept" column="Dept_ID"/>
    </class>

2,在one方的集合上面添加order-by属性

    	 <bag name="ems" inverse="true" order-by="sequence">
    	 	<key column="Dept_ID"/>
    	 	<one-to-many class="Employee"/>
    	 </bag>

order-by属性的意思是,在加载many方集合的时候,使用order by语句按照many方的指定属性来查询;

级联:
组合关系:强聚合关系,代表整体和部分之间不能分开,整体和部分单独存在没有意义;
分析:
　　1,组合关系的两个对象都是在一个模块当中管理的;都是在整体那个对象的模块中管理;
　　2,对于销售订单对象来说:
　　　　1),存在一个列表;
　　　　2),添加:在添加页面需要添加销售订单对象上的属性,还需要添加这个销售订单的明细数据;
　　　　3),修改:仍然在销售订单的编辑页面中完成;
　　　　4),删除:在销售订单列表中删除销售订单;
　　3,对于销售订单明细对象来说:
　　　　1),对于销售订单明细对象,不需要列表;
　　　　2),添加:
　　　　　　1),在销售订单对象的添加的时候,可以添加销售订单明细对象;
　　　　　　2),在销售订单对象的保存,可以添加销售订单明细对象;
　　　　3),修改:在销售订单对象的修改方法中完成的;
　　　　4),删除:在销售订单对象的修改方法中完成的;在删除销售订单的时候,也要去删除这个销售订单的明细;
分析执行流程:
　　1,只需要有销售订单对象的DAO接口就可以了,销售订单明细的CRUD都是在销售订单对象的DAO中完成的;
　　2,save:
　　　　1),保存销售订单对象;
　　　　2),保存销售订单对象对应的销售订单明细对象;
　　3,update:
　　　　1),修改销售订单对象(游离);
　　　　2),保存新的销售订单明细对象(临时对象);
　　　　3),修改修改过的销售订单明细对象(游离);
　　　　4),删除去掉了的销售订单明细对象(删除和主对象没有关系的销售订单明细对象);
　　4,delete:
　　　　1),删除销售订单对象的明细;
　　　　2),删除主对象;

使用级联来完成SaleBillDAOImpl:(在组合关系中,一般把整体称为主对象,把部分称为子对象)
　　1,在one方的集合上面,可以添加cascade属性,这个属性的意思就叫做级联;
　　2,级联能根据配置的级联策略,对这个集合里面的对象自动做一些操作;

级联策略:
　　1,save-update:在保存或者修改主对象的时候,去级联的持久化临时的子对象,修改游离的子对象;
　　2,delete:在删除主对象的时候,去级联的删除所有的子对象;
　　3,all:save-update+delete
　　4,delete-orphan:删除和主对象打破关系的子对象;
　　5,all-delete-orphan:all+delete-orphan
　　6,一般来说,对于组合关系,我们就直接使用all-delete-orphan就可以了;

PS:
Hibernate.initialize(bill.getItems());
可以使用Hibernate.initialize去初始化一个代理对象;

一对一:
1,使用many2one来实现one2one

hibernate在这种方式映射one2one不是很好理解(不讲)

2,使用主键外键的方式来实现one2one

两种实现方式的区别:
1,使用第一种方式两个对象没有先后之分,都可以独立存在;
2,使用第二种方式,主对象必须先存在,再有从对象;

 映射文件(以QQ和QQ空间的关系为例):

    <class name="QQNumber" table="qqNumber">
		<id name="id" column="id">
			<generator class="native"/>
		</id>
		<property name="number" column="number"/>
		<one-to-one name="zone"/>
    </class>

	<class name="QQZone" table="qqZone">
		<id name="id" column="id">
			<!-- foreign表示参照其他主键来生成主键id -->
			<generator class="foreign">
				<!-- 根据属性number对应的类的主键生成主键 -->
				<param name="property">number</param>
			</generator>
		</id>
		<property name="title" column="title"/>
		<!-- constrained表示在主键上面添加number属性的外键约束 -->
		<one-to-one name="number" constrained="true"/>
	</class>

1,在从对象中,从对象的主键需要参照number属性的主键来生成,所以从对象的主键生成策略为foreign;
2,在foreign策略中,需要配置一个property(属性),告诉hibernate,从对象的主键是根据哪个属性对应的主键来生成;
3,默认情况下,one2one并没有生成从对象主键的外键约束,在从对象中的one-to-one元素中添加constrained属性来为从表的主键添加外键约束;
4,不管是先保存从对象还是先保存主对象,甚至直接保存从对象,hibernate都会先保存主对象,在保存从对象;
5,从主对象拿从对象,不存在延迟加载的问题,hibernate使用一条SQL就把主对象和对应的从对象一起查询出来了;
思考:为什么hibernate在这个地方不用延迟加载,他是不想用,还是不能用?为什么?
6,从从对象拿主对象,使用延迟加载;
　　1),必须在session关闭之前实例化主对象;
　　2),一定存在主对象;
思考:为什么从对象拿主对象又可以使用延迟加载?

选择:
1,一般情况下,都不会使用one2one关系,我们一般都直接使用单向的many2one+业务逻辑来完成one2one;
2,如果非得使用one2one,使用主键外键的方式实现;

组件关系：

粗粒度的对象设计

public class Company {

	private Long id;
	private String name;

	private String provice;
	private String city;
	private String street;

	private String regProvice;
	private String regCity;
	private String regStreet;
        //省略get/set
}

细粒度的对象设计

public class Company {

	private Long id;
	private String name;

	private Address address;
	private Address regAddress;
        //省略get/set
}    

public class Address {

	private String provice;
	private String city;
	private String street;
        //省略get/set
}

分析:
1,对象粒度细,分工明确;
2,地址表可以被其他的表重复使用;
3,需要连接很多表才能完成查询;

为了提高性能,我们可以把address的所有内容直接放到company表中,在表里面,相当于只有一张表,在对象中,有多个对象;
我们把单独存在没有意义,必须在其他对象中存在才有意义的对象(没有自己的表,它的属性都是在主表中),把这种对象称为组件对象
我们把组件对象依赖的那个主对象,称为组件对象的宿主对象;

分析
1,对于对象来说,对象粒度够细;
2,对于宿主对象来说,查询够快;
3,组件对象的内容不能被其他对象直接使用;

映射文件：

	<class name="Company" table="company">
		<id name="id" column="id">
			<generator class="native"/>
		</id>
		<property name="name" column="name"/>

		<!-- 配置组合关系 -->
		<component name="address">
			<property name="provice"/>
			<property name="city"/>
			<property name="street"/>
		</component>

		<component name="regAddress">
			<property name="provice" column="REG_PROVICE"/>
			<property name="city" column="REG_CITY"/>
			<property name="street" column="REG_STREET"/>
		</component>
	</class>

说明
1,只有一个映射文件(宿主对象的映射文件);
2,组件对象使用component元素来映射,在component元素中,使用property子元素来映射组件对象中的属性;
3,如果一个宿主对象中存在同一个组件对象2个以上;必须在其中一个的property中修改列的名字;
4,查询的时候使用一条SQL查询,不存在延迟加载问题;

　

many2many（以老师和学生的关系做为例子）：

表的设计和SQL

映射文件

	<class name="Teacher" table="teacher">
		<id name="id" column="id">
			<generator class="native"/>
		</id>
		<property name="name" column="name"/>
		<set name="students" table="STU_TEA">
			<key column="TEA_ID"/>
			<many-to-many class="Student" column="STU_ID"/>
		</set>
	</class>

	<class	name="Student" table="student">
		<id name="id" column="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="teachers" table="STU_TEA" inverse="true">
			<key column="STU_ID"/>
			<many-to-many class="Teacher" column="TEA_ID"/>
		</set>
	</class>

进一步研究:
1,在映射文件里面,set需要table属性,来告知中间表;
2,set中的key子元素代表,在中间表里面那格列作为外键关联到我自己;
3,many-to-many元素:和集合中的对象是多对多的关系;
4,many-to-many的column属性代表:在中间表里面那个列作为外键关联到对方表的主键;
5,many-to-many双方的配置其实是相反的;

6,如果配置的集合是set,hibernate会为中间表创建一个复合主键,
7,不管集合是list还是set,都需要让一边放弃对关系的维护inverse=true;
8,get的时候,使用延迟加载;
　　1),必须在session关闭之前初始化;
　　2),不能使用ifnull来判断集合中是否有对象,只能使用size()来判断;
9,一般来说,我们使用单向的many2many;
10,在项目中,我们应该让哪边来维护关系?需要看具体的设计.页面里面;
哪个模块在管理关系,我们就把关系配置在哪边（如下图的设计，便是把关系配置在项目模块）.

泛化关系（继承关系）：
one-table:

　　表结构和SQL

映射文件

	<class name="Product" table="product" discriminator-value="1">
		<id name="id" column="id">
			<generator class="native"/>
		</id>
		<!-- discriminator表示一个鉴别器,type表示鉴别器所属列的类型 -->
		<discriminator column="TYPES" type="int"/>
		<property name="name" column="name"/>

		<subclass name="Book" discriminator-value="2">
			<property name="isbn"/>
			<property name="author"/>
		</subclass>

		<subclass name="Clothes" discriminator-value="3">
			<property name="color"/>
		</subclass>
	</class>

分析:
1,整个继承体系的所有对象的所有属性全部放在一张表里面;
2,只需要一个映射文件,并且这个映射文件映射整个继承体系的根对象;
3,需要创建一个鉴别器的列;
4,需要为每一个类设置对应鉴别器列的值;
5,在多态查询的时候,需要查询出所有的列,并根据鉴别器的值选择需要实例化的真正对象;

one-table的优劣势
1,优点:简单;多态查询非常块;
2,缺点:表结构不稳定;数量增长很快,要查询某一个具体的类型很慢;null字段;
　　没法使用非空约束;

pre-table：

表结构和SQL

映射文件

	<class name="Product" table="product">
		<id name="id" column="id">
			<generator class="increment"/>
		</id>
		<property name="name" column="name"/>

		<union-subclass name="Book" table="book">
			<property name="isbn"/>
			<property name="author"/>
		</union-subclass>		

		<union-subclass name="Clothes" table="clothes">
			<property name="color"/>
		</union-subclass>
	</class>

小结:
1,继承体系中的每一个对象单独放在一个表里面;
2,为了防止id的冲突,所以per-table的方式要求id不能使用自动增长的方式;
3,使用union-subclass映射子类
4,在多态查询的时候,需要把所有的表使用union拼装成一个大表,并在这个大表中使用class来分辨具体的子类型;

优劣势:onetable的优势就是pertable的劣势;onetable的劣势就是pertable的优势

选择:
1,一般情况尽量避免使用继承;
2,如果真的需要使用继承,请使用onetable的方式;

　

映射枚举类型:

在枚举里面,一个枚举实例有两个值:
name:枚举的名字,可以使用枚举类型.valueOf(String)方法来还原这个枚举类型实例;
1,数据库直观;2,枚举类型位置随意变化;

ordinal:枚举在该类型中的位置;可以使用Sex.values()[0]来根据索引位置类还原这个枚举类型实例;
2,可以修改枚举类型的名字;

映射方式：

		<property name="sex">
			<!-- 此处类型需要引入使用枚举类的类,全限定名如下 -->
			<type name="org.hibernate.type.EnumType">
				<!-- 引入枚举类的类型,写全限定名 -->
				<param name="enumClass">com.rk1632._07_enum.Sex</param>
				<!-- 是否使用枚举属性名作为数据库保存的方式 -->
				<!-- 如果为false,则会使用枚举属性的顺序作为数据库保存数据的方式(从零开始) -->
				<param name="useNamed">true</param>
			</type>
		</property>

1,如果使用名字的方式映射,设置useNamed为true,如果使用位置的方式,useNamed为false;
2,记得,枚举类型要写全限定名;