二、框架学习 （一）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 }
