二、框架学习（一）Hibernate框架学习（4）Hibernate查询操作

Hibernate的查询方式

1 对象导航查询

(1)根据id查询某个客户,再查询这个客户里面所有的联系人

2 OID查询

(1)根据id查询某一条记录,返回对象

3 hql查询。

(1) Query对象,写hql语句实现查询

4 QBC查询。

(1) Criteria对象

5 本地sql查询

(1) SQLQuery对象,使用普通sql实现查询

测试数据库如下

t_customer表：

t_linkman表：

一、对象导航查询

　　1 查询某个客户里面所有联系人过程，使用对象导航实现

　　客户类：

 1 package cn.itcast.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Customer {
 7     private Integer cid;
 8     private String custName;
 9     private String custLevel;
10     private String custSource;
11     private String custPhone;
12     private String custMobile;
13     
14     private Set<LinkMan> setLinkMan=new HashSet<LinkMan>();
15 
16     public Integer getCid() {
17         return cid;
18     }
19 
20     public void setCid(Integer cid) {
21         this.cid = cid;
22     }
23 
24     public String getCustName() {
25         return custName;
26     }
27 
28     public void setCustName(String custName) {
29         this.custName = custName;
30     }
31 
32     public String getCustLevel() {
33         return custLevel;
34     }
35 
36     public void setCustLevel(String custLevel) {
37         this.custLevel = custLevel;
38     }
39 
40     public String getCustSource() {
41         return custSource;
42     }
43 
44     public void setCustSource(String custSource) {
45         this.custSource = custSource;
46     }
47 
48     public String getCustPhone() {
49         return custPhone;
50     }
51 
52     public void setCustPhone(String custPhone) {
53         this.custPhone = custPhone;
54     }
55 
56     public String getCustMobile() {
57         return custMobile;
58     }
59 
60     public void setCustMobile(String custMobile) {
61         this.custMobile = custMobile;
62     }
63 
64     public Set<LinkMan> getSetLinkMan() {
65         return setLinkMan;
66     }
67 
68     public void setSetLinkMan(Set<LinkMan> setLinkMan) {
69         this.setLinkMan = setLinkMan;
70     }
71 
72     @Override
73     public String toString() {
74         return "Customer [cid=" + cid + ", custName=" + custName + ", custLevel=" + custLevel + ", custSource="
75                 + custSource + ", custPhone=" + custPhone + ", custMobile=" + custMobile 
76                 + "]";
77     }
78     
79     
80     
81 }

　　　　客户类对应的xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping>
 6     <!-- 1配置类和表对应
 7         c1ass标签
 8         name属性:实体类全路径
 9         tab1e属性:数据库表名称 
10     -->
11     <class name="cn.itcast.entity.Customer" table="t_Customer">
12         <!-- 2配置实体类id和表id对应
13             hibernate要求实体类有一个属性唯一值
14             hibernate要求表有字段作为唯一值
15         -->
16         <!-- id标签
17             name属性:实体类里面主d属性名称
18             co1umn属性:生成的表字段名称
19         -->
20         <id name="cid" column="cid">
21             <!-- 设置数据库表id增长策略
22                 native:生成表id值就是主键自动增长 
23             -->
24             <generator class="native"></generator>
25         </id>
26         <!-- 
27             配置其他属性和表字段对应
28             name属性:实体类属性名称
29             column属性:生成表字段名称
30          -->
31         <property name="custName" column="custName"></property>
32         <property name="custLevel" column="custLevel"></property>
33         <property name="custSource" column=" custSource"></property>
34         <property name="custPhone" column=" custPhone"></property>
35         <property name="custMobile" column=" custMobile"></property>
36         <!-- 一对多设置 -->
37         <set name="setLinkMan" cascade="save-update,delete" inverse="true">
38             <key column="clid"></key>
39             <one-to-many class="cn.itcast.entity.LinkMan"/>
40         </set>
41     </class>
42 </hibernate-mapping>

　　　　联系人类：

 1 package cn.itcast.entity;
 2 
 3 public class LinkMan {
 4     private Integer lkm_id;
 5     private String lkm_name;
 6     private String lkm_gender;
 7     private String lkm_phone;
 8     private Customer customer;
 9     
10     
11     
12     
13     
14     
15     public Customer getCustomer() {
16         return customer;
17     }
18     public void setCustomer(Customer customer) {
19         this.customer = customer;
20     }
21     public Integer getLkm_id() {
22         return lkm_id;
23     }
24     public void setLkm_id(Integer lkm_id) {
25         this.lkm_id = lkm_id;
26     }
27     public String getLkm_name() {
28         return lkm_name;
29     }
30     public void setLkm_name(String lkm_name) {
31         this.lkm_name = lkm_name;
32     }
33     public String getLkm_gender() {
34         return lkm_gender;
35     }
36     public void setLkm_gender(String lkm_gender) {
37         this.lkm_gender = lkm_gender;
38     }
39     public String getLkm_phone() {
40         return lkm_phone;
41     }
42     public void setLkm_phone(String lkm_phone) {
43         this.lkm_phone = lkm_phone;
44     }
45     @Override
46     public String toString() {
47         return "LinkMan [lkm_id=" + lkm_id + ", lkm_name=" + lkm_name + ", lkm_gender=" + lkm_gender + ", lkm_phone="
48                 + lkm_phone + ", customer=" + customer + "]";
49     }
50     
51     
52     
53     
54     
55 }

　　　　　　联系人类对应的xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping>
 6     <!-- 1配置类和表对应
 7         c1ass标签
 8         name属性:实体类全路径
 9         tab1e属性:数据库表名称 
10     -->
11     <class name="cn.itcast.entity.LinkMan" table="t_LinkMan">
12         <!-- 2配置实体类id和表id对应
13             hibernate要求实体类有一个属性唯一值
14             hibernate要求表有字段作为唯一值
15         -->
16         <!-- id标签
17             name属性:实体类里面主d属性名称
18             co1umn属性:生成的表字段名称
19         -->
20         <id name="lkm_id" column="lkm_id">
21             <!-- 设置数据库表id增长策略
22                 native:生成表id值就是主键自动增长 
23             -->
24             <generator class="native"></generator>
25         </id>
26         <!-- 
27             配置其他属性和表字段对应
28             name属性:实体类属性名称
29             column属性:生成表字段名称
30          -->
31         <property name="lkm_name" column="lkm_name"></property>
32         <property name="lkm_gender" column="lkm_gender"></property>
33         <property name="lkm_phone" column="lkm_phone"></property>
34         <!-- 一对多设置 -->
35         <many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
36     </class>
37 </hibernate-mapping>

　　　　　　代码：

 1 package cn.itcast.hibernatetest;
 2 
 3 import java.util.HashSet;
 4 import java.util.List;
 5 import java.util.Set;
 6 
 7 import org.hibernate.Session;
 8 import org.hibernate.SessionFactory;
 9 import org.hibernate.Transaction;
10 import org.junit.Test;
11 
12 import cn.itcast.entity.Customer;
13 import cn.itcast.entity.LinkMan;
14 import cn.itcast.utils.HibernateUtils;
15 
16 public class test {
17     @Test
18     public void test1(){
19         //获取sessionFactory对象，HibernateUtils是自己编写的工具类
20         SessionFactory sessionFactory=HibernateUtils.getSessionFactory();
21         //通过sessionFactory获取session对象
22         Session session=sessionFactory.openSession();
23         //开启事务
24         Transaction tx=session.beginTransaction();
25         
26         
27         Customer customer=session.get(Customer.class,10);
28         
29         Set<LinkMan> set=customer.getSetLinkMan();
30         for (LinkMan linkMan : set) {
31             System.out.println(linkMan);
32         }
33         
34         //提交事务
35         tx.commit();
36         //关闭session和sessionFactory
37         session.close();
38         sessionFactory.close();
39         
40     }
41 }

结果：

Hibernate:

select

customer0_.cid as cid1_0_0_,

customer0_.custName as custName2_0_0_,

customer0_.custLevel as custLeve3_0_0_,

customer0_.custSource as custSour4_0_0_,

customer0_.custPhone as custPhon5_0_0_,

customer0_.custMobile as custMobi6_0_0_

from

t_Customer customer0_

where

customer0_.cid=?

Hibernate:

select

setlinkman0_.clid as clid5_1_0_,

setlinkman0_.lkm_id as lkm_id1_1_0_,

setlinkman0_.lkm_id as lkm_id1_1_1_,

setlinkman0_.lkm_name as lkm_name2_1_1_,

setlinkman0_.lkm_gender as lkm_gend3_1_1_,

setlinkman0_.lkm_phone as lkm_phon4_1_1_,

setlinkman0_.clid as clid5_1_1_

from

t_LinkMan setlinkman0_

where

setlinkman0_.clid=?

LinkMan [lkm_id=53, lkm_name=1, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=51, lkm_name=3, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=54, lkm_name=4, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

LinkMan [lkm_id=52, lkm_name=2, lkm_gender=222, lkm_phone=123456789, customer=Customer [cid=10, custName=苹果苹果, custLevel=1, custSource=null, custPhone=18763897307, custMobile=3434492]]

二、 OID查询

　　　　test代码：

 1 package cn.itcast.hibernatetest;
 2 
 3 import java.util.HashSet;
 4 import java.util.List;
 5 import java.util.Set;
 6 
 7 import org.hibernate.Session;
 8 import org.hibernate.SessionFactory;
 9 import org.hibernate.Transaction;
10 import org.junit.Test;
11 
12 import cn.itcast.entity.Customer;
13 import cn.itcast.entity.LinkMan;
14 import cn.itcast.utils.HibernateUtils;
15 
16 public class test {
17     @Test
18     public void test2(){
19         SessionFactory sessionFactory=null;
20         Session session=null;
21         Transaction tx=null;
22         
23         try {
24             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
25             sessionFactory=HibernateUtils.getSessionFactory();
26 
27             //通过sessionFactory获取session对象
28             session=sessionFactory.openSession();
29             
30             //开启事务
31             tx=session.beginTransaction();
32             
33             //OID查询就是使用get方法查询出一条记录
34             LinkMan linkMan=session.get(LinkMan.class, 52);
35             System.out.println(linkMan);
36             
37             //提交事务
38             tx.commit();
39         } catch (Exception e) {
40             //异常回滚
41             tx.rollback();
42         }finally{
43             //关闭session和sessionFactory
44             session.close();
45             sessionFactory.close();
46         }
47     }
48 }

三、 HQL查询。

　　　　　　HQL查询是使用Hibernate Query Language进行的一种查询方式，在这种查询方式中必须要写HQL语句才能查询

1 查询所有

　　查询所有的hql语句格式为：from 实体类名称（以查询所有商品为例）

　　　　　　代码：

 1     @Test
 2     public void test3(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10 
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             // 1、得到Query对象，并写入hql语句
18             Query query = session.createQuery("from LinkMan");
19             //2、使用Query对象的list方法得到数据集合
20             List<LinkMan> list = query.list();
21             //3、遍历集合获取数据
22             for (LinkMan linkMan : list) {
23                 System.out.println(linkMan);
24             }
25             
26             //提交事务
27             tx.commit();
28         } catch (Exception e) {
29             //异常回滚
30             tx.rollback();
31         }finally{
32             //关闭session和sessionFactory
33             session.close();
34             sessionFactory.close();
35         }
36     }

2、条件查询

　　条件查询有准确查询和模糊查询，使用hql语句完成。

　　（1）准确查询hql语句：from 实体类名 where 实体属性名 = ？ and 实体类属性名 = ？。

　　准确查询代码：

 1     @Test
 2     public void test4(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("from LinkMan where lkm_gender = ?");
21             //2、填写上一步中占位符的内容
22             query.setParameter(0, "男");
23             //3、使用Query对象的list方法得到数据集合
24             List<LinkMan> list = query.list();
25             //3、遍历集合获取数据
26             for (LinkMan linkMan : list) {
27                 System.out.println(linkMan);
28             }
29             
30             //提交事务
31             tx.commit();
32         } catch (Exception e) {
33             //异常回滚
34             tx.rollback();
35         }finally{
36             //关闭session和sessionFactory
37             session.close();
38             sessionFactory.close();
39         }
40     }

　　（2）模糊查询hql语句：from 实体类名 where 实体类属性名 like ？。

　　模糊查询代码：

 1     @Test
 2     public void test5(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("from LinkMan where lkm_phone like ?");
21             //2、填写上一步中占位符的内容
22             query.setParameter(0, "%1025%");
23             //3、使用Query对象的list方法得到数据集合
24             List<LinkMan> list = query.list();
25             //3、遍历集合获取数据
26             for (LinkMan linkMan : list) {
27                 System.out.println(linkMan);
28             }
29             
30             //提交事务
31             tx.commit();
32         } catch (Exception e) {
33             //异常回滚
34             tx.rollback();
35         }finally{
36             //关闭session和sessionFactory
37             session.close();
38             sessionFactory.close();
39         }
40     }

3、排序查询

　　排序查询hql语句：正序: form 实体类名称 order by 实体类属性名 asc

　　　　　　　　　　倒序：from 实体类名称 order by 实体类属性名 desc

　　（1）正序查询代码

 1     @Test
 2     public void test6(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("from LinkMan order by lkm_name asc");
21             //2、使用Query对象的list方法得到数据集合
22             List<LinkMan> list = query.list();
23             //3、遍历集合获取数据
24             for (LinkMan linkMan : list) {
25                 System.out.println(linkMan);
26             }
27             
28             //提交事务
29             tx.commit();
30         } catch (Exception e) {
31             //异常回滚
32             tx.rollback();
33         }finally{
34             //关闭session和sessionFactory
35             session.close();
36             sessionFactory.close();
37         }
38     }

　　　　（2）倒序查询代码：

 1     @Test
 2     public void test7(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("from LinkMan order by lkm_name desc");
21             //2、使用Query对象的list方法得到数据集合
22             List<LinkMan> list = query.list();
23             //3、遍历集合获取数据
24             for (LinkMan linkMan : list) {
25                 System.out.println(linkMan);
26             }
27             
28             //提交事务
29             tx.commit();
30         } catch (Exception e) {
31             //异常回滚
32             tx.rollback();
33         }finally{
34             //关闭session和sessionFactory
35             session.close();
36             sessionFactory.close();
37         }
38     }

4、分页查询

　　在mysql数据库中分页使用limit实现，在Hibernate中使用Query对象的两个方法实现。

　　分页查询代码：

 1     @Test
 2     public void test8(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("from LinkMan");
21             //2、使用Query的方法实现分页
22             //2.1设置第一个要查询的位置（计算公式：（当前页数-1）*每页的记录数）
23             query.setFirstResult(0);
24             //2.2设置每页显示的最大记录数
25             query.setMaxResults(2);
26             // 2、使用Query对象的list方法得到数据集合
27             List<LinkMan> list = query.list();
28             // 3、遍历集合获取数据
29             for (LinkMan linkMan : list) {
30                 System.out.println(linkMan);
31             }
32             
33             
34             
35             //提交事务
36             tx.commit();
37         } catch (Exception e) {
38             //异常回滚
39             tx.rollback();
40         }finally{
41             //关闭session和sessionFactory
42             session.close();
43             sessionFactory.close();
44         }
45     }

5、投影查询

　　投影查询概念：查询的不是表中的所有字段，而是一部分字段

　　代码：

 1     @Test
 2     public void test9(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("select lkm_name from LinkMan");
21             // 2、使用Query对象的list方法得到数据集合
22             List<Object> list = query.list();
23             // 3、遍历集合获取数据
24             for (Object object: list) {
25                 System.out.println(object);
26             }
27             
28             
29             
30             //提交事务
31             tx.commit();
32         } catch (Exception e) {
33             //异常回滚
34             tx.rollback();
35         }finally{
36             //关闭session和sessionFactory
37             session.close();
38             sessionFactory.close();
39         }
40     }

6、聚集函数查询

　　常用聚集函数：count avg max min sum

　　以count为例进行说明

　　hql语句：select count(*) from 实体类名称

　　　　代码：

 1     @Test
 2     public void test10(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             // 1、得到Query对象，并写入hql语句
20             Query query = session.createQuery("select count(*) from LinkMan");
21             //2、获取结果（结果为long类型）
22             Object obj = query.uniqueResult();
23             //3、转化为long(类型为long，转为int会报错)
24             
25             Long long1 = (Long) obj;
26             int count = long1.intValue();
27             System.out.println(count);
28             
29             
30             
31             //提交事务
32             tx.commit();
33         } catch (Exception e) {
34             //异常回滚
35             tx.rollback();
36         }finally{
37             //关闭session和sessionFactory
38             session.close();
39             sessionFactory.close();
40         }
41     }

四、 QBC查询。

　　　　使用QBC不在需要写hql语句，而是使用criteria对象的各种方法来实现

1、查询所有

 1     @Test
 2     public void test11(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             //2、调用方法得到数据
22             List<LinkMan> list = criteria.list();
23             for (LinkMan linkMan : list) {
24                 System.out.println(linkMan);
25             }
26             
27             
28             
29             //提交事务
30             tx.commit();
31         } catch (Exception e) {
32             //异常回滚
33             tx.rollback();
34         }finally{
35             //关闭session和sessionFactory
36             session.close();
37             sessionFactory.close();
38         }
39     }

2、条件查询

　　（1）准确查询

 1     @Test
 2     public void test12(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             
22             /**
23              * 使用方法设置查询条件
24              * 使用criteria的add方法添加条件
25              * 使用Restrictios的静态方法设置条件
26              */
27             criteria.add(Restrictions.eq("lkm_id", 1));
28             
29             //2、调用方法得到数据
30             List<LinkMan> list = criteria.list();
31             for (LinkMan linkMan : list) {
32                 System.out.println(linkMan);
33             }
34             
35             
36             
37             //提交事务
38             tx.commit();
39         } catch (Exception e) {
40             //异常回滚
41             tx.rollback();
42         }finally{
43             //关闭session和sessionFactory
44             session.close();
45             sessionFactory.close();
46         }
47     }

　　　　（2）模糊查询

 1     @Test
 2     public void test13(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             
22             /**
23              * 使用方法设置查询条件
24              * 使用criteria的add方法添加条件
25              * 使用Restrictios的静态方法设置条件
26              */
27             criteria.add(Restrictions.like("lkm_phone", "%1025%"));
28             
29             //2、调用方法得到数据
30             List<LinkMan> list = criteria.list();
31             for (LinkMan linkMan : list) {
32                 System.out.println(linkMan);
33             }
34             
35             
36             
37             //提交事务
38             tx.commit();
39         } catch (Exception e) {
40             //异常回滚
41             tx.rollback();
42         }finally{
43             //关闭session和sessionFactory
44             session.close();
45             sessionFactory.close();
46         }
47     }

3、排序查询

　　（1）正序查询

 1     @Test
 2     public void test14(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             
22              /**
23              * 使用方法设置查询条件 
24              * 使用criteria的addOrder方法添加排序
25              *  使用Order的静态方法设置排属性
26              */
27             criteria.addOrder(Order.asc("lkm_name"));
28             
29             //2、调用方法得到数据
30             List<LinkMan> list = criteria.list();
31             for (LinkMan linkMan : list) {
32                 System.out.println(linkMan);
33             }
34             
35             
36             
37             //提交事务
38             tx.commit();
39         } catch (Exception e) {
40             //异常回滚
41             tx.rollback();
42         }finally{
43             //关闭session和sessionFactory
44             session.close();
45             sessionFactory.close();
46         }
47     }

　　　　（2）降序查询：

 1     @Test
 2     public void test15(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             
22             /**
23              * 使用方法设置查询条件 
24              * 使用criteria的addOrder方法添加排序
25              *  使用Order的静态方法设置排属性
26              */
27             criteria.addOrder(Order.desc("lkm_name"));
28             
29             //2、调用方法得到数据
30             List<LinkMan> list = criteria.list();
31             for (LinkMan linkMan : list) {
32                 System.out.println(linkMan);
33             }
34             
35             
36             
37             //提交事务
38             tx.commit();
39         } catch (Exception e) {
40             //异常回滚
41             tx.rollback();
42         }finally{
43             //关闭session和sessionFactory
44             session.close();
45             sessionFactory.close();
46         }
47     }

4、分页查询

 1     @Test
 2     public void test16(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             
18             
19             //1、创建criteria对象，指定要查询的实体类的名称
20             Criteria criteria = session.createCriteria(LinkMan.class);
21             
22              //设置第一个要查询记录的位置
23             criteria.setFirstResult(0);
24             //2、设置每页最大的记录是
25             criteria.setMaxResults(2);
26             
27             //2、调用方法得到数据
28             List<LinkMan> list = criteria.list();
29             for (LinkMan linkMan : list) {
30                 System.out.println(linkMan);
31             }
32             
33             
34             
35             //提交事务
36             tx.commit();
37         } catch (Exception e) {
38             //异常回滚
39             tx.rollback();
40         }finally{
41             //关闭session和sessionFactory
42             session.close();
43             sessionFactory.close();
44         }
45     }

5、统计查询

 1     @Test
 2     public void test17(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             //1、创建criteria对象，指定要查询的实体类的名称
18             Criteria criteria = session.createCriteria(LinkMan.class);
19             criteria.setProjection(Projections.rowCount());
20             // 2、调用方法得到数据
21             Object object = criteria.uniqueResult();
22             Long long1 = (Long) object;
23             int count = long1.intValue();
24             System.out.println(count);
25             
26             //提交事务
27             tx.commit();
28         } catch (Exception e) {
29             //异常回滚
30             tx.rollback();
31         }finally{
32             //关闭session和sessionFactory
33             session.close();
34             sessionFactory.close();
35         }
36     }

6、离线查询

 1     @Test
 2     public void test18(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             // 1、创建DetachedCriteria对象，指定要查询的实体类的名称
18             DetachedCriteria cDetachedCriteria = DetachedCriteria.forClass(LinkMan.class);
19             //2、得到criteria对象（最终执行时才用到session）
20             Criteria criteria = cDetachedCriteria.getExecutableCriteria(session);
21             criteria.setProjection(Projections.rowCount());
22             // 3、调用方法得到数据
23             Object object = criteria.uniqueResult();
24             Long long1 = (Long) object;
25             int count = long1.intValue();
26             System.out.println(count);
27             
28             //提交事务
29             tx.commit();
30         } catch (Exception e) {
31             //异常回滚
32             tx.rollback();
33         }finally{
34             //关闭session和sessionFactory
35             session.close();
36             sessionFactory.close();
37         }
38     }

7、QBC查询条件

五、本地SQL查询

本地SQL查询是使用SQLQuery类，使用的是原生态的sql

 1     @Test
 2     public void test19(){
 3         SessionFactory sessionFactory=null;
 4         Session session=null;
 5         Transaction tx=null;
 6         
 7         try {
 8             //获取sessionFactory对象，HibernateUtils是自己编写的工具类
 9             sessionFactory=HibernateUtils.getSessionFactory();
10             
11             //通过sessionFactory获取session对象
12             session=sessionFactory.openSession();
13             
14             //开启事务
15             tx=session.beginTransaction();
16             
17             // 1、创建SQLQuery对象，指定要查询的实体类的名称
18             SQLQuery SqlQuery=session.createSQLQuery("select * from t_linkman");
19             // 2、设置用来接收结果的实体类
20             SqlQuery.addEntity(LinkMan.class);
21             // 3、用list接收结果
22             List<LinkMan> list=SqlQuery.list();
23             for (LinkMan linkMan : list) {
24                 System.out.println(linkMan);
25             }
26             
27             //提交事务
28             tx.commit();
29         } catch (Exception e) {
30             //异常回滚
31             tx.rollback();
32         }finally{
33             //关闭session和sessionFactory
34             session.close();
35             sessionFactory.close();
36         }
37     }

posted @ 2018-01-17 09:38 秋心无波阅读(186) 评论(0) 编辑收藏举报

刷新页面返回顶部

秋心无波

二、框架学习 （一）Hibernate框架学习 （4）Hibernate查询操作

Hibernate的查询方式

一、 对象导航查询

二、 OID查询

三、 HQL查询。

1 查询所有

2、条件查询

3、排序查询

4、分页查询

5、投影查询

6、聚集函数查询

四、 QBC查询。

1、查询所有

2、条件查询

3、排序查询

4、分页查询

5、统计查询

6、离线查询

7、QBC查询条件

五、 本地SQL查询

公告

二、框架学习（一）Hibernate框架学习（4）Hibernate查询操作

一、对象导航查询

五、本地SQL查询