Hibernate---對象的三種狀態
阿新 • • 發佈：2018-06-06
ont ring ive 刪除 com 文件讀取 JD 進行 pda
Hibernate---對象的三種狀態
簡而言之，hibernate本就是面向對象的基於ORM的框架，位於dao層，對數據進行操作的框架。我就談談hibernate的對象的三種狀態。他們分別為：遊離，持久和瞬時。通過代碼來詳解一下吧。
hibernate.cgf.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- property 元素用於配置Hibernate中的屬性
鍵:值
-->
<!-- hibernate.connection.driver_class : 連接數據庫的驅動 -->
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- hibernate.connection.username : 連接數據庫的用戶名 -->
<property name="hibernate.connection.username">root</property>
<!-- hibernate.connection.password : 連接數據庫的密碼 -->
<property name="hibernate.connection.password">root</property>
<!-- hibernate.connection.url : 連接數據庫的地址,路徑 -->
<property name="hibernate.connection.url">
jdbc:mysql://localhost:3306/Hibernate
</property>
<!-- show_sql: 操作數據庫時,會 向控制臺打印sql語句 -->
<property name="show_sql">true</property>
<!-- format_sql: 打印sql語句前,會將sql語句先格式化 -->
<property name="format_sql">true</property>
<!-- hbm2ddl.auto: 生成表結構的策略配置
update(最常用的取值): 如果當前數據庫中不存在表結構,那麽自動創建表結構.
如果存在表結構,並且表結構與實體一致,那麽不做修改
如果存在表結構,並且表結構與實體不一致,那麽會修改表結構.會保留原有列.
create(很少):無論是否存在表結構.每次啟動Hibernate都會重新創建表結構.(數據會丟失)
create-drop(極少): 無論是否存在表結構.每次啟動Hibernate都會重新創建表結構.每次Hibernate運行結束時,刪除表結構.
validate(很少):不會自動創建表結構.也不會自動維護表結構.Hibernate只校驗表結構. 如果表結構不一致將會拋出異常.
-->
<property name="hbm2ddl.auto">update</property>
<!-- 數據庫方言配置
org.hibernate.dialect.MySQLDialect (選擇最短的)
-->
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- hibernate.connection.autocommit: 事務自動提交
<property name="hibernate.connection.autocommit">true</property>
-->
<!-- 將Session與線程綁定=> 只有配置了該配置,才能使用getCurrentSession -->
<property name="hibernate.current_session_context_class">
thread
</property>
<!-- 引入ORM 映射文件
填寫src之後的路徑
-->
<mapping resource="resource/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>user.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- ORM元數據 表對象關系映射文件
package : 配置該配置文件中類所在的包. -->
<hibernate-mapping package="com.huhu.domain">
<!-- class: 配置實體與表的關系
name : 填寫實體的完整類名
table: 與實體對應表的名稱
dynamic-insert:動態插入 默認值是false
true=>如果字段值為null,不參與insert語句
dynamic-update:動態更新 默認值"false"
true=> 沒改動過的屬性,將不會生成到update語句中
-->
<class name="com.huhu.domain.User" table="t_user">
<!-- id: 配置實體與表中 id對應
name: user對象中標識主鍵的屬性名稱
column: 主鍵在表中的列名
length: 列的數據長度
unsaved-value(不常用): 指定主鍵為什麽值時,當做null來處理.
access(強烈推薦不要用):field 那麽在操作屬性時,會直接操作對應的字段而不是get/set方法
-->
<id name="id" column="id">
<!-- generator:主鍵生成策略
1.increment 數據庫自己生成主鍵. 先從數據庫中查詢最大的ID值,將ID值加1作為新的主鍵
2.identity 依賴於數據的主鍵自增功能
3.sequence 序列,依賴於數據中的序列功能(Oracle).
4.hilo(純了解,永遠用不到) : Hibernate自己實現序列的算法,自己生成主鍵. (hilo算法 )
5.native 自動根據數據庫判斷,三選一. identity|sequence|hilo
6.uuid 生成32位的不重復隨機字符串當做主鍵
7.assigned 自己指定主鍵值. 表的主鍵是自然主鍵時使用.
-->
<generator class="native"></generator>
</id>
<!-- property : 實體中屬性與表中列的對應
name : 實體中屬性名稱
column : 表中列的名稱
length : 數據長度
precision: 小數點後的精度
scale: 有效位數
insert(一般不用): 該屬性是否加入insert語句.
update(一般不用): 該屬性是否加入update語句.
not-null : 指定屬性的約束是否使用 非空
unique : 指定屬性的約束是否使用 唯一
-->
<!--
type: 表達該屬性的類型
可以用三種方式指定屬性
java類型 數據庫類型指定 Hibernate類型指定
java.lang.String varchar string
-->
<property name="name" column="name"></property>
<property name="password" column="password"></property>
</class>
</hibernate-mapping> User
package com.huhu.domain;
// Hibernate
public class User {
private Integer id;
private String name;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", password=" + password
+ "]";
}
} HibernateUtils
package com.huhu.utils;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
//完成Hibernate工具類
//封裝配置文件讀取操作
//封裝Sessionfactroy創建操作
//封裝session獲得操作
public class HibernateUtils {
private static SessionFactory sf;
static{
//1加載配置
Configuration conf = new Configuration().configure();
//2 根據Configuration 配置信息創建 SessionFactory
sf = conf.buildSessionFactory();
//
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
@Override
public void run() {
System.out.println("虛擬機關閉!釋放資源");
sf.close();
}
}));
}
public static org.hibernate.Session openSession(){
//3 獲得session
Session session = sf.openSession();
return session;
}
public static org.hibernate.Session getCurrentSession(){
//3 獲得session
Session session = sf.getCurrentSession();
return session;
}
public static void main(String[] args) {
System.out.println(openSession());
}
}
HibernateDemo1
package com.huhu.a_state;
import com.huhu.domain.User;
import com.huhu.utils.HibernateUtils;
import org.hibernate.Session;
/**
* 對象的三種狀態
*/
public class HibernateDemo1 {
//三種狀態
public void fun1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------
User u = new User(); //status : 瞬時狀態
u.setName("tom"); //status : 瞬時狀態
u.setPassword("1234"); //status : 瞬時狀態
//保存
session.save(u); //status : 持久狀態
//調用save方法時,數據庫有沒有對應記錄
//沒有記錄，但最終會被同步到數據庫中，仍時持久狀態
//--------------------------------------
session.getTransaction().commit(); //status : 持久狀態
session.close(); //status : 遊離狀態
}
// 三種狀態的轉換 瞬時=》持久
public void fun2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------
User u = new User(); //status : 瞬時狀態
u.setName("he"); //status : 瞬時狀態
u.setPassword("123456"); //status : 瞬時狀態
session.save(u); //status : 持久狀態
//--------------------------------------
session.getTransaction().commit(); //status : 持久狀態
//事務提交時會把持久對象保存到數據庫
//increment=>hibernate 自動查詢最大id，然後生成主鍵
//assigned =>自動生成主鍵
session.close();
}
// 瞬時=》遊離 瞬時：沒有關聯沒有id 遊離：沒有關聯有id(與數據庫對應的id)
public void fun3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
User u = new User();
u.setId(2); //此時為遊離狀態
//--------------------------------------
session.getTransaction().commit(); //status : 持久狀態
//事務提交時會把持久對象保存到數據庫
session.close();
}
//持久=》瞬時1 持久：有關聯，有id，瞬時：無關聯無id
public void fun4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 2); //持久狀態
//--------------------------------------
session.getTransaction().commit();
//事務提交時會把持久對象保存到數據庫
session.close(); //遊離狀態
u.setId(null);
}
//持久=》瞬時1 持久：有關聯，有id，瞬時：無關聯無id
public void fun5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 4); //持久狀態
session.evict(u); //將User對象和session的關聯移除
u.setId(null); //瞬時對象
//--------------------------------------
session.getTransaction().commit();
session.save(u);
//事務提交時會把持久對象保存到數據庫
session.close(); //遊離狀態
}
// 持久=》遊離 持久：有關聯，有id
public void fun6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 4); //持久狀態
session.evict(u); //將User對象和session的關聯移除
//--------------------------------------
session.getTransaction().commit(); //遊離
session.close(); //遊離狀態
}
// 遊離=》瞬時 瞬時：無關聯無id
public void fun7() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 4); //持久狀態
session.evict(u); //瞬時
u.setId(null); //瞬時
//--------------------------------------
session.getTransaction().commit(); //瞬時
session.close(); //瞬時狀態
}
// 遊離=》持久 是否與session關聯
public void fun8() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//status : 持久狀態
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 4); //持久狀態
session.evict(u); //遊離
session.update(u); //持久
//--------------------------------------
session.getTransaction().commit(); //持久 打印updata語句
session.close(); //瞬時狀態
}
public void fun9() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
//--------------------------------------//
//通過get方法，得到持久狀態對象
User u = (User) session.get(User.class, 4);
u.setName("nenen");
//--------------------------------------
session.getTransaction().commit();
session.close(); //瞬時狀態
}
public static void main(String[] args) {
HibernateDemo1 d = new HibernateDemo1();
//d.fun1();
d.fun9();
}
}
代碼顯而易見。如果覺得不明顯再來一個圖吧。
總結下吧：
三種狀態有什麽用：
1.持久狀態：我們使用hibernate主要時為了持久化數據
2.對於對象的狀態： 我們期望我們現需要同步到數據庫的數據，都被轉化為持久化
持久話對象的特點:
hibernate會自動將持久話對象的變化同步到數據庫.
所以說hibernate是一個面向對象的框架，利用對象的操作數據。
Hibernate---對象的三種狀態