程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> hibernate初步2，hibernate

hibernate初步2，hibernate

編輯：JAVA綜合教程

hibernate初步2，hibernate

Hibernate級聯設計

數據庫表之間的關系（主要關系有一對多、一對一、多對多）主要是從如下三個方面體現出來：

1.表體設計

2.實體類的設計

3.配置文件

以下是一些重要級聯設計參數屬性介紹：

cascade級聯操作，默認值為 none

1.none：只做級聯查詢

2.save-update：級聯查詢，級聯插入和級聯更新

3.delete：級聯查詢，級聯刪除

4.all：級聯查詢，級聯插入，級聯更新和級聯刪除

5.all-delete-orphan：基礎主從表記錄關系時，會把從表對應的記錄一並刪除

inverse：維護兩張表之間的關系，默認值是 false，即維護從表的外鍵值

1.ture：不維護從表外鍵值

2.false：維護從表外鍵值

3.在 hibernate 中通過對 inverse 屬性的值決定是由雙向關聯的哪一方來維護表和表之間的關系. inverse=false 的為主動方，inverse=true 的為被動方, 由主動方負責維護關聯關系

4. 在沒有設置 inverse=true 的情況下，父子兩邊都維護父子關系

5.在 1-n 關系中，將 n 方設為主控方將有助於性能改善

6.在 1-N 關系中，若將 1 方設為主控方會額外多出 update 語句。

注意：cascade 和 inverse 優先考慮cascade操作，然後再考慮 inverse 操作！

lazy:是否延遲加載從表取出來的數據

1.true 延遲加載

2.flase 不延遲加載

一對多關聯關系映射（表的設計原則是：在多的一方添加外鍵鏈來描述彼此之間的關系）

POJO類的設計：

1.設計 OrderItem 類，它代表為“1”的一方：

public class OrderItem {
    private int id;
    private int amount;
    private String productName;
    private UserOrder userOrder;

    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public int getAmount() {return amount;}
    public void setAmount(int amount) {this.amount = amount;}
    public String getProductName() {return productName;}
    public void setProductName(String productName) {this.productName = productName;}
    public UserOrder getUserOrder() {return userOrder;}
    public void setUserOrder(UserOrder userOrder) {this.userOrder = userOrder;}
}

2.設計 UserOrder 類，它代表為"n"的一方：

import java.util.HashSet;
import java.util.Set;

public class UserOrder {
    private int id;
    private int userId;
    private int status;
    private double cost;
    /**
     * 存放相關聯的OrderItem對象
     */
    private Set<OrderItem> orderItems = new HashSet<OrderItem>();
    //從面向對象的角度來看，在“多”的一方使用一個集合用來保存另一個相關聯的對象的信息。
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public int getUserId() {return userId;}
    public void setUserId(int userId) {this.userId = userId;}
    public int getStatus() {return status;}
    public void setStatus(int status) {this.status = status;}
    public double getCost() {return cost;}
    public void setCost(double cost) {this.cost = cost;}
    
    public Set<OrderItem> getOrderItems() {
        return orderItems;
    }
    public void setOrderItems(Set<OrderItem> orderItems) {
        this.orderItems = orderItems;
    }
    @Override
    public String toString() {
        return "UserOrder [id=" + id + ", userId=" + userId + ", status=" + status + ", cost=" + cost + "]";
    }
}

3.建立 OrderItem 的 Hibernate 相關映射配置文件：orderitem.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="net.togogo.onetomany.pojo.OrderItem" table="order_item" >
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="amount" type="int">
            <column name="amount" length="11" />
        </property>
        <property name="productName" type="string">
            <column name="productName" length="30" />
        </property>
  
        <many-to-one name="userOrder" class="net.togogo.onetomany.pojo.UserOrder" cascade="all" column="order_id">
　　　　 </many-to-one>
    </class> 
</hibernate-mapping>

4.建立 UserOrder 的 Hibernate 相關映射配置文件：userorder.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
　　<!--  POJO 數據庫中的表對應的實體類 -->
    <class name="net.togogo.onetomany.pojo.UserOrder" table="user_order" >
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="userId" type="int">
            <column name="user_id" length="11" />
        </property>
        <property name="status" type="int">
            <column name="status" length="11" />
        </property>
        <property name="cost" type="double">
            <column name="cost" />
        </property>
       
        <!-- many-to-one屬性說明: 
　　　　　* name:設定待映射的持久化類的名字。 
　　　　　　name="orderItems"，對應UserOrder中的setOrderItems(Set<OrderItem> orderItems)方法

　　　　　column:設定和持久化類的屬性對應的表的外鍵。 

　　　　　class:設定持久化類的屬性的類型。
 
　　　　　not-null:是否允許為空。 

        cascade：級聯操作，默認值是none，常用的值：
        1)none：只做級聯查詢
        2)save-update：級聯查詢,級聯插入和級聯更新
        3)delete：級聯查詢,級聯刪除
        4)all：級聯查詢,級聯插入，級聯刪除，級聯更新
        5)all-delete-orphan：解除主從表記錄關系時，會把從表對應的記錄一並刪除
        
        inverse：維護兩張表之間的關系，默認是false,即維護從表的外鍵值
        1）true：不維護從表外鍵值
        2) false：維護從表外鍵值
        
        cascade和inverse：優先考慮cascade操作，然後再考慮inverse
        
        lazy:是否延遲加載從表的數據，true，延遲加載，false，立即加載
         -->

        <set name="orderItems" cascade="all-delete-orphan" inverse="false" lazy="true">
            <!-- 從表的外鍵字段 -->
            <key column="order_id"></key>
            <one-to-many class="net.togogo.onetomany.pojo.OrderItem"/>
        </set>
    </class>   
</hibernate-mapping>

5.在 hibernate.cfg.xml 配置文件加入 userorder.hbm.xml 和 orderitem.hbm.xml 相關信息：

<!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 name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
　　　　　<!-- 所使用的數據庫名 -->
        <property name="hibernate.connection.url">
　　　　　　 jdbc:mysql://localhost:3306/hibernate_db
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>  
        <!-- 設置連接池大小 -->
        <property name="hibernate.connection.pool_size">10</property>
        <!-- 
        實質是調用 Statement.setFetchSize() 方法設定JDBC的Statement讀取數據的時候每次從數據庫中取出的記錄條數。
　　　　 例如一次查詢1萬條記錄，對於Oracle的JDBC驅動來說，是不會 1 次性把1萬條取出來的，而只會取出Fetch Size條數，
　　　　 當紀錄集遍歷完了這些記錄以後，再去數據庫取Fetch Size條數據。因此大大節省了無謂的內存消耗。
        Fetch Size設的越大，讀數據庫的次數越少，速度越快；Fetch Size越小，讀數據庫的次數越多，速度越慢。
        Oracle數據庫的JDBC驅動默認的Fetch Size=10，是一個保守的設定，根據測試，當Fetch Size=50時，性能會提升1倍之多，
　　　　　當Fetch Size=100，性能還能繼續提升20%，Fetch Size繼續增大，性能提升的就不顯著了。
        並不是所有的數據庫都支持Fetch Size特性，例如MySQL就不支持。MySQL就像上面那種最壞的情況，總是一下就把1萬條記錄完全取出來，
　　　　　內存消耗會非常驚人！
         -->
        <property name="hibernate.jdbc.fetch_size">50</property>
        <!-- 
        設定對數據庫進行批量刪除，批量更新和批量插入的時候的批次大小，類似於設置緩沖區大小的意思。Batch Size越大，
　　　　　　批量操作的向數據庫發送sql的次數越少，速度就越快。測試結果是當Batch Size=0的時候，使用Hibernate對Oracle
　　　　　　數據庫刪除1萬條記錄需要25秒，Batch Size = 50的時候，刪除僅僅需要5秒！
        　Oracle數據庫 Batch Size = 30 的時候比較合適
         -->
        <property name="hibernate.jdbc.batch_size">50</property>
                
        <!-- 顯示底層的sql語句,開發階段設為true,項目發布階段設為false -->
        <property name="show_sql">true</property>
        <property name="format_sql">false</property>
        <property name="use_sql_comments">false</property>
        
        <!-- 在啟動和停止時自動地創建，更新或刪除數據庫模式。取值 create | update | create-drop | validate，
　　　　推薦使用update，update值表示如果之前有表，就用之前的表，否則創建新的表 -->
        <property name="hbm2ddl.auto">update</property>
        <mapping resource="net/togogo/onetomany/pojo/userorder.hbm.xml"/>
        <mapping resource="net/togogo/onetomany/pojo/orderitem.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

一對一級聯關系映射（表的設計原則是：存在主從關系，主可以沒有從，但從不能沒有主。在從表中將主鍵鏈（默認擁有唯一約束和非空約束）聲明成外鍵約束即可。---------也就是說，有一列既是主鍵列又是外鍵鏈。）

POJO類的設計

1.設計 Boy 類，它代表為"1"的一方：

public class Boy {
    private int id;
    private String name;
    private Girl girl;

    public int getId() { return id;}
    public void setId(int id) { this.id = id;}
    public String getName() {return name; }
    public void setName(String name) { this.name = name;}
    public Girl getGirl() {return girl;}
    public void setGirl(Girl girl) {this.girl = girl;} 
}

2.設計 Girl 類，它代表為"1"的另一方：

public class Girl {
    private int id;
    private String name;
    private Boy boy;
    
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Boy getBoy() {return boy;}
    public void setBoy(Boy boy) {this.boy = boy;}
}

3.建立 Boy 的 Hibernate 相關映射配置文件：boy.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Mapping file autogenerated by MyEclipse Persistence Tools -->
<hibernate-mapping>
    <class name="net.togogo.onetoone.pojo.Boy" table="boy">
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="name" type="string">
            <column name="name" length="30" />
        </property>

        <many-to-one name="girl" cascade="all" lazy="false"
            class="net.togogo.onetoone.pojo.Girl" unique="true" column="g_id"></many-to-one>
    </class>

</hibernate-mapping>

4.建立 Girl 的 Hibernate 相關映射配置文件：girl.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Mapping file autogenerated by MyEclipse Persistence Tools -->
<hibernate-mapping>
    <class name="net.togogo.onetoone.pojo.Girl" table="girl">
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="name" type="string">
            <column name="name" length="30" />
        </property>

        <one-to-one name="boy" cascade="all" lazy="false"
            class="net.togogo.onetoone.pojo.Boy">           
        </one-to-one>
    </class>
</hibernate-mapping>

5.在 hibernate.cfg.xml 配置文件加入 boy.hbm.xml 和 girl.hbm.xml 相關信息：

<!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 name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/hibernate_db
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
                
        <!-- 設置連接池大小 -->
        <property name="hibernate.connection.pool_size">10</property>   
        <property name="hibernate.jdbc.fetch_size">50</property>
        <property name="hibernate.jdbc.batch_size">50</property>
        <property name="show_sql">true</property>
        <property name="format_sql">false</property>
        <property name="use_sql_comments">false</property>    
        <property name="hbm2ddl.auto">update</property>
        
        <mapping resource="net/togogo/onetoone/pojo/girl.hbm.xml"/>
        <mapping resource="net/togogo/onetoone/pojo/boy.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

多對多級聯關系映射（數據庫表的設計原則：增加一個表用來保存兩個表之間的關系）

POJO類的設計：

1.設計 Couse 類，它代表為"多"的一方：

public class Course {
    private int id;
    private String name;

    public int getId() {return id;}
    public void setId(int id) {this.id = id; }
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}    
}

2.設計 Stu 類，它代表為"多"的另一方：

public class Stu {
    private int id;
    private String name;
    private Set<Course> courses = new HashSet<Course>();

    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Set<Course> getCourses() {return courses;}
    public void setCourses(Set<Course> courses) {this.courses = courses;}    
}

3.建立 Course 的 Hibernate 相關映射配置文件：course.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="net.togogo.manytomany.pojo.Course" table="course">
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="name" type="string">
            <column name="name" length="30" />
        </property>
    </class>
</hibernate-mapping>

4.建立 Stu 的 Hibernate 相關映射配置文件：stu.hbm.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Mapping file autogenerated by MyEclipse Persistence Tools -->
<hibernate-mapping>
    <class name="net.togogo.manytomany.pojo.Stu" table="stu">
        <id name="id" type="int">
            <column name="id" />
            <generator class="native"></generator>
        </id>
        <property name="name" type="string">
            <column name="name" length="30" />
        </property>     
        <!-- inverse="false"，在這裡是要維護stu_course中的記錄值 -->
         <set name="courses" cascade="all" inverse="false" lazy="false" table="stu_course">
            <key column="s_id"/>
            <many-to-many column="c_id" class="net.togogo.manytomany.pojo.Course"></many-to-many>
        </set>    
    </class>
</hibernate-mapping>

5.在 hibernate.cfg.xml 配置文件加入 stu.hbm.xml 和 course.hbm.xml 相關信息：

<!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 name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/hibernate_db
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <!-- 設置連接池大小 -->
        <property name="hibernate.jdbc.fetch_size">50</property>
        <property name="hibernate.jdbc.batch_size">50</property>
        <property name="show_sql">true</property>
        <property name="format_sql">false</property>
        <property name="use_sql_comments">false</property>
        <property name="hbm2ddl.auto">update</property>
        
        <mapping resource="net/togogo/manytomany/pojo/stu.hbm.xml"/>
        <mapping resource="net/togogo/manytomany/pojo/course.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

對象的狀態轉化

Hibernate 把對象分為 4 種狀態:
1.臨時狀態
2.持久狀態
3.游離狀態
4.刪除狀態
Session 的特定方法能使對象從一個狀態轉換到另一個狀態

臨時狀態(transient)
1.在使用代理主鍵的情況下, OID 通常為 null
2.不處於 Session 的緩存中
3.在數據庫中沒有對應的記錄

持久化狀態(托管狀態)（Persist）
1.OID 不為 null
2.位於 Session 緩存中
3.持久化對象和數據庫中的相關記錄對應
4.Session 在清理緩存時, 會根據持久化對象的屬性變化, 來同步更新數據庫
5.在同一個 Session 實例的緩存中, 數據庫表中的每條記錄只對應唯一的持久化對象

游離狀態(Detached)
1.OID 不為 null
2.不再處於 Session 的緩存中
3.一般情況需下, 游離對象是由持久化對象轉變過來的, 因此在數據庫中可能還存在與它對應的記錄

刪除狀態(Removed)
1.OID 不為 null
2.從一個 Session實例的緩存中刪除
3.Session 已經計劃將其從數據庫刪除, Session 在清理緩存時, 會執行 SQL delete 語句, 刪除數據庫中的對應記錄
4.一般情況下, 應用程序不該再使用被刪除的對象