课程内容
a) Xml
b) annotation
2Hibernate原理模拟 -什么是O/R Mapping以及为什么要有O/R Mapping
风格
a)JPA
b)hibernate – extension
资源
3hibernate annotation references
环境准备
1下载hibernate-distribution-3.3.2.GA-dist
2下载hibernate-annotations-3[1].4.0.GA
3注意阅读hibernate compatibility matrix(hibernate 网站download)
HibernateHelloWorld
1建立新java 项目,名为hibernate_0100_HelloWorld
2学习建User-library-hibernate,并加入相应的jar包
a)项目右键-buildpath-configure build path-add library—
b)选择User-library,在其中新建 libraray,命名为 hibernate
c)在该library中加入hibernate所需jar包
i. hibernate core
ii. /required
iii. slf-nop jar
a)create database hibernate；
b)use hibernate；
c)create table Student (id int primary key, namevarchar(20), age int)；
5建立hibernate 配置文件hibernate.cfg.xml
c) 注释掉暂时用不上的内容
7建立Student 映射文件 Student.hbm.xml
a)参考文档
9写测试类Main,在Main中对Student对象进行直接的存储测试
a)要调用 new Configuration().configure().buildSessionFactory(),而不是
要省略 configure，否则会出 hibernatedialect must be set 的异常
b)重要的是:
iii. 主动学习，砍弃被动接受灌输的习惯！
a)错误读完整
b)读—昔误的关键行
c)排除法
d)比较法
e)google
建立Annotation 版本的 HelloWorld
1创建teacher 表，create table teacher (id int primary key, name varhcar(20),title varchar(lO));
3在hibernate lib 中加入annotation的jar包
a) hibernate annotaion jar
b) ejb3 persistence jar
c) hibernate common-annotations.jar
d) 注意文裆中没有提到hibernate-common-annotations.jar 文件
5在hibernate.cfg.xml中建立映射<mapping class:.../〉
6参考文裆进行测试（注意文裆中缺少configure()的小bug)
a)配置eclipse属性信息content assist-activation--加上@
Whatis and Why 0/R Mapping
6Hibernate_0200_OR_Mapping_Simulation
0/RMapping Frameworks
a)意愿统一天下
Hibernate基础配置
1对应项目：Hibernate_0300_BasicConfiguration
3 hibernate.cfg.xml:hbni2ddl.auto：create、update。。。。
a) 先建表还是先建实体类—先建表
a)slf4j与log4j的关系：slf4j像是一个大管家，可以管理许多的日志框架，log4j是其中之一
b)加入slf4j-log4j.jar,加入 log4j 的 jar 包,去掉 slf4-nop.jar
c)从hibernate/project/etc目录 copy log4j.properties
d)査询hibernate文裆，日志部分，调整日志的输出策略
a) 需要注意jUnit的Bug
6 hibernate.cfg.xml：show_sql 是否输出SQL语句
7 hibernate.cfg.xml：format_sql 格式化SQL语句，美化SQL语句
<!-- 格式化显示输出sql -->
<propertyname="format_sql">true</property>
a) Annotation: @Table
b)xml:自己査询
a) 不用写@column 与默认的@Basic效果一样
b) Xml中不用写 column
a)Annotation: @Column
b)xml:自己査询
a)Annotation：@Transient 定义不写入数据库，属性透明
b)xml不写
a)Annotation：@Temporal(参数) 参数有3种 只显示时间,只显示日期,时间日期都显示
//@Temporal(TemporalType.DATE) 只显示日期
//@Temporal(TemporalType.TIME) 只显示时间
//@Temporal(TemporalType.TIMESTAMP) 显示日期与时间
b) xml:指定 type
<classname="Teacher" table="Teacher" >
<idname="id" column="id"></id>
<propertyname="name" type="time" />
</class>
a) @Enumerated
@Enumerated(EnumType.ORDINAL) 枚举类型按位置数,如:0,1,2 ...存储
@Enumerated(EnumType.STRING) 枚举类型按设定值存储
b) xml:麻烦
a) best practice：保持 field(变量定义) 和 get set 方法的一致
ID生成策略
a) 我们观察hibernate生成表的结构并不是为了将来就用它生成，（可能还有自己的扩展，比如index等）而是为了明白我们应该建立什么样的表和实体类映射
a)generator
<idname="id" >
<generatorclass="native"></generator>
</id>
b)常用四个：native identitysequence uuid
a) 自定义ID
b) AUTO(直接写 @GeneratedValue相当如native) (@GeneratedValue(strategy=GenerationType.AUTO))
i. 默认：对 MySQL,使用auto_increment
ii. 对 Oracle使用hibernate_sequence(名称固定）
c) IDENTITY(@GeneratedValue(strategy=GenerationType.IDENTITY))
d) SEQUENCE(@GeneratedValue(strategy=GenerationType.SEQUENCE))
i. @SequenceGenerator(可自定义在数据库生成指定的sequence名)
@Id
//在@GeneratedValue中增加 generator="teacherSEQ"
@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="teacherSEQ")
//"teacherSEQ"为@SequenceGenerator的标识名
//"teacherSEQ_DB"为指定到数据库生成的Sequence名
@SequenceGenerator(name="teacherSEQ",sequenceName="teacherSEQ_DB")
public int getId() {
return id;
}
e) TABLE (可以忘记)
i.@TableGenerator
@TableGenerator(
name="teacherID", //被调用的TABLE名字
table="teacherID_DB", //数据库建立的表名
pkColumnName="key_value",
pkColumnValue="pk_value",
valueColumnName="teacher", //pkColumnValue对应类名
allocationSize=1 //pkColumnValue对应类名
)
@GeneratedValue(strategy=GenerationType.TABLE,generator=" teacherID")
注：如果使用注解方式的uuid 如下：
@Id
@GeneratedValue(generator="teacherUUID")
@GenericGenerator(name="teacherUUID",strategy="uuid")
a) 用Junit测试时Hibernate Session Factory初始化异常不提示.疑似一个bug
b) 用main来做测试
a) Xml方式: composite-id
i. 将联合主键的属性提取出来,重新编写一个pojo类（原pojo类中的id，name要删除并新加入属性“StudentPK”）
public class StudentPK implements Serializable {
private String id;
private String name;
… …
ii. 新建pojo类必须实现 java.io.Serializable 序列化接口
iii. 新pojo类要重写equals和hashCode方法
@Override
public booleanequals(Object o) {
if(o instanceof StudentPk) {
StudentPk pk = (StudentPk)o;
if(this.id == pk.getId()&& this.name.equals(pk.getName())) {
return true;
}
}
return false;
}
@Override
public int hashCode(){
return this.name.hashCode();
}
iv. 联合主键生成策略XML配置方法
<hibernate-mapping>
<classname="com.bjsxt.pojo.Student" >
<composite-idname="studentPK" class="com.bjsxt.pojo.StudentPK">
<key-propertyname="id"></key-property>
<key-propertyname="name"></key-property>
</composite-id>
<propertyname="age" />
<propertyname="sex" />
<propertyname="good" type="yes_no"></property>
</class>
</hibernate-mapping>
b) Annotation
i. 前三步与Xml方式前三步一样 都要建立新pojo类 都要实现Serializable接口 重写equals和hashCode方法.
ii. 方法1在新类前写@Embeddable，在原pojo类的新属性“TercherPK”的get方法前写@ld，如下
@ Embeddable
public class TeacherPK implements Serializable {
private String id;
private String name;
… …
@Entity
public class Teacher {
private TeacherPK teacherPK ;
@Id
public TeacherPK getTeacherPK() {
return teacherPK;
}
… …
iii. 方法2：@EmbeddedlD(*)新pojo类无需加注解，只需在原pojo类新属性“TercherPK”的get方法前写@EmbeddedlD即可
iv.方法3：@Id @IdClass(*) 新pojo类无需加注解，原pojo类的id，name属性保留不变，也无需新增“TercherPK”属性。 只在id，name的get方法前都加@Id，并在原pojo类前加“@IdClass(TeacherPK).class)”，如下
@Entity
@IdClass(TeacherPK.class)
public class Teacher{
private String id;
private String name;
@Id
public String getId(){
return id;
}
@Id
public StringgetName() {
return name;
}
... ...
核心幵发接口介绍
a)AnnotationConfiguration
b)进行配置信息的管理
c)用来产生SessionFactory
d)可以在configure方法中指定hibernate配置文件
e)只气关注一个方法即：buildSessionFactory
a)用来产生和管理Session
b)通常情况下每个应用只需要一个SessionFactory
c)除非要访间多个数据库的情况
d)关注两个方法即：openSessiongetCurrentsession
i. open session每次都是新的，需要close
ii. getCurrentsession从上下文找，如果有，用旧的，如果没有，建新的
1. 用途，界定事务边界
2. 事务提交自动close
3. 上下文配置可参见xml文件中
<propertyname="current_session_context_classs">thread</property>
4. current_session_context_class (jta、thread常用managed、custom.Class少用)
a) thread 使用connection 但数据库连接管理事务
b）jta （全称java transaction api）-java分布式事务管理（多数据库访问）
jta由中间件提供（jboss WebLogic等，tomcat不支持）
a)管理一个数据库的任务单元（简单说就是增删 改 查）
b)方法(CRUD)
i. Save() session.save(对象);
ii. Delete session.delete(对象);
iii. Load Student s1=(Student)session.load(Student.class,1);
iv. Get Students1=(Student)session.get(Student.class, 1);
v. get与load的区别（面试重点，原理）
1. 不存在对应记录时表现不一样
2. load返回的是代理对象，等到真正用到对象的内容时才发出sql语句
3. get直接从数据库加载，不会延迟
vi. updates session.update(对象);
1. 用来更新detached对象，更新完成后转为persistent状态
2. 更新transient对象会报错
3. 更新自己设定id的transient对象可以（数据库有对应记录）
4. persistent状态的对象只要设定（如:t.setName…）不同字段就会发生更新
5. 更新部分更改的字段
a)xml 设定 property 标签的update 属性，annotation 设定@Column 的 updatable
属性，不过这种方式很少用，因为不灵活（忘记）
b) 使用xml中的dynamic-update，JPA1.0 Annotation 没有对应的属性，hibernate 扩
展？
i. 同一个session可以，跨session不行，不过可以用merge()(不重要）
c) 使用HQL(EjBQL)(建议）
vii. saveOrUpdate() session.saveOrUpdate(对象);
viii. clear方法 session.clear();
1.无论是load还是get,都会首先査找缓存（一级缓存)，如果没有，才会去数据库査找，调用
clear()方法可以强制清除session缓存
ix. flush()方法 session.flush();
1.当session的事务提交后,会强制将内存(session缓存)与数据库同步.默认情况下是session的事务提交(commit)时才同步!
2. session的FlushMode设置,可以设定在什么时候同步缓存与数据库(很少用)
例如: session.setFlushMode(FlushMode.AUTO)
x. find方法已经过时！
new SchemaExport(newAnnotationConfiguration().configure()).create(false, true);
a) 参考Hibernate査询(HQLEJBQL)的内容
a)Hibernate中涉及很多非常非常细节的区别,但在实际应用中用得极少,请大家先享受写项目的乐
趣，再来探讨这些细节问题
i. 比如save和persist的区别
ii. merge、evict等方法
iii. 比如 refresh、lock 等
b)建议的学习方法，动手实验
c) 细节问题参考补充视频
三种对象状态
a)有没有ID
b)ID在数据库中有没有
c)在内存中有没有（session缓存）
a)transient：内存中一个对象，没ID,缓存中也没有
b)persistent：内存中有，缓存中有，数据库有（ID)
c)detached：内存有，缓存没有，数据库有，ID
4对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比 如改变属性的
值会不会发出update语句？
a)强烈建议动手实验
b)进行正常人的思考
c)绝对不要去背这些东西！背过也并不代表你有多牛！
关系映射(重要)
对象之间的关系
1这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于
下列关系之一时，数据库表该如何映射，编程上该如何对待(红色为重点中的重点)
a)怎么写Annotation
b)增删改査CRUD怎么写
a)单向（主键、外键）
b)双向（主键、外键）
c)中间表
a)一张主表，多张子表
a)@Embeddable
b)@ Embedded
一对一关联
a)项目名称：hibernate_0600_one2one_uni_fk
b)Annotation: 在被约束表字段的get方法上加@0ne20ne @JoinColumn
@OneToOne
@JoinColumn(name="wifeid")//指定生成的数据库字段名
public Wife getWife() {
returnwife;
}
c)xml: 在被约束表的xml配置文件中加<many-to-one unique
<classname="com.bjsxt.pojo.StuIdCard">
<id name="id">
<generatorclass="native"></generator>
</id>
<property name="num"/>
<many-to-one name="student"column="studentId" unique="true">
</many-to-one>
</class>
unique="true"是保证生成的字段唯一,这样<many-to-one 也达到了一对一的效果
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-oneproperty-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-onename="stuIdCard"property-ref="student"></one-to-one>
其中, property-ref 相当于mappedBy
此方式生成的StuIdCard表中包含studentid字段作为fk外键, Student表中不生成额外的字段
特别说明: 一对一单向外键关联与一对一双向外键关联在数据库的表的格式是一样的,区别在于
java程序中. 双向外键关联可通过Hibernate在两个类间互相调用彼此,而单向外键关联只能单方向调用.
a)项目名称：hibernate_0800_one2one_uni_pk
b)@primaryKeyJoinColumn
c)xml: <one-to-one id 使用 foreign class
a)项目名称：hibernate_0900_one2one_bi_pk
b)@primaryKeyJoinColumn（不常用，了解）
c)xml: <one-to-one id 使用foreign class和<one-to-one property-ref
a)项目名称：hibernate_1000_one2one_uni_fk_composite
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属性值作用是可指定生成的字段名所对应的目标表字段名*/
publicWife getWife() {……}
组件映射
4annotation: @ Embeddable @Embbeded
对象模型
Husband(id,name,wife)
Wife(name,age)
Annotation:
在Husband的wife属性上建立注解
@Embedded表明该对象是从别的位置嵌入过来的,是不需要单独映射的表.
这种方式生成的表为husband(id,name,wifename,wifeage),不会生成wife表.
@Embedded
Public WiftgetWife(){
}
@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 {… …}
<class name="Husband" >
<idname="id">
<generatorclass="native"/>
</id>
<propertyname="name"></property>
<componentname="wife">
<propertyname="wifeName"/>
<propertyname="wifeAge"/>
</component>
</class>
多对一与一对多
a)项目名称：hibernate_1200_many2one_uni
实体模型(User多对一Group)
User(id,name,group)多
Group(id,name)一
|
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-onename="group" column="groupId" />
标签会在”多”的一端添加外键,相当于在数据库中添加外键
生成的表为user(id,name,groupid),t_group(id,groupname)
属性cascade
<many-to-onename="group" column="groupid" cascade="all"/>
取值all,none,save-update,delete,对象间的级联操作,只对增删改起作用.
在存储时User时,设置了cascade="all"会自动存储相应的t_group.而不用管user关联的对象(通常情况下会优先存储关联的对象,然后再存储user).
a)项目名称：hibernate_1300_one2many_uni
模型(group一对多user)
Group(id,name,users)一
User(id,name)多
设计时在一的这一端存在着多的集合,生成的数据库表通常是在多的一端生成外键.
Set<User> users=new HashSet<User>();
d) Annotation:@One2Many
在一的这一端Group端users属性上进行注解配置
@OneToMany //一对多关联 Group是一的一方 User是多的一方
@JoinColumn(name="groupid") //指定User表中生成与Group对应的字段名注意此处与多对一配置方式不同
publicSet<User> getUsers(){ ……. }
Hibernate默认将OneToMany理解为ManyToMany的特殊形式，如果不指定生成的外键列@JoinColumn(name="groupId")，则会默认生成多对多的关系,产生一张中间表。
e) xml:<set <one2many
XML配置中配置一的那一端Group
<class name="com.hibernate.Group"table="t_group">
<idname="id">
<generatorclass="native"/>
</id>
<propertyname="name"/>
<setname="users">
<keycolumn="groupId"/>指定生成外键字段的名字
<one-to-manyclass="com.pojo.User"/>
</set>
</class>
一对多与多对一的双向关联是同一种情况.
关系模型(group一对多user)
User(id,name,group)多
Set<User> users=newHashSet<User>()
配置规则:一般以多的一端为主,先配置多的一端
在多的一端User端配置group
@ManyToOne
@JoinColumn(name="groupid")
在一的一端Group端配置时,在users只需要加个mappedBy="groupid"
@OneToMany(mappedBy="group")
XML配置
Group中
<set name="users">
<keycolumn="groupId"/>
<one-to-manyclass="com.hibernate.User"/>
</set>
在User中
<many-to-one name="group"column="groupId"/>
务必确保在多的一端生成的生成的外键和一的一方生成的外键的名字相同,都为groupId.
如果名字不同则会在多的一端生成多余的外键
多对多
a) 项目：hibernate_1500_many2many_uni
关系模型(Teache多对多Student),从Teacher这一端能关联到students.
Teacher(id,name,students)多
Student(id,name)多
Set<Student> students=newHashSet<Student>()
在Teacher那一端配置
b) 例如：老师和学生的关系，老师需要知道自己教了哪些学生
c) 数据库：生成中间表
d) Annotation：@Many2Many
Teacher类中写：
privateSet<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
<classname="com.xxx.Teacher">
<idname="id">
<generatorclass="native"/>
</id>
<propertyname="name"/>
<setname="students" table="t_s">table定义中间表的表名
<keycolumn="teacher_id"></key>
<many-to-manyclass="com.xxx.Student" column="student_id"/>
</set>
</class>
a)项目：hibernate_1600_many2many_bi
多对多双向配置只需要在两端类进行配置就才可以.
关系模型(Teache多对多Student)
Teacher(id,name,students)多
Student(id,name,teachers)多
Set<Student> students=new HashSet<Student>()
Set<Teacher> teachers = newHashSet<Teacher>();
b)老师知道自己教了哪些学生，学生也知道教自己的有哪些老师
c) 数据库：生成中间表
d)Annotation：
在Teacher这一端的students上配置
@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
1hibernate_1700_one2many_many2one_bi_crud
2设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管）
3cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大
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删除
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();
7Update时@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();
8Delete时@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();
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)
11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据
|
teacher |
student |
|
t1 |
s1 |
|
t1 |
s2 |
|
t2 |
s1 |
|
t2 |
s2 |
关系映射总结
集合映射（不太重要）
1项目名称：hibernate_1800_Collections_Mapping
a) @OrderBy
继承映射（不太重要）
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 {... ...}
作业:
a)使用联合主键@Embeddedld
i. 实现 Serializable 接口
b)不使用联合主键(视频中实际例子采用此类方法)
注：自己的项目与马老的方式不同，但可实现同样的功能（除从学生查课程外），具体见项目hibernate_2300_Stu_Course_Score
a)实体类（表）
b)导航（编程方便）
c)确定了编程方式
a) 在同—个类中使用One2Many和Many20ne
关系模型(Tree)
Tree(int id,String name,Tree parent,List children)多
privateList<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
1NativeSQL >HQL.> EJBQL(JPQL 1.0) >QBC(Query By Criteria) > QBE(Query By Example)"
1注意session.clear()的运用，尤其在不断分页循环的时候
a)在一个大集合中进行遍历，遍历msg，取出其中的含有敏感字样的对象
b)另外一种形式的内存泄露 ( //面试题：Java有内存泄漏吗？语法级别没有但是可由java引起,例如:连接池不关闭,或io读取后不关闭)
21+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.categoryc "
d)QBC
//QBC(Query By Criteria) 解决N+1问题说明如下:
//使用QBC的 createCriteria(*.class)执行查询也可避免N+1问题
3list和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用二级缓存，需打开查询缓存
<property name="cache.use_query_cache">true</property>
调用Query的setCachable (true)方法指明使用二级缓存
例如：session.createQuery("fromCategory").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中配置)
a)事务：ACID
i. Atomic ConsistencyItegrity Durability
b)事务并发时可能出现的问题：
第一类丢失更新(Lost Update)
|
时间 |
取款事务A |
存款事务B |
|
T1 |
开始事务 |
|
|
T2 |
开始事务 |
|
|
T3 |
查询账户余额为1000元 |
|
|
T4 |
查询账户余额为1000元 |
|
|
T5 |
汇入100元把余额改为1100元 |
|
|
T6 |
提交事务 |
|
|
T7 |
取出100元把余额改为900 元 |
|
|
T8 |
撤销事务 |
|
|
T9 |
余额恢复为1000元(丢失更新) |
dirtyread脏读(读到了另一个事务在处理中还未提交的数据)
|
时间 |
取款事务A |
存款事务B |
|
T1 |
开始事务 |
|
|
T2 |
开始事务 |
|
|
T3 |
查询账户余额为1000元 |
|
|
T4 |
汇入100元把余额改为1100元 |
|
|
T5 |
查询账户余额为1100元(读取脏数据) |
|
|
T6 |
回滚 |
|
|
T7 |
取款1100 |
|
|
T8 |
提交事务失败 |
non-repeatableread 不可重复读
|
时间 |
取款事务A |
存款事务B |
|
T1 |
开始事务 |
|
|
T2 |
开始事务 |
|
|
T3 |
查询账户余额为1000元 |
|
|
T5 |
汇入100元把余额改为1100元 |
|
|
T5 |
提交事务 |
|
|
T6 |
查询帐户余额为1100元 |
|
|
T8 |
提交事务 |
secondlost update problem 第二类丢失更新(不可重复读的特殊情况)
|
时间 |
取款事务A |
存款事务B |
|
T1 |
开始事务 |
|
|
T2 |
开始事务 |
|
|
T3 |
查询账户余额为1000元 |
|
|
T4 |
查询账户余额为1000元 |
|
|
T5 |
取出100元把余额改为900元 |
|
|
T6 |
提交事务 |
|
|
T7 |
汇入100元 |
|
|
T8 |
提交事务 |
|
|
T9 |
把余额改为1100元(丢失更新) |
phantomread 幻读
|
时间 |
查询学生事务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=01008=1000(位移计算效率高)
1.只要数据库支持事务,就不可能出现第一类丢失更新
2.read-uncommitted(允许读取未提交的数据) 会出现dirty read, phantom-read,
non-repeatableread 问题
3.read-commited(读取已提交的数据项目中一般都使用这个)不会出现dirty read,因为只有另
一个事务提交才会读出来结果，但仍然会出现 non-repeatable read 和 phantom-read
使用read-commited机制可用悲观锁乐观锁来解决non-repeatable read 和 phantom-read问题
4.repeatableread(事务执行中其他事务无法执行修改或插入操作较安全)
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 updatehibernate 会自动获取锁
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元(丢失更新) |
相关推荐
《Hibernate学习笔记特别详细》 Hibernate，作为一款开源的Object-Relational Mapping（ORM）框架，为Java开发者提供了强大的数据库操作支持。它简化了数据库访问的复杂性，使得开发人员可以像操作对象一样操作...
在本篇《Hibernate学习笔记》中，我们将深入探讨Hibernate这一流行的Java对象关系映射（ORM）框架。Hibernate允许开发者以面向对象的方式处理数据库操作，极大地简化了数据存取的复杂性。以下是一些关键知识点： 1....
Hibernate学习笔记整理 以下是 Hibernate 框架的详细知识点： Hibernate 介绍 Hibernate 是一个 ORM（Object-Relational Mapping）框架，用于将 Java 对象映射到数据库表中。它提供了一个简洁的方式来访问和操作...
【Java相关课程系列笔记之十四Hibernate学习笔记】 Hibernate是一个开源的对象关系映射（ORM）框架，它极大地简化了Java应用程序对数据库的操作。本笔记将详细阐述Hibernate的核心概念、使用方法和特性。 一、...
hibernate 学习笔记精要hibernate 学习笔记精要hibernate 学习笔记精要hibernate 学习笔记精要
《Hibernate学习笔记——马士兵教程解析》 在Java开发领域，ORM(Object-Relational Mapping)框架的使用已经非常普遍，其中Hibernate作为一款优秀的ORM框架，因其强大的功能和易用性深受开发者喜爱。本文将根据马...
这套笔记是我学习Hibernate，进行相关技术点训练时记录下来的，其中包括技术点说明与相关事例，拿出来与大家分享。
### 马士兵Hibernate学习笔记知识点总结 #### 一、课程内容概览 - **HelloWorld**：通过简单的示例程序介绍如何启动一个基于Hibernate的Java项目。 - **Hibernate原理模拟**：解释O/R Mapping的概念及其重要性。 -...
### 马士兵Hibernate学习笔记知识点总结 #### 一、HelloWorld示例 - **目的**：通过简单的示例理解Hibernate的基本使用流程。 - **步骤**： - 创建Java项目`hibernate_0100_HelloWorld`。 - 建立库依赖，包括...
Hibernate是一款强大的Java持久...通过阅读这份“Hibernate API帮助文档”和“Hibernate学习笔记”，你将能够深入理解Hibernate的工作原理，掌握其API的使用，并能在实际项目中有效地利用Hibernate进行数据持久化操作。
**Hibernate学习笔记与总结** Hibernate 是一款开源的对象关系映射（ORM）框架，它为Java开发者提供了一种在关系数据库上操作对象数据的便捷方式。本文将深入探讨Hibernate的核心概念、配置、实体类、映射文件、...
### Hibernate 学习笔记知识点概览 #### 一、Hibernate 概述 - **定义**：Hibernate 是一款开源的对象关系映射（ORM）框架，它实现了将 Java 应用程序中的对象模型映射到关系型数据库中的记录。通过 ORM 技术，...
### JDBC与Hibernate学习笔记 #### 一、JDBC概述 **1.1 ODBC与JDBC的区别** - **ODBC（Open Database Connectivity）**: 开放式数据库连接是一种开放标准的应用程序接口（API），用于实现数据库应用程序与不同...
### 对象持久化与Hibernate学习笔记 #### 一、对象持久化的概念与重要性 - **定义**: 对象持久化是指将程序中的对象状态存储到持久化存储设备上的过程，以便在程序结束运行后仍然可以保留这些数据。 - **必要性**:...
【hibernate学习笔记】 在Java开发中，Hibernate是一个强大的对象关系映射（ORM）框架，它极大地简化了数据库操作。以下是对Hibernate的学习要点的详细解释： 1. **建立第一个Hibernate版本的HelloWorld** - **...
标题：Hibernate学习笔记3 描述：本篇笔记深入探讨了Hibernate框架中一对多关系的映射及持久化对象状态管理，结合个人理解与实践经验，旨在为读者提供一份详实的学习资料。 ### 一、一对多关系映射详解 在...