Hibernate框架 重中之重的Criteria查询 和注解

写好一篇博客，不是容易的事。原因是：你要给自己以后看的时候，还能看懂，最重要的是当别人看到你的博客文章的时候，也一样很清楚的明白你自己写的东西。其实这也是一种成就感！！

对于每一个知识点，要有必要的解释 语言及真实的代码。

今天呢，我就详细的写着 Hibernate框架的一种检索方式：Criteria查询。下面我写的这些案例，可能对于大牛没有什么好看的，但是对于初学者来说，却是一笔财富。

首先我们要知道的检索方式： 

Hibernate框架提供了5种检索对象的方式

     1.导航对象图检索方式：根据已经加载的对象导航到其他对象

     2.OID检索方式：按照对象的OID来检索对象

     3.HQL检索方式：使用面向对象的HQL查询语言

     4.QBC检索方式：使用QBC(Query By Criteria)API来检索对象，这种API封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口

     5.本地SQL检索方式：使用本地数据库的SQL查询语句

什么是Criteria

Criteria是一种比hql更面向对象的查询方式。Criteria 可使用 Criterion 和 Projection 设置查询条件。可以设置 FetchMode(联合查询抓取的模式 ) ，设置排序方式，Criteria 还可以设置 FlushModel （冲刷 Session 的方式）和 LockMode。

Criteria查询 就是 通过面向对象化的设计，将数据查询条件封装为一个对象

Criteria是一个接口，它继承了 另一个接口。

它里面有很多的方法，看图说话：

有了这些方法，我们可以再深度研究，这个方法里面的参数，有了什么接口或是类的类型。例如举个简单的例子：

对于add的方法，里面有了一个参数，它的返回类型为 Criterion。现在我们再对Criterion研究。

Restrictions类提供了创建Criterion对象的方法。我们看下图，它是SimpleExpression ，

 但是我们再耐心的往下看，就知道了

你看到没有，其实首先呢，Restrictions 创建了SimpleExpression对象，然后SimpleExpression又实现了Criterion。所以Restrictions类提供了创建Criterion对象的方法。这样我们就很清楚了这些接口或类的关系了。

所以，到这里大家应该清楚，想好一门技术，其实很简单，就是要不断的挖掘，坚持的做下去，你就是大牛。

使用Criteria查询的步骤：

（1）.使用Session 接口 的createCriteria（）方法创建 Criteria对象。

（2）.使用Restrictions类提供的静态方法设置查询条件，这些静态方法返回Criterion对象，一个Criterion对象代表一个查询条件Criteria接口的add（）方法用来添加查询条件。

（3）.使用Criteria接口的list()方法执行查询语句，list()方法返回java.util.List类型的结果，List集合中的每一个元素都是持久化对象。

下面我们正式通过例子来说明一切。

 第一个案例：查询所有的信息

//1.查询所有部分信息private static void selectAllDept() {  Session session = HibernateUtil.currentSession();  session.beginTransaction();  Criteria criteria = session.createCriteria(Dept.class);  @SuppressWarnings("unchecked")  List<Dept> list = criteria.list();   for (Dept dept : list) {    System.out.println("部门编号:"+dept.getDeptNo()+","+"部门名称:"+dept.getdName());  }  session.getTransaction().commit();  HibernateUtil.closeSessio();  }

 代码解释：session.createCriteria(）方法创建Criteria对象，createCriteria（）方法的参数是持久化类的类型，使用criteria.list()执行的查询语句，list()方法的返回值是List集合。

第二个案例：Criteria带条件查询   查询部门名称为“开发部”的部门

private static void selectToCriteriaOfDeptNo() {  Session session = HibernateUtil.currentSession();  session.beginTransaction();   Criteria criteria = session.createCriteria(Dept.class);   Criterion criterion = Restrictions.eq("dName", "开发部");     criteria.add(criterion);   @SuppressWarnings("unchecked")   List<Dept> list =criteria.list();   for (Dept dept : list) {     System.out.println("部门编号:"+dept.getDeptNo()+","+"部门名称:"+dept.getdName());  }  session.getTransaction().commit();  HibernateUtil.closeSessio();}

 代码解释：Restrictions.eq（）方法设定条件，eq()方法的第一个参数是持久化类的属性，第二个参数是条件，返回值是Criterion对象。

第三个案例：关联查询  查询“开发部”所有员工

/*   * createCriteria()   *    * @SuppressWarnings("unchecked")  List<Employee> list = session.createCriteria(Employee.class)   .add(Restrictions.ilike("ename", "a", MatchMode.ANYWHERE))   .createCriteria("dept")   .add(Restrictions.eq("dName", "开发部").ignoreCase())   .list();  for (Employee employee : list) {     System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname()+","+"部门名称:"+employee.getDept().getdName());  }*/    /*  createAlias   * @SuppressWarnings("unchecked")  List<Employee> list = session.createCriteria(Employee.class,"emp")  .createAlias("dept", "d")  .add(Restrictions.ilike("emp.ename", "a", MatchMode.ANYWHERE)).add(Restrictions.eq("d.dName", "开发部")      .ignoreCase()).list();  for (Employee employee : list) {     System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname()+","+"部门名称:"+employee.getDept().getdName());  }  */  @SuppressWarnings("unchecked")  List<Dept> list = session.createCriteria(Dept.class,"d")  .setFetchMode("emps", FetchMode.JOIN)  .add(Restrictions.eq("d.loc", "北京").ignoreCase())  .list();  /*for (Dept dept : list) {  System.out.println("部门名称:"+dept.getdName()+","+dept.getLoc()+","+dept.getEmps().size());  }*/  //过滤掉重复的数据  HashSet<Dept> set=new HashSet<Dept>(list);  for (Dept dept : set) {    System.out.println("部门名称:"+dept.getdName()+","+dept.getLoc()+","+dept.getEmps().size());  }       session.getTransaction().commit();  HibernateUtil.closeSessio();

第四个案例：范围  查询地址为bj或者sh的员工信息

      Criteria criteria = session.createCriteria(Emp.class);            //1.2 Collection的实现类      List<String> lists=new ArrayList<String>();      lists.add("bj");      lists.add("sh");           Criterion criterion=Restrictions.in("empCity", lists);           //1.2       criteria.add(criterion);      criteria.add(criterion);      List<Emp> list = criteria.list();      for (Emp emp : list) {        System.out.println(emp.getEmpName());      }

第五个案例：字符串模式匹配，查询员工地址中包含“s”的所有员工

 Criteria criteria = session.createCriteria(Emp.class);           Criterion criterion = Restrictions.ilike("empCity", "%b%");           criteria.add(criterion);            List<Emp> list = criteria.list();      for (Emp emp : list) {        System.out.println(emp.getEmpName());      }

第六个案例：逻辑运算 and 过滤 查找地址是bj 并且 名称中包含 “雨” 的员工信息

 Criteria criteria= session.createCriteria(Emp.class);      Criterion c1 = Restrictions.eq("empCity", "bj");      Criterion c2= Restrictions.like("empName", "号",MatchMode.ANYWHERE);           Criterion criterion = Restrictions.and(c1, c2);            criteria.add(criterion);            List<Emp> list = criteria.list();      for (Emp emp : list) {        System.out.println(emp.getEmpName());      }

第七个案例：集合运算集合运算 查询 没有员工的部门

  Criteria criteria = session.createCriteria(Dept.class);            Criterion criterion = Restrictions.isEmpty("emps");            criteria.add(criterion);                  List<Dept> list = criteria.list();      for (Dept dept : list) {        System.out.println(dept.getDeptName());      }

第八个案例：

动态查询
* 如何查找出符合以下条件的员工信息：
职位是工程师，如：job = ‘engineer’
工资大于2000元，如：salary > 2000
入职时间在2006年12月31日至2008年12月31日之间
如何查找出符合以下条件的员工信息：
地址 = ‘bj’
员工编号大于0

Session session = HibernateUtil.currentSession();  session.beginTransaction();  //1.准备对象的封装条件  EmployeeCondition empcon=new EmployeeCondition();  empcon.setEmpno(21);  empcon.setEname("张三");  //2.添加动态条件   Criteria criteria = session.createCriteria(Employee.class);   if(empcon.getEname()!=null){     criteria.add(Restrictions.like("ename", empcon.getEname(),MatchMode.EXACT));   }   if(empcon.getEmpno()!=null){     criteria.add(Restrictions.eq("empno", empcon.getEmpno()));   }   //3.执行查询   @SuppressWarnings("unchecked")  List<Employee> list = criteria.list();   for (Employee employee : list) {    System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname());  }  session.getTransaction().commit();  HibernateUtil.closeSessio();

第九个案例：

排序 addOrder()
* 查询工号大于0的员工，查询结果按员工 编号升序排列

Session session = HibernateUtil.currentSession();  session.beginTransaction();  Criteria criteria = session.createCriteria(Employee.class);  SimpleExpression expression = Restrictions.gt("empno", 2);   @SuppressWarnings("unchecked")  List<Employee> list = criteria  .add(expression)  .addOrder(Order.asc("empno"))  .list();   for (Employee employee : list) {     System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname());  }  /*@SuppressWarnings("unchecked")  List<Employee> list=(List<Employee>) criteria.add( Restrictions.gt("empno", 2)).addOrder(Order.asc("empno")).list();  for (Employee employee : list) {    System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname());  }*/   session.getTransaction().commit();   HibernateUtil.closeSessio();

第十个案例：

分页
* Criteria接口提供了设置分页的方法
setFirstResult(int firstResult) 起始记录的索引
setMaxResult(int maxResult) 最大记录条数
//10.分页 查询员工表中的4-6条数据，每页3条数据

  Criteria criteria = session.createCriteria(Emp.class);      //总记录数      //新的类型 ：条件(Restrictions)    Projections      //1.1       Projection projection = Projections.count("empId");      //1.2       criteria.setProjection(projection);      //1.3       Integer count = ((Long)criteria.uniqueResult()).intValue();      System.out.println(count);      //预置2个变量      int pageSize=3;      int pageIndex=2;           criteria.setFirstResult((pageIndex-1)*pageSize);      criteria.setMaxResults(pageSize);            List<Emp> list = criteria.list();      for (Emp emp : list) {        System.out.println(emp.getEmpName());      }

或是下面这个：

Criteria criteria = session.createCriteria(Employee.class)  .add(Restrictions.eq("deptNo", 1))  .setProjection(Projections.count("empno"));   Integer count = (Integer) criteria.uniqueResult();//查询总记录数   //分页   int pageSize=2;//每页显示的记录数   int totalpages=(count%pageSize==0)?(count/pageSize):(count/pageSize+1);//总页数   int pageIndex=1;//当前页号       criteria = session.createCriteria(Employee.class)        .add(Restrictions.eq("deptNo", 1))        .addOrder(Order.desc("empno"));        @SuppressWarnings("unchecked")        List<Employee> list = criteria.        setFirstResult((pageIndex-1)*pageSize)        .setMaxResults(pageSize)        .list();        for (Employee employee : list) {           System.out.println("员工编号:"+employee.getEmpno()+","+"员工名称:"+employee.getEname());           System.out.println("总记录数:"+totalpages);           System.out.println("总记录数:"+pageIndex);        }        session.getTransaction().commit();        HibernateUtil.closeSessio();

第十一个案例：

DetachedCriteria和Criteria功能类似，它实现了CriteriaSpecification接口
Criteria是由Session对象创建的
DetachedCriteria创建时不需要Session对象
使用DetachedCriteria来构造查询条件
可以把DetachedCriteria作为方法参数传递给业务层
* 查询开发部的员工

  //1.构建一个Detached对象      DetachedCriteria detachedCriteria=DetachedCriteria.forClass(Emp.class);      //1.2 别名      detachedCriteria.createAlias("dept", "d");      //1.3 指定检索条件      Criterion criterion = Restrictions.eq("d.deptName", "开发部");      //bind 绑定            detachedCriteria.add(criterion);      //detachedCriteria的方法植入对session的引入           List<Emp> list = detachedCriteria.getExecutableCriteria(session).list();            for (Emp emp : list) {        System.out.println(emp.getEmpName());      }    }

在这十几案例中，这个案例算是最重要的了，看似代码少，但是DetachedCriteria非常重要，在以后公司如果用的到的话，都是用DetachedCriteria 类的一些方法实现查询的。Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)进行DetachedCriteria 实例的创建。

DetachedCriteria有如下方法：

第十二案例：查询唯一对象

Session session = HibernateUtil.currentSession();  session.beginTransaction();  Employee employee = (Employee) session.createCriteria(Employee.class)  .add(Restrictions.isNotNull("empno"))  .addOrder(Order.desc("empno"))  .setMaxResults(1) //如果有多个对象，不设这个的话，会报异常，NonUniqueResultException  .uniqueResult();  System.out.println(employee.getEmpno()+","+employee.getEname());  session.getTransaction().commit();  HibernateUtil.closeSessio();

注意：如果有多个对象的时候，一定要写setMaxResults(1)  方法，限制条数，否则会报如下异常：

第十三个案例：投影

Session session = HibernateUtil.currentSession();  session.beginTransaction();  // setProjection()   /* List<String> list = session.createCriteria(Dept.class).setProjection(Property.forName("dName")).list();    for (String deptName : list) {    System.out.println(deptName);  }*/  //Projections.projectionList()  @SuppressWarnings("unchecked")  List<Object[]> list = session.createCriteria(Dept.class)     .setProjection(Projections.projectionList()    .add(Property.forName("loc"))    .add(Property.forName("dName"))).list();    for (Object[] obj : list) {    System.out.println("地址："+obj[0]+"," +"名称:"+obj[1]);  }    session.getTransaction().commit();  HibernateUtil.closeSessio();}

通过上面的十几个案例，可以大致对Criteria查询有些了解，可以再去深入的了解Ciiteria 查询的其他方法，能了解的更广！！

可以通过上面的例子，我们可以看到Restrictions 有了很多的方法，现在来总结一下：

只要我们把Restrictions的这些方法搞定，就差不多了。。。

第二部分 ：注解

Hibernate 提供了Hibernate Annootations 扩展包，它可以替换复杂的hbm.

作用：它可以代替配置文件，大大简化代码量，代码可读性比较高，编写的工作量比较轻。

使用注解的步骤：

1.添加jar包

01.hibernate-annotations-3.4.0.GA根目录下的hibernate-annotations.jar

02.hibernate-annotations-3.4.0.GA\lib目录下的hibernate-commonons-annotations.jar,ejb3-persitence.jar.

注意：

在hibernate中，通常配置对象关系映射关系有两种，一种是基于的方式，另一种是基于annotation的注解方式

熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，这两种方式，发现使用annotation的方式可以更简介，通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用hibernate3的版本就需要引入annotation的jar包。

2.使用注解配置持久化类及对象关联关系。

3.使用AnnotationsConfiguration建立会话工厂。

sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();

<mapping resource="cn/entity/Dept.hbm." />

1.@Entity注释指名这是一个实体Bean。2.@Table注释指定了Entity所要映射带数据库表3.@Table.name()用来指定映射表的表名4.如果缺省@Table注释，系统默认采用类名作为映射表的表名5.实体Bean的每个实例代表数据表中的一行数据，行中的一列对应实例中的一个属性

 * initialValue 初值 * sequenceName 序列的名称 * strategy 策略 * @Column注释定义了将成员属性映射到关系表中的哪一列和该列的结构信息 * secondaryTable：从表名。如果此列不建在主表上（默认是主表），该属性定义该列所在从表的名字 * GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列。（这个值要与generator一起使用） * generator 指定生成主键使用的生成器（可能是orcale中的序列）。 * @SequenceGenerator —— 注解声明了一个数据库序列。该注解有如下属性 ： * name 表示该表主键生成策略名称，它被引用在@GeneratedValue中设置的 “gernerator”值中 * sequenceName 表示生成策略用到的数据库序列名称。 * initialValue 表示主键初始值，默认为0. * allocationSize 每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50. * SEQUENCE：使用数据库德SEQUENCE列莱保证唯一（Oracle数据库通过序列来生成唯一ID） * name：映射的列名 * */

6.@Column注释定义了将成员属性映射到关系表中的哪一列和该列的结构信息1）name：映射的列名。如：映射tbl_user表的name列，可以在name属性的上面或getName方法上面加入；2）unique：是否唯一；3）nullable：是否允许为空；4）length：对于字符型列，length属性指定列的最大字符长度；5）insertable：是否允许插入；6）updatetable：是否允许更新；7）columnDefinition：定义建表时创建此列的DDL；8）secondaryTable：从表名。如果此列不建在主表上（默认是主表），该属性定义该列所在从表的名字。7.@Id注释指定表的主键，它可以有多种生成方式：1）TABLE：容器指定用底层的数据表确保唯一；2）SEQUENCE：使用数据库德SEQUENCE列莱保证唯一（Oracle数据库通过序列来生成唯一ID）；3）IDENTITY：使用数据库的IDENTITY列莱保证唯一；4）AUTO：由容器挑选一个合适的方式来保证唯一；5）NONE：容器不负责主键的生成，由程序来完成。@GeneratedValue注释定义了标识字段生成方式。@Temporal注释用来指定java.util.Date或java.util.Calender属性与数据库类型date、time或timestamp中的那一种类型进行映射。@Temporal(value=TemporalType.TIME)

import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.OneToOne;import javax.persistence.Table;  @Entity  @Table(name="IdCard")  public class IdCard {    @Id     //限定长度为18位，相当于约束    @Column(length=18)    private String cid;    @Column(name="cname")    private String cname;    //mappedBy  表示由 craid所在的对象维护关联关系    @OneToOne(mappedBy="craid")    private Student stu;    public IdCard() {    }    public String getCid() {      return cid;    }    public void setCid(String cid) {      this.cid = cid;    }    public IdCard(String cid, String cname, Student stu) {      super();      this.cid = cid;      this.cname = cname;      this.stu = stu;    }    public String getCname() {      return cname;    }    public void setCname(String cname) {      this.cname = cname;    }    public Student getStu() {      return stu;    }    public void setStu(Student stu) {      this.stu = stu;    }   

import javax.persistence.CascadeType;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToOne;import javax.persistence.Table;import org.hibernate.annotations.CollectionId;  @Entity  @Table(name="MyStudent")  public class Student {    //标示属性    @Id    //使用默认的序列  Hibernate_Sequence    @GeneratedValue    private Integer id;    @Column(name="name")    private String name;    //一对一关联 保存学生的时候自动保存身份证对象    @OneToOne(cascade={CascadeType.ALL})    //在底层的MyStudent数据表中植入的列名    @JoinColumn(name="cid")    private IdCard craid;        public Student() {      super();    }    public Student(Integer id, String name, IdCard craid) {      super();      this.id = id;      this.name = name;      this.craid = craid;    }    public Integer getId() {      return id;    }    public void setId(Integer id) {      this.id = id;    }    public String getName() {      return name;    }    public void setName(String name) {      this.name = name;    }    public IdCard getCraid() {      return craid;    }    public void setCraid(IdCard craid) {      this.craid = craid;    }       

   <mapping class="cn.happy.entity.Student"/>   <mapping class="cn.happy.entity.IdCard"/>

  Session session = HibernateUtils.currentSession();  session.beginTransaction();  Student stu=new Student();  stu.setName("李四");    IdCard cid=new IdCard();  cid.setCid("123321311111111111");   stu.setCraid(cid);    session.save(cid);  session.save(stu);    session.getTransaction().commit();  HibernateUtils.closeSession();}

@Entity  @Table(name="Dept")  public class Dept {    @Id    //引用生成器    @GeneratedValue    private Integer deptNo;     //默认Hibernate管理    private String deptName;    @OneToMany(mappedBy="dept")    @LazyCollection(LazyCollectionOption.FALSE)    private Set<Emp> emps=new HashSet<Emp>();    

@Entity@Tablepublic class Emp {  @Id  private Integer empId;  @Column  private String empName;  @ManyToOne  @JoinColumn(name="deptNo")  private Dept dept;

    Session session = HibernateUtils.currentSession();    Transaction tx = session.beginTransaction();    //    Dept dept = (Dept)session.load(Dept.class, 21);//    //    System.out.println(dept.getDeptName());            Emp emp = (Emp)session.load(Emp.class, 21);        System.out.println(emp.getEmpName());        tx.commit();    HibernateUtils.closeSession();

@Entity@Table(name="YEmp")public class Emp {  @Id  @GeneratedValue  private Integer eid;//员工编号    private String ename;//员工名称  //创建连接表  @ManyToMany(cascade=CascadeType.ALL)  @JoinTable(      name="YEmpPro",      joinColumns=@JoinColumn(name="eid"),      inverseJoinColumns=@JoinColumn(name="pid")  )  private Set<Project> pros=new HashSet<Project>();//员工对应的项目

* * 项目表 * */@Entity@Table(name="YProject")public class Project {  @Id  @GeneratedValue  private Integer pid;//项目编号  private String pname;//项目名称    @ManyToMany(mappedBy="pros")//将控制权转交给主表  private Set<Emp> emps=new HashSet<Emp>();//员工对应的项目

  Session session;  Transaction tx;  @Before  public void mybefore(){    session= HibernateUtils.currentSession();    tx=session.beginTransaction();  }    @After  public void myafter(){     tx.commit();     HibernateUtils.closeSession();  }    /**   * 1.1  保存部门   */    @Test    public void groupTest(){    Emp emp1=new Emp("李四");    Emp emp2=new Emp("王五");        Project p1=new Project("项目一");    Project p2=new Project("项目二");        emp1.getPros().add(p1);        emp1.getPros().add(p2);    emp2.getPros().add(p2);        session.save(emp1);    session.save(emp2);           }