2. 程式人生 > >Hibernate各種查詢方式及查詢策略

Hibernate各種查詢方式及查詢策略

阿新 • • 發佈：2019-02-20

在瞭解Hibernate的基本知識後，重點讓我們看下相關查詢方式和查詢優化策略吧！
話不多說，先來張思維導圖看下：
2

1.一對多情況

*以例項呈現：

如下：

1. JavaWEB中一對多的設計及其建表原則

2. 先匯入SQL的建表語句

* 建立今天的資料庫：create database hibernate_day03;
* 在資料中找到客戶和聯絡人的SQL指令碼

3. 編寫客戶和聯絡人的JavaBean程式（注意一對多的編寫規則）

*客戶的JavaBean如下:

public class Customer {
            private
 
 Long cust_id;
            private String cust_name;
            private Long cust_user_id;
            private Long cust_create_id;
            private String cust_source;
            private String cust_industry;
            private String cust_level;
            private String cust_linkman;
            private
 
 String cust_phone;
            private String cust_mobile;

            private Set<Linkman> linkmans = new HashSet<Linkman>();

        }

*聯絡人的JavaBean如下:

public class Linkman {
            private Long lkm_id;
            private String lkm_name;
            private String lkm_gender;
            private
 
 String lkm_phone;
            private String lkm_mobile;
            private String lkm_email;
            private String lkm_qq;
            private String lkm_position;
            private String lkm_memo;

            private Customer customer;

        }

4. 編寫客戶和聯絡人的對映配置檔案（注意一對多的配置編寫）

* 客戶的對映配置檔案如下

<class name="com.itheima.domain.Customer" table="cst_customer">
            <id name="cust_id" column="cust_id">
                <generator class="native"/>
            </id>
            <property name="cust_name" column="cust_name"/>
            <property name="cust_user_id" column="cust_user_id"/>
            <property name="cust_create_id" column="cust_create_id"/>
            <property name="cust_source" column="cust_source"/>
            <property name="cust_industry" column="cust_industry"/>
            <property name="cust_level" column="cust_level"/>
            <property name="cust_linkman" column="cust_linkman"/>
            <property name="cust_phone" column="cust_phone"/>
            <property name="cust_mobile" column="cust_mobile"/>

            <set name="linkmans">
                <key column="lkm_cust_id"/>
                <one-to-many class="com.itheima.domain.Linkman"/>
            </set>
        </class>

聯絡人的對映配置檔案如下:

<class name="com.itheima.domain.Linkman" table="cst_linkman">
            <id name="lkm_id" column="lkm_id">
                <generator class="native"/>
            </id>
            <property name="lkm_name" column="lkm_name"/>
            <property name="lkm_gender" column="lkm_gender"/>
            <property name="lkm_phone" column="lkm_phone"/>
            <property name="lkm_mobile" column="lkm_mobile"/>
            <property name="lkm_email" column="lkm_email"/>
            <property name="lkm_qq" column="lkm_qq"/>
            <property name="lkm_position" column="lkm_position"/>
            <property name="lkm_memo" column="lkm_memo"/>

            <many-to-one name="customer" class="com.itheima.domain.Customer" column="lkm_cust_id"/>
        </class>

*級聯儲存操作

** 1. 測試：如果現在程式碼只插入其中的一方的資料

* 如果只儲存其中的一方的資料，那麼程式會丟擲異常。
* 如果想完成只儲存一方的資料，並且把相關聯的資料都儲存到資料庫中，那麼需要配置級聯！！

* 級聯儲存是方向性

** 2. 級聯儲存效果

* 級聯儲存：儲存一方同時可以把關聯的物件也儲存到資料庫中！！
* 使用cascade="save-update"

*級聯刪除操作

在資料庫中演示含有外來鍵的刪除客戶功能，那麼SQL語句是會報出錯誤的
* 例如：delete from customers where cid = 1;如果使用Hibernate框架直接刪除客戶的時候，測試發現是可以刪除的，這是簡單地刪除操作，而還有另一種刪除，即級聯刪除，* ，這也是具有方向性的，但是需要慎用！

* cascade的用法

取值如下：
* none – 不使用級聯
* save-update – 級聯儲存或更新
* delete – 級聯刪除
* delete-orphan – 孤兒刪除.(注意：只能應用在一對多關係)
* all – 除了delete-orphan的所有情況.（包含save-update delete）
* all-delete-orphan – 包含了delete-orphan的所有情況.（包含save-update delete delete-orphan）
注意的是，孤兒刪除（孤子刪除），只有在一對多的環境下才有孤兒刪除：
* 在一對多的關係中,可以將一的一方認為是父方.將多的一方認為是子方.孤兒刪除:在解除了父子關係的時候.將子方記錄就直接刪除。
*

* 外來鍵的放棄

如果雙方都維護外來鍵的時候，會產生多餘的SQL語句。產生的原因：session的一級快取中的快照機制，會讓雙方都更新資料庫，產生了多餘的SQL語句。如果不想產生多餘的SQL語句，那麼需要一方來放棄外來鍵的維護！
* 在標籤上配置一個inverse=”true”.true:放棄.false:不放棄.預設值是false
*

2.多對多情況

* 例項展示

1. 編寫使用者和角色的JavaBean

//使用者的JavaBean程式碼如下:
     public class User {
            private Long user_id;
            private String user_code;
            private String user_name;
            private String user_password;
            private String user_state;

            private Set<Role> roles = new HashSet<Role>();
        }
     //角色的JavaBean程式碼如下
        public class Role {
            private Long role_id;
            private String role_name;
            private String role_memo;

            private Set<User> users = new HashSet<User>();
        }

2. 使用者和角色的對映配置檔案如下:

 * 使用者的對映配置檔案如下:
        <class name="com.itheima.domain.User" table="sys_user">
            <id name="user_id" column="user_id">
                <generator class="native"/>
            </id>
            <property name="user_code" column="user_code"/>
            <property name="user_name" column="user_name"/>
            <property name="user_password" column="user_password"/>
            <property name="user_state" column="user_state"/>

            <set name="roles" table="sys_user_role">
                <key column="user_id"/>
                <many-to-many class="com.itheima.domain.Role" column="role_id"/>
            </set>
        </class>

 * 角色的對映配置檔案如下
        <class name="com.itheima.domain.Role" table="sys_role">
            <id name="role_id" column="role_id">
                <generator class="native"/>
            </id>
            <property name="role_name" column="role_name"/>
            <property name="role_memo" column="role_memo"/>

            <set name="users" table="sys_user_role">
                <key column="role_id"/>
                <many-to-many class="com.itheima.domain.User" column="user_id"/>
            </set>
        </class>

3. 多對多進行雙向關聯的時候:必須有一方去放棄外來鍵維護權

* 級聯儲存

* <set cascade="save-update">

* 雙方必須有一方放棄對外來鍵的維護

 <inverse="true">

3.查詢方式

*通過OID方式查詢

 * session.get(物件.class,OID)
 * session.load(物件.class,OID)

注意：load具有延遲快取的效果！

*物件的導航的方式

* HQL的檢索方式（ Hibernate Query Language）

1. HQL的介紹

* HQL(Hibernate Query Language) 是面向物件的查詢語言, 它和 SQL 查詢語言有些相似
* 在 Hibernate 提供的各種檢索方式中, HQL 是使用最廣的一種檢索方式

2. HQL與SQL的關係

* HQL 查詢語句是面向物件的,Hibernate負責解析HQL查詢語句, 然後根據物件-關係對映檔案中的對映資訊, 把 HQL 查詢語句翻譯成相應的 SQL 語句. 
* HQL 查詢語句中的主體是域模型中的類及類的屬性
* SQL 查詢語句是與關係資料庫繫結在一起的. SQL查詢語句中的主體是資料庫表及表的欄位

3.一些基本查詢例項

1.HQL基本的查詢格式
* 支援方法鏈的程式設計，即直接呼叫list()方法
* 簡單的程式碼如下
* session.createQuery(“from Customer”).list();

  1. 使用別名的方式

    • 可以使用別名的方式
      • session.createQuery(“from Customer c”).list();
      • session.createQuery(“select c from Customer c”).list();

  2. 排序查詢

    • 排序查詢和SQL語句中的排序的語法是一樣的

      • 升序

        • session.createQuery(“from Customer order by cust_id”).list();

      • 降序

        • session.createQuery(“from Customer order by cust_id desc”).list();

  3. 分頁查詢

    • Hibernate框架提供了分頁的方法，咱們可以呼叫方法來完成分頁

    • 兩個方法如下

      • setFirstResult(a) – 從哪條記錄開始，如果查詢是從第一條開啟，值是0
      • setMaxResults(b) – 每頁查詢的記錄條數

    • 演示程式碼如下

      • List list = session.createQuery(“from LinkMan”).setFirstResult(0).setMaxResults().list();

  4. 帶條件的查詢

    • setParameter(“?號的位置，預設從0開始”,”引數的值”); 不用考慮引數的具體型別
    • 按位置繫結引數的條件查詢（指定下標值，預設從0開始）
    • 按名稱繫結引數的條件查詢（HQL語句中的 ? 號換成 :名稱 的方式）
 //例如程式碼如下:
        Query query = session.createQuery("from Linkman where lkm_name like ? order by lkm_id desc");
        query.setFirstResult(0).setMaxResults(3);
        query.setParameter(0, "%熊%");
        List<Linkman> list = query.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }

6.聚合查詢
例如：

// 獲取總的記錄數
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select count(c) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

// 獲取某一列資料的和
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

7.投影查詢
* 如果查詢多個欄位，例如下面這種方式

List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
* 如果查詢兩個欄位，也可以把這兩個欄位封裝到物件中
    * 先在持久化類中提供對應欄位的構造方法
    * 使用下面這種HQL語句的方式

List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
            for (Customer customer : list) {
                System.out.println(customer);
            }

8.HQL多表查詢
1. 多表的查詢進來使用HQL語句進行查詢，HQL語句和SQL語句的查詢語法比較類似。
* 內連線查詢
* 顯示內連線
* select * from customers c inner join orders o on c.cid = o.cno;
* 隱式內連線
* select * from customers c,orders o where c.cid = o.cno;

* 外連線查詢
    * 左外連線
        * select * from customers c left join orders o on c.cid = o.cno;
    * 右外連線
        * select * from customers c right join orders o on c.cid = o.cno;

  1. HQL的多表查詢

    • 迫切和非迫切：
      • 非迫切返回結果是Object[]
      • 迫切連線返回的結果是物件，把客戶的資訊封裝到客戶的物件中，把訂單的資訊封裝到客戶的Set集合中。

  2. 內連線查詢

    • 內連線使用 inner join ，預設返回的是Object陣列
Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Object[]> list = session.createQuery("from Customer c inner join c.linkmans").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        tr.commit();
* 迫切內連線:inner join fetch ，返回的是實體物件
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
    Set<Customer> set = new HashSet<Customer>(list);
    for (Customer customer : set) {
        System.out.println(customer);
    }
    tr.commit();

  1. 左外連線查詢

    • 左外連線: 封裝成List

Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
        Set<Customer> set = new HashSet<Customer>(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }
        tr.commit();

* QBC的檢索方式——Query By Criteria – 條件查詢

  1. 簡單查詢，使用的是Criteria介面
List<Customer> list = session.createCriteria(Customer.class).list();
    for (Customer customer : list) {
        System.out.println(customer);
    }
  1. 排序查詢
    • 需要使用addOrder()的方法來設定引數，引數使用org.hibernate.criterion.Order物件
* 具體程式碼如下：
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();
  1. 分頁查詢
    • QBC的分頁查詢也是使用兩個方法
      • setFirstResult();
      • setMaxResults();
* 程式碼如下;
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        criteria.setFirstResult(0);
        criteria.setMaxResults(3);
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();
  1. 條件查詢（Criterion是查詢條件的介面，Restrictions類是Hibernate框架提供的工具類，使用該工具類來設定查詢條件）
    • 條件查詢使用Criteria介面的add方法，用來傳入條件。
    • 使用Restrictions的新增條件的方法，來新增條件，例如：
      • Restrictions.eq – 相等
      • Restrictions.gt – 大於號
      • Restrictions.ge – 大於等於
      • Restrictions.lt – 小於
      • Restrictions.le – 小於等於
      • Restrictions.between – 在之間
      • Restrictions.like – 模糊查詢
      • Restrictions.in – 範圍
      • Restrictions.and – 並且
      • Restrictions.or – 或者
* 測試程式碼如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設定排序
        criteria.addOrder(Order.desc("lkm_id"));
        // 設定查詢條件
        criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

* 聚合函式查詢（Projection的聚合函式的介面，而Projections是Hibernate提供的工具類，使用該工具類設定聚合函式查詢）

* 使用QBC的聚合函式查詢，需要使用criteria.setProjection()方法
* 具體的程式碼如下
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    Criteria criteria = session.createCriteria(Linkman.class);
    criteria.setProjection(Projections.rowCount());
    List<Number> list = criteria.list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

*離線查詢

  1. 離線條件查詢使用的是DetachedCriteria介面進行查詢，離線條件查詢物件在建立的時候，不需要使用Session物件，只是在查詢的時候使用Session物件即可。

  2. 建立離線條件查詢物件

    • DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

  3. 具體的程式碼如下

Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
    // 設定查詢條件
    criteria.add(Restrictions.eq("lkm_gender", "男"));
    // 查詢資料
    List<Linkman> list = criteria.getExecutableCriteria(session).list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();

* SQL檢索方式（瞭解）

* 本地的SQL檢索
例如：

 Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
    sqlQuery.setParameter(0,"男");
    sqlQuery.addEntity(Linkman.class);
    List<Linkman> list = sqlQuery.list();
    System.out.println(list);
    tr.commit();

4.查詢優化策略

*延遲載入

1. 延遲載入先獲取到代理物件，當真正使用到該物件中的屬性的時候，才會傳送SQL語句，是Hibernate框架提升效能的方式

2. 類級別的延遲載入

* Session物件的load方法預設就是延遲載入
* Customer c = session.load(Customer.class, 1L);沒有傳送SQL語句，當使用該物件的屬性時，才傳送SQL語句.

* 使類級別的延遲載入失效
** 在標籤上配置lazy=”false”
** Hibernate.initialize(Object proxy);

3. 關聯級別的延遲載入（查詢某個客戶，當檢視該客戶下的所有聯絡人是是否是延遲載入）

!!!預設是延遲載入………

Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Customer c = session.get(Customer.class, 1L);
        System.out.println("=============");
        System.out.println(c.getLinkmans().size());
        tr.commit();

*Hibernate框架查詢策略

1. 查詢策略：使用Hibernate查詢一個物件的時候，查詢其關聯物件.應該如何查詢.是Hibernate的一種優化手段!!!

2. Hibernate框架的檢索策略解決的問題

  • 查詢的時機
Customer c1 = (Customer) session.get(Customer.class, 1);
        System.out.println(c1.getLinkmans().size());

  • lazy屬性解決查詢的時機的問題，需要配置是否採用延遲載入！！

  • 查詢的語句形式

List<Customer> list = session.createQuery("from Customer").list();
        for(Customer c : list){
            System.out.println(c.getLinkmans());
        }
  • fetch屬性就可以解決查詢語句的形式的問題！！

*Set標籤上配置策略

1. 在標籤上使用fetch和lazy屬性

  • fetch的取值 – 控制SQL語句生成的格式

    • select – 預設值.傳送查詢語句
    • join – 連線查詢.傳送的是一條迫切左外連線!!!配置了join.lazy就失效了
    • subselect – 子查詢.傳送一條子查詢查詢其關聯物件.(需要使用list()方法進行測試)

  • lazy的取值 – 查詢關聯物件的時候是否採用延遲!

    • true – 預設.延遲
    • false – 不延遲
    • extra – 及其懶惰

2. set標籤上的預設值是fetch=”select”和lazy=”true”

3. 總結：Hibernate框架都採用了預設值，開發中基本上使用的都是預設值。特殊的情況。

*many-to-one標籤上配置策略

1. 在標籤上使用fetch和lazy屬性

  • fetch的取值 – 控制SQL的格式.

    • select – 預設。傳送基本select語句查詢
    • join – 傳送迫切左外連線查詢

  • lazy的取值 – 控制載入關聯物件是否採用延遲.

    • false – 不採用延遲載入.
    • proxy – 預設值.代理.現在是否採用延遲.
      • 由另一端的上的lazy確定.如果這端的class上的lazy=”true”.proxy的值就是true(延遲載入).
      • 如果class上lazy=”false”.proxy的值就是false(不採用延遲.)

2. 在標籤上的預設值是fetch=”select”和proxy。

相關推薦

Hibernate各種查詢方式及查詢策略

在瞭解Hibernate的基本知識後，重點讓我們看下相關查詢方式和查詢優化策略吧！ 話不多說，先來張思維導圖看下： 1.一對多情況 *以例項呈現： 如下： 1. JavaWEB中一對多的設計及其建表原則 2. 先匯入SQL的建表語

hibernate的查詢方式及抓取策略

查詢方式       根據唯一標識id進行檢索：                   get與load方法(https://blog.csdn.net/qq_4060591

hibernate查詢方式和查詢策略

創建 檢索策略 聯系人 多表 左外連接 基本上 如果 唯一標識 情況 1.Hibernate框架的查詢方式 1) 唯一標識OID的檢索方式 * session.get(對象.class,OID) 2) 對象的導航的方式 3) HQL的

Hibernate 註解的方式進行查詢

Student 類 @Entity @NamedQueries(value={ **@NamedQuery**(name="first",query="from Student"), **@NamedQuery**(name

ssh框架hibernate 查詢方式和查詢功能優化

Hibernate框架的查詢方式* 1. 唯一標識OID的檢索方式 * session.get(物件.class,OID) 2. 物件的導航的方式 3. HQL的檢索方式 * Hibernate Query Language -- Hibe

前端跨域問題各種解決方式及原理

create jsonp json 註意 require font name 報錯 lencod 跨域的各種解決方式及原理 因為瀏覽器有某些安全級別的限制，例如，同源策略，所以在進行瀏覽器端的web應用開發的時候，經常會遇到跨域問題。 同源策略：只有在同源的情況下（同域

第三方支付各種支付方式及廠商的對比分析，文件檢視筆記

     由於臨近實習，於是想趁著這段時間把所有想學的，無論是用於裝逼也好，實用也好的技術拉一拉，互相認識認識，算是入個門。      大概半個月前，花了部分精力與時間倉促的練習了一下第三方授權登陸，單點登陸,以及spring-secu

【copy】Linux下查詢檔案及查詢包含指定內容的檔案常用命令

轉載自   http://blog.csdn.net/yi412/article/details/19212335 在微軟的Windows作業系統中要查詢一份檔案是相當簡單的事情，只要在桌面上點選“開始”－“搜尋”中就能按照各種方式在本地硬碟上，區域網絡，甚至在INTERNET上查詢各種

linux下查詢檔案及查詢包含指定內容的檔案常用命令。

 每一種作業系統都是由成千上萬個不同種類的檔案所組成的。其中有系統本身自帶的檔案，使用者自己的檔案，還有共享檔案等等。我們有時候經常忘記某份檔案放在硬碟中的哪個地方。 在微軟的Windows作業系統中要查詢一份檔案是相當簡單的事情，只要在桌面上點選“開始”－“搜尋”中就

Linux下查詢檔案及查詢包含指定內容的檔案常用命令

每一種作業系統都是由成千上萬個不同種類的檔案所組成的。其中有系統本身自帶的檔案，使用者自己的檔案，還有共享檔案等等。我們有時候經常忘記某份檔案放在硬碟中的哪個地方。 在微軟的Windows作業系統中要查詢一份檔案是相當簡單的事情，只要在桌面上點選“開始”－“搜尋”中就能按照各種方式在本地硬碟上，區域網絡，甚

Hibernate各種基本註解及一對一(多)關係對映採坑筆記

hibernate提供兩種方式配置關係對映，一種XMl配置，一種註解。SpringBoot已經自帶了hibernate註解方式，我也是特別喜歡使用註解，特此記下常用的知識點。

mysql5.7新密碼登入方式及密碼策略

在Centos6.6上安裝MySQL5.7.12時，遇到了一個問題 安裝後在/root目錄下沒有發現有.mysql_secret這個檔案，所以沒有沒法按照官方文件上說的那樣使用，這裡記錄下， 解決方式： 首先修改MySQL授權登入方式---（跳過授權驗證方式啟動MySQL）：[[email 

Hibernate第四天：Hibernate的查詢方式、抓取策略

 目錄 1Hibernate的查詢的方式 1.1Hibernate的查詢方式：OID查詢 1.1.1使用get方法 1.1.2使用load方法 1.2Hibernate的查詢方式：物件導航檢索 1.3Hibernate的查詢方式：HQL檢索 1.3.1初始化一些

Hibernate查詢方式與抓取策略（優化）

4. Hibernate查詢方式與抓取策略（優化） 申明：本篇部落格引用黑馬教育；Hibernate其他系列為博主根據黑馬教育整理得到。 上接Hibernate關聯對映（一對多/多對多）：https://blog.csdn.net/biggerchong/article/details/

Hibernate查詢方式&抓取策略

Hibernate的查詢方式 1、OID查詢 hibernate根據物件的OID（主鍵）進行檢索 　　使用get方法 Customer customer=session.get(Customer.class,1l); 　　使用load方法 Customer customer=s

Hibernate學習10——Hibernate 查詢方式

9.png property ice pub gets reat sed desc ring 本章主要是以查詢Student的例子： Student.java: package com.cy.model; public class Student { priv

Hibernate 映射及查詢

外鏈接 實體類 映射 類屬性 數據庫 名稱 個學生 通過 cal 實體類和實體之間的關系：一對多，多對多 數據庫設計：e_r 一個實體對象就是一個表格， 如果是1對多的關系，將多方的主鍵拿到1方做外鍵。 多對多：重新建立一張新的表格，將雙方的主鍵拿到這裏做外鍵

Hibernate框架之路（四）hibernate查詢方式

集合 commit void div 第一個 -- cto 下標 action OID查詢 /** * OID 查詢 * 根據ID查詢 * 一對多查詢 */ @Test public void

hibernate detached分離查詢 與 抓取策略註意事項

set list() javascrip 外連接 抓取策略 list sel pic title 1.detached在抓取策略為 jion顯式左外連接查詢情況下 會產生笛卡兒積現象 DetachedCriteria dc = DetachedCrit

Hibernate查詢方式（補）

sof qbc nbsp ros ron 客戶 多對多 它的 記錄 -----------------siwuxie095 Hibernate 查詢方式 1、對象導航查詢 根據已經加載的對象，導航到它的