Hibernate入門（四）—— 查詢_ZenDei技術網路在線

一、Hibernate查詢 1.Hibernate檢索(查詢)方式的分類 OID檢索 :根據主鍵查詢,get/load 對象導航檢索 :通過一個對象獲得其關聯對象.【重點】 Category category = session.get(Category.class, 1);Set<Product> ...

一、Hibernate查詢

1.Hibernate檢索(查詢)方式的分類

OID檢索 :根據主鍵查詢,get/load

對象導航檢索 :通過一個對象獲得其關聯對象.【重點】

Category category = session.get(Category.class, 1);
Set<Product> products = category.getProducts();

HQL檢索 :HQL,Hibernate Query Language(Hibernate查詢語言,語法與SQL類似,但是又是面向對象的 ) 【掌握】
QBC檢索 :QBC,Query By Criteria(條件查詢,更加面向對象的查詢方式) 【掌握】
SQL檢索 :SQL,使用原生SQL進行查詢【瞭解】

2.HQL查詢

2.1概述

　　 HQL：Hibernate Query Language。是面向對象(在sql裡面的列名在hql裡面應該寫屬性名)的查詢語言, 它和SQL查詢語言有些相似。

語法:

String hql =...

Query query = session.createQuery(hql);

list(); 查詢多個
uniqueResult();查詢一個

原則: 把表名改成類名, 把資料庫的列改成Java裡面的屬性名

2.2基本查詢

2.2.1查詢所有

查詢所有的分類

 1 //查詢所有的分類
 2     @Test
 3     public void fun01(){
 4         Session session = HibernateUtils.openSession();
 5         Transaction transaction = session.beginTransaction();
 6         
 7         //String hql = "select c from Category c";
 8         String hql = "from Category";
 9         Query query = session.createQuery(hql);
10         List<Category> list = query.list();
11         for (Category category : list) {
12             System.out.println(category.toString());
13         }
14         
15         transaction.commit();
16         session.close();
17     }

2.2.2條件查詢

大於，小於，大於等於，大於小於查詢

 1 //查詢id大於1的分類
 2     @Test
 3     public void fun02(){
 4         Session session = HibernateUtils.openSession();
 5         Transaction transaction = session.beginTransaction();
 6         
 7         /*String hql = "from Category where cid > ?";
 8         Query query = session.createQuery(hql);
 9         query.setInteger(0, 1);*/
10         
11         String hql = "from Category where cid > :類別id";
12         Query query = session.createQuery(hql);
13         query.setInteger("類別id", 1);
14         List<Category> list = query.list();
15         for (Category category : list) {
16             System.out.println(category.toString());
17         }
18         
19         transaction.commit();
20         session.close();
21     }

like查詢

 1 //查詢商品名包含iPhone的商品
 2     @Test
 3     public void fun03(){
 4         Session session = HibernateUtils.openSession();
 5         Transaction transaction = session.beginTransaction();
 6         
 7         
 8         String hql = "from Product where pname like ?";
 9         Query query = session.createQuery(hql);
10         query.setString(0, "%iPhone%");
11         List<Product> list = query.list();
12         for (Product product: list) {
13             System.out.println(product.toString());
14         }
15         
16         transaction.commit();
17         session.close();
18     }

between and查詢

String hql = "from Product where price between ? and ?";
Query query = session.createQuery(hql);
query.setDouble(0, 2000);
query.setDouble(1, 5000);
List<Product> list = query.list();

in 查詢

 1 @Test
 2      //查詢pid在(2,8,11,12,100)的商品信息
 3      public void fun05(){
 4          Session session = HibernateUtils.getCurrentSession();
 5          Transaction transaction = session.beginTransaction();
 6          
 7         //String sql = "select * from t_product where  pid in(?,?,?,?)";
 8          String hql = "from Product where pid in(?,?,?,?)";
 9          Query query = session.createQuery(hql);
10          //設置參數,查詢
11          List list = query.setInteger(0, 2).setInteger(1, 8).setInteger(2, 11).setInteger(3, 12).list();
12          
13          System.out.println(list.toString());
14          
15          transaction.commit();
16 
17      }

2.3.聚合查詢

統計類別的個數

String hql = "select count(*) from Category";
Query query = session.createQuery(hql);
Long n =  (Long) query.uniqueResult();
System.out.println(n.intValue());

2.4分組查詢

統計各個類別的商品數量

String hql = "select category.cid, count(*) from Product group by category.cid";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

2.5排序查詢

安照商品價格(升序)查詢所有的商品

String hql = "from Product order by price asc";
Query query = session.createQuery(hql);
List<Product> list = query.list();
for (Product product : list) {
    System.out.println(product);
}

2.6.分頁查詢

setFirstResult:設置開始查詢的下標，最小取值是0，0代表第一條記錄

setMaxResults: 設置查詢結果顯示的條數。

顯示第一頁的數據,一頁顯示4條

String hql = "from Product";
Query query = session.createQuery(hql);
query.setFirstResult(0);
query.setMaxResults(4);
List<Product> list = query.list();
for (Product product : list) {
        System.out.println(product);
}

2.7 投影查詢

查詢指定欄位

查詢商品的名字和價格

String hql = "select pname, price from Product";
Query query = session.createQuery(hql);
List<Object[]> list =  query.list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

3.QBC查詢

3.1概述

　　QBC,Query By Criteria(條件查詢,更加面向對象的查詢方式)

3.2常見的條件查詢

語法

//創建QBC條件查詢
Criteria criteria = session.createCriteria(Class);
//添加條件
criteria.add(Restrictions.api...);
//查詢多個
List list = criteria.list();
//或者查詢一個
Object object =  criteria.uniqueResult();

運算符	條件API	描述
=	Restrictions.eq()	等於
>	Restrictions.gt()	大於
<	Restrictions.lt()	小於
>=	Restrictions.ge()	大於等於
<=	Restrictions.le()	小於等於
between	Restrictions.between()	在某個範圍內
like	Restrictions.like()	模糊查詢
in	Restrictions.in()	在...中
and	Restrictions.and()	並且
or	Restrictions.or()	或者

Java代碼

 1 // 條件查詢
 2     @Test
 3     public void fun01() {
 4         Session session = HibernateUtils.openSession();
 5         Transaction transaction = session.beginTransaction();
 6 
 7         Criteria criteria = session.createCriteria(Product.class);
 8         List<Product> list = criteria.add(Restrictions.between("price", 2000.0, 3000.0)).list();
 9         for (Product product : list) {
10             System.out.println(product.toString());
11         }
12         
13         transaction.commit();
14         session.close();
15     }

//and 查詢; 查詢商品名以iP開頭的並且價格大於4000的商品
Criteria criteria = session.createCriteria(Product.class);
List<Product> list = criteria.add(Restrictions.like("pname", "iP%")).add(Restrictions.gt("price", 4000.0)).list();

//or查詢;  查詢價格大於3000的或者pid=1的商品
Criteria criteria = session.createCriteria(Product.class);
List<Product> list = criteria.add(Restrictions.or(Restrictions.gt("price", 3000.0)).add(Restrictions.eq("pid", 1))).list();

3.3.聚合查詢

語法

//創建QBC條件查詢
Criteria criteria = session.createCriteria(Class);
//設置聚合
criteria.setProjection(Projections.api...);
//查詢出結果
long result = (long) criteria.uniqueResult();

運算符	條件API	描述
sum	Projections.sum()	求和
count	Projections.count()	計數
max	Projections.max()	最大值
min	Projections.min()	最小值
avg	Projections.avg()	平均值

統計商品的數量

Criteria criteria = session.createCriteria(Product.class);
Object result = criteria.setProjection(Projections.count("pid")).uniqueResult();
System.out.println("result="+result);

多項聚合

//創建QBC條件查詢
Criteria criteria = session.createCriteria(Class);
//添加多種聚合
ProjectionList list = Projections.projectionList();
list.add(Projections.api...);
...
//設置聚合
criteria.setProjection(list);
//查詢出結果
Object[] result = (Object[]) criteria.uniqueResult();

//實例
//統計每一個類別下的商品數量  cid count(pid)  兩個聚合條件
Criteria criteria = session.createCriteria(Product.class);
ProjectionList projectionList = Projections.projectionList();   
projectionList.add(Projections.groupProperty("category.cid"));
projectionList.add(Projections.count("pid"));
List<Object[] > list = criteria.setProjection(projectionList).list();

3.4分組查詢

統計不同類別下商品的數量

Criteria criteria = session.createCriteria(Product.class);
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.count("pid")).add(Projections.groupProperty("category.cid"));

List<Object[]> list = criteria.setProjection(projectionList).list();
for (Object[] objects : list) {
    System.out.println(Arrays.toString(objects));
}

3.5排序查詢

語法

//創建QBC條件查詢
Criteria criteria = session.createCriteria(Class);
//添加排序
criteria.addOrder(Order.api...);
//查詢出結果
List list = criteria.list();

運算符	條件API	描述
desc	Order.desc()	降序
asc	Order.asc()	升序

3.6.分頁查詢

setFirstResult:設置開始查詢的下標，最小取值是0，0代表第一條記錄設置a

setMaxResults: 設置查詢結果顯示的條數。設置 b

3.7離線條件查詢

　　我們之前也執行過條件查詢，不過這些條件查詢都是先創建了Criteria對象，然後再不斷的追加條件。這種情況在提交比較少的時候，看上去是還不錯的。假如我們這些參數都是要上層service 傳遞過來的，那麼顯得就不是那麼好看了。所以我們想想能否在外面先封裝好了，然後直接給我一個總的條件即可。這個總的條件，就是包含了前面的所有的條件。這就是離線條件查詢。意思是，可以現在前面先封裝條件，脫離session 創建出Criteria這個情況。

語法

//創建離線的DetachedCriteria對象
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(User.class);
//設置條件
detachedCriteria.add(Restrictions.like("u_name", "%奧%"));
//轉成可執行狀態
Criteria criteria = detachedCriteria.getExecutableCriteria(session);

List<User> list = criteria.list();

4,SQL查詢【瞭解】

String sql = "select * from t_product";
SQLQuery sqlQuery = session.createSQLQuery(sql);
sqlQuery.addEntity(Product.class);

List<Product> list = sqlQuery.list();
        
for (Product product : list) {
    System.out.println(product.toString());
}

5.連接查詢

5.1MySql裡面的多表查詢

5.1.1交叉查詢

語法
```
select * from A,B
```

5.1.2內連接查詢

隱式內連接查詢
```
 select * from A ,B where A.id = B.id;
```

顯示內連接

select * from A inner join B on A.id = B.id;

5.1.3外連接查詢

左外連接

 select * from A left outer join B on A.id = B.id;

右外連接

 select * from A right outer join B on A.id = B.id;

5.2 HQL連接查詢

5.2.1類別

交叉連接
內連接：內連接、迫切內連接

外連接：左外連接、右外連接

連接類型	語法
內連接	inner join 或者 join
迫切內連接	inner join fetch 或者 join fetch
左外連接	left outer join 或者 left join
迫切左外連接	left outer join fetch 或者 left join fetch
右外連接	right outer join 或者 right join
迫切右外連接	right outer join fetch 或者 right join fetch

5.2.2內連接

內連接查詢可以獲取兩表的公共部分的記錄。

HQL內連接(發送三條查詢語句)

String hql = "from Category c inner join c.products";
Query query = session.createQuery(hql);
List<Object[]> list =  query.list();

HQL迫切內連接（發送一條查詢語句）

//String hql = "from Category c inner  join fetch c.products";
String hql = "select distinct c  from Category c inner  join fetch c.products";
Query query = session.createQuery(hql);
List<Category> list =  query.list();

5.2.3外連接

HQL左外連接

String hql = "from Category c left outer join  c.products";
List<Object[]> list = session.createQuery(hql).list();

HQL迫切左外連接

String hql = "from Category c left outer  join fetch c.products";
List<Category> list = session.createQuery(hql).list();

　　總結:

- 迫切連接是Hibernate獨有的查詢方式,迫切內連接比內連接多一個關鍵字fetch
- 內連接查詢結果中為Object[]數組
- 迫切內連接查詢結果為具體對象。

二、查詢優化

1、類級別延遲載入

1.1 描述

懶載入預設是開啟的.一般不需要修改

session.get(): 非懶載入方法

session.load(): 預設就是是懶載入

1.2使load懶載入失效

在映射配置文件的<class>標簽上配置lazy=”false”

<class name="com.pri.bean.Category" table="t_category" lazy="false">

2.關聯級別的懶載入

2.1 概述

　　當查詢對應的對象時候, 是否立即查詢出其關聯的對象; eg: 查詢id的為1分類,是否立即查詢出是該類別下的商品

　　一般通過 '抓取策略' 和 '懶載入' 配合起來優化查詢.抓取策略:意思是抓取其關聯對象,在<set>和<many-to-one>標簽上有一個fetch屬性,fetch控制發送什麼類型的語句來抓取其關聯的對象

　　fetch: 抓取策略 :控制發送什麼類型的Sql語句 sql語句:就是對錶查詢(連接)

　　lazy: 懶或者不懶

2.2set的懶載入

2.2.1描述

在一的一方操作,即在set標簽上配置 fetch 和 lazy

fetch:控制的是查詢其關聯對象的時候採用的SQL語句的格式.

fetch的取值	發送的SQL語句類型
select:預設值	發送一條select語句查詢其關聯對象.
join	發送一條迫切左外連接查詢關聯對象.
subselect	發送一條子查詢查詢其關聯對象.

lazy:控制的是查詢其關聯對象的時候是否採用延遲載入的策略.

lazy的取值	含義
true(預設值)	預設查詢關聯對象的時候採用延遲載入.
false	查詢關聯對象的時候不採用延遲載入
extra	及其懶惰. 查詢關聯對象的時候採用比延遲載入更懶惰的方式進行查詢.

2.2.2例子

下麵的操作都是在在一的一方操作,即在set標簽上配置 fetch 和 lazy

當fetch取值為select的時候

fetch的取值	lazy的取值	結果
select	true	多方在使用時才進行載入(懶載入) 註: 預設值
select	false	多方在一方載入時就載入(不是懶載入)
select	extra	多方在使用時才進行載入，如果使用時的操作是聚合類型，那麼只會進行聚合查詢。

當fetch取值為join的時候

fetch的取值 lazy的取值結果

join lazy失效(不管是true還是false) fetch採用的是迫切左外連接查詢，將兩張表的結果全部查詢出來。lazy失效。

fetch的取值	lazy的取值	結果
join	lazy失效(不管是true還是false)	fetch採用的是迫切左外連接查詢，將兩張表的結果全部查詢出來。lazy失效。

當fetch取值為subselect的時候

fetch的取值	lazy的取值	結果
subselect	true	多方在使用時才進行載入，發送的是子查詢語句
subselect	false	多方在一方載入時就載入，發送的是子查詢語句
subselect	extra	多方在一方載入時就載入，如果使用時的操作是聚合類型，那麼只會進行聚合查詢發送的是子查詢語句

註意: 使用Hibernate子查詢時候,不能查一個. Hibernate如果發現in() 的值是一個,把in變成=

2.3many-to-one懶載入

2.3.1描述

在多的一方操作,即在many-to-one標簽上配置 fetch 和 lazy

fetch:控制的是查詢其關聯對象的時候採用的SQL語句的格式.

fetch的取值發送的SQL語句類型

select:預設值發送一條select語句查詢其關聯對象.

join 發送一條迫切左外連接查詢關聯對象.

lazy:查詢其關聯對象的時候是否採用延遲載入.

lazy的取值	含義
proxy	預設值.是否採用延遲取決於一的一方的class上的lazy的值.
false	不採用延遲載入其關聯對象.
no-proxy(瞭解)	不用研究是否採用延遲

2.3.2例子

下麵的操作都是在多的一方操作,即在many-to-one標簽上配置 fetch 和 lazy

當select為fetch的時候,發送的是普通的sql語句

fetch的取值	lazy的取值	結果
select	proxy	如果一的一方的class上的lazy的值為true,使用一的一方再載入(懶載入); 如果一的一方的class上的lazy的值為false,一方在多方載入時就載入(不是懶載入)
select	false	一方在多方載入時就載入(不是懶載入)

當select為join的時候,是迫切左外連接

fetch的取值 lazy的取值結果

join 失效發送左外連接查詢,不是懶載入

fetch的取值	lazy的取值	結果
join	失效	發送左外連接查詢,不是懶載入

3 批量抓取（瞭解）

在set標簽上配置 batch-size = num

1 Criteria criteria = session.createCriteria(Category.class);
2 List<Category> list = criteria.list();
3 
4 for (Category category : list) {
5     Set<Product> products = category.getProducts();
6     for (Product product : products) {
7         System.out.println(product.toString());
8     }
9 }

同時抓取多方表中指定的條數的數據