马士兵hibernate（原始笔记）

一对一关联

1
一对一单向外键关联

a)
项目名称：hibernate_0600_one2one_uni_fk

b)
Annotation: 在被约束表字段的get方法上加@0ne20ne @JoinColumn

@OneToOne

@JoinColumn(name="wifeid") //指定生成的数据库字段名

public Wife getWife() {

return wife;

}

c)
xml: 在被约束表的xml配置文件中加<many-to-one unique

<class name="com.bjsxt.pojo.StuIdCard">

<id name="id">

<generator class="native"></generator>

</id>

<property name="num"/>

<many-to-one name="student" column="studentId" unique="true">

</many-to-one>

</class>

unique="true"是保证生成的字段唯一,这样<many-to-one
也达到了一对一的效果

2
一对一双向外键关联

a)
项目名称：hibernate_0700_one2one_bi_fk^

b)
Annotation: @0ne20ne(mappedBy=”另一个类里定义的属性名”)

规律：凡是双向关联，必设mappedBy

在Wife类中 写Husband对象属性并添加注解@OneToOne(mappedBy="wife")
mappedBy作用

是指定这个一对一关联是被Husband类的 wife属性(准确说是getWife方法)做的映射

@OneToOne(mappedBy="wife")

public Husband getHusband() {

return husband;

}

在
类中写Wife对象属性

@OneToOne

@JoinColumn(name="wifeid") //指定生成的数据库字段名

public Wife getWife() {

return wife;

}

此注释将由Husband表中生成wifeid字段作为fk外键,wife表中不生成额外的Husbandid字段

c)
xml: many-to-one unique <one-to-one property-ref

在Student类中写StuIdCard属性, StuIdCard类中写Student属性

StuIdCard.hbm.xml文件中加

<many-to-one name="student" column="studentId" unique="true"></many-to-one>

Student.hbm.xml文件中加

<one-to-one name="stuIdCard" property-ref="student"></one-to-one>

其中, property-ref
相当于mappedBy

此方式生成的StuIdCard表中包含studentid字段作为fk外键,
Student表中不生成额外的字段

特别说明: 一对一单向外键关联与一对一双向外键关联在数据库的表的格式是一样的,区别在于

java程序中. 双向外键关联可通过Hibernate在两个类间互相调用彼此,而单向外键关联只能单方向调用.

3
一对一单向主键关联（不重要，忘记）

a)
项目名称：hibernate_0800_one2one_uni_pk

b)
@primaryKeyJoinColumn

c)
xml: <one-to-one id
使用 foreign class

4
一对一双向主键关联（不重要，忘记）

a)
项目名称：hibernate_0900_one2one_bi_pk

b)
@primaryKeyJoinColumn（不常用，了解）

c)
xml: <one-to-one id
使用foreign class和<one-to-one
property-ref

5
联合主键

a)
项目名称：hibernate_1000_one2one_uni_fk_composite

b)
@JoinColumns

Wife类中建立联合主键,建立方式参考 ID生成策略中的联合主键部分

Husband类中写Wife对象属性,并在其get方法上写@OneToOne即可完成一对一外键映射

若想要指定生成的外键名
则需使用@JoinColumns注解,如下:

@OneToOne

@JoinColumns( { @JoinColumn(name = "wifeid", referencedColumnName = "id"),

@JoinColumn(name = "wifename", referencedColumnName = "name") })

/*@JoinColumns用于在一对一外键关联存在联合主键情况时指定生成的外键字段名称

@JoinColumns的参数为@JoinColumn数组
@JoinColumn内除需指定name属性外还需指定

referencedColumnName属性值
作用是可指定生成的字段名所对应的目标表字段名*/

public Wife getWife() {……}

组件映射

1
项目：hibernate_1100_component

2
对象关系：一个对象是另外一个对象的一部分

3
数据库表：一张表

4
annotation: @ Embeddable @Embbeded

对象模型

Husband(id,name,wife)

Wife(name,age)

Annotation:

在Husband的wife属性上建立注解

@Embedded
表明该对象是从别的位置嵌入过来的,是不需要单独映射的表.

这种方式生成的表为husband(id,name,wifename,wifeage),不会生成wife表.

@Embedded

Public Wift getWife(){

}

@AttributeOverride注解需要写在getWife方法上,可以重新指定生成的Wife类组件生成的字段名,例如:Husband与Wife两个类中都有name字段,这样在生成表的时候会有冲突,此时采用@AttributeOverride注解可以指定Wife类中的name属性对应新的字段名—“wifename”,不过@AttributeOverride注解不常用,因为有更好的解决方法.
1：不要在组件的两个映射类中写同名属性；2：如果真的有重复，那么可以在分类中（此处为Wife类）的重复名称的属性上使用如下内容以指定新的字段名：

@Column(name="wifename")

public String getName() {

return name;

}

另外，@ Embeddable注解好像是写在分类（Wife类）的类名前的，不过好像不写也行

@Embeddable

public
class Wife {… …}

5
xml: 使用<component,例如:

<class name="Husband" >

<id name="id">

<generator class="native"/>

</id>

<property name="name"></property>

<component name="wife">

<property name="wifeName"/>

<property name="wifeAge"/>

</component>

</class>

多对一与一对多

1
多对一单向关联

a)
项目名称：hibernate_1200_many2one_uni

实体模型(User多对一Group)

User(id,name,group)多

Group(id,name)一

b)
数据库表设计：在多方加外键

错误做法：在一方加冗余

perosnid	person name	dreamid
1	zhangsan	1
1	zhangsan	2

dreamid	dreamdescr
1	earn money
2	eat a lot

c)
annotaion: @Many2One

只需要在多的一端User属性group进行注解配置

@ManyToOne //多对一关联
User是多的一方 Group是一的一方

@JoinColumn(name="groupid") //指定User表中生成与Group对应的字段名

public Group getGroup() {

return group;

}

d)
xml：
<many-to-one

<many-to-one name="group" column="groupId" />

标签会在”多”的一端添加外键,相当于在数据库中添加外键

生成的表为user(id,name,groupid),t_group(id,groupname)

属性cascade

<many-to-one name="group" column="groupid"
cascade="all" />

取值all,none,save-update,delete,对象间的级联操作,只对增删改起作用.

在存储时User时,设置了 cascade="all" 会自动存储相应的t_group.而不用管user关联的对象(通常情况下会优先存储关联的对象,然后再存储user).

2
一对多单向关联

a)
项目名称：hibernate_1300_one2many_uni

模型(group一对多user)

Group(id,name,users)一

User(id,name)多

设计时在一的这一端存在着多的集合,生成的数据库表通常是在多的一端生成外键.

Set<User> users
=
new HashSet<User>();

b)
类：在一的一方存在多方的集合

c)
数据库表同上

d)
Annotation:@One2Many

在一的这一端Group端users属性上进行注解配置

@OneToMany                //一对多关联
Group是一的一方 User是多的一方

@JoinColumn(name="groupid")
//指定User表中生成与Group对应的字段名
注意此处与多对一配置方式不同

public Set<User> getUsers(){       …….      }

Hibernate默认将OneToMany理解为ManyToMany的特殊形式，如果不指定生成的外键列@JoinColumn(name="groupId")，则会默认生成多对多的关系,产生一张中间表。

e)
xml:<set <one2many

XML配置中配置一的那一端Group

<class name="com.hibernate.Group" table="t_group">

<id name="id">

<generator class="native"/>

</id>

<property name="name"/>

<set name="users">

<key column="groupId"/>指定生成外键字段的名字

<one-to-many class="com.pojo.User"/>

</set>

</class>

3
一对多（多对一）双向关联

一对多与多对一的双向关联是同一种情况.

关系模型(group一对多user)

Group(id,name,users)一

User(id,name,group)多

Set<User> users=new HashSet<User>()

配置规则:一般以多的一端为主,先配置多的一端

在多的一端User端配置group

@ManyToOne

@JoinColumn(name="groupid")

在一的一端Group端配置时,在users只需要加个mappedBy="groupid"

@OneToMany(mappedBy="group")

XML配置

Group中

<set name="users">

<key column="groupId"/>

<one-to-many class="com.hibernate.User"/>

</set>

在User中

<many-to-one name="group" column="groupId"/>

务必确保在多的一端生成的生成的外键和一的一方生成的外键的名字相同,都为groupId.

如果名字不同则会在多的一端生成多余的外键

多对多

1
单向关联：

a)
项目：hibernate_1500_many2many_uni

关系模型(Teache多对多Student),从Teacher这一端能关联到students.

Teacher(id,name,students)多

Student(id,name)多

Set<Student> students=new HashSet<Student>()

在Teacher那一端配置

b)
例如：老师和学生的关系，老师需要知道自己教了哪些学生

c)
数据库：生成中间表

d)
Annotation：@Many2Many

Teacher类中写：

private Set<Student> students =
new HashSet<Student>();

@ManyToMany                          //多对多关联
Teacher是主的一方 Student是附属的一方

@JoinTable(

name="t_s",              //指定中间表表名

joinColumns={@JoinColumn(name="teacherid")},//本类主键在中间表生成的对应字段名

inverseJoinColumns={@JoinColumn(name="studentid")}//对方类主键在中间表生成的对应字段名

)

public Set<Student> getStudents(){……}

e)
XML：<many2many

<class name="com.xxx.Teacher">

<id name="id">

<generator class="native"/>

</id>

<property name="name"/>

<set name="students" table="t_s">table定义中间表的表名

<key column="teacher_id"></key>

<many-to-many class="com.xxx.Student" column="student_id"/>

</set>

</class>

2
双向关联：

a)
项目：hibernate_1600_many2many_bi

多对多双向配置只需要在两端类进行配置就才可以.

关系模型(Teache多对多Student)

Teacher(id,name,students)多

Student(id,name,teachers)多

Set<Student> students
=
new HashSet<Student>()

Set<Teacher> teachers =
new HashSet<Teacher>();

b)
老师知道自己教了哪些学生，学生也知道教自己的有哪些老师

c)
数据库：生成中间表

d)
Annotation：

在Teacher这一端的students上配置

@ManyToMany

@JoinTable(name="t_s",

joinColumns={@JoinColumn(name="teacher_id")},

inverseJoinColumns={@JoinColumn(name="student_id")}

)

在Student一端的teachers只需要配置

@ManyToMany(mappedBy="students")

注意：mappedBy
与
@JoinTable等一类的配置要分开，不然表字段可能乱

e)
XML：

XML配置方式:两端配置一样,注意表名和生成的中间表的字段属性名要一致

Teacher那一端配置

<set name="students" table="t_s">

<key column="teacher_id"/>

<many-to-many class="com.xxx.Student" column="student_id"/>

</set>

在Student那一端配置

<set name="teachers" table="t_s">

<key column="student_id"></key>

<many-to-many class="com.xxx.Teacher" column="teacher_id"/>

</set>

生成的数据库表和上面是一样的

关联关系中的CRUD_Cascade_Fetch

1
hibernate_1700_one2many_many2one_bi_crud

2
设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管）

3
cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大

a)
Cascade的属性是数组格式，指明做什么操作的时候关联对象是绑在一起的

b)
refresh = A里面需要读B改过之后的数据

cascade={CascadeType.ALL}

CascadeType取值

ALL    Cascade all operations所有情况

MERGE  Cascade merge operation合并(merge=save+update)

PERSIST  Cascade persist operation存储
persist()

REFRESH  Cascade refresh operation刷新

REMOVE   Cascade remove operation删除

4
铁律：双向关系在程序中要设定双向关联

5
铁律：双向mappedBy

6
fetch

a)
铁律：双向不要两边设置Eager(会有多余的査询语句发出)

b)
对多方设置fetch的时候要谨慎，结合具体应用，一般用Lazy不用eager，特殊情况（多方数量不多的时候可以考虑，提高效率的时候可以考虑）

@OneToMany(mappedBy="group",

cascade={CascadeType. ALL }, //控制增删改(即CUD)

fetch=FetchType. EAGER //控制查询(即R)
EAGER值代表取出关联 LAZY值为不取关联

//多的一方fetch取值默认为LAZY
一的一方默认为EAGER

)

另外：如果User类(即多的一方)中设置fetch=FetchType.LAZY 则在调用多(即Group)的对象值的时候

类似延迟加载 即需要在commit();之前 session还存在时调用
如：

System. out .println( user.getGroup().getName() );

session.getTransaction().commit();

7
Update时@ManyToOne()中的cascade参数关系

session.beginTransaction();

User user = (User)session.load(User. class ,1);

//user对象属性改变
事务commit时自动判断与数据库原有数据不同
可自动update

//此时的update与@ManyToOne()中的cascade或fetch参数取值无关

user.setName("user1");

user.getGroup().setName("group1");

session.getTransaction().commit();

如果user改变在commit()之后
且想要执行Update方法时
user与group表同时更新则，则User类的cascade={CascadeType.ALL}，并在程序中写如下代码：

session.beginTransaction();

User user = (User)session.get(User. class ,1);

session.getTransaction().commit();

user.setName("user1");

user.getGroup().setName("group1");

Session session2 =
sessionFactory .getCurrentSession();

session2.beginTransaction();

session2.update(user);

session2.getTransaction().commit();

8
Delete时@ManyToOne()中的cascade关系

如果User及Group类中均设为@ManyToOne(cascade={CascadeType.All})，那么在执行如下：

session.beginTransaction();

User user = (User)session.load(User. class ,1);

session.delete(user);

session.getTransaction().commit();

注意：此处删除的是
多对一(即User对Group)
中的“多”的一方(User类)

会删除user及user对应的group，再反向对应group的user都会删除，原因就是设置了@ManyToOne(cascade={CascadeType.All})

三种方法可避免全部删除的情况：

1． 去掉@ManyToOne(cascade={CascadeType.All})设置；

2． 直接写Hql语句执行删除；

3． 将user对象的group属性设为null，相当于打断User与Group间的关联，代码如下

session.beginTransaction();

User user = (User)session.load(User. class ,1);

user.setGroup(null);

session.delete(user);

session.getTransaction().commit();

注意：如果删除的是
多对一中的“一”的一方(Group类)时，如果使用第3种方式(user属性设为null)来打断两个对象间的关联的话，代码与之前不同,如下：

session.beginTransaction();

Group group = (Group)session.load(Group. class ,1);

//循环将group中的set集合下的各个user对象设为null

//相当于先将数据库中user表中与group表关联的字段(即groupid)设为null

for(User user :group.getUsers()){

System.out.println(user.getName());

user.setGroup(null);

}

//再将group的set集合设为null,相当于将group表中与user表关联的字段(即userid)设为null

//此句的前提是user表中的关联字段(groupid)已经为null,如没有则相当于破坏了一对多关联,会报错

group.setUsers(null);

session.delete(group);

session.getTransaction().commit();

9
O/RMapping
编程模型

a)
映射模型

i.
jpa annotation(java提供的annotation配置--常用)

ii.
hibernate annotation extension(Hibernate扩展的annotation配置--较少用)

iii.
hibernate xml(Hibernate的xml配置方式--常用)

iv.
jpa xml(java提供的xml配置--较少用)

b)
编程接口

i.
Jpa(不常用)

ii.
hibernate(现在用)

c)
数据査询语言

i.
HQL

ii.
EJBQL(JPQL)

10
要想删除或者更新先做load,除了精确知道ID之外

11
如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据

12
练习：多对多的CRUD

teacher	student
t1	s1
t1	s2
t2	s1
t2	s2

关系映射总结

1
什么样的关系，设计什么样的表，进行什么样的映射

2
CRUD,按照自然的理解即可（动手测试）

集合映射（不太重要）

1
项目名称：hibernate_1800_Collections_Mapping

2
Set

3
List
(与Set差不多
多个@OrderBy)

a) @OrderBy

4
Map

a) @Mapkey

继承映射（不太重要）

1
三种方式

a)
一张总表SINGLE_TABLE

i. hibernate_1900_lnheritence_Mapping_Single_Table

b)
每个类分别一张表TABLE_PER_CLASS

i. hibernate_2000_lnheritence_Mapping_Table_Per_Class

c)
每个子类一张表jOINED

i. hibernate_2100_lnheritence_Mapping_JOINED

父类上加注解@Inheritance(strategy=InheritanceType. JOINED )

@Inheritance(strategy=InheritanceType. JOINED )

public
class Person {... ...}

作业:

1
学生课程、分数的设计(重要)

a)
使用联合主键@Embeddedld

i.
实现 Serializable
接口

b)
不使用联合主键(视频中实际例子采用此类方法)

注：自己的项目与马老的方式不同，但可实现同样的功能（除从学生查课程外），具体见项目hibernate_2300_Stu_Course_Score

2
设计：

a)
实体类（表）

b)
导航（编程方便）

c)
确定了编程方式

3
树状结构的设计（至关重要）

a)
在同—个类中使用One2Many和Many20ne

关系模型(Tree)

Tree(int
id,String
name,Tree parent,List children)多

private List<Tree> children = new ArrayList<Tree>();

@Id

@GeneratedValue

public int getId(){

return id;

}

@ManyToOne

@JoinColumn(name="parent_id")

public Tree getParent(){

return parent;

}

//fetch=FetchType.EAGER可省略
即为@OneToMany的默认值fetch=FetchType.LAZY

//若树形较小
可使用EAGER
一次全部载入内存

//若为LAZY则查询树形时不会一次全部载入内存(适用于较大的树形),会每取一个叶子节点就select

一次

@OneToMany(mappedBy="parent",

cascade={CascadeType.ALL},

fetch=FetchType.EAGER   )

public List<Tree> getChildren() {

return children;

}