Criterion & DetachedCriteria

今天笔记主要是记录笔记,以及代码: 

criteria:
创建查询接口:createCriteria(class)
查询条件接口:add(各种条件);

Restrictions 提供了设置参数的各种接口
逻辑运算 not or and
字符串模式匹配 like ilike
范围运算 in not in between between and
比较运算 eq/le/lt.....
集合运算 isNotEmpty
可以链式编程
List grades=session.createCriteria(Grade.class)
.add(Restrictions.or(Restrictions.eq("gradename", "一年级"), Restrictions.le("gradeid", 3)))
.list();

关于各种方法的使用,代码中都有注释

注解配置:
可以在启动AnnotationConfiguration时在数据库创建配置的表

注解:

 需要引入四个包:

   

 1 package entity;
 2 import java.io.Serializable;
 3 import javax.persistence.*;
 4
 5 @Entity
 6 @Table(name="test_g")
 7 public class TestNoteGrade implements Serializable{
 8     private Integer id ;
 9     private String name;
10     @Id
11     @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="seq_grade")
12     @SequenceGenerator(name="seq_grade",sequenceName="seq_gradeid",allocationSize=1,initialValue=1)
13     public Integer getId() {
14         return id;
15     }
16
17     public void setId(Integer id) {
18         this.id = id;
19     }
20     @Basic
21     public String getName() {
22         return name;
23     }
24     public void setName(String name) {
25         this.name = name;
26     }
27
28
29
30
31 }

  在hibernate中需要配置 mapping:

    <mapping class="entity.TestNoteGrade"/>

  还有种生成实体类与映射文件的方法:

    反推(用myeclipse来操作)

java 测试代码:

  1 package test4Criteria;
  2
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 import java.util.Set;
  6
  7 import junit.framework.TestCase;
  8 import org.hibernate.Criteria;
  9 import org.hibernate.Session;
 10 import org.hibernate.cfg.AnnotationConfiguration;
 11 import org.hibernate.criterion.Criterion;
 12 import org.hibernate.criterion.DetachedCriteria;
 13 import org.hibernate.criterion.Order;
 14 import org.hibernate.criterion.Projections;
 15 import org.hibernate.criterion.Property;
 16 import org.hibernate.criterion.Restrictions;
 17
 18 import entity.Grade;
 19 import entity.Student;
 20 import entity.TrStudent;
 21
 22 import util.HibernateUtil;
 23
 24 public class Criterion01 extends TestCase{
 25     Session session=null;
 26
 27
 28
 29     /**
 30      * critertion 查询
 31      */
 32     public void testCriterion1(){
 33         try {
 34             session=HibernateUtil.currentSession();
 35             session.beginTransaction();
 36             //查询整个类
 37             List grade=session.createCriteria(Grade.class).list();
 38             for(int i=0;i<grade.size();i++){
 39                 Grade gra=(Grade)grade.get(i);
 40                 System.out.println(gra);
 41
 42             }
 43
 44
 45         } catch (Exception e) {
 46             // TODO: handle exception
 47             e.printStackTrace();
 48         }finally{
 49             HibernateUtil.closeSession();
 50         }
 51         try {
 52             session=HibernateUtil.currentSession();
 53             session.beginTransaction();
 54             //查询指定值
 55             List grade=session.createCriteria(Grade.class)//
 56                         .add(Restrictions.eq("gradename","一年级"))//
 57                         .list();
 58             for(int i=0;i<grade.size();i++){
 59                 Grade gra=(Grade)grade.get(i);
 60                 System.out.println(gra);
 61
 62             }
 63
 64
 65         } catch (Exception e) {
 66             // TODO: handle exception
 67             e.printStackTrace();
 68         }finally{
 69             HibernateUtil.closeSession();
 70         }
 71
 72     }
 73     /**
 74      * 比较运算
 75      */
 76     public void testCriterion2(){
 77         try {
 78             session=HibernateUtil.currentSession();
 79             session.beginTransaction();
 80             //大于条件
 81             List grades=session.createCriteria(Grade.class).add(Restrictions.gt("gradeid", 2)).list();
 82
 83             for(int i=0;i<grades.size();i++){
 84                 System.out.println((Grade)grades.get(i));
 85
 86             }
 87         } catch (Exception e) {
 88             // TODO: handle exception
 89             e.printStackTrace();
 90         }finally{
 91             HibernateUtil.closeSession();
 92
 93         }
 94         System.out.println("---大于等于条件--------------------");
 95         try {
 96             session=HibernateUtil.currentSession();
 97             session.beginTransaction();
 98             //大于等于条件
 99             List grades=session.createCriteria(Grade.class).add(Restrictions.ge("gradeid", 2)).list();
100
101             for(int i=0;i<grades.size();i++){
102                 System.out.println((Grade)grades.get(i));
103
104             }
105         } catch (Exception e) {
106             // TODO: handle exception
107             e.printStackTrace();
108         }finally{
109             HibernateUtil.closeSession();
110
111         }
112
113         System.out.println("---小于等于条件--------------------");
114         try {
115             session=HibernateUtil.currentSession();
116             session.beginTransaction();
117             //大于等于条件
118             List grades=session.createCriteria(Grade.class).add(Restrictions.le("gradeid", 2)).list();
119
120             for(int i=0;i<grades.size();i++){
121                 System.out.println((Grade)grades.get(i));
122
123             }
124         } catch (Exception e) {
125             // TODO: handle exception
126             e.printStackTrace();
127         }finally{
128             HibernateUtil.closeSession();
129
130         }
131         System.out.println("---等于空--------------------");
132         try {
133             session=HibernateUtil.currentSession();
134             session.beginTransaction();
135             //大于等于条件
136             List grades=session.createCriteria(Grade.class).add(Restrictions.isNull("gradeid")).list();
137
138             for(int i=0;i<grades.size();i++){
139                 System.out.println((Grade)grades.get(i));
140
141             }
142         } catch (Exception e) {
143             // TODO: handle exception
144             e.printStackTrace();
145         }finally{
146             HibernateUtil.closeSession();
147
148         }
149
150     }
151     /**
152      * 范围运算
153      */
154     public void testCriterion3(){
155         try {
156             session=HibernateUtil.currentSession();
157             session.beginTransaction();
158             Object[] obj={1,2,3};
159             //in
160             List grades=session.createCriteria(Grade.class)//
161                     .add(Restrictions.in("gradeid",obj))//
162                     .list();
163             for(int i=0;i<grades.size();i++){
164                 System.out.println((Grade)grades.get(i));
165
166             }
167         } catch (Exception e) {
168             // TODO: handle exception
169             e.printStackTrace();
170         }
171         finally{
172             HibernateUtil.closeSession();
173
174         }
175         System.out.println("-----not--in------");
176         try {
177             session=HibernateUtil.currentSession();
178             session.beginTransaction();
179             Object[] obj={1,2,3};
180             //in
181             List grades=session.createCriteria(Grade.class)//
182                     .add(Restrictions.not(Restrictions.in("gradeid",obj)))//
183                     .list();
184             for(int i=0;i<grades.size();i++){
185                 System.out.println((Grade)grades.get(i));
186
187             }
188         } catch (Exception e) {
189             // TODO: handle exception
190             e.printStackTrace();
191         }
192         finally{
193             HibernateUtil.closeSession();
194
195         }
196
197         System.out.println("--not-between- and--");
198         try {
199             session=HibernateUtil.currentSession();
200             session.beginTransaction();
201             Object[] obj={1,2,3};
202             //in
203             List grades=session.createCriteria(Grade.class)//
204                     .add(Restrictions.not(Restrictions.between("gradeid",1,3)))//
205                     .list();
206             for(int i=0;i<grades.size();i++){
207                 System.out.println((Grade)grades.get(i));
208
209             }
210         } catch (Exception e) {
211             // TODO: handle exception
212             e.printStackTrace();
213         }
214         finally{
215             HibernateUtil.closeSession();
216
217         }
218
219         System.out.println("---between- and--");
220         try {
221             session=HibernateUtil.currentSession();
222             session.beginTransaction();
223             Object[] obj={1,2,3};
224             //in
225             List grades=session.createCriteria(Grade.class)//
226                         .add(Restrictions.between("gradeid",1,3))//
227                         .list();
228             for(int i=0;i<grades.size();i++){
229                 System.out.println((Grade)grades.get(i));
230
231             }
232         } catch (Exception e) {
233             // TODO: handle exception
234             e.printStackTrace();
235         }
236         finally{
237             HibernateUtil.closeSession();
238
239         }
240     }
241
242     /**
243      * 字符串模式匹配  like ilike
244      */
245     public void testCriterion4(){
246         try {
247             session=HibernateUtil.currentSession();
248             session.beginTransaction();
249             String scase="ab";
250             List student=session.createCriteria(Student.class).add(Restrictions.like("name", "%"+scase+"%")).list();
251             for(int i=0;i<student.size();i++){
252                     Student stu=(Student)student.get(i);
253                     String name=stu.getName();
254                     System.out.print(name.substring(0, name.indexOf(scase)));
255                     System.err.print(name.substring(name.indexOf(scase),(name.indexOf(scase)+scase.length())));
256                     if(name.indexOf(scase)==name.length()-scase.length()){
257                         System.out.println("");
258
259                     }
260                     System.out.println(name.substring(name.indexOf(scase)+scase.length(),name.length()));
261
262             }
263
264         } catch (Exception e) {
265             // TODO: handle exception
266         }finally{
267             HibernateUtil.closeSession();
268
269         }
270         System.out.println("------ilike----------");
271         try {
272             session=HibernateUtil.currentSession();
273             session.beginTransaction();
274             String scase="eli";
275             List student=session.createCriteria(Student.class).add(Restrictions.ilike("name", "%"+scase+"%")).list();
276             for(int i=0;i<student.size();i++){
277                 Student stu=(Student)student.get(i);
278                 String name=stu.getName().toLowerCase();
279                 System.out.print(name.substring(0, name.indexOf(scase)));
280                 System.err.print(name.substring(name.indexOf(scase),(name.indexOf(scase)+scase.length())));
281                 if(name.indexOf(scase)==name.length()-scase.length()){
282                     System.out.println("");
283
284                 }
285                 System.out.println(name.substring(name.indexOf(scase)+scase.length(),name.length()));
286
287             }
288         } catch (Exception e) {
289             // TODO: handle exception
290         }finally{
291             HibernateUtil.closeSession();
292
293         }
294     }
295     /**
296      * 逻辑运算
297      */
298     public void testCriterion5(){
299         try {
300             session=HibernateUtil.currentSession();
301             session.beginTransaction();
302             List grades=session.createCriteria(Grade.class).add(Restrictions.and(Restrictions.eq("gradename", "一年级"), Restrictions.le("gradeid", 5))).list();
303             for(int i=0;i<grades.size();i++){
304                 System.out.println(grades.get(i));
305
306             }
307         } catch (Exception e) {
308             // TODO: handle exception
309             e.printStackTrace();
310         }finally{
311             HibernateUtil.closeSession();
312
313         }
314         System.out.println("-------or-----------");
315         try {
316             session=HibernateUtil.currentSession();
317             session.beginTransaction();
318             List grades=session.createCriteria(Grade.class).add(Restrictions.or(Restrictions.eq("gradename", "一年级"), Restrictions.le("gradeid", 3))).list();
319             for(int i=0;i<grades.size();i++){
320                 System.out.println(grades.get(i));
321
322             }
323         } catch (Exception e) {
324             // TODO: handle exception
325             e.printStackTrace();
326         }finally{
327             HibernateUtil.closeSession();
328
329         }
330         System.out.println("-------not-----------");
331         try {
332             session=HibernateUtil.currentSession();
333             session.beginTransaction();
334             List grades=session.createCriteria(Grade.class).add(Restrictions.not(Restrictions.eq("gradename", "一年级"))).list();
335             for(int i=0;i<grades.size();i++){
336                 System.out.println(grades.get(i));
337
338             }
339         } catch (Exception e) {
340             // TODO: handle exception
341             e.printStackTrace();
342         }finally{
343             HibernateUtil.closeSession();
344
345         }
346
347     }
348     /**
349      * 集合运算
350      */
351     public void testCriterion6(){
352         try {
353             session=HibernateUtil.currentSession();
354             session.beginTransaction();
355             List grades=session.createCriteria(Grade.class).add(Restrictions.isNotEmpty("stu")).list();
356             for(int i=0;i<grades.size();i++){
357                 System.out.println(((Grade)grades.get(i)).getStu());
358             }
359
360
361         } catch (Exception e) {
362             // TODO: handle exception
363             e.printStackTrace();
364         }finally{
365             HibernateUtil.closeSession();
366
367         }
368     }
369
370     /**
371      * 动态查询
372      */
373     public void testTrends(){
374         try {
375             session=HibernateUtil.currentSession();
376             session.beginTransaction();
377             TrStudent tr=new TrStudent();
378             tr.setName("%eli%");
379             tr.setStartGrade(1);
380             tr.setEndGrade(3);
381             Criteria cri= session.createCriteria(Student.class);
382             if(tr.getName()!=null){
383                 cri.add(Restrictions.like("name", tr.getName()));
384             }if(tr.getStartGrade()!=null&&tr.getEndGrade()!=null){
385                 cri.add(Restrictions.between("gradeid",tr.getStartGrade(),tr.getEndGrade()));
386
387             }if(tr.getStartGrade()!=null&&tr.getEndGrade()==null){
388                 cri.add(Restrictions.ge("gradeid",tr.getStartGrade()));
389
390             }
391             if(tr.getStartGrade()==null&&tr.getEndGrade()!=null){
392                 cri.add(Restrictions.le("gradeid",tr.getEndGrade()));
393
394             }
395             List student=cri.addOrder(Order.asc("gradeid")).setMaxResults(80).list();
396             //根据年级排序,每页显示十条
397             Integer pagesize=10;
398             Integer page=1;
399             System.out.println(student.size()/pagesize);
400             for(int i=0;i<student.size()/pagesize;i++){
401                 System.out.println("--------第 "+page+" 页-------------");
402                 List students=cri.addOrder(Order.asc("gradeid")).setFirstResult(pagesize*(page-1)).setMaxResults(pagesize).list();
403                 page++;
404                 for(int j=0;j<students.size();j++){
405                     System.out.println(students.get(j));
406                 }
407                 System.out.println(page);
408
409
410
411             }
412
413
414         } catch (Exception e) {
415             // TODO: handle exception
416             e.printStackTrace();
417         }finally{
418             HibernateUtil.closeSession();
419         }
420
421
422     }
423     /**
424      * 链接查询
425      */
426     public void testrelevance(){
427         try {
428             session=HibernateUtil.currentSession();
429             session.beginTransaction();
430             List student=session.createCriteria(Student.class).createCriteria("grade").addOrder(Order.asc("gradeid")).setMaxResults(20).list();
431             for(int i=0;i<student.size();i++){
432                 System.out.println(student.get(i)+"\t"+((Student)student.get(i)).getGrade().getGradename());
433             }
434
435
436
437         } catch (Exception e) {
438             // TODO: handle exception
439             e.printStackTrace();
440         }finally{
441             HibernateUtil.closeSession();
442         }
443         System.out.println("---createAlias()查询---");
444         try {
445             session=HibernateUtil.currentSession();
446             session.beginTransaction();
447             List student=session.createCriteria(Student.class,"s").createAlias("grade","g").addOrder(Order.asc("s.gradeid")).setMaxResults(20).list();
448             for(int i=0;i<student.size();i++){
449                 System.out.println(student.get(i)+"\t"+((Student)student.get(i)).getGrade().getGradename());
450             }
451
452         } catch (Exception e) {
453             // TODO: handle exception
454             e.printStackTrace();
455         }finally{
456             HibernateUtil.closeSession();
457         }
458     }
459
460     /**
461      * 投影查询
462      */
463     public void testProj(){
464         System.out.println("--查询记录总数--");
465         try {
466             session=HibernateUtil.currentSession();
467             session.beginTransaction();
468             //查询所有年级名称
469             Object obj=session.createCriteria(Grade.class)
470                     .setProjection(Projections.projectionList().add(Projections.rowCount()))
471                     .list();
472             System.out.println("所有班级:"+obj);
473
474         } catch (Exception e) {
475             // TODO: handle exception
476             e.printStackTrace();
477         }finally{
478             HibernateUtil.closeSession();
479         }
480
481         System.out.println("--查询班级名称--");
482         try {
483             session=HibernateUtil.currentSession();
484             session.beginTransaction();
485             //查询所有年级名称
486             Object obj=session.createCriteria(Grade.class)
487                     .setProjection(Projections.projectionList().add(Property.forName("gradename")))
488                     .list();
489             System.out.println(obj);
490
491         } catch (Exception e) {
492             // TODO: handle exception
493             e.printStackTrace();
494         }finally{
495             HibernateUtil.closeSession();
496         }
497     }
498
499     /**
500      * DetachedCriteria 离线查询
501      */
502     public void testoff_line(){
503         try {
504             //这段代码一般放在web产生查询条件
505             DetachedCriteria det=DetachedCriteria.forClass(Student.class,"s")
506                     .createAlias("s.grade", "g")
507                     .add(Restrictions.eq("g.gradename", "幼儿园"));
508
509             //数据访问层
510             session=HibernateUtil.currentSession();
511             session.beginTransaction();
512             List students=det.getExecutableCriteria(session).add(Restrictions.ilike("s.name","%yap%")).setMaxResults(50).list();
513             //打印
514             for(int i=0;i<students.size();i++){
515                 System.out.println(students.get(i)+"\t"+((Student)students.get(i)).getGrade().getGradename());
516             }
517
518         } catch (Exception e) {
519             // TODO: handle exception
520             e.printStackTrace();
521         }finally{
522             HibernateUtil.closeSession();
523
524         }
525     }
526     /**注解 的效果
527      * 启动时会在数据库创建一个表
528      */
529     public void testNote(){
530         try {
531             AnnotationConfiguration anc=new AnnotationConfiguration().configure();
532             session=anc.buildSessionFactory().openSession();
533             session.beginTransaction();
534             session.getTransaction().commit();
535         } catch (Exception e) {
536             // TODO: handle exception
537             e.printStackTrace();
538             session.getTransaction().rollback();
539         }finally{
540             session.close();
541         }
542
543     }
544
545
546
547
548
549
550 }

Criterion&DetachedCriteria

时间: 2024-08-24 19:43:56

Criterion & DetachedCriteria的相关文章

利用DetachedCriteria构建HQL参数动态匹配

此文章是基于 搭建SpringMVC+Spring+Hibernate平台 1. DetachedCriteria构建类:CriteriaBuilder.java package com.ims.persistence.base; import java.math.BigDecimal; import java.sql.Types; import java.util.Map; import org.apache.commons.lang3.StringUtils; import org.hibe

网页分页功能的实现

最近在学习JavaWeb的时候,用到了分页功能,现在进行一个记录,以备不时之需 第一步:先完成分页Bean的编写. 就是对当前页数,每页显示的记录数,总记录数,总页数,分页显示的信息进行封装.作为通用的分页功能的实现,这里用到了泛型 import java.util.List; /** * 分页封装 * */ public class PageBean<T> { private int currPage;//当前页数 private int pageSize;//每页显示记录数 private

Hibernate3.3.2+Spring2.5.5+Struts2.1.6+Extjs3.0.0 Annotations注解框架整合及其代码分享

原创整理不易,转载请注明出处:Hibernate3.3.2+Spring2.5.5+Struts2.1.6+Extjs3.0.0 Annotations注解框架整合及其代码分享 代码下载地址:http://www.zuidaima.com/share/1780237805931520.htm 一.准备 1. Hibernate: hibernate-distribution-3.3.2.GA, hibernate-annotations-3.4.0.GA 2. Spring: spring-fr

6Hibernate进阶----青软S2SH(笔记)

关于关联关系的配置,用注解配置如下(这里引用的jar包是javax.persistence) // @ManyToOne(fetch=FetchType.LAZY) @ManyToOne(fetch=FetchType.EAGER) @JoinColumn(name="supplier_id",nullable=true) private Supplier supplier; 用xml文件配置如下,这个跟注解配置有些不同,就不详解了,反正我也不会用xml配置 例子 /* 使用HQL对查

hibernate 框架学习笔记---网上摘抄的一个非常好的例子

编写Spring+Hibernate框架下的应用,总是离不了编写一个通用的泛型GenericHibernateDao.查阅了网上不少的GenericHibernateDao实现,归纳整理为如下实现,供后续编码参考. 首先定义接口泛型DAO接口 GenericDao package com.th.huz; import java.io.Serializable;import java.util.Collection;import java.util.Iterator;import java.uti

Hibernate也需要呵护——Hibernate的泛型DAO

众所周之,面向对象的基础是抽象.也可以说,抽象促使编程在不断发展.对于数据库的访问,曾经写过HqlHelper,EFHelper.编写Spring+Hibernate框架下的应用,也同样离不了编写一个通用的泛型GenericHibernateDao.查阅了网上不少的GenericHibernateDao实现,归纳整理为如下实现,供后续编码参考. 一. DAO泛型的接口 GenericDao package ICT.framework.orm.hibernate; import java.io.S

SSH框架整合截图(二)

客户拜访管理 1 什么是客户拜访 (1)客户:与公司有业务往来的 (2)用户:可以使用系统的人 2 用户和客户关系 (1)用户和客户之间是拜访的关系 (2)用户 和 客户 是 多对多关系 ** 一个用户可以拜访多个客户,一个客户可以被多个用户拜访 (3)多对多建表: - 创建第三张表,使用外键维护关系 3 多对多配置 (1)缺陷:第三张表只有两个字段(两个id值) 4 把多对多拆分成两个一对多实现(1)用户.客户.拜访(2)用户 和 拜访是一对多 (3)客户和拜访是一对多 配置用户和客户关系 (

javaWeb校内网开发(二)

今天主要将Spring.Hibernate集成进CMS中,以及完成简单的数据库查询. 首先集成Spring,首先web项目中加入jar,关于Spring的jar这里不做要求(最好都用3.0以上的),在web.xml中加入Spring的监听,引导项目启动Spring,配置contextConfigLocation这个参数来装入Spring的配置文件. <?xml version="1.0" encoding="UTF-8"?> <web-app xm

Spring(一)

Spring    1.IoC容器    2.AOP实现    3.数据访问支持:简化hibernate编码,声明式事物    4.Web集成    Spring Framework        Inversion of Control(控制反转/Dependency Inversion Principle):    1.一个重要的面向对象编程的法则来削减计算机程序的耦合问题    2.轻量级的Spring框架的核心    实现技术:    1.Java反射技术实现    2.配置文件组装对象