hibernate學習筆記（總結）

hibernate學習筆記

課程內容

1 HelloWorld

a) Xml

b) annotation

2 Hibernate原理模擬 - 什麼是O/R Mapping以及爲什麼要有O/R Mapping

3 常見的0/R框架(瞭解)

4 hibernate基礎配置（重點）

5 ID生成策略（重點 AUTO)

6 Hibernate核心開發接口介紹（重點）

7 對象的三種狀態（瞭解）

8 關係映射（重點）

9 Hibernate査詢（HQL)

10 在Struts基礎上繼續完善BBS200

11 性能優化（重點）

12 補充話題

風格

1 先脈絡，後細節

2 先操作，後原理

3 重Annotation,輕xml配置文件

a) JPA

b) hibernate – extension

資源

1 http://www. hibernate.org

2 hibernate zh_CN文檔

3 hibernate annotation references

環境準備

1 下載hibernate-distribution-3.3.2.GA-dist

2 下載hibernate-annotations-3[1].4.0.GA

3 注意閱讀hibernate compatibility matrix(hibernate 網站download)

4 下載slf4jl.5.8

Hibernate HelloWorld

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

3 引入mysql的JDBC驅動包

4 在mysql中建立對應的數據庫以及表

a) create database hibernate；

b) use hibernate；

c) create table Student (id int primary key, namevarchar(20), age int)；

5 建立hibernate 配置文件hibernate.cfg.xml

a) 從參考文檔中copy

b) 修改對應的數據庫連接

c) 註釋掉暫時用不上的內容

6 建立Student 類

7 建立Student 映射文件 Student.hbm.xml

a) 參考文檔

8 將映射文件加入到hibernate.cfg.xml中

a) 參考文檔

9 寫測試類Main,在Main中對Student對象進行直接的存儲測試

a) 參考文擋

10 FAQ：

a) 要調用 new Configuration().configure().buildSessionFactory(),而不是

要省略 configure，否則會出 hibernate dialect must be set 的異常

11 Note:

a) 請務必建立自己動手査文擋的能力

b) 重要的是:

i. 要建立自己動手查一手文檔的信心

ii. 還有建立自己動手查一手文檔的習慣！

iii. 主動學習，砍棄被動接受灌輸的習慣！

12 建立能力

a) 錯誤讀完整

b) 讀—昔誤的關鍵行

c) 排除法

d) 比較法

e) google

建立 Annotation 版本的 HelloWorld

1 創建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO));

2 創建Teacher 類

3 在hibernate lib 中加入annotation的jar包

a) hibernate annotaion jar

b) ejb3 persistence jar

c) hibernate common-annotations.jar

d) 注意文襠中沒有提到hibernate-common-annotations.jar 文件

4 參考Annotaion文檔建立對應的註解

5 在hibernate.cfg.xml中建立映射<mapping class:.../〉

6 參考文襠進行測試（注意文襠中缺少configure()的小bug)

7 FAQ: @不給提示

a) 配置eclipse屬性信息content assist-activation--加上@

What is and Why 0/R Mapping

1 JDBC操作數據庫很繁瑣

2 Sql語句編寫並不是面向對象的

3 可以在對象和關係表之間建立關聯來簡化編程

4 0/R Mapping 簡化編程

5 0/R Mapping跨越數據庫平臺

6 Hibernate_0200_OR_Mapping_Simulation

Hibernate基礎配置

1 對應項目：Hibernate_0300_BasicConfiguration

2 介紹MSQL的圖形化客戶端

3 hibernate.cfg.xml: hbni2ddl.auto：create、update。。。。

a) 先建表還是先建實體類—先建表

4 搭建日誌環境並配置顯示DDL語句

a) slf4j與log4j的關係：slf4j像是一個大管家，可以管理許多的日誌框架，log4j是其中之一

b) 加入slf4j-log4j.jar,加入 log4j 的 jar 包,去掉 slf4-nop.jar

c) 從hibernate/project/etc 目錄 copy log4j.properties

d) 査詢hibernate文襠，日誌部分，調整日誌的輸出策略

5 搭建jUnit環境

a) 需要注意jUnit的Bug

6 hibernate.cfg.xml：show_sql 是否輸出SQL語句

7 hibernate.cfg.xml：format_sql 格式化SQL語句，美化SQL語句

8 表名和類名不同,對錶名進行配置

a) Annotation: @Table

b) xml:自己査詢

9 字段名和屬性相同

a) 不用寫@column 與默認的@Basic效果一樣

b) Xml中不用寫 column

10 字段名和屬性名不同

a) Annotation: @Column

b) xml:自己査詢

11 不需要psersistence的字段(不用列)

a) Annotation：@Transient 定義不寫入數據庫，屬性透明

b) xml不寫

12 映射日期與時間類型，指定時間精度

a) Annotation：@Temporal(參數) 參數有3種只顯示時間,只顯示日期,時間日期都顯示

//@Temporal(TemporalType.DATE) 只顯示日期

//@Temporal(TemporalType.TIME) 只顯示時間

//@Temporal(TemporalType.TIMESTAMP) 顯示日期與時間

b) xml:指定 type

</class>

13 映射枚舉類型( 比較少用)

a) @Enumerated

@Enumerated(EnumType.ORDINAL) 枚舉類型按位置數,如:0,1,2 ...存儲

@Enumerated(EnumType.STRING) 枚舉類型按設定值存儲

b) xml:麻煩

14 字段映射的位置（field或者get方法）

a) best practice：保持 field(變量定義) 和 get set 方法的一致

15 @Lob

16 課外：CLOBBLOB類型的數據存取

17 課外：Hibernate自定義數據類型

18 hibernate 類型

ID生成策略

1 對應項目：hibernate_0400_ID

2 注意：

a) 我們觀察hibernate生成表的結構並不是爲了將來就用它生成，（可能還有自己的擴展，比如index等）而是爲了明白我們應該建立什麼樣的表和實體類映射

3 xml生成id

a) generator

</id>

b) 常用四個：native identity sequence uuid

4 註解方式：@GeneratedValue

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")

5 FAQ;

a) 用Junit測試時Hibernate Session Factory初始化異常不提示.疑似一個bug

b) 用main來做測試

6 聯合主鍵

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 boolean equals(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>

<composite-id name="studentPK" class="com.bjsxt.pojo.StudentPK">

<key-property name="id"></key-property>

<key-property name="name"></key-property>

</composite-id>

</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 String getName() {

return name;

}

... ...

核心幵發接口介紹

1 hibernate_0500_CoreAPI

2 Hibernate API文檔需要單獨下載

3 Configuration

a) AnnotationConfiguration

b) 進行配置信息的管理

c) 用來產生SessionFactory

d) 可以在configure方法中指定hibernate配置文件

e) 只氣關注一個方法即：buildSessionFactory

4 SessoinFactor

a) 用來產生和管理Session

b) 通常情況下每個應用只需要一個SessionFactory

c) 除非要訪間多個數據庫的情況

d) 關注兩個方法即：openSession getCurrentsession

i. open session每次都是新的，需要close

ii. getCurrentsession從上下文找，如果有，用舊的，如果沒有，建新的

1. 用途，界定事務邊界

2. 事務提交自動close

3. 上下文配置可參見xml文件中

<property name="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不支持）

5 Session

a) 管理一個數據庫的任務單元（簡單說就是增刪改查）

b) 方法(CRUD)

i. Save() session.save(對象);

ii. Delete session.delete(對象);

iii. Load Student s1=(Student)session.load(Student.class, 1);

iv. Get Student s1=(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方法已經過時！

6 SchemaExport (自動建表)

new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);

7 Query 接口

a) 參考Hibernate査詢(HQLEJBQL)的內容

8 Note：

a) Hibernate中涉及很多非常非常細節的區別,但在實際應用中用得極少,請大家先享受寫項目的樂

趣，再來探討這些細節問題

i. 比如save和persist的區別

ii. merge、evict 等方法

iii. 比如 refresh、lock 等

b) 建議的學習方法，動手實驗

c) 細節問題參考補充視頻

三種對象狀態

1 上一個 project

2 三種狀態的區分關鍵在於

a) 有沒有ID

b) ID在數據庫中有沒有

c) 在內存中有沒有（session緩存）

3 三種狀態：

a) transient：內存中一個對象，沒ID,緩存中也沒有

b) persistent：內存中有，緩存中有，數據庫有（ID)

c) detached：內存有，緩存沒有，數據庫有，ID

4 對這三種狀態需要關注的問題是在該狀態下如果進行數據庫的操作會發生什麼結果，比如改變屬性的

值會不會發出update語句？

a) 強烈建議動手實驗

b) 進行正常人的思考

c) 絕對不要去背這些東西！背過也並不代表你有多牛！

對象之間的關係

1 這裏的關係映射指的是對象之間的關係，並不是指數據庫的關係，本章解決的問題是當對象之間處於

下列關係之一時，數據庫表該如何映射，編程上該如何對待(紅色爲重點中的重點)

2 簡化問題：

a) 怎麼寫 Annotation

b) 增刪改査CRUD怎麼寫

3 —對一

a) 單向（主鍵、外鍵）

b) 雙向（主鍵、外鍵）

c) 中間表

4 —對多

a) 一張主表，多張子表

5 組件映射

a) @Embeddable

b) @ Embedded

一對一關聯

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

</id>

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

</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元(丟失更新)

hibernate學習筆記（總結）

課程內容

風格

資源

環境準備

Hibernate HelloWorld

建立 Annotation 版本的 HelloWorld

What is and Why 0/R Mapping

0/R Mapping Frameworks

Hibernate基礎配置

ID生成策略

核心幵發接口介紹

三種對象狀態

關係映射(重要)

對象之間的關係

一對一關聯

組件映射

多對一與一對多

多對多

關聯關係中的CRUD_Cascade_Fetch

關係映射總結

集合映射（不太重要）

繼承映射（不太重要）

作業:

Hibernate 查詢(Query Language)

HQL vs EJBQL

hibernate學習筆記（總結）

spring中的AOP和IOC

Spring AOP JDK動態代理

JBPM與OA的集成

spring常見知識點

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結