hibernate笔记4--qbc查询

Criteria:是一种完全面向对象的查询方式，Criteria查询也叫做qbc查询（query by Criteria）。
         查询全部，分页查询，统计查询，条件查询，排序查询，离线查询

代码演示:
     1.建库;
     2.导入jar包(required/log4j/mysqlconnector)
     2.建实体类(注意持久化类的编写规则);
     3.编制映射关系文件(Linkman.hbm.xml);
     4.编制核心配置文件(hibernate.cfg.xml);
     5.编写工具类(HibernateUtils.java),增加getCurrentSession方法;
     6.编写测试代码;

--------------------------------------------------------

6.编写测试代码;

  1 package demo;
  2
  3 import java.util.List;
  4
  5 import org.hibernate.Criteria;
  6  import org.hibernate.Session;
  7  import org.hibernate.Transaction;
  8  import org.hibernate.criterion.Order;
  9  import org.hibernate.criterion.Projections;
 10  import org.hibernate.criterion.Restrictions;
 11  import org.junit.Test;
 12
 13 import entity.Linkman;
 14  import utils.HibernateUtils;
 15
 16 //QBC查询
 17 public class Demo03 {
 18      // 查询所有
 19     @Test
 20      public void findAll() {
 21          // 获取当前线程session
 22          Session cs = HibernateUtils.getCurrentSession();
 23          // 开启事务并返回事务对象
 24         Transaction tx = cs.beginTransaction();
 25          // 获取criteria对象,同时即进行查询所有
 26         Criteria cc = cs.createCriteria(Linkman.class);
 27          // 获取结果集
 28         List list = cc.list();
 29          for (Object object : list) {
 30              System.out.println(object);
 31          }
 32          // 提交事务
 33         tx.commit();
 34      }
 35
 36     // 条件查询
 37     @Test
 38      public void findCondition() {
 39          // 获取当前线程session
 40          Session cs = HibernateUtils.getCurrentSession();
 41          // 开启事务,并返回事务对象
 42         Transaction tx = cs.beginTransaction();
 43          // 获取criteria
 44          Criteria c = cs.createCriteria(Linkman.class);
 45          c.add(Restrictions.like("lkmName", "R%"));
 46          // 获取结果集
 47         List list = c.list();
 48          for (Object object : list) {
 49              System.out.println(object);
 50          }
 51          // 提交事务
 52         tx.commit();
 53      }
 54
 55     // 分页查询
 56     @Test
 57      public void findByPage() {
 58          // 获取当前 线程session
 59          Session cs = HibernateUtils.getCurrentSession();
 60          // 开启事务,并返回事务对象
 61         Transaction tx = cs.beginTransaction();
 62          // 获取criteria
 63          Criteria c = cs.createCriteria(Linkman.class);
 64          // 调用方法,分页查询
 65         c.setFirstResult(0);
 66          c.setMaxResults(1);
 67          // 获取结果集
 68         List list = c.list();
 69          for (Object object : list) {
 70              System.out.println(object);
 71          }
 72          // 提交事务
 73         tx.commit();
 74      }
 75
 76     // 排序查询
 77     @Test
 78      public void findWithOrder() {
 79          // 获取当前线程session
 80          Session cs = HibernateUtils.getCurrentSession();
 81          // 开启事务,并返回事务对象
 82         Transaction tx = cs.beginTransaction();
 83          // 获取criteria
 84          Criteria c = cs.createCriteria(Linkman.class);
 85          // 调用方法,倒序查询
 86         c.addOrder(Order.desc("lkmId"));
 87          // 获取结果集
 88         List list = c.list();
 89          for (Object object : list) {
 90              System.out.println(object);
 91          }
 92          // 提交事务
 93         tx.commit();
 94      }
 95
 96     // 统计查询
 97     @Test
 98      public void findCount() {
 99          // 获取当前线程session
100          Session cs = HibernateUtils.getCurrentSession();
101          // 开启事务,并返回事务对象
102         Transaction tx = cs.beginTransaction();
103          // 获取criteria
104          Criteria c = cs.createCriteria(Linkman.class);
105          // 调用方法,统计查询
106         c.setProjection(Projections.count("lkmId"));
107          // 获取结果
108         Object obj = c.uniqueResult();
109          System.out.println(obj);
110          // 提交事务
111         tx.commit();
112      }
113  }
114 -----------------------------------------------
115 离线查询:模拟三层架构
116 package demo;
117
118 import java.util.List;
119
120 import org.hibernate.Criteria;
121  import org.hibernate.Session;
122  import org.hibernate.Transaction;
123  import org.hibernate.criterion.DetachedCriteria;
124  import org.hibernate.criterion.Restrictions;
125  import org.junit.Test;
126
127 import entity.Linkman;
128  import utils.HibernateUtils;
129
130 //离线查询
131 public class Demo04 {
132      @Test
133      public void web() {
134          DetachedCriteria dc = DetachedCriteria.forClass(Linkman.class);
135          dc.add(Restrictions.eq("lkmId", 4L));
136          service(dc);
137      }
138
139     public void service(DetachedCriteria dc) {
140          dao(dc);
141      }
142
143     public void dao(DetachedCriteria dc) {
144          Session cs = HibernateUtils.getCurrentSession();
145          Transaction tx = cs.beginTransaction();
146          Criteria c = dc.getExecutableCriteria(cs);
147          List list = c.list();
148          for (Object object : list) {
149              System.out.println(object);
150          }
151          tx.commit();
152
153     }
154  }
155