马士兵Hibernate学习笔记 -

@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,例如:

</id>

</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

</id>

<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中

<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

</id>

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

<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那一端配置

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

</set>

在Student那一端配置

<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;

}

Hibernate 查询(Query Language)

HQL vs EJBQL

1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)"

2 总结：QL应该和导航关系结合，共同为査询提供服务。

性能优化

1 注意session.clear()的运用，尤其在不断分页循环的时候

a) 在一个大集合中进行遍历，遍历msg，取出其中的含有敏感字样的对象

b) 另外一种形式的内存泄露 ( //面试题：Java有内存泄漏吗？语法级别没有但是可由java引起,例如:连接池不关闭,或io读取后不关闭)

2 1+N问题 (典型的面试题) (详见hibernate_2800_Hibernate_1+N项目)

a) @ManyToOne(fetch=FetchType.LAZY)

//fetch=FetchType.LAZY 解决N+1问题说明如下:

//当多对一(@ManyToOne)已经设定属性" fetch=FetchType.LAZY "时

//只有当需要时(如:t.getCategory().getName()时)才会去获取关联表中数据可以解决N+1问题

b) @BatchSize

//@BatchSize 解决N+1问题说明如下:

//在与查询表(此例中为Topic类)关联的表类(此例中为Category类)头处加@BatchSize(size=5)

//表示每次可查出5条记录从而减少了select语句的个数

c) join fetch

//join fetch 解决N+1问题说明如下:

//修改hql语句为--" from Topic t left join fetch t.category c "

d) QBC

//QBC(Query By Criteria) 解决N+1问题说明如下:

//使用QBC的 createCriteria(*.class)执行查询也可避免N+1问题

3 list和iterate不同之处（//主要为了面试详见hibernate_2900_Hibernate_list_iterate）

a) list取所有

b) iterate先取 ID,等用到的时候再根据ID来取对象

c) session中list第二次发出，仍会到数据库査询

d) iterate 第二次，首先找session 级缓存

4 一级缓存和二级缓存和査询缓存（面试题）(详见hibernate_3000_Hibernate_3KindsOf_Cache)

a) 什么是缓存

b) 什么是一级缓存，session级别的缓存

c) I什么是二级缓存，SessionFactory级别的缓存，可以跨越session存在

i. 经常被访间

ii. 改动不大不会经常改动

iii. 数重有限

d) 打开二级缓存

i. hibernate.cfg.xml 设定：

<property

name= "cache.use_second_level_cache">true</property>

<property

name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

ii. @Cache注解(由hibernate扩展提供)

@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)

注：使用EhCache二级缓存需要导入ehcache-1.2.3.jar及commons-logging-1.0.4.jar包

e) load默认使用二级缓存，iterate默认使用二级缓存

f) list默认往二级缓存加数据，但是查询的时候不使用

g) 如果要query用二级缓存，需打开查询缓存

调用Query的setCachable (true)方法指明使用二级缓存

例如：session.createQuery("from Category").setCacheable(true).list();

h) 缓存算法：（纯为了面试）

i. LRU LFU FIFO

1. Least Recently Used –最近很少被使用

2. Least Frequently Used (命中率高低)

3. First In First Out 按顺序替换

ii. memoryStoreEvictionPolicy = "LRU" (ehcache.xml中配置)

5 事务并发处理(面试的意义更大)

a) 事务：ACID

i. Atomic Consistency Itegrity Durability

b) 事务并发时可能出现的问题：

第一类丢失更新(Lost Update)

时间	取款事务A	存款事务B
T1	开始事务
T2		开始事务
T3	查询账户余额为1000元
T4		查询账户余额为1000元
T5		汇入100元把余额改为1100元
T6		提交事务
T7	取出100元把余额改为900 元
T8	撤销事务
T9	余额恢复为1000元(丢失更新)

dirty read脏读(读到了另一个事务在处理中还未提交的数据)

时间	取款事务A	存款事务B
T1	开始事务
T2		开始事务
T3		查询账户余额为1000元
T4		汇入100元把余额改为1100元
T5	查询账户余额为1100元(读取脏数据)
T6		回滚
T7	取款1100
T8	提交事务失败

non-repeatable read 不可重复读

时间	取款事务A	存款事务B
T1	开始事务
T2		开始事务
T3	查询账户余额为1000元
T5		汇入100元把余额改为1100元
T5		提交事务
T6	查询帐户余额为1100元
T8	提交事务

second lost update problem 第二类丢失更新(不可重复读的特殊情况)

时间	取款事务A	存款事务B
T1		开始事务
T2	开始事务
T3		查询账户余额为1000元
T4	查询账户余额为1000元
T5		取出100元把余额改为900元
T6		提交事务
T7	汇入100元
T8	提交事务
T9	把余额改为1100元(丢失更新)

phantom read 幻读

时间	查询学生事务A	插入新学生事务B
T1	开始事务
T2		开始事务
T3	查询学生为10人
T4		插入1个学生
T5	查询学生为11人
T6		提交事务
T7	提交事务

c) 数据库的事务隔离机制

i. 查看 java.sql.Connection 文档

ii. 1：read-uncommitted 2：read-committed 4：repeatable read 8：serializable（数字代表对应值）

为什么取值要使用 1 2 4 8 而不是 1 2 3 4

1=0000 2=0010 4=0100 8=1000(位移计算效率高)

1. 只要数据库支持事务,就不可能出现第一类丢失更新

2. read-uncommitted(允许读取未提交的数据) 会出现dirty read, phantom-read,

non-repeatable read 问题

3. read-commited(读取已提交的数据项目中一般都使用这个)不会出现dirty read,因为只有另

一个事务提交才会读出来结果，但仍然会出现 non-repeatable read 和 phantom-read

使用read-commited机制可用悲观锁乐观锁来解决non-repeatable read 和 phantom-read问题

4. repeatable read(事务执行中其他事务无法执行修改或插入操作较安全)

5. serializable解决一切问题(顺序执行事务不并发，实际中很少用)

d) 设定hibernate的事务隔离级别(使用hibernate.connection.isolation配置取值1、2、4、8)

i. hibernate.connection.isolation = 2（如果不设默认依赖数据库本身的级别）

ii. 用悲观锁解决repeatable read的问题（依赖于数据库的锁）

(详见项目 hibernate_3100_Hibernate_Concurrency_Pessimistic_Lock)

1. select ... for update

2. 使用另一种load方法--load(xx.class , i , LockMode.Upgrade)

a) LockMode.None无锁的机制，Transaction结束时，切换到此模式

b) LockMode.read在査询的时候hibernate会自动获取锁

c) LockMode.write insert update hibernate 会自动获取锁

d) 以上3种锁的模式，是hibernate内部使用的(不需要设)

e) LockMode.UPGRADE_NOWAIT是 ORACLE 支持的锁的方式

e) Hibernate(JPA)乐观锁定(ReadCommitted)

(详见项目hibernate_3200_Hibernate_Concurrency_Optimistic_Lock)

实体类中增加version属性(数据库也会对应生成该字段,初始值为0)，并在其get方法前加

@Version注解，则在操作过程中没更新一次该行数据则version值加1，即可在事务提交前判断该数据是否被其他事务修改过.

@Version

时间	转账事务A	取款事务B
T1		开始事务
T2	开始事务
T3	查询学生为10人	查询账户余额为1000 version=0
T4	查询账户余额为1000 version=0
T5		取出100 把余额改为900 version=1
T6		提交事务
T7	汇入100元
T8	提交事务 ? version>0 throw Exception
T9	把余额改为1100元(丢失更新)

查看图片附件

分享到：

域名申请 | 淘宝面试内容

2011-12-19 16:05
浏览 1811
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论