第15课 持久化对象的三种状态
一、 瞬时对象(Transient Object)：
使用new操作符初始化的对象不是立刻就持久的。它们的状态是瞬时的，也就是说它们没有任何跟数据库表相关联的行为，只要应用不再引用这些对象(不再被任何其它对象所引用)，它们的状态将会丢失，并由垃圾回收机制回收
二、 持久化对象(Persistent Object)：
持久实例是任何具有数据库标识的实例，它有持久化管理器Session统一管理，持久实例是在事务中进行操作的----它们的状态在事务结束时同数据库进行同步。当事务提交时，通过执行SQL的INSERT、UPDATE和DELETE语句把内存中的状态同步到数据库中。
三、 离线对象(Detached Object)：
Session关闭之后，持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步，它们不再受hibernate管理。
四、 三种状态的区分：
1、 有没有ID，(如果没有则是Transient状态)
2、 ID在数据库中有没有
3、 在内存里有没有(session缓存)
五、 总结：
Transient对象：随时可能被垃圾回收器回收(在数据库中没有于之对应的记录，应为是new初始化)，而执行save()方法后，就变为Persistent对象(持久性对象)，没有纳入session的管理
内存中一个对象，没有ID，缓存中也没有
Persistent对象：在数据库有存在的对应的记录，纳入session管理。在清理缓存(脏数据检查)的时候，会和数据库同步。
内存中有、缓存中有、数据库有(ID)
Detached对象：也可能被垃圾回收器回收掉(数据库中存在对应的记录，只是没有任何对象引用它是指session引用)，注引状态经过Persistent状态，没有纳入session的管理
内存有、缓存没有、数据库有(ID)
第16课 关系映射(重点)
注意：这里的关系是指：对象之间的关系，并不是指数据库的关系,-----红色重要
存在以下关系：
1、 一对一
u 单向(主键、外键)
u 双向(主键、外键)
2、 一对多
u 单向
u 双向
3、 多对一
u 单向
u 双向
4、 多对多
u 单向
u 双向
5、 集合映射
u List
u Set
u Map
6、 继承关系(不重要)
u 单表
u 多表
u 一张主表、多张子表
7、 组件映射
u @Embeddable
u @Embedded
一、 一对一关联映射
² 两个对象之间是一对一的关系，如Person-IdCard(人—身份证号)
² 有两种策略可以实现一对一的关联映射
Ø 主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
Ø 唯一外键关联：外键关联，本来是用于多对一的配置，但是如果加上唯一的限制之后，也可以用来表示一对一关联关系。
对象模型
实体类：
/** 人－实体类 */
public class Person {
private int id;
private String name;
public int getId() {return id; }
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
}
/**身份证-实体类*/
public class IdCard {
private int id;
private String cardNo;
public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getCardNo(){ return cardNo;}
public void setCardNo(StringcardNo) {this.cardNo = cardNo;}
}
(一) 唯一外键关联-单向(unilateralism)
1、 说明：
人—-> 身份证号(PersonàIdCard)，从IdCard看不到Person对象
2、 对象模型
需要在Person类中持有IdCard的一个引用idCard，则IdCard中没有Person的引用
3、 关系模型
关系模型目的：是实体类映射到关系模型(数据库中)，是要求persion中添加一个外键指向idcard
4、 实体类：
注：IdCard是被引用对象，没有变化。
/** 人－实体类 */
public class Person {
private int id;
private String name;
private IdCard idCard;//引用IdCard对象
public int getId() {return id; }
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(String name){this.name = name;}
public IdCard getIdCard() { return idCard;}
public void setIdCard(IdCardidCard) {this.idCard = idCard;}
}
5、 xml映射
IdCard实体类的映射文件：
因为IdCard是被引用的，所以没有什么特殊的映射
<hibernate-mapping>
<class name="com." table="t_idcard">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
</hibernate-mapping>
Person实体类的映射文件
在映射时需要添加一个外键的映射，就是指定IdCard的引用的映射。这样映射到数据库时，就会自动添加一个字段并作用外键指向被引用的表
<hibernate-mapping>
<class name="com." table="t_person">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- <many-to-one>:在多的一端(当前Person一端)，加入一个外键(当前为idCard)指向一的一端(当前IdCard),但多对一 关联映射字段是可以重复的，所以需要加入一个唯一条件unique="true",这样就可以此字段唯一了。-->
<many-to-one name="idCard" unique="true"/>
</class>
</hibernate-mapping>
注意：这里的<many-to-one>标签中的name属性值并不是数据库中的字段名，而是Person实体类中引用IdCard对象成员属性的getxxx方法后面的xxx(此处是getIdCard，所以是idCard)，要求第一个字段小写。如果不指定column属性，则数据库中的字段名同name值
6、 annotateon注解映射
注意IdCard是被引用对象，除正常注解，无需要其它注解
/**身份证*/
@Entity
public class IdCard {
private int id;
private String cardNo;
@Id
@GeneratedValue
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getCardNo(){return cardNo;}
public void setCardNo(StringcardNo) {this.cardNo = cardNo;}
}
而引用对象的实体类需要使用@OneToOne进行注解，来表面是一对一的关系
再使用@JoinColumn注解来为数据库表中这个外键指定个字段名称就可以了。如果省略@JoinColumn注解，则hibernate会自动为其生成一个字段名(好像是：被引用对象名称_被引用对象的主键ID)
/** 人－实体类 */
@Entity
public class Person {
private int id;
private IdCard idCard;//引用IdCard对象
private String name;
@Id
@GeneratedValue
public int getId() {return id;}
@OneToOne//表示一对一的关系
@JoinColumn(name="idCard")//为数据中的外键指定个名称
public IdCard getIdCard(){ return idCard;}
public String getName() {return name;}
public void setId(int id) {this.id = id;}
public void setIdCard(IdCardidCard) {this.idCard = idCard;}
public void setName(Stringname) {this.name = name;}
}
7、 生成的SQL语句：
create tableIdCard (
id integernot null auto_increment,
cardNo varchar(255),
primary key(id)
)
create tablePerson (
id integernot null auto_increment,
namevarchar(255),
idCardinteger,//新添加的外键
primary key(id)
)
alter tablePerson
add indexFK8E488775BE010483 (idCard),
addconstraint FK8E488775BE010483
foreign key(idCard) //外键
referencesIdCard (id)//引用IdCard的id字段
8、 存储测试
Session session = sf.getCurrentSession();
IdCard idCard = new IdCard();
("88888888888888888888888");
();
// 如果先不保存idCard，则出抛出Transient异常，因为idCard不是持久化状态。
(idCard);
Person person = new Person();
("菜10");
(idCard);
(person);
().commit();
(二) 唯一外键关联-双向
1、 说明：
人<—-> 身份证号(Person<->IdCard)双向：互相持有对方的引用
2、 对象模型：
3、 关系模型：
关系模型没有任务变化，同单向
4、 实体类：
实体类，只是相互持有对象的引用，并且要求getter和setter方法
5、 xml映射
Person实体类映射文件：同单向的没有变化
IdCard实体类映射文件：如果使用同样的方法映射，这样就会在表中也添加一个外键指向对象，但对象已经有一个外键指向自己了，这样就造成了庸字段，因为不需要在表另外添加字段，而是让hibernate在加载这个对象时，会根据对象的ID到对方的表中查询外键等于这个ID的记录，这样就把对象加载上来了。也同样需要使用<one-to-one>标签来映射，但是需要使用property-ref属性来指定对象持有你自己的引用的成员属性名称(是gettxxxx后面的名称)，这样在生成数据库表时，就不会再添加一个多于的字段了。数据加载时hibernate会根据这些配置自己加载数据
<class name="com." table="idcard">
<id name="id" column="id">
<generator class="native"/></id>
<property name="cardNo"/>
<!--<one-to-one>标签：告诉hibernate如何加载其关联对象
property-ref属性：是根据哪个字段进行比较加载数据 -->
<one-to-one name="person" property-ref="idCard"/>
</class>
一对一 唯一外键 关联映射 双向 需要在另一端(当前IdCard)，添加<one-to-one>标签，指示hibernate如何加载其关联对象(或引用对象)，默认根据主键加载(加载person),外键关联映射中，因为两个实体采用的是person的外键来维护的关系，所以不能指定主键加载person,而要根据person的外键加载，所以采用如下映射方式：
<!--<one-to-one>标签：告诉hibernate如何加载其关联对象
property-ref属性：是根据哪个字段进行比较加载数据 -->
<one-to-one name="person" property-ref="idCard"/>
6、 annotateon注解映射
Person注解映射同单向一样
IdCard注解映射如下：使用@OneToOne注解来一对一，但这样会在表中多加一个字段，因为需要使用对象的外键来加载数据，所以使用属性mappedBy属性在实现这个功能
@Entity
public class IdCard {
private int id;
private String cardNo;
private Person person;
//mappedBy：在指定当前对象在被Person对象的idCard做了映射了
//此值：当前对象持有引用对象中引用当前对象的成员属性名称(getXXX后的名称)
//因为Person对象的持有IdCard对象的方法是getIdCard()因为需要小写,所以为idCard
@OneToOne(mappedBy="idCard")
public Person getPerson(){return person;}
public void setPerson(Person person){this.person = person;}
@Id
@GeneratedValue
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getCardNo(){return cardNo;}
public void setCardNo(StringcardNo) {this.cardNo = cardNo;}
}
7、 生成SQL语句
因为关系模型没有变化，也就是数据库的结构没有变化，只是在数据加载时需要相互加载对方，这由hibernate来完成。因为生成的sql语句同单向一样。
8、 存储测试
存储同单向一样
9、 总结：
规律：凡是双向关联，必设mappedBy
(三) 主键关联-单向(不重要)
主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
1、 说明：
人—-> 身份证号(PersonàIdCard)，从IdCard看不到Person对象
2、 对象模型
站在人的角度来看，对象模型与唯一外键关联一个，只是关系模型不同
3、 关系模型
因为是person引用idcard，所以idcard要求先有值。而person的主键值不是自己生成的。而是参考idcard的值，person表中即是主键，同时也是外键
4、 实体类：
实体类同 一对一 唯一外键关联的实体类一个，在person对象中持有idcard对象的引用(代码见唯一外键关系)
5、 xml映射
IdCard映射文件，先生成ID
<class name="com." table="t_idcard">
<id name="id"column="id">
<generator class="native"/>
</id>
<property name="cardNo"/>
</class>
Person实体类映射文件，ID是根据IdCard主键值
<class name="com."table="t_person">
<id name="id"column="id">
<!--因为主键不是自己生成的，而是作为一个外键(来源于其它值)，所以使用foreign生成策略
foreign:使用另外一个相关联的对象的标识符，通常和<one-to-one>联合起来使用。再使用元素<param>的属性值指定相关联对象(这里Person相关联的对象为idCard,则标识符为idCard的id)为了能够在加载person数据同时加载IdCard数据，所以需要使用一个标签<one-to-one>来设置这个功能。 -->
<generator class="foreign">
<!-- 元素<param>属性name的值是固定为property -->
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<!-- <one-to-one>标签
表示如何加载它的引用对象(这里引用对象就指idCard这里的name值是idCard)，同时也说是一对一的关系。 默认方式是根据主键加载(把person中的主键取出再到IdCard中来取相关IdCard数据。) 我们也说过此主键也作为一个外键引用 了IdCard，所以需要加一个数据库限制(外键约束)constrained="true" -->
<one-to-one name="idCard"constrained="true"/>
6、 annotateon注解映射
Person实体类注解
方法：只需要使用@OneToOne注解一对一关系，再使用@PrimaryKeyJoinColumn来注解主键关系映射。
@Entity
public class Person {
private int id;
private IdCard idCard;//引用IdCard对象
private String name;
@Id
public int getId() {return id;}
@OneToOne//表示一对一的关系
@PrimaryKeyJoinColumn//注解主键关联映射
public IdCard getIdCard(){ return idCard;}
public String getName() {return name;}
public void setId(int id) {this.id = id;}
public void setIdCard(IdCard idCard){this.idCard = idCard;}
public void setName(Stringname) {this.name = name;}
}
IdCard实体类，不需要持有对象的引用，正常注解就可以了。
7、 生成SQL语句
生成的两个表并没有多余的字段，因为是通过主键在关键的
create tableIdCard (
id integernot null auto_increment,
cardNovarchar(255),
primary key (id)
)
create tablePerson (
id integernot null,
namevarchar(255),
primary key(id)
)
alter table person
add index FK785BED805248EF3 (id),
add constraint FK785BED805248EF3
foreign key (id) references idcard (id)
注意：annotation注解后，并没有映射出外键关键的关联，而xml可以映射，是主键关联不重要
8、 存储测试
session = HibernateUtils.getSession();
tx = ();
IdCard idCard = new IdCard();
("88888888888888888888888");
Person person = new Person();
("菜10");
(idCard);
//不会出现TransientObjectException异常
//因为一对一主键关键映射中，默认了cascade属性。
(person);
();
9、 总结
让两个实体对象的ID保持相同，这样可以避免多余的字段被创建
<id name="id"column="id">
<!—person的主键来源idcard，也就是共享idCard的主键-->
<generator class="foreign">
<param name="property">idCard</param>
</generator>
</id>
<property name="name"/>
<!—one-to-one标签的含义：指示hibernate怎么加载它的关联对象，默认根据主键加载
constrained="true"，表面当前主键上存在一个约束：person的主键作为外键参照了idCard-->
<one-to-one name="idCard" constrained="true"/>
(四) 主键关联-双向(不重要)
主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
主键关联映射，实际是数据库的存储结构并没有变化，只是要求双方都可以持有对象引用，也就是说实体模型变化，实体类都相互持有对方引用。
另外映射文件也变化了。
1、 xml映射
Person实体类映射文件不变，
IdCard如下：
<class name="com." table="t_idcard">
<id name="id" column="id">
<generator class="native"/> </id>
<property name="cardNo"/>
<!—one-to-one标签的含义：指示hibernate怎么加载它的关联对象(这里的关联对象为person)，默认根据主键加载-->
<one-to-one name="person"/>
</class>
2、 annotateon注解映射：
Person的注解不变，同主键单向注解
IdCard注解，只需要在持有对象引用的getXXX前加上
@OneToOne(mappedBy="idCard") 如下：
@Entity
public class IdCard {
private int id;
private String cardNo;
private Person person;
@OneToOne(mappedBy="idCard")
public Person getPerson(){
return person;
}}
(五) 联合主键关联(Annotation方式)
实现上联合主键的原理同唯一外键关联-单向一样，只是使用的是@JoinColumns，而不是@JoinColumn，实体类注解如下：
@OneToOne
@JoinColumns(
{
@JoinColumn(name="wifeId", referencedColumnName="id"),
@JoinColumn(name="wifeName", referencedColumnName="name")
}
)
public WifegetWife() {
return wife;
}
注意：@oinColumns注解联合主键一对一联系，然后再使用@JoinColumn来注解当前表中的外键字段名，并指定关联哪个字段，使用referencedColumnName指定哪个字段的名称
二、 component（组件）关联映射
(一) Component关联映射：
目前有两个类如下：
大家发现用户与员工存在很多相同的字段，但是两者有不可以是同一个类中，这样在实体类中每次都要输入很多信息，现在把联系信息抽取出来成为一个类，然后在用户、员工对象中引用就可以，如下：
值对象没有标识，而实体对象具有标识，值对象属于某一个实体，使用它重复使用率提升，而且更清析。
以上关系的映射称为component（组件）关联映射
在hibernate中，component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid,component可以成为是值对象（DDD）。
采用component映射的好处:它实现了对象模型的细粒度划分，层次会更加分明，复用率会更高。
(二) User实体类：
public class User {
private int id;
private String name;
private Contact contact;//值对象的引用
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getName() { return name;}
public void setName(Stringname) { this.name = name;}
public ContactgetContact() { return contact;}
public void setContact(Contactcontact) { this.contact = contact;}
}
(三) Contact值对象：
public class Contact {
private String email;
private String address;
private String zipCode;
private String contactTel;
public String getEmail(){ return email;}
public void setEmail(Stringemail) { this.email = email; }
public StringgetAddress() {return address;}
public void setAddress(Stringaddress) {this.address = address;}
public StringgetZipCode() {return zipCode;}
public void setZipCode(StringzipCode) {this.zipCode = zipCode;}
public StringgetContactTel() { return contactTel;}
public voidsetContactTel(String contactTel){this.contactTel = contactTel;}
}
(四) xml--User映射文件(组件映射)：
<hibernate-mapping>
<class name="com." table="t_user">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<!-- <component>标签用于映射Component(组件)关系
其内部属性正常映射。
-->
<component name="contact">
<property name="email"/>
<property name="address"/>
<property name="zipCode"/>
<property name="contactTel"/>
</component>
</class>
</hibernate-mapping>
(五) annotateon注解
使用@Embedded用于注解组件映射，表示嵌入对象的映射
@Entity
public class User {
private int id;
private String name;
private Contact contact;//值对象的引用
@Id
@GeneratedValue
public int getId() { return id;}
@Embedded//用于注解组件映射，表示嵌入对象的映射
public ContactgetContact() {return contact;}
public void setContact(Contactcontact) {this.contact = contact;}
Contact类是值对象，不是实体对象，是属于实体类的某一部分，因此没有映射文件
(六) 导出数据库输出SQL语句：
create table User (
id integer not null auto_increment,
address varchar(255),
contactTel varchar(255),
email varchar(255),
zipCode varchar(255),
name varchar(255),
primary key (id)
)
(七) 数据表结构：
注：虽然实体类没有基本联系信息，只是有一个引用，但在映射数据库时全部都映射进来了。以后值对象可以重复使用，只要在相应的实体类中加入一个引用即可。
(八) 组件映射数据保存：
session =HibernateUtils.getSession();
tx =();
User user= new User();
("10");
Contactcontact = new Contact();
("wjt276");
("aksdfj");
("230051");
("3464661");
(contact);
(user);
();
实体类中引用值对象时，不用先保存值对象，因为它不是实体类，它只是一个附属类,而()中保存的对象是实体类。
三、 多对一 –单向
场景：用户和组；从用户角度来，多个用户属于一个组(多对一 关联)
使用hibernate开发的思路：先建立对象模型(领域模型)，把实体抽取出来。
目前两个实体：用户和组两个实体，多个用户属于一个组，那么一个用户都会对应于一个组，所以用户实体中应该有一个持有组的引用。
(一) 对象模型图：
(二) 关系模型：
(三) 关联映射的本质：
将关联关系映射到数据库，所谓的关联关系是对象模型在内存中一个或多个引用。
(四) 实体类
User实体类：
public class User {
private int id;
private String name;
private Group group;
public Group getGroup() {return group; }
public void setGroup(Group group) {this.group = group;}
public int getId() {return id; }
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) { this.name = name;}}
Group实体类：
public class Group {
private int id;
private String name;
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
}
实体类建立完后，开始创建映射文件，先建立简单的映射文件：
(五) xml方式：映射文件：
1、 Group实体类的映射文件：
<hibernate-mapping>
<class name="com." table="t_group">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
2、 User实体类的映射文件：
<hibernate-mapping>
<class name="com." table="t_user">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name"/>
<!--<many-to-one> 关联映射 多对一的关系
name:是维护的属性(),这样表示在多的一端表里加入一个字段名称为group,
但group与SQL中的关键字重复，所以需要重新命名字段(column="groupid").这样这个字段(groupid)会作为外键参照数据库中group表(t_group也叫一的一端)，也就是就在多的一 端加入一个外键指向一的一端。 -->
<many-to-one name="group" column="groupid"/>
</class>
</hibernate-mapping>
3、 ※<many-to-one>标签※：
例如：<many-to-one name="group" column="groupid"/>
<many-to-one> 关联映射 多对一的关系
name:是维护的属性(),这样表示在多的一端表里加入一个字段名称为group,但group与SQL中的关键字重复，所以需要重新命名字段(column="groupid").这样这个字段(groupid)会作为外键参照数据库中group表(t_group也叫一的一端)，也就是就在多的一端加入一个外键指向一的一端。
这样导出至数据库会生成下列语句：
alter table t_user drop foreign keyFKCB63CCB695B3B5AC
drop table if exists t_group
drop table if exists t_user
create table t_group (id integer not nullauto_increment, name varchar(255), primary key (id))
create table t_user (id integer not nullauto_increment, name varchar(255), groupid integer,primary key (id))
alter table t_user add index FKCB63CCB695B3B5AC (groupid), add constraint FKCB63CCB695B3B5AC foreign key (groupid) referencest_group (id)
(六) annotation
Group(一的一端)注解只需要正常的注解就可以了，因为在实体类中它是被引用的。
User*(多的一端)：@ManyToOne来注解多一对的关键，并且用@JoinColumn来指定外键的字段名
@Entity
public class User {
private int id;
private String name;
private Group group;
@ManyToOne
@JoinColumn(name="groupId")
public Group getGroup() {
return group;
}
(七) 多对一 存储(先存储group(对象持久化状态后，再保存user))：
session = HibernateUtils.getSession();
tx =();
Groupgroup = new Group();
("wjt276");
(group); //存储Group对象。
Useruser1 = new User();
("菜10");
(group);//设置用户所属的组
Useruser2 = new User();
("容祖儿");
(group);//设置用户所属的组
//开始存储
(user1);//存储用户
(user2);
();//提交事务
执行后hibernate执行以下SQL语句：
Hibernate: insert into t_group (name) values (?)
Hibernate: insert into t_user (name, groupid) values (?, ?)
Hibernate: insert into t_user (name, groupid) values (?, ?)
注意：如果上面的(group)不执行，则存储不存储不成功。则抛出TransientObjectException异常。
因为Group为Transient状，Object的id没有分配值。2610644
结果：persistent状态的对象是不能引用Transient状态的对象
以上代码操作，必须首先保存group对象，再保存user对象。我们可以利用cascade(级联)方式，不需要先保存group对象。而是直接保存user对象，这样就可以在存储user之前先把group存储了。
利用cascade属性是解决TransientObjectException异常的一种手段。
(八) 重要属性-cascade(级联)：
级联的意思是指定两个对象之间的操作联运关系，对一个 对象执行了操作之后，对其指定的级联对象也需要执行相同的操作，取值：all、none、save_update、delete
1、 all：代码在所有的情况下都执行级联操作
2、 none:在所有情况下都不执行级联操作
3、 save-update：在保存和更新的时候执行级联操作
4、 delete：在删除的时候执行级联操作。
1、 xml
例如：<many-to-one name="group"column="groupid" cascade="save-update"/>
2、 annotation
cascade属性：其值： 所有
save+ update
例如：
@ManyToMany(cascade={})
注意：cascade只是帮我们省了编程的麻烦而已，不要把它的作用看的太大
(九) 多对一 加载数据
代码如下：
session = HibernateUtils.getSession();
tx =();
Useruser = (User)(User.class, 3);
System.out.println("=" + ());
System.out.println("=" + ().getName());
//提交事务
();
执行后向SQL发出以下语句：
Hibernate: select user0_.id as id0_0_,user0_.name as name0_0_, user0_.groupid as groupid0_0_ from t_user user0_ whereuser0_.id=?
Hibernate: select group0_.id as id1_0_,group0_.name as name1_0_ from t_group group0_ where group0_.id=?
可以加载Group信息：因为采用了<many-to-one>这个标签，这个标签会在多的一端(User)加一个外键，指向一的一端(Group)，也就是它维护了从多到一的这种关系，多指向一的关系。当你加载多一端的数据时，它就能把一的这一端数据加载上来。当加载User对象后hibernate会根据User对象中的groupid再来加载Group信息给User对象中的group属性。
四、 一对多 - 单向
在对象模型中，一对多的关联关系，使用集合来表示。
实例场景：班级对学生；Classes(班级)和Student(学生)之间是一对多的关系。
(一) 对象模型：
(二) 关系模型：
一对多关联映射利用了多对一关联映射原理。
(三) 多对一、一对多的区别：
多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一的。
一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多的。
两者使用的策略是一样的，只是各自所站的角度不同。
(四) 实体类
Classes实体类：
public class Classes {
private int id;
private String name;
//一对多通常使用Set来映射，Set是不可重复内容。
//注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，
private Set<Student>students = new HashSet<Student>();
public int getId() {return id; }
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
}
Student实体类：
public class Student {
private int id;
private String name;
public int getId() {return id;}
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) { this.name = name;}
}
(五) xml方式：映射
1、 Student映射文件：
<hibernate-mapping>
<class name="com." table="t_student">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
</class>
</hibernate-mapping>
2、 Classes映射文件：
<hibernate-mapping>
<class name="com." table="t_classess">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<!--<set>标签 映射一对多(映射set集合),name="属性集合名称"，然后在用<key>标签，在多的一端加入一个外键(column属性指定列名称)指向一的一端，再采用<one-to-many>标签说明一对多，还指定<set>标签中name="students"这个集合中的类型要使用完整的类路径(例如：class="com.") -->
<set name="students">
<key column="classesid"/>
<one-to-many class="com."/>
</set>
</class>
</hibernate-mapping>
(六) annotateon注解
一对多 多的一端只需要正常注解就可以了。
需要在一的一端进行注解一对多的关系。
使用@OneToMany
@Entity
public class Classes {
private int id;
private String name;
// 一对多通常使用Set来映射，Set是不可重复内容。
// 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，
private Set<Student>students = new HashSet<Student>();
@OneToMany//进行注解为一对多的关系
@JoinColumn(name="classesId")//在多的一端注解一个字段(名为classessid)
public Set<Student>getStudents() {
return students;
}
(七) 导出至数据库(hbmàddl)生成的SQL语句：
create table t_classes (id integer not null auto_increment, namevarchar(255), primary key (id))
create table t_student (id integer not null auto_increment, namevarchar(255), classesid integer, primary key (id))
alter table t_student add index FK4B90757070CFE27A (classesid), add constraint FK4B90757070CFE27A foreign key (classesid) referencest_classes (id)
(八) 一对多 单向存储实例：
session = HibernateUtils.getSession();
tx =();
Studentstudent1 = new Student();
("10");
(student1);//必需先存储，否则在保存classess时出错.
Studentstudent2 = new Student();
("祖儿");
(student2);//必需先存储，否则在保存classess时出错.
Set<Student>students = new HashSet<Student>();
(student1);
(student2);
Classesclasses = new Classes();
("wjt276");
(students);
(classes);
();
(九) 生成的SQL语句：
Hibernate: insert into t_student (name) values (?)
Hibernate: insert into t_student (name) values (?)
Hibernate: insert into t_classes (name) values (?)
Hibernate: update t_student set classesid=? where id=?
Hibernate: update t_student set classesid=? where id=?
(十) 一对多，在一的一端维护关系的缺点：
因为是在一的一端维护关系，这样会发出多余的更新语句，这样在批量数据时，效率不高。
还有一个，当在多的一端的那个外键设置为非空时，则在添加多的一端数据时会发生错误，数据存储不成功。
(十一) 一对多 单向数据加载：
session = HibernateUtils.getSession();
tx =();
Classesclasses = (Classes)(Classes.class, 2);
System.out.println("=" + ());
Set<Student> students = ();
for(Iterator<Student> iter = ();();){
Studentstudent = ();
System.out.println(());
}
();
(十二) 加载生成SQL语句：
Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ fromt_classes classes0_ where classes0_.id=?
Hibernate: select students0_.classesid as classesid1_, students0_.id asid1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_studentstudents0_ where students0_.classesid=?
五、 一对多 - 双向
是加载学生时，能够把班级加载上来。当然加载班级也可以把学生加载上来
1、 在学生对象模型中，要持有班级的引用,并修改学生映射文件就可以了。。
2、 存储没有变化
3、 关系模型也没有变化
(一) xml方式：映射
学生映射文件修改后的：
<class name="com." table="t_student">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<!--使用多对一标签映射 一对多双向，下列的column值必需与多的一端的key字段值一样。-->
<many-to-one name="classes" column="classesid"/>
</class>
如果在一对多的映射关系中采用一的一端来维护关系的话会存在以下两个缺点：①如果多的一端那个外键设置为非空时，则多的一端就存不进数据；②会发出多于的Update语句，这样会影响效率。所以常用对于一对多的映射关系我们在多的一端维护关系，并让多的一端维护关系失效(见下面属性)。
代码：
<class name="com." table="t_classes">
<id name="id"column="id">
<generator class="native"/>
</id>
<property name="name"column="name"/>
<!--
<set>标签 映射一对多(映射set集合),name="属性集合名称"
然后在用<key>标签，在多的一端加入一个外键(column属性指定列名称)指向一的一端
再采用<one-to-many>标签说明一对多，还指定<set>标签中name="students"这个集合中的类型
要使用完整的类路径(例如：class="com.")
inverse="false":一的一端维护关系失效(反转) ：false：可以从一的一端维护关系(默认)；true：从一的一端维护关系失效，这样如果在一的一端维护关系则不会发出Update语句。 -->
<set name="students"inverse="true">
<key column="classesid"/>
<one-to-many class="com."/>
</set>
</class>
(二) annotateon方式注解
首先需要在多的一端持有一的一端的引用
因为一对多的双向关联，就是多对一的关系，我们一般在多的一端来维护关系，这样我们需要在多的一端实体类进行映射多对一，并且设置一个字段，而在一的一端只需要进行映射一对多的关系就可以了，如下：
多的一端
@Entity
public class Student {
private int id;
private String name;
private Classes classes;
@ManyToOne
@JoinColumn(name="classesId")
public ClassesgetClasses() {
return classes;
}
一的一端
@Entity
public class Classes {
private int id;
private String name;
// 一对多通常使用Set来映射，Set是不可重复内容。
// 注意使用Set这个接口，不要使用HashSet,因为hibernate有延迟加载，
private Set<Student>students = new HashSet<Student>();
@OneToMany(mappedBy="classes")//进行注解为一对多的关系
public Set<Student>getStudents() {
return students;}
(三) 数据保存：
一对多 数据保存，从多的一端进行保存：
session = HibernateUtils.getSession();
tx =();
Classesclasses = new Classes();
("wjt168");
(classes);
Studentstudent1 = new Student();
("10");
(classes);
(student1);
Studentstudent2 = new Student();
("祖儿");
(classes);
(student2);
//提交事务
();
注意：一对多，从多的一端保存数据比从一的一端保存数据要快，因为从一的一端保存数据时，会多更新多的一端的一个外键(是指定一的一端的。)
(四) 关于inverse属性：
inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，默认inverse为false，所以我们可以从一的一端和多的一端维护关联关系，如果设置inverse为true，则我们只能从多的一端维护关联关系。
注意：inverse属性，只影响数据的存储，也就是持久化
(五) Inverse和cascade区别：
Inverse是关联关系的控制方向
Casecade操作上的连锁反应
(六) 一对多双向关联映射总结：
在一的一端的集合上使用<key>，在对方表中加入一个外键指向一的一端
在多的一端采用<many-to-one>
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误
如果在一的一端维护一对多的关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关系。
六、 多对多 - 单向
Ø 一般的设计中，多对多关联映射，需要一个中间表
Ø Hibernate会自动生成中间表
Ø Hibernate使用many-to-many标签来表示多对多的关联
Ø 多对多的关联映射，在实体类中，跟一对多一样，也是用集合来表示的。
(一) 实例场景：
用户与他的角色(一个用户拥有多个角色，一个角色还可以属于多个用户)
(二) 对象模型：
(三) 关系模型：
(四) 实体类
Role实体类：
public class Role {
private int id;
private String name;
public int getId() return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) { this.name = name;}}
User实体类：
public class User {
private int id;
private String name;
private Set<User> roles = newHashSet<User>();// Role对象的集合
public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
public Set<User>getRoles() {return roles;}
public voidsetRoles(Set<User> roles) {this.roles = roles; }
(五) xml方式：映射
Role映射文件：
<class name="com." table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
</class>
User映射文件：
<class name="com." table="t_user">
<id name="id"column="id">
<generator class="native"/>
</id>
<property name="name"/>
<!--使用<set>标签映射集合(set)，标签中的name值为对象属性名(集合roles)，而使用table属性是用于生成第三方表名称，例：table="t_user_role"，但是第三方面中的字段是自动加入的，作为外键分别指向其它表。
所以表<key>标签设置，例：<key column="userid"/>，意思是：在第三方表(t_user_role)中加入一个外键并且指向当前的映射实体类所对应的表(t_user).使用<many-to-many>来指定此映射集合所对象的类(实例类)，并且使用column属性加入一个外键指向Role实体类所对应的表(t_role) -->
<setname="roles" table="t_user_role">
<key column="userid"/>
<many-to-many class="com." column="roleid"/>
</set>
</class>
(六) annotation注解方式
注意：因为是多对多单向(当然用户拥有多个角色，一个角色也可属性多个用户，但这里角色看不到用户)，所以角色只需要正常注解就可以了，
现在要使用@ManyToMany来注解多对多的关系，并使用@JoinTabel来注解第三方表的名称，再使用joinColumns属性来指定当前对象在第三方表中的字段名，并且这个字段会指向当前类相对应的表，最后再用inverseJoinColumns来指定当前类持有引用的实体类在第三方表中的字段名，并且指向被引用对象相对应的表，如下：
@Entity
public class User {
private int id;
private String name;
private Set<User> roles = new HashSet<User>();// Role对象的集合 @Id
@GeneratedValue
public int getId() {return id;}
@ManyToMany
@JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称
joinColumns={@JoinColumn(name="userId")},
//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象
inverseJoinColumns={@JoinColumn(name="roleId")}
//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表
)
public Set<User> getRoles() {return roles;}
(七) 生成SQL语句
create table t_role (id integer not null auto_increment, namevarchar(255), primary key (id))
create table t_user (id integer not null auto_increment, namevarchar(255), primary key (id))
create table t_user_role (userid integer not null, roleid integer notnull, primary key (userid, roleid))
alter table t_user_role add index FK331DEE5F1FB4B2D4 (roleid), add constraint FK331DEE5F1FB4B2D4 foreign key (roleid) referencest_role (id)
alter table t_user_role add index FK331DEE5F250A083E(userid), add constraint FK331DEE5F250A083E foreign key (userid) referencest_user (id)
注：根据DDL语句可以看出第三方表的主键是一个复合主键(primary key (userid, roleid))，也就是说记录不可以有相同的数据。
(八) 数据库表及结构：
(九) 多对多关联映射 单向数据存储：
session = HibernateUtils.getSession();
tx =();
Role r1 = new Role();
("数据录入人员");
(r1);
Role r2 = new Role();
("商务主管");
(r2);
Role r3 = new Role();
("大区经理");
(r3);
User u1 = new User();
("10");
Set<Role>u1Roles = new HashSet<Role>();
(r1);
(r2);
(u1Roles);
User u2 = new User();
("祖儿");
Set<Role>u2Roles = new HashSet<Role>();
(r2);
(r3);
(u2Roles);
User u3 = new User();
("成龙");
Set<Role>u3Roles = new HashSet<Role>();
(r1);
(r2);
(r3);
(u3Roles);
(u1);
(u2);
(u3);
();
发出SQL语句：
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_role (name) values (?)
Hibernate: insert into t_user (name) values (?)
Hibernate: insert into t_user (name) values (?)
Hibernate: insert into t_user (name) values (?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
Hibernate: insert into t_user_role (userid, roleid)values (?, ?)
注：前三条SQL语句，添加Role记录，第三条到第六条添加User，最后7条SQL语句是在向第三方表(t_user_role)中添加多对多关系(User与Role关系)
(十) 多对多关联映射 单向数据加载：
session =HibernateUtils.getSession();
tx =();
User user =(User)(User.class, 1);
System.out.println("=" + ());
for(Iterator<Role> iter = ().iterator();();){
Rolerole = (Role) ();
System.out.println(());
}
();
生成SQL语句：
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_useruser0_ where user0_.id=?
=10
Hibernate: select roles0_.userid as userid1_, roles0_.roleid as roleid1_,role1_.id as id2_0_, role1_.name as name2_0_ from t_user_role roles0_ leftouter join t_role role1_ on roles0_.roleid=role1_.id where roles0_.userid=?
商务主管
数据录入人员
七、 多对多 - 双向
多对多关联映射 双向 两方都持有对象引用，修改对象模型,但数据的存储没有变化。
(一) xml方式：映射
再修改映射文件：
<class name="com." table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<!—order-by 属性是第三方表哪个字段进行排序-->
<set name="users" table="t_user_role"order-by="userid">
<key column="roleid"/>
<many-to-many class="com." column="userid"/>
</set> </class>
注：数据的存储与单向一样。但一般维护这个多对多关系，只需要使用一方，而使另一方维护关系失效。
总结：
<!— order-by 属性是第三方表哪个字段进行排序-->
<set name="users" table="t_user_role"order-by="userid">
<key column="roleid"/>
<many-to-many class="com." column="userid"/>
</set>
Ø table属性值必须和单向关联中的table属性值一致
Ø <key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致
Ø 在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致。
(二) annotation注解方式
多对多关联映射 双向 两方都持有对象引用，修改对象模型,但数据的存储没有变化
只需要修改注解映射就可以了。
User实体类注解没有变化和单向一样：
@Entity
public class User {
private int id;
private Set<User> roles = new HashSet<User>();// Role对象的集合 @Id
@GeneratedValue
public int getId() {return id;}
@ManyToMany
@JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称
joinColumns={@JoinColumn(name="userId")},//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象
inverseJoinColumns={@JoinColumn(name="roleId")}
//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表
)
public Set<User> getRoles() {return roles;}
Role实体类注解也非常的简单:使用@ManyToMany注解，并使用mappedBy属性指定引用对象持有自己的的属性名
@Entity
public class Role {
private int id;
private String name;
private Set<User> users = newHashSet<User>();
@Id
@GeneratedValue
public int getId() {return id; }
@ManyToMany(mappedBy="roles")
public Set<User>getUsers() {return users;}
public voidsetUsers(Set<User> users) {this.users = users; }
多对多关联映射 双向 数据加载
session =HibernateUtils.getSession();
tx =();
Role role= (Role)(Role.class, 1);
System.out.println("=" + ());
for(Iterator<User> iter = ().iterator();();){
Useruser = ();
System.out.println("=" + ());
}
();
生成SQL语句：
Hibernate: select role0_.id as id2_0_, role0_.name as name2_0_ from t_rolerole0_ where role0_.id=?
=数据录入人员
Hibernate: select users0_.roleid as roleid1_, users0_.userid as userid1_,user1_.id as id0_0_, user1_.name as name0_0_ from t_user_role users0_ leftouter join t_user user1_ on users0_.userid=user1_.id where users0_.roleid=?order by users0_.userid
=10
=成龙
八、 关联关系中的CRUD_Cascade_Fetch
1、 设定cascade可以设定在持久化时对于关联对象的操作(CUD，R归Fetch管)
2、 cascade仅仅是帮助我们省了编程的麻烦而已，不要把它的作用看的太大
a) cascade的属性指明做什么操作的时候关系对象是绑在一起的
b) refresh=A里面需要读B改过之后的数据
3、 铁律：双向关系在程序中要设定双向关联
4、 铁律：双向一定需要设置mappedBy
5、 fetch
a) 铁律：双向不要两边设置Eager(会有多余的查询语句发出)
b) 对多方设置fetch的时候要谨慎，结合具体应用，一般用Lazy不用eager，特殊情况(多方数量不多的可以考虑，提高效率的时候可以考虑)
6、 O/RMapping编程模型
a) 映射模型
i. jpa annotation
ii. hibernate annotation extension
b) 编程接口
i. jpa
ii. hibernate
c) 数据查询语言
i. HQL
ii. EJBQL(JPQL)
7、 要想删除或者更新，先做load，除了精确知道ID之外
8、 如果想消除关联关系，先设定关系为null，再删除对应记录，如果不删记录，该记录就变成垃圾数据
九、 集合映射
1、 Set
2、 List
a) @OrderBy
注意:List与Set注解是一样的，就是把Set更改为List就可以了
private List<User>users = new ArrayList<User>();
@OneToMany(mappedBy="group",
cascade={CascadeType.ALL}
)
@OrderBy("name ASC")//使用@OrderBy注解List中使用哪个字段进行排序，可以组合排序，中间使用逗号分开
public List<User>getUsers() { return users;}
public voidsetUsers(List<User> users) {this.users = users;}
3、 Map
a) @Mapkey
注解：关联模型中并没有变化，只是注解发生了变化，而这个变化是给hibernate看的
Map在映射时，因为Key是唯一的，所以一般可以使用主键表示，然后在映射时使用@MapKey来注解使用哪个字段为key,如下：
private Map<Integer,User> users = new HashMap<Integer, User>();
@OneToMany(mappedBy="group", cascade=CascadeType.ALL)
@MapKey(name="id")//注解使用哪个字段为key
public Map<Integer,User> getUsers() { return users;}
public voidsetUsers(Map<Integer, User> users) {this.users = users;}
数据加载：
Session s = sessionFactory.getCurrentSession();
();
Group g =(Group)(Group.class, 1);
for(<Integer,User> entry : ().entrySet()) {
System.out.println(().getName());
}
().commit();
十、 继承关联映射
继承映射：就是把类的继承关系映射到数据库里(首先正确的存储，再正确的加载数据)
(一) 继承关联映射的分类：
Ø 单表继承：每棵类继承树使用一个表(table per class hierarchy)
Ø 具体表继承：每个子类一个表(table per subclass)
Ø 类表继承：每个具体类一个表(table per concrete class)(有一些限制)
Ø 实例环境：动物Animal有三个基本属性，然后有一个Pig继承了它并扩展了一个属性，还有一个Brid也继承了并且扩展了一个属性
(二) 对象模型：
(三) 单表继承SINGLE_TABLE：
每棵类继承树使用一个表
把所有的属性都要存储表中，目前至少需要5个字段，另外需要加入一个标识字段(表示哪个具体的子类)
t_animal
| Id |
Name |
Sex |
Weight |
Height |
Type |
| 1 |
猪猪 |
true |
100 |
|
P |
| 2 |
鸟鸟 |
false |
|
50 |
B |
其中：
①、id:表主键
②、name:动物的姓名，所有的动物都有
③、sex:动物的性别，所有的动物都有
④、weight:猪(Pig)的重量，只有猪才有，所以鸟鸟就没有重量数据
⑤、height：鸟(height)的调试，只有鸟才有，所以猪猪就没有高度数据
⑥、type:表示动物的类型；P表示猪；B表示鸟
1、 实体类
Animal实体类：
public class Animal {
private int id;
private String name;
private boolean sex;
public int getId() {return id; }
public void setId(int id) { this.id = id;}
public String getName() {return name;}
public void setName(Stringname) {this.name = name;}
public boolean isSex() {return sex;}
public void setSex(boolean sex) {this.sex = sex;}
}
Pig实体类：
public class Pig extends Animal {
private int weight;
public int getWeight() {return weight;}
public void setWeight(int weight) {this.weight = weight;}
}
Bird实体类：
public class Bird extends Animal {
private int height;
public int getHeight() {return height;}
public void setHeight(int height) {this.height = height;}
}
2、 xml方式：映射
<class name="Animal" table="t_animal"lazy="false">
<id name="id">
<generator class="native"/>
</id>
<discriminator column="type" type="string"/>
<property name="name"/>
<property name="sex"/>
<subclass name="Pig" discriminator-value="P">
<property name="weight"/>
</subclass>
<subclass name="Bird" discriminator-value="B">
<property name="height"/>
</subclass>
</class>
1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。
2、理解如何存储
存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值
正确的加载对象
多态查询：在hibernate加载数据的时候能鉴别出正真的类型（instanceOf）
get支持多态查询
load只有在lazy=false，才支持多态查询
hql支持多态查询
3、 annotation注解
父类中注解如下：
使用@Inheritance注解为继承映射，再使用strategy属性来指定继承映射的方式
strategy有三个值：InheritanceType.SINGLE_TABLE 单表继承
InheritanceType.TABLE_PER_CLASS 类表继承
InheritanceType.JOINED 具体表继承
再使用@DiscriminatorColumn注意标识字段的字段名，及字段类型
在类中使用@DiscriminatorValue来注解标识字段的值
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name="discriminator",
discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("person")
public class Person {private int id;private String name;
@Id
@GeneratedValue
public int getId() {return id;}
继承类中注解如下：
只需要使用@DiscriminatorValue来注解标识字段的值
4、 导出后生成SQL语句：
create table t_animal (id integer not null auto_increment, typevarchar(255) not null, name varchar(255), sex bit, weight integer, heightinteger, primary key (id))
5、 数据库中表结构：
6、 单表继承数据存储：
session = HibernateUtils.getSession();
tx =();
Pig pig = new Pig();
("猪猪");
(true);
(100);
(pig);
Bird bird = new Bird();
("鸟鸟");
(false);
(50);
(bird);
();
存储执行输出SQL语句：
Hibernate: insert into t_animal (name, sex, weight, type) values (?, ?, ?,'P')//自动确定无height字段,并且设置标识符为P
Hibernate: insert into t_animal (name, sex, height, type) values (?, ?, ?,'B') //自动确定无weight字段,并且设置标识符为B
解释：hibernate会根据单表继承映射文件的配置内容，自动在插入数据时哪个子类需要插入哪些字段，并且自动插入标识符字符值（在映射文件中配置了）
7、 单表继承映射数据加载(指定加载子类)：
session =HibernateUtils.getSession();
tx =();
Pig pig =(Pig)(Pig.class, 1);
System.out.println("=" + ());
System.out.println("=" + ());
Bird bird =(Bird)(Bird.class, 2);
System.out.println("" + ());
System.out.println("=" + ());
();
8、 加载执行输出SQL语句：
Hibernate: select pig0_.id as id0_0_, pig0_.name as name0_0_, pig0_.sex assex0_0_, pig0_.weight as weight0_0_ from t_animal pig0_ where pig0_.id=? and pig0_.type='P'
//hibernate会根据映射文件自动确定哪些字段(虽然表中有height,但hibernate并不会加载)属于这个子类，并且确定标识符为B（已经在配置文件中设置了）
=猪猪
=100
Hibernate: select bird0_.id as id0_0_, bird0_.name as name0_0_, bird0_.sexas sex0_0_, bird0_.height as height0_0_ from t_animal bird0_ where bird0_.id=?and bird0_.type='B'
//hibernate会根据映射文件自动确定哪些字段虽然表中有weight,但hibernate并不会加载属于这个子类，并且确定标识符为B（已经在配置文件中设置了）
=鸟鸟
=50
9、 单表继承映射数据加载(指定加载父类)：
session = HibernateUtils.getSession();
tx =();
//不会发出SQL，返回一个代理类
Animal animal =(Animal)(Animal.class, 1);
//发出SQL语句，并且加载所有字段的数据(因为使用父类加载对象数据)
System.out.println("=" + ());
System.out.println("=" + ());
();
加载执行生成SQL语句：
Hibernate: select animal0_.id as id0_0_, animal0_.name as name0_0_,animal0_.sex as sex0_0_, animal0_.weight asweight0_0_, animal0_.height as height0_0_, animal0_.type as type0_0_ from t_animal animal0_ where animal0_.id=?
//注：因为使用父类加载数据，所以hibernate会将所有字段(height、weight、type)的数据全部加载，并且条件中没有识别字段type(也就不区分什么子类，把所有子类全部加载上来。)
10、 单表继承映射数据加载(指定加载父类，看能否鉴别真实对象)：
session = HibernateUtils.getSession();
tx =();
//不会发出SQL语句(load默认支持延迟加载(lazy))，返回一个animal的代理对象(此代理类是继承Animal生成的，也就是说是Animal一个子类)
Animal animal =(Animal)(Animal.class, 1);
//因为在上面返回的是一个代理类(父类的一个子类)，所以animal不是Pig
//通过instanceof是反应不出正直的对象类型的，因此load在默认情况下是不支持多态查询的。
if (animal instanceof Pig) {
System.out.println("是猪");
} else {
System.out.println("不是猪");//这就是结果
}
System.out.println("=" + ());
System.out.println("=" + ());
();
11、 多态查询：
在hibernate加载数据的时候能鉴别出正直的类型(通过instanceof)
get支持多态查询；load只有在lazy=false，才支持多态查询；HQL支持多态查询
12、 采用load，通过Animal查询，将<class>标签上的lazy设置为false
session = HibernateUtils.getSession();
tx = ();
//会发出SQL语句，因为设置lazy为false，不支持延迟加载
Animal animal =(Animal)(Animal.class, 1);
//可以正确的判断出Pig的类型，因为lazy=false，返回具体的Pid类型
//此时load支持多态查询
if (animal instanceof Pig) {
System.out.println("是猪");//结果
} else {
System.out.println("不是猪");
}
System.out.println("=" + ());
System.out.println("=" + ());
();
13、 采用get，通过Animal查询,可以判断出正直的类型
session = HibernateUtils.getSession();
tx = ();
//会发出SQL语句，因为get不支持延迟加载，返回的是正直的类型，
Animal animal =(Animal)(Animal.class, 1);
//可以判断出正直的类型
//get是支持多态查询
if (animal instanceof Pig) {
System.out.println("是猪");//结果
} else {
System.out.println("不是猪");
}
System.out.println("=" + ());
System.out.println("=" + ());
();
14、 采用HQL查询，HQL是否支持多态查询
List animalList = ("from Animal").list();
for (Iteratoriter = (); ();) {
Animal a = (Animal)();
//能够正确鉴别出正直的类型，HQL是支持多态查询的。
if (a instanceof Pig) {
System.out.println("是Pig");
} else if (a instanceof Bird) {
System.out.println("是Bird");
}
}
15、 通过HQL查询表中所有的实体对象
* HQL语句：("").list();
* 因为所有对象都是继承Object类
List list = ("from ").list();
for (Iteratoriter = (); ();){
Object o =();
if (o instanceof Pig) {
System.out.println("是Pig");
} else {
System.out.println("是Bird");
}
}
(四) 具体表继承JOINED：
每个类映射成一个表(table per subclass)
对象模型不用变化，存储模型需要变化
1、 关系模型：
每个类映射成一个表(table per subclass)
注：因为需要每个类都映射成一张表，所以Animal也映射成一张表(t_animal),表中字段为实体类属性
而pig子类也需要映射成一张表(t_pid)，但为了与父类联系需要加入一个外键(pidid)指向父类映射成的表(t_animal),字段为子类的扩展属性。Bird子类同样也映射成一张表(t_bird),也加入一个外键(birdid)指向父类映射成的表(t_animal),字段为子类的扩展属性。
2、 xml方式（每个类映射成一个表）：
<class name="com." table="t_animal">
<id name="id"column="id"><!-- 映射主键 -->
<generator class="native"/>
</id>
<property name="name"/><!-- 映射普通属性 -->
<property name="sex"/>
<!--<joined-subclass>标签：继承映射 每个类映射成一个表 -->
<joined-subclass name="com." table="t_pig">
<!-- <key>标签：会在相应的表（当前映射的表）里，加入一个外键 , 参照指向当前类的父类(当前Class标签对象的表(t_animal))-->
<key column="pigid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="com." table="t_bird">
<key column="birdid"/>
<property name="height"/>
</joined-subclass>
</class>
1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，
这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，
有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。
如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。
3、 annotation注解
因为，子类生成的表需要引用父类生成的表，所以只需要在父类设置具体表继承映射就可以了，其它子类只需要使用@Entity注解就可以了
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class Person {
private int id;
private String name;
@Id
@GeneratedValue
public int getId() {return id;}
4、 导出输出SQL语句：
create table t_animal (id integer notnull auto_increment, name varchar(255), sex bit, primary key (id))
create table t_bird (birdid integernot null, height integer, primary key (birdid))
create table t_pig (pigid integer notnull, weight integer, primary key (pigid))
altertable t_bird add index FKCB5B05A4A554009D(birdid), add constraint FKCB5B05A4A554009D foreign key (birdid) referencest_animal (id)
alter table t_pig add index FK68F8743FE77AC32 (pigid), add constraint FK68F8743FE77AC32 foreign key (pigid) references t_animal (id)
//共生成三个表，并在子类表中各有一个外键参照指向父类表
数据的存储，不需要其它的任务变化，直接使用单表继承存储就可以了，加载也是一样。
具体表继承效率没有单表继承高，但是单表继承会出现多余的庸于字段，具体表层次分明
(五) 类表继承TABLE_PER_CLASS
每个具体类映射成一个表(table per concreteclass)(有一些限制)
对象模型不用变化，存储模型需要变化
1、 关系模型：
每个具体类(Pig、Brid)映射成一个表(table per concrete class)(有一些限制)
t_pig
| Id |
Name |
Sex |
Weight |
| 1 |
猪猪 |
True |
100 |
t_bird
| Id |
Name |
Sex |
Height |
| 2 |
鸟鸟 |
False |
50 |
2、 xml方式：映射文件：
<class name="com." table="t_animal">
<id name="id"column="id"><!-- 映射主键 -->
<generator class="assigned"/><!-- 每个具体类映射一个表主键生成策略不可使用native --> </id>
<property name="name"/><!-- 映射普通属性 -->
<property name="sex"/>
<!--使用<union-subclass>标签来映射"每个具体类映射成一张表"的映射关系
，实现上上面的表t_animal虽然映射到数据库中，但它没有任何作用。 -->
<union-subclass name="com." table="t_pig">
<property name="weight"/>
</union-subclass>
<union-subclass name="com." table="t_bird">
<property name="height"/>
</union-subclass>
</class>
理解如何映射
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，
即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，
joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
父类用普通<class>标签定义即可
子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
Union-subclass标签不再需要包含key标签（与joined-subclass不同）
Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，
定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，
但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所
有属性的映射字段。
注意：在保存对象的时候id是不能重复的（不能使用自增生成主键）
3、 annotation注解
只需要对父类进行注解就可以了，
因为子类表的ID是不可以重复，所以一般的主键生成策略已经不适应了，只有表主键生成策略。
首先使用@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)来注解继承映射，并且使用具体表继承方式，使用@TableGenerator来申明一个表主键生成策略
再在主键上@GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)来注解生成策略为表生成策略，并且指定表生成策略的名称
继承类只需要使用@Entity进行注解就可以了
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@TableGenerator(
name="t_gen",
table="t_gen_table",
pkColumnName="t_pk",
valueColumnName="t_value",
pkColumnValue="person_pk",
initialValue=1,
allocationSize=1
)
public class Person {
private int id;
private String name;
@Id
@GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)
public int getId() {return id;}
4、 导出输出SQL语句：
create table t_animal (id integer not null, name varchar(255), sex bit, primary key (id))
create table t_bird (id integer not null, name varchar(255), sex bit, height integer, primary key(id))
create table t_pig (id integer not null, name varchar(255), sex bit, weight integer, primary key(id))
注：表t_animal、 t_bird、t_pig并不是自增的，是因为bird、pig都是animal类，也就是说animal不可以有相同的ID号(Bird、Pig是类型，只是存储的位置不同而以)
5、 数据库表结构如下：
注：如果不想t_animal存在(因为它没有实际的作用)，可以设置<class>标签中的abstract="true"(抽象表)，这样在导出至数据库时，就不会生成t_animal表了。
<class name="com." table="t_animal" abstract="true">
<id name="id"column="id"><!-- 映射主键 -->
…………
(六) 三种继承关联映射的区别：
1、 第一种：它把所有的数据都存入一个表中，优点：效率好（操作的就是一个表）；缺点：存在庸于字段，如果将庸于字段设置为非空，则就无法存入数据；
2、 第二种：层次分明，缺点：效率不好（表间存在关联表）
3、 第三种：主键字段不可以设置为自增主键生成策略。
一般使用第一种
第17课 hibernate树形结构(重点)
树形结构：也就是目录结构，有父目录、子目录、文件等信息，而在程序中树形结构只是称为节点。
一棵树有一个根节点，而根节点也有一个或多个子节点，而一个子节点有且仅有一个父节点(当前除根节点外)，而且也存在一个或多个子节点。
也就是说树形结构，重点就是节点，也就是我们需要关心的节点对象。
节点：一个节点有一个ID、一个名称、它所属的父节点(根节点无父节点或为null)，有一个或多的子节点等其它信息。
Hibernate将节点抽取出成实体类，节点相对于父节点是“多对一”映射关系，节点相对于子节点是“一对多”映射关系。
一、 节点实体类：
/** * 节点*/
public class Node {
private int id; //标识符
private String name; //节点名称
private int level; //层次，为了输出设计
private boolean leaf; //是否为叶子节点，这是为了效率设计，可有可无
//父节点：因为多个节点属于一个父节点，因此用hibernate映射关系说是“多对一”
private Node parent;
//子节点：因为一个节点有多个子节点，因此用hibernate映射关系说是“一对多”
private Set children;
public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getName() {return name;}
public void setName(Stringname) { this.name = name;}
public int getLevel() { return level;}
public void setLevel(int level) {this.level = level;}
public boolean isLeaf() {return leaf;}
public void setLeaf(boolean leaf) {this.leaf = leaf;}
public Node getParent() {return parent;}
public void setParent(Nodeparent) {this.parent = parent;}
public SetgetChildren() {return children;}
public void setChildren(Setchildren) {this.children = children;}}
二、 xml方式：映射文件：
<class name="com." table="t_node">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="level"/>
<property name="leaf"/>
<!— 一对多：加入一个外键，参照当前表t_node主键， 而属性parent类型为Node，也就是当前类，则会在同一个表中加入这个字段，参照这个表的主键-->
<many-to-one name="parent" column="pid"/>
<!--<set>标签是映射一对多的方式，加入一个外键，参照主键。-->
<set name="children" lazy="extra"inverse="true">
<key column="pid"/>
<one-to-many class="com."/>
</set>
</class>
三、 annotation注解
因为树型节点所有的数据，在数据库中只是存储在一个表中，而对于实体类来说，节点对子节点来说是一对多的关系，而对于父节点来说是多对一的关系。因此可以在一个实体类中注解。如下
@Entity
public class Node {
private int id; // 标识符
private String name; // 节点名称
private int level; // 层次，为了输出设计
private boolean leaf; // 是否为叶子节点，这是为了效率设计，可有可无
// 父节点：因为多个节点属于一个父节点，因此用hibernate映射关系说是“多对一”
private Node parent;
// 子节点：因为一个节点有多个子节点，因此用hibernate映射关系说是“一对多”
private Set<Node> children = newHashSet<Node>();
@Id
@GeneratedValue
public int getId() {return id;}
@OneToMany(mappedBy="parent")
public Set<Node>getChildren() {return children;}
@ManyToOne
@JoinColumn(name="pid")
public Node getParent() {return parent;}
四、 测试代码：
public class NodeTest extends TestCase {
//测试节点的存在
public void testSave1(){
NodeManage.getInstanse().createNode("F:\\hibernate\\hibernate_training_tree");
}
//测试节点的加载
public void testPrintById(){
NodeManage.getInstanse().printNodeById(1);
}}
五、 相应的类代码：
public classNodeManage {
private static NodeManage nodeManage= newNodeManage();
private NodeManage(){}//因为要使用单例，所以将其构造方法私有化
//向外提供一个接口
public static NodeManage getInstanse(){
return nodeManage;
}
/**
* 创建树
*@param filePath 需要创建树目录的根目录
*/
public void createNode(String dir) {
Session session = null;
try {
session =();
();
File root = new File(dir);
//因为第一个节点无父节点，因为是null
(root, session, null,0);
().commit();
} catch (HibernateException e) {
();
().rollback();
} finally {
(session);
}}
/**
* 保存节点对象至数据库
*@param file 节点所对应的文件
*@param session session
*@param parent 父节点
*@param level 级别
*/
public void saveNode(File file, Sessionsession, Node parent, int level) {
if (file == null ||!()){return;}
//如果是文件则返回true,则表示是叶子节点，否则为目录，非叶子节点
boolean isLeaf = ();
Node node = new Node();
(());
(isLeaf);
(level);
(parent);
(node);
//进行循环迭代子目录
File[] subFiles = ();
if (subFiles != null && > 0){
for (int i = 0; i < ; i++){
(subFiles[i],session, node, level + 1);
}}}
/**
* 输出树结构
*@param id
*/
public void printNodeById(int id) {
Session session = null;
try {
session =();
();
Node node =(Node)(, 1);
printNode(node);
().commit();
} catch (HibernateException e) {
();
().rollback();
} finally {
(session);
}
}
private void printNode(Node node) {
if (node == null){ return; }
int level = ();
if (level > 0){
for (int i = 0; i < level; i++){
(" |");
}
("--");
}
(() +(() ? "" : "[" + ().size() +"]"));
Set children = ();
for (Iterator iter =(); (); ){
Node child = (Node)();
printNode(child);
}}}