Criteria学习002之Criterion&Restrictions

      前面学习了Criteria的简单用法查询。现在来学习下Criteria查询条件稍微复杂时，该怎么办。

      查看API文档或Critira接口源码，我们看到public Criteria add(Criterion criterion);方法，可通过它添加约束条件。Criterion也是个接口，查看的实现类。

      看这些实现类的类名，就大概明白什么意思了，看文档或源码，发现这些类的构造方法都是protected的，也就是说，如果我们需要使用这些类，不能直接new一个。老外给我们提供了一个类Restrictions。

           Restrictions提供了非常多静态方法，都是返回Criterion。

Restrictions.eq --> equal,等于.

Restrictions.allEq --> 参数为Map对象,使用key/value进行多个等于的比对,相当于多个Restrictions.eq的效果

Restrictions.gt --> great-than > 大于

Restrictions.ge --> great-equal >= 大于等于

Restrictions.lt --> less-than, < 小于

Restrictions.le --> less-equal <= 小于等于

Restrictions.between --> 对应SQL的between子句

Restrictions.like --> 对应SQL的LIKE子句

Restrictions.in --> 对应SQL的in子句

Restrictions.and --> and 关系

Restrictions.or --> or 关系

Restrictions.isNull --> 判断属性是否为空,为空则返回true

Restrictions.isNotNull --> 与isNull相反

Restrictions.sqlRestriction --> SQL限定的查询

Order.asc --> 根据传入的字段进行升序排序

Order.desc --> 根据传入的字段进行降序排序

MatchMode.EXACT --> 字符串精确匹配.相当于"like 'value'"

MatchMode.ANYWHERE --> 字符串在中间匹配.相当于"like '%value%'"

MatchMode.START --> 字符串在最前面的位置.相当于"like 'value%'"

MatchMode.END --> 字符串在最后面的位置.相当于"like '%value'"

   接下来我们弄个小例子测试下。

Grade.java

@Entity
@Table(name="grade")
public class Grade {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	private String name;
	@OneToMany(fetch = FetchType.LAZY, mappedBy = "grade")
	private List<Student> students;

Student.java

@Entity
@Table(name="student")
public class Student {
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int id;
	private String name;
	private int age;
	@ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "grade_id")
	private Grade grade;

TestModel.java

package com.fei.hibernate.model;

import java.util.List;




import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;


public class TestModel {
	public static SessionFactory sf=null;
	@BeforeClass
	public static void beforeClass(){
		 sf=new Configuration().configure().buildSessionFactory();
	}
	@AfterClass
	public static void afterClass(){
		sf.close();
	}
	
	@Test
	public void testSave(){
		Grade g1 = new Grade("高一");
		Student s101 = new Student("貂蝉",15,g1);
		Student s102 = new Student("张蕊",16,g1);
		Student s103 = new Student("甄宓",14,g1);
		
		Grade g2 = new Grade("高二");
		Student s201 = new Student("蔡琰",17,g2);
		Student s202 = new Student("小乔",15,g2);
		Student s203 = new Student("大乔",17,g2);
		
		Session session = sf.openSession();
		Transaction transaction = session.beginTransaction();
		transaction.begin();
		
		session.save(g1);
		session.save(s101);
		session.save(s102);
		session.save(s103);
		
		session.save(g2);
		session.save(s201);
		session.save(s202);
		session.save(s203);
		
		session.flush();
		transaction.commit();
		session.close();
	}
/**	
	@Test
	public void testDeleteGrade(){
		Session session = sf.openSession();
		Transaction transaction = session.beginTransaction();
		transaction.begin();
		
		Grade g1 = (Grade) session.get(Grade.class, Integer.valueOf(3));
		Grade g2 = (Grade) session.get(Grade.class, Integer.valueOf(4));
		
		session.delete(g1);
		session.delete(g2);
		
		session.flush();
		transaction.commit();
		session.close();
	}
**/	
	
	/**
	 *select s.* 
	 *from student s
	 *join grade g on g.id = s.grade_id
	 *where g.name='高一' 
	 *order by age asc
	 */
	@Test
	public void testQuery(){
		Session session = sf.openSession();
		Criteria criteria = session.createCriteria(Student.class);
		criteria.createAlias("grade","g");//对Student类中的grade使用别名，这样g.name时就知道是grade中的name，而不是student中的name
		criteria.add(Restrictions.eq("g.name", "高一"))
		          .addOrder(Order.asc("age"));
		List<Student> students = criteria.list();
		print(students);
		session.close();
	}
	
	private void print(List<Student> students){
		System.out.println("===================================");
		System.out.println("id\t name\t age\t grade.name");
		for(Student s : students){
			System.out.println(s.getId()+"\t"+s.getName()+"\t         "+s.getAge()+"\t"+s.getGrade().getName());
		}
	}
}

查询的结果：

Hibernate: 
    select
        this_.id as id0_1_,
        this_.age as age0_1_,
        this_.grade_id as grade4_0_1_,
        this_.name as name0_1_,
        g1_.id as id1_0_,
        g1_.name as name1_0_ 
    from
        student this_ 
    inner join
        grade g1_ 
            on this_.grade_id=g1_.id 
    where
        g1_.name=? 
    order by
        this_.age asc
===================================
id	 name	 age	 grade.name
3	甄宓	         14	高一
1	貂蝉	         15	高一
2	张蕊	         16	高一

     Restrictions的方法很多，这里就不一一验证了，我们只需知道该怎么做就OK了，如果对某方法实在不懂该怎么用，问度娘就OK了。