Hibernate一些_方法_@注解_代碼示例_html/css_WEB-ITnose

//第一步
SessionFactory :

1 創建一個SessionFactory對象

Configuration :

 //創建Configuration對象
 Configuration configuration = new Configuration().configuer();
 // 4.0之后為了分布式,用了這種設計 鏈接hibernate框架
 ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
 .applySettings(configuration.getProperties())
 .buildServiceRegistry();

SessionFactory :

 //創建一個SessionFactor對象
 SessionFactory sessionFactiony = null;
 給SessionFactory對象賦值
 sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 //或 SessionFactory sessionFactiony = configuration.buildSessionFactory(serviceRegistry);//也行,一樣

//第二步
Session :

2 創建 Session對象
//用上面創建好的SessionFactory對象,調用方法,創建一個session對象
(1) Session session = sessionFactory.getCurrentSession();
(2) Session session = sessionFactory.opensession();

getCurrentSession :

創建session對象 如果有,就不創建,如果沒有就創建
Session session = sessionFactory.getCurrentSession();
并且,自動關閉資源 不用寫 session.close();

opensession :

創建session對象,別管有沒有,都創建
Session session = sessionFactory.opensession();

并且,用手動關閉資源,
session.close();

//第三步
Transaction :

3 開啟事務:hibernate中,然后數據庫操作,都必須是事務的,哪怕是查詢
Transaction transaction = session.beginTransaction();

//第四步

4 執行數據保存操作

//增
Save :

Save();//添加語句方法,生成insert into 表名(列,列)values(?,?)

//刪
Delete :

Delete();//刪除語句方法,生成delete from 表 where id=?;

//改
Update :

Update();//修改語句,
//如果表里面有對應的語句,就生成修改語句update 表名 set (列名,列名)=(列值,列值) where id = ?;

//查
Load :

Load();//查詢語句方法,生成查詢語句,select * from 表 where id=?
//如果不訪問里面的屬性,就只是查詢一下,并不會執行到數據庫,除非用里面每行對應的對象,去調用一個屬性,才會真正的到數據庫
//如果只是提交了,沒有訪問里面的屬性,不會生成查詢語句,就是沒有對數據庫進行操作

Get :

Get();//查詢語句方法,生成查詢語句,select * from 表 where id=?
//只要提交,就會生成查詢語句,

//Get()和Load()的區別 Load()和Get()的區別

Get() : 只要調用Get()方法并提交,就直接生成查詢語句去訪問數據庫
Load() : 要調用Load()方法并提交,且,如果沒有訪問對象里面的屬性,不會生成查詢語句,也不會操作數據庫,一定要獲取一下屬性,獲取對象引用,也算獲取屬性

//第五步
commit :
5 提交事務
transaction.commit();// 提交事務
transaction是第三步,開啟事務的對象

//第六步
Session_close :
6 關閉Session
// session.close();//getCurrentSession();不需要手動關閉,opensession需要手動關閉

//第七步
SessionFactory_close :
7 關閉SessionFactory對象
sessionFactory.close();

//強注解,強注釋

!!!對表來說,只有多的一方保存少的一方的引用,那些設置都是給程序看的,和數據庫沒有任何關系!!!

@ :
@Entity 在類名上面加的,用于創建表 默認是類名
創建實體類和數據標的映射,指定表名
將一個類聲明為一個實體bean（即一個持久化POJO類）。
@Entity(name="表名") 這樣也行,就規定了表名

@Table :
@Table(name="表名");也行
//1 必須得加:

@IdClass 讓兩個類關聯起來 后面是類名
在類上面寫
聯合主鍵,就是把主鍵都寫在后面指定的類中
@IdClass(value=StudentPK.class)


@Column 設置當前列在修改的時候,是否可以被修改
在實體類的get**()方法上寫 , 就是對于的列
@Column(updatable=false) false就是修改的時候,這個列不能被修改
里面對應的值 :

name 指定列名(默認是屬性名)

unique 設置該列是否設置唯一約束 默認值是false

nullable 設置該列的值是否可以為空,默認值是false

insertable 該列是否作為生成insert語句中的一個列,默認值是true 就是添加的時候,不在此列添加值

updatetable 該列是否作為生成updatetable語句中的一個列,默認是true 就是修改的時候,不修改此列

columnDefinition 為這個特定列覆蓋sql ddl片段(這可能導致無法在不同數據庫間移植)

table 定義對應的表 默認為主表

length 列長度, 默認值255

precision 列十進制精度(decimal precision) 默認值0 此列最大值為N位 位數

scale 如果列十進制數值范圍(decimal scale)可用,在此設置,默認值0

從數據庫查詢出來的數據,我都保存在這里
DTO : 叫Date Traction Object
VO : 值對象 Value Object

@SequenceGenerator :
序列生成器
@SequenceGenerator(name="sequenceGenerator",sequenceName="Msg_SEQ",initialValue=0,allocationSize=1)//生成器名字,序列的名字,起始值為0,步長為1

@TableGenerator 生成器 寫在類上面
//用來存放實體類對應的表,下一次要用的id(存放id的表)
//為主鍵單獨創建一個表,可以跨數據庫平臺,MySQL主鍵自增是自己指定,不是外界指定,可能相同

//有什么好處,能夠解決數據跨平臺保存的問題,因為不同的數據庫平臺生成數據的方式不一樣,比如primary key(pk),如何還能保證呢?自己寫個類庫,兼容不同平臺
//這里的方式是新建一張表,專門用于保存ID,表名:GENERATOR_TABLE,表里面有兩列
//第一列,保存pkColumnName="key", 主鍵所在列的名字
//第二列,保存Id值 valueColumnName="studentId"
//第三列和第四列保存的是值:第三列是key的值,就是要保存id的表名,第四列要保存的步進值,初始值默認是一
//這就意味著,該表可以為無數的表保存Id值,只要對應的表來去一次值,id默認就會加一.有點像一個序列的集合

@TableGenerator( //生成器
name = "student_GEN",//生成器的名字
table = "GENERATOR_TABLE", //在數據庫中,表的名字
pkColumnName = "key", //主鍵所在列的名字
valueColumnName = "studentId", //保存下一次,要保存id列的數據,是去這里取得的ID的值
pkColumnValue = "Student", //指定要用到Id的那張表
initialValue=1, //起始值為1
allocationSize = 1 //步長為1
)

@Id 在實體類的getId()上面強注釋
獲取對應的id作為列名,并能在這個方法中,獲取id的值
相當于設置表里面的主鍵

@GeneratedValue //在@id和getId()直接設置的 去生成器里面拿值,讓每次要添加的數據,ID不相同,不唯一 設置該列自增

generator="生成器的名字" //在哪個生成器取Id
5種格式
1 Auto 隨機
2 table 生成一個表,存放在表里面
3 Identity 序列一類的
4 sequence 序列生成器,生成序列化的數字
5 自定義 自己寫的
@GeneratedValue(strategy=GenerationType.生成的格式 , generator="生成器的名字")
@GeneratedValue(strategy=GenerationType.TABLE , generator="student_GEN")

@OneToOne

要么都寫,一個寫@oneToone 一個寫@ManyToOne
要么在多的里面寫@ManyToOne 多的里面必須要加 unique="true" 設置唯一 就是一對一了

XML :
@OneToOne(mappedBy="wife")
//我不保留對方的引用,只讓對方保存我的引用,并且,是對方的wife那條屬性,保存的是我的引用,
告訴hibernate我們是一對一關系,但是映射是在husband的wife的屬性做的,以那邊為標準,這邊不用管,但是那邊的屬性指向的是wife的id
就是在對面表中,生成一個列,這個列,專門保存本表的id的引用,當本表添加的時候,就讓對面表的這個列,生成一個值,當對面表添加的時候,會參考這個列,生成一個ID,當做對面表的ID
在本實體類中,獲取另外一個類的屬性的get**()上面寫
@OneToOne
告訴hibernate我們是一對一關系,但是映射是在husband的wife的屬性做的,以那邊為標準,這邊不用管,但是那邊的屬性指向的是wife

@ManyToOne

告訴hibernate我們是多對一的關系

多對一 必須寫在多的里面

@JoinTable : //更改表的名字和列的名字

@ManyToMany//多對多

// 想更改表的名字和列的名字
@JoinTable(name = "t_s", // 表名 中間表
joinColumns = { @JoinColumn(name = "teacher_id") },// 中間表的列名
inverseJoinColumns = { @JoinColumn(name = "student_id") })//上面的列名指向的是誰,先通過上面指定的列名,找到這個列名,就能找到student表

@JoinColumn

自己指定外鍵列的名字,還可以指定長度,約束等
@JoinColumn(name="wifeid") 指定外鍵名字為wifeid 寫在外鍵列的get外鍵引用()方法上面

//在少的表,設置多的表中,保存少的表的引用的列的列名
//多的表,保存少的表的引用的那個列的列名

@Embedded

把兩個表弄成一個表,且另一個表沒有@Entity,寫在get**()方法上面
@Embedded(name="asd")指定別的表,保存當前表的引用的那個列的列名

!!!只有在一對一的時候,才有主鍵映射和外鍵映射
//主鍵映射

@PrimaryKeyJoinColumn
在對面引用的列上面加 @PrimaryKeyJoinColumn 就是主鍵映射
主鍵映射 : 不會多生成一個列,添加的時候,會去參照另一個表的主鍵來生成本表的主鍵,本表主鍵和另一個表的主鍵有關聯

//外鍵映射

@ForeignKeyJoinColumn
@OneToOne(mappedBy="wife") //我不保留對面的引用,讓對面來保存我的引用,并且是保存在對面的wife這個屬性,
//我不保存對面的引用,讓對面用wife這個屬性來保存我的引用

外鍵映射 : 多生成一個列,添加的時候,這個新的列會去參照另一個表的主鍵,讓這個列,和另一個表有關聯

mappedBy :

只要是有雙向的關系,就必須保持對方的引用,必須有mappendBy(對面)(限于雙向) 少的一方必須用set集合保存多的一方的引用,且兩邊都注明多對以@ManyToOne(多的寫) 和@OneToMany(一個的寫)

對表來說,只有多的一方保存少的一方的引用,那些設置都是給程序看的,和數據庫沒有任何關系

@OneToMany(mappedBy="group",//就是在對面表中,生成一個列,這個列,專門保存本表的id的引用,當本表添加的時候,就讓對面表的這個列,生成一個值,當對面表添加的時候,會參考這個列,生成一個ID,當做對面表的ID
cascade={CascadeType.ALL},//設置級聯操作,在什么時候起作用
fetch=FetchType.EAGER //級聯操作的時機,這里默認是Lazy因為是少的一方

)

cascade :

cascade={CascadeType.ALL/DETACH/MERGE/PERSIST/REFRESH/REMOVE/自定義};
//設置級聯操作在什么時候起作用,就是A的增刪改查,B也有改變,就相當于是綁定了事件,后面的值,就是事件,當觸發這個事件的時候,就A,B兩個表的屬性都更新同步,級聯操作
ALL : 是所有操作都級聯
DETACH :
MERGE : 也就是修改的時候,相當于update,級聯
REMOVE : 刪除的時候,級聯
還有自定義
fetch :

fetch=FetchType.EAGER/LAZY //這是級聯操作的時機,
EAGER : 的時候,是比如 A里面有個列保存了B的引用,如果這里設置的是EAGER.那取出或者查看的時候,會把這個保存B的引用的那個列也拿出來,

生成語句 :
//生成一條查詢語句

LAZY : 的時候,是如果 A里面有個列保存了B的引用,如果這里設置的是LAZY,那取出或者查看的時候,不會把這個保存B的引用的那個列拿出來,只取出別的列,如果在關閉session對象(緩沖)之前,用到那個保存B的引用的那個列,就會再生成一個查詢語句,去數據庫查詢,再把那個列拿出來

生成語句 :
//如果用到保存B引用的那個列,就會生成兩個查詢語句,否則就是生成一個查詢語句,并且第一次查詢語句中不包括保存B引用的那個列

//執行順序
@Before/@BerforeClass -- > @Test --> @After/@AfterClass

@Before :

用于測試類中 , 用它強注釋的,是第一個執行的,
測試方法是成員方法 此方法是公共的,沒有返回值的,沒有參數列表的,成員方法

@BerforeClass

用于測試類中 , 用它強注釋的,是第一個執行的,
測試方法是靜態方法 此方法是公共的,靜態的,沒有返回值的,沒有參數列表的,靜態方法

@Test :

測試方法 :
1 公共的 的成員方法
2 沒有返回值
3 沒有形參列表

@After :

用于測試類中 , 用它強注釋的,是最后一個執行的,
測試方法是成員方法 此方法是公共的,沒有返回值的,沒有參數列表的,成員方法

@AfterClass :

用于測試類中 , 用它強注釋的,是最后一個執行的,
測試方法是靜態方法 此方法是公共的,靜態的,沒有返回值的,沒有參數列表的,靜態方法

//三種狀態 :

瞬時狀態(臨時狀態)--->持久狀態(保存到數據庫)--->游離狀態(保存完成后關閉session對象 (session.close()))

//三種狀態的區分關鍵在于
1 有沒有ID
2 ID在數據庫中有沒有
3 內存中有沒有(session緩存)

Transient :

Transient(瞬時狀態) : 內存中一個實體類對象,沒有ID,緩存中也沒有
//實例化實體類的時候,就是瞬時狀態

Persistent :

Persistent(持久狀態) : 內存中有,緩存中有,數據庫中有(ID)
//保存到數據庫中,就是持久狀態

Detached :

Detached(游離狀態) : 內存有,緩存沒有,數據庫有,ID
//關閉session對象之后(session.close()),就是游離狀態

//這三種狀態需要關注的問題是在該狀態下,如果進行數據庫操作會發生什么結果,比如改變屬性的值會不會發出update語句

瞬時狀態 : 不會發出update語句
持久狀態 和 游離狀態 都會發出update語句

//聯合主鍵

@EmbeddedId : 嵌入的,寫在實體類中,主鍵類的引用上面,對應的get主鍵類();方法上面
@Embeddable : 可被嵌入的,該類作為另一個類的一部分,寫在主鍵類中,
1
@IdClass :
比如說是兩個主鍵,id和name列,就在實體類中的getId()和getName()上面,加@id 聲明主鍵,并且在類上面寫 @IdClass(寫的主鍵類名.class), 再把這兩個主鍵寫在一個實體類中,
但是這個存有多個主鍵的實體類,必須實現serializable這個接口
在主鍵類的類上面,不用寫@Embeddable

2
@EmbeddedId :
或者是本類中不寫id和name,但是有主鍵類的引用,然后在主鍵類對應的get主鍵類();方法上面,寫個@EmbeddedId,就行了
但是在主鍵類的類上面,要寫@Embeddable

//關聯兩個表

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

//面向對象的形式 :

HQL :

Query :

//---------------------------模糊查詢

QBE :
Topic tExample = new Topic();//自己寫的類
//創建類對象,就是一個表中的一個行的屬性
tExample.setTitle("T_");//往對象里面設置屬性(set***()方法) , 像T_的,一個典型,只能是一個確定值的對象,用于搜索,

Example e = Example.create(tExample).ignoreCase().enableLike();// 靜態方法 添加模糊查詢的方法
Criteria c = session.createCriteria(Topic.class)//給指定類(表)添加約束
.add(Restrictions.gt("id", 2))//id屬性大于2的
.add(Restrictions.lt("id", 8))//id屬性小于8的
.add(e);//上面寫好的模糊查詢 "T_"

//-----------------1+N

//1+N:只要查詢當前對象,他就會查詢別的
//可以多表查詢,可以解決1+N問題
//設置為Lazy
@BatchSize :

@BatchSize(size = 5);////@BathSize: 默認是一個一個抓取,這里可以指定每次抓取的個數
寫在類上面

left_outer_join_fetch :

(用iterator(迭代器)就不能使用join)

Query q = session.createQuery("from Topic t left outer join fetch t.category c ");//Topic是對象,對象里面有個屬性是另外一個表的引用,t.category就能獲得另外一個類對應的表和其中的屬性

List<Category> topics = q.list();//把查詢出來的值,封裝到對應的對象中,再封裝到list集合中
簡寫 :
List<Category> topics = session.createQuery("from Topic t left outer join fetch t.category c");

前提 : 必須有一個對象(表)中的屬性(列),保存的是另一個表的引用
如 : Topic對象中 有個屬性 保存了Category的引用

如 : List<Category> topics = session.createQuery("from 表1 別名(t) left outer join fetch t.表名2 別名(c)");

inner_join_fetch :

List<Category> topics = session.createQuery("from Topic t inner join fetch t.category c");

left_outer_join_fetch :

結果集 :
表2在表1的左邊
//先查詢Topic對象對應的表,再通過topic找到category對應的表,都查詢出來,并且,category對應的表,查詢出來并顯示在Topic的左面 (相當于把兩個表的結果集,合并成一個表,一個在左面,一個在右面)
List<Category> topics = session.createQuery("from Topic t left outer join fetch t.category c");

right_outer_join_fetch :

結果集 :
表2在表1的右邊
//先查詢Topic對象對應的表,再通過topic找到category對應的表,都查詢出來,并且,category對應的表,查詢出來并顯示在Topic的右面 (相當于把兩個表的結果集,合并成一個表,一個在左面,一個在右面)
List<Category> topics = session.createQuery("from Topic t right outer join fetch t.category c");

iterator :

// iterator: 如果使用不允許使用join
//迭代器,把查詢的數據直接用迭代器遍歷
Iterator<泛型,一般用于對象名> categories = session.createQuery("from 對象 別名").iterate();//
Iterator<Category> categories = session.createQuery("from Category c").iterate();//

while (categories.hasNext()) {//hasNext(),是問下一位還有沒有元素,返回值為boolean型,true/false
Category c = categories.next();//next()是取得下一位元素的值,
System.out.println(c.getName());//因為里面都是對象,所以可以通過上面獲取的對象的引用,去訪問對象里面的屬性
}

Cacheable :

開啟緩存,要和ehcache.xml一起使用
List<Category> categories = session.createQuery("from Category").setCacheable(true).list();//查詢Category對象對應的表,然后放入緩存中,封裝到list集合中
setCacheable(true);//開啟緩存

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com