你的位置:首页 > Java教程

[Java教程]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();

4.在配置文件(hibernate.cfg.

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

废话不多说,案例解释一切:

@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.

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

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

@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.

cascade属性的联级操作:

 

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