今天呢，我就详细的写着 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.like("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.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" />
基础知识：
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.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("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
@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.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.xml配置文件的inverse="true",mappedBy属性值dept是Emp类中的属性名。
cascade属性的联级操作：
到这里就差不多了，通过上面的案例，我们明显可以看到，注解比配置文件要简单的多，代码量少，方便维护。
314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
