寫好一篇博客，不是容易的事。原因是：你要給自己以後看的時候，還能看懂，最重要的是當別人看到你的博客文章的時候，也一樣很清楚的明白你自己寫的東西。其實這也是一種成就感！！
對於每一個知識點，要有必要的解釋 語言及真實的代碼。
今天呢，我就詳細的寫著 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.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所要映射帶數據庫表 [email protected]()用來指定映射表的表名 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屬性的聯級操作：
到這裡就差不多了，通過上面的案例，我們明顯可以看到，注解比配置文件要簡單的多，代碼量少，方便維護。
