Hibernate框架之Criteria查询和注解（重点☆☆☆☆☆，难点☆☆☆）

2022-07-26 17:58:07

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

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

今天呢，我就详细的写着 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();
    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();
     @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个变量
           ;
           ;

           criteria.setFirstResult((pageIndex-)*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())
    .setProjection(Projections.count("empno"));
     Integer count = (Integer) criteria.uniqueResult();//查询总记录数
     //分页
     ;//每页显示的记录数
     )?(count/pageSize):(count/pageSize+);//总页数
     ;//当前页号
              criteria = session.createCriteria(Employee.class)
                .add(Restrictions.eq())
                .addOrder(Order.desc("empno"));
                @SuppressWarnings("unchecked")
                List<Employee> list = criteria.
                setFirstResult((pageIndex-)*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.]+]);
    }

    session.getTransaction().commit();
    HibernateUtil.closeSessio();
}

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

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

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

第二部分：注解

Hibernate 提供了Hibernate Annootations 扩展包，它可以替换复杂的hbm.xml文件，使得Hibernate 程序的开发大大简化。即利用注解后，可不用定义持久haunted类的*.hbm.xml文件，而直接以注解方式写入持久化类的实现中。

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

使用注解的步骤：

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中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式

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

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

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

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

4.在配置文件（hibernate.cfg.xml）中声明持久化类

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

基础知识：

.@Entity注释指名这是一个实体Bean。
.@Table注释指定了Entity所要映射带数据库表
.@Table.name()用来指定映射表的表名
.如果缺省@Table注释，系统默认采用类名作为映射表的表名
.实体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：映射的列名
 *
 */

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

废话不多说，案例解释一切：

@OneToOne :建立持久化类之间的一对一关联关系

持久化类：

IdCard

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;
        }

Student：

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;
        }

hibernate.cfg.xml：

     <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(");
    stu.setCraid(cid);

    session.save(cid);
    session.save(stu);

    session.getTransaction().commit();
    HibernateUtils.closeSession();
}

@OneToMany:建立持久化类之间的一对多关联关系

Dept:

@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>();

Emp：　　

@Entity
@Table
public  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.);

        System.out.println(emp.getEmpName());

        tx.commit();
        HibernateUtils.closeSession();

@ManyToMany:建立持久化类之间的多对多关系

Emp:

@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>();//员工对应的项目

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);

       }

一些注解的解释：

mappedBy="dept"：设置了维系关系的控制权交给Emp类的这一方，相当于Dept.hbm.xml配置文件的inverse="true",mappedBy属性值dept是Emp类中的属性名。

cascade属性的联级操作：

到这里就差不多了，通过上面的案例，我们明显可以看到，注解比配置文件要简单的多，代码量少，方便维护。

码农公寓

相关文章