Hibernate核心技术精讲-优快云博客

1.Hibernate的持久化类和对象标识符
1.1.Hibernate的持久化类
1.1.1.什么是持久化类
Hibernate是持久层的ORM框架，专注于数据的持久化工作。所谓的持久化，就是将内存中的数据永久存储到关系型数据库中。那么知道了什么是持久化，什么又是持久化类呢？其实所谓的持久化类指的是一个Java类与数据库表建立了映射关系，那么这个类称为是持久化类。其实你可以简单的理解为持久化类就是一个Java类有了一个映射文件与数据库的表建立了关系。
1.1.2.持久化类的编写规范
我们在编写持久化类的时候需要有以下几点需要注意：
持久化类需要提供无参数的构造方法。因为在Hibernate的底层需要使用反射生成类的实例。
持久化类的属性需要私有，对私有的属性提供公有的get和set方法。因为在Hibernate底层会将查询到的数据进行封装。
持久化类的属性要尽量使用包装类的类型。因为包装类和基本数据类型的默认值不同，包装类的类型语义描述更清晰而基本数据类型不容易描述。举个例子：
假设表中有一列员工工资，如果使用double类型，如果这个员工工资忘记录入到系统中，系统会将默认值0存入到数据库，如果这个员工工资被扣完了，也会向系统中存入0.那么这个0就有了多重含义，而如果使用包装类类型就会避免以上情况，如果使用Double类型，忘记录入工资就会存入null，而这个员工工资被扣完了，就会存入0，不会产生歧义。
持久化类要有一个唯一标识OID与表的主键对应。因为Hibernate中需要通过这个唯一标识OID区分在内存中是否是同一个持久化类。在Java中通过地址区分是否是同一个对象的，在关系型数据库的表中是通过主键区分是否同一条记录。那么Hibernate就是通过这个OID来进行区分的。Hibernate是不允许在内存中出现两个OID相同的持久化对象的。
持久化类尽量不要使用final进行修饰。因为Hibernate中有延迟加载的机制，这个机制中会产生代理对象，Hibernate产生代理对象使用的是字节码的增强技术完成的，其实就是产生了当前类的一个子类对象实现的。如果使用了final修饰持久化类。那么就不能产生子类，从而就不会产生代理对象，那么Hibernate的延迟加载策略（是一种优化手段）就会失效。
一般都实现Serializable接口。

一个标准的持久化类示例：
public class Customer implements Serializable{

private static final long serialVersionUID = 1L;
private Long cust_id;
private String cust_name;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_address;
private String cust_phone;

public Long getCust_id() {
	return cust_id;
}
public void setCust_id(Long cust_id) {
	this.cust_id = cust_id;
}
public String getCust_name() {
	return cust_name;
}
public void setCust_name(String cust_name) {
	this.cust_name = cust_name;
}
public String getCust_source() {
	return cust_source;
}
public void setCust_source(String cust_source) {
	this.cust_source = cust_source;
}
public String getCust_industry() {
	return cust_industry;
}
public void setCust_industry(String cust_industry) {
	this.cust_industry = cust_industry;
}
public String getCust_level() {
	return cust_level;
}
public void setCust_level(String cust_level) {
	this.cust_level = cust_level;
}
public String getCust_address() {
	return cust_address;
}
public void setCust_address(String cust_address) {
	this.cust_address = cust_address;
}
public String getCust_phone() {
	return cust_phone;
}
public void setCust_phone(String cust_phone) {
	this.cust_phone = cust_phone;
}
@Override
public String toString() {
	return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_source=" + cust_source
			+ ", cust_industry=" + cust_industry + ", cust_level=" + cust_level + ", cust_address=" + cust_address
			+ ", cust_phone=" + cust_phone + "]";
}

}
1.2.Hibernate中对象标识符OID
OID全称是Object Identifier，又叫做对象标识符。
它是hibernate用于区分两个对象是否是同一个对象的标识。
我们都知道，虚拟机内存区分两个对象看的是内存的地址是否一致。数据库区分两个对象，靠的是表的主键。hibernate负责把内存中的对象持久化到数据库表中，靠的就是对象标识符来区分两个对象是否是同一个。实体类中映射主键的字段就是OID，如下图所示：

如果在Hibernate内存里出现两个不一致的对象OID一致：
/**
* 测试OID的作用：
* 准备工作：去掉主键生成策略，由我们自己来指定主键值
*/
@Test
public void test1(){
Customer customer1 = new Customer();
customer1.setCust_id(3L);
customer1.setCust_name(“阿里”);
Customer customer2 = new Customer();
customer2.setCust_id(3L);
customer2.setCust_name(“阿里”);

	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();
	
	session.save(customer1);
	session.save(customer2);
	
	tx.commit();
	session.close();
}

出现如下问题：

1.3.Hibernate的主键生成策略
在讲解Hibernate的主键生成策略之前，先来了解两个概念，即自然主键和代理主键，具体如下：
自然主键：把具有业务含义的字段作为主键，称之为自然主键。例如在customer表中，如果把name字段作为主键，其前提条件必须是：每一个客户的姓名不允许为null，不允许客户重名，并且不允许修改客户姓名。尽管这也是可行的，但是不能满足不断变化的业务需求，一旦出现了允许客户重名的业务需求，就必须修改数据模型，重新定义表的主键，这给数据库的维护增加了难度。

代理主键：把不具备业务含义的字段作为主键，称之为代理主键。该字段一般取名为“ID”，通常为整数类型，因为整数类型比字符串类型要节省更多的数据库空间。在上面例子中，显然更合理的方式是使用代理主键。

2.Hibernate的一级缓存和对象状态
2.1.Hibernate的一级缓存
2.1.1.什么是Hibernate的一级缓存
Hibernate的一级缓存就是指Session缓存，Session缓存是一块内存空间，用来存放相互管理的java对象，在使用Hibernate查询对象的时候，首先会使用对象属性的OID值在Hibernate的一级缓存中进行查找，如果找到匹配OID值的对象，就直接将该对象从一级缓存中取出使用，不会再查询数据库；如果没有找到相同OID值的对象，则会去数据库中查找相应数据。当从数据库中查询到所需数据时，该数据信息也会放置到一级缓存中。Hibernate的一级缓存的作用就是减少对数据库的访问次数。

在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java 集合构成了 Session 缓存。只要 Session 实例没有结束生命周期，存放在它缓存中的对象也不会结束生命周期。故一级缓存也被称为是Session级别的缓存。

Hibernate的一级缓存有如下特点：
当应用程序调用Session接口的save()、update()、saveOrUpdate时，如果Session缓存中没有相应的对象，Hibernate就会自动的把从数据库中查询到的相应对象信息加入到一级缓存中去。
当调用Session接口的load()、get()方法，以及Query接口的list()、iterator()方法时，会判断缓存中是否存在该对象，有则返回，不会查询数据库，如果缓存中没有要查询对象，再去数据库中查询对应对象，并添加到一级缓存中。
当调用Session的close()方法时，Session缓存会被清空。
2.1.2.测试Hibernate的一级缓存
/**
* 测试hibernate一级缓存的存在
*/
@Test
public void test3() {
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//根据id查询出对象，并放入一级缓存中
Customer customer1 = session.get(Customer.class, 2L);
System.out.println(customer1);

	//第二次查询id为2的对象，发现一级缓存中有id为2的对象，就直接从一级缓存中取，不查询数据库
	Customer customer2 = session.get(Customer.class, 2L);
	System.out.println(customer2);
	
	System.out.println(customer1 == customer2);
	
	tx.commit();
	session.close();
}

2.2.快照机制
2.2.1.什么是Hibernate的快照机制
Hibernate 向一级缓存放入数据时，同时复制一份数据放入到Hibernate快照中，当使用commit()方法提交事务时，同时会清理Session的一级缓存，这时会使用OID判断一级缓存中的对象和快照中的对象是否一致，如果两个对象中的属性发生变化，则执行update语句，将缓存的内容同步到数据库，并更新快照；如果一致，则不执行update语句。Hibernate快照的作用就是确保一级缓存中的数据和数据库中的数据一致。
2.2.2.测试快照机制
/**
* 测试快照机制
*/
@Test
public void test7() {
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();

	//查询id为2的客户，放到一级缓存中，同时复制一份数据放入到hibernate快照中
	Customer customer  = session.get(Customer.class, 2L);
	//打印出来为“李四”
	System.out.println(customer.getCust_name());
	//修改客户的姓名为“小刚”，没有更新，直接提交事务，发现会发送update语句更新数据库中的数据
	customer.setCust_name("小刚");

	//当事务提交时，会利用OID比较一级缓存和快照中的对象是否一致，如果不一致，则发送update语句更新表
	//快照机制的作用就是保证一级缓存中的数据和数据库中一致
	tx.commit();
	session.close();
}

2.3.Hibernate中对象的三种状态
2.3.1.三种状态的说明
Hibernate为了更好的来管理持久化类，特将持久化类分成了三种状态。在Hibernate中持久化的对象可以划分为三种状态，分别是瞬时态、持久态和脱管态，一个持久化类的实例可能处于三种不同状态中的某一种，三种状态的详细介绍如下。
1、瞬时态（transient）
瞬时态也称为临时态或者自由态，瞬时态的实例是由new命令创建、开辟内存空间的对象，不存在持久化标识OID（相当于主键值），尚未与Hibernate Session关联，在数据库中也没有记录，失去引用后将被JVM回收。瞬时状态的对象在内存中是孤立存在的，与数据库中的数据无任何关联，仅是一个信息携带的载体。
2、持久态（persistent）
持久态的对象存在持久化标识OID ，加入到了Session缓存中，并且相关联的Session没有关闭，在数据库中有对应的记录，每条记录只对应唯一的持久化对象，需要注意的是，持久态对象是在事务还未提交前变成持久态的。
3、脱管态（detached）
脱管态也称离线态或者游离态，当某个持久化状态的实例与Session的关联被关闭时就变成了脱管态。脱管态对象存在持久化标识OID，并且仍然与数据库中的数据存在关联，只是失去了与当前Session的关联，脱管状态对象发生改变时Hibernate不能检测到。

2.3.2.学习对象的三种状态我们需要明确的
1、是为了更好的掌握hibernate中操作的方法。
2、区分状态只有两个标识
一是否有OID
二是否和Session建立的关系
临时状态：
没有OID，和Session没有关系。
持久化状态：
有OID，和Session有关系。
脱管状态：
有OID，和Session没有关系。
3.Hibernate事务的管理
3.1.事务的回顾
什么是事务：
事务：指的是逻辑上的一组操作，组成这组操作的各个单元要么一起成功要么一起失败。
事务的特性
原子性：事务的不可分割
一致性：事务执行的前后，数据完整性保持一致。
隔离性：一个事务的执行，不应该受到其他事务的干扰。
持久性：一旦事务结束，数据就持久到数据库中。
如果不考虑隔离性，引发安全性问题：
读问题：
脏读：一个事务读到另一个事务未提交的数据。
不可重复读：一个事务读到另一个事务已经提交update的数据，导致一个事务中多次查询结果不一致。
虚读：一个事务读到另一个事务已经提交insert的数据，导致一个事务中多次查询结果不一致。
写问题：（了解）
丢失更新
丢失更新
解决读问题：设置事务隔离级别
read uncommitted ：以上读问题都有可能发生
read committed ：避免脏读，但是不可重复读和虚读有可能发生。
repeatable read ：避免脏读和不可重复读，但是虚读有可能发生。
serializable ：以上读问题都能解决。
3.2.Hibernate中设置事务的隔离级别

4
3.3.Hibernate中设置session与当前线程绑定
事务控制不应该是在DAO层实现的，应该在Service层实现，并且在Service中调用多个DAO实现一个业务逻辑的操作。具体操作如下显示：

其实最主要的是如何保证在Service中开启的事务时使用的Session对象和DAO中多个操作使用的是同一个Session对象。
其实有两种办法可以实现：
可以在业务层获取到Session，并将Session作为参数传递给DAO。
可以使用ThreadLocal将业务层获取的Session绑定到当前线程中，然后在DAO中获取Session的时候，都从当前线程中获取。

其实使用第二种方式肯定是最优方案，那么具体的实现已经不用我们来完成了，Hibernate的内部已经将这个事情做完了。我们只需要完成一段配置即可。
Hibernate5中自身提供了三种管理 Session 对象的方法
Session 对象的生命周期与本地线程绑定
Session 对象的生命周期与 JTA 事务绑定
Hibernate 委托程序管理 Session 对象的生命周期

在 Hibernate 的配置文件中, hibernate.current_session_context_class 属性用于指定 Session 管理方式, 可选值包括
thread：Session 对象的生命周期与本地线程绑定
jta：Session 对象的生命周期与 JTA 事务绑定
managed：Hibernate 委托程序来管理 Session 对象的生命周期

配置步骤：
1、在hibernate.cfg.xml文件中配置

thread
2、获取Session时使用的方法：
/**
* 获取当前线程里的Session的公共方法
* 和openSession的区别：
* getCurrentSession：如果当前线程有session,就直接拿过来用，如果没有，就新创建一个
* openSession:不管当前线程有没有session，都取创建新的
* @return
*/
public static Session getCurrentSession(){
return sf.getCurrentSession();
}

测试getCurrentSession和openSession的区别
/**
* 测试getCurrentSession,是否是从当前线程中获取session
*/
@Test
public void test1(){
Session session = HibernateUtils.getCurrentSession();
Session session1 = HibernateUtils.getCurrentSession();
//true
System.out.println(session==session1);
}

/**
 * 测试openSession,是否是从当前线程中获取session
 */
@Test
public void test2(){
	Session session = HibernateUtils.openSession();
	Session session1 = HibernateUtils.openSession();
	//false
	System.out.println(session==session1);

}
3、保存代码：
/**
* 每次获取session时，都从当前线程中获取
* 细节：当把session与当前线程绑定后，当事务提交后，session自动关闭了，不需要我们再手动关闭了
/
@Test
public void test10() {
Session session = HibernateUtils.getSession();
Transaction tx = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name(“库里”);
session.save(customer);
tx.commit();
session.close();
}
细节：
当我们把Session绑定到当前线程之后，关闭session就是hibernate来做的，我们就不用关了。
4.Hibernate的查询API
4.1.Query:HQL查询
4.1.1.概述
Query代表面向对象的一个Hibernate查询操作。在Hibernate中，通常使用session.createQuery()方法接受一个HQL语句，然后调用Query的list()或uniqueResult()方法执行查询。所谓的HQL是Hibernate Query Language缩写，其语法很像SQL语法，但它是完全面向对象的。
在Hibernate中使用Query对象的步骤，具体所示：
（1）获得Hibernate的Session对象。
（2）编写HQL语句。
（3）调用session.createQuery 创建查询对象。
（4）如果HQL语句包含参数，则调用Query的setXxx设置参数。
（5）调用Query对象的方法执行查询。
HQL的说明：
把表的名称换成实体类名称。把表字段名称换成实体类属性名称。
例如：
SQL：select * from cst_customer where cust_name like ?
HQL：select * from Customer where custName = ?
其中不能写select * ，写为：from Customer where custName = ?
4.1.2.常用查询
4.1.2.1.查询所有
/*
* 查询表里的所有数据
* sql语句的写法：select * from 表名
* from 类名
/
@Test
public void test1(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Query对象
Query query = session.createQuery(“from Customer”);
//执行Query
List list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
tx.commit();
}
4.1.2.2. 条件查询
/*
* 条件查询
*/
@Test
public void test2(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Query对象
Query query = session.createQuery(“from Customer where cust_name like ?”);
//设置参数
query.setString(0, “%百%”);
//执行Query
List list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
tx.commit();
}

4.1.2.3. 分页查询
/**
* 分页查询
*/
@Test
public void test3(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Query对象
Query query = session.createQuery(“from Customer”);
//设置分页的信息
//设置开始查询的位置
query.setFirstResult(1);
//设置查询的最大记录数
query.setMaxResults(3);
//执行Query
List list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
tx.commit();
}

4.1.2.4. 排序查询
/**
* 排序查询
* 使用order by关键字
* asc 默认升序
* desc 降序
/
@Test
public void test4(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//创建Query对象
Query query = session.createQuery(“from Customer order by cust_id desc”);
//执行Query
List list = query.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
4.1.2.5.统计查询
/*
* 统计查询：使用聚合函数查询
* 使用聚合函数，不使用group by子句，只能查询到一行一列的数据
*
/
@Test
public void test5(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//创建Query对象
Query query = session.createQuery("select count() from Customer");
//执行Query
//当确定结果集只有一行数据时，才能使用uniqueResult
//count函数查询到值是long型
long total = (long) query.uniqueResult();
System.out.println(total);
}
4.1.2.6.投影查询
/**
* 投影查询
* 投影：使用一个实体的部分字段信息，来构建实体类对象，叫做对象的投影（在hibernate中的叫法）
* 使用HQL的方式查询实体类的部分字段信息，并且封装到实体类中。(QBC也能实现投影查询，但是不如hql的好用，所以使用投影查询，一般都用HQL)
* HQL语句的写法：
* select new Customer() from Customer
* * 实体类要求：
* 必须提供一个相同参数列表的构造函数
*
*/
@Test
public void test6(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//创建Query对象
Query query = session.createQuery(“select new Customer(cust_id,cust_name) from Customer”);
//执行Query
List list = query.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
tx.commit();
}
4.1.3.Query中方法说明
list方法：该方法用于查询语句，返回的结果是一个list集合。
setter方法：Query接口中提供了一系列的setter方法用于设置查询语句中的参数，针对不同的数据类型，需要用到不同的setter方法。
uniqueResult()方法：该方法用于返回唯一的结果，在确保只有一条记录的查询时可以使用该方法。
setFirstResult()方法：该方法可以设置获取第一个记录的位置，也就是它表示从第几条记录开始查询，默认从0开始计算。
setMaxResult()方法：该方法用于设置结果集的最大记录数，通常与setFirstResult()方法结合使用，用于限制结果集的范围，以实现分页功能。

4.2.Criteria:QBC查询
4.2.1.概述
Criteria是一个完全面向对象，可扩展的条件查询API，通过它完全不需要考虑数据库底层如何实现，以及SQL语句如何编写，它是Hibernate框架的核心查询对象。Criteria 查询，又称为QBC查询（Query By Criteria），它是Hibernate的另一种对象检索方式。
org.hibernate.criterion.Criterion是Hibernate提供的一个面向对象查询条件接口，一个单独的查询就是Criterion接口的一个实例，用于限制Criteria对象的查询，在Hibernate中Criterion对象的创建通常是通过Restrictions 工厂类完成的，它提供了条件查询方法。
通常，使用Criteria对象查询数据的主要步骤，具体如下：
（1）获得Hibernate的Session对象。
（2）通过Session获得Criteria对象。
（3）使用Restrictions的静态方法创建Criterion条件对象。Restrictions类中提供了一系列用于设定查询条件的静态方法，这些静态方法都返回Criterion实例，每个Criterion实例代表一个查询条件。
（4）向Criteria对象中添加Criterion 查询条件。Criteria的add()方法用于加入查询条件。
（5）执行Criterita的 list() 或uniqueResult() 获得结果。
细节：
HQL能查的，QBC都能查，反之亦然。
4.2.2.常用查询
4.2.2.1.基本查询
/**
* 查询所有
*/
@Test
public void test1(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//执行查询
List list = criteria.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
tx.commit();
}

4.2.2.2.条件查询
/**
* 条件查询
*/
@Test
public void test2(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//设置查询条件
criteria.add(Restrictions.like(“cust_name”, “%李%”));
criteria.add(Restrictions.eq(“cust_level”, “普通客户”));
//执行查询
List list = criteria.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
tx.commit();

4.2.2.3.分页查询
/**
* 分页查询
/
@Test
public void test3(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//设置分页信息
//设置开始查询记录的索引
criteria.setFirstResult(0);
//设置查询的最大记录数
criteria.setMaxResults(3);
//执行查询
List list = criteria.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
tx.commit();
}
4.2.2.4.排序查询
/*
* 排序查询
/
@Test
public void test4(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//按照cust_id降序排序
criteria.addOrder(Order.desc(“cust_id”));
//执行查询
List list = criteria.list();
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
tx.commit();
}
4.2.2.5.统计查询
/*
* 统计查询
/
@Test
public void test5(){
Session session = HibernateUtils.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria对象
Criteria criteria = session.createCriteria(Customer.class);
//等价于select count()
criteria.setProjection(Projections.rowCount());
//执行查询
long total = (long)criteria.uniqueResult();
System.out.println(total);
tx.commit();
}
4.2.2.6.离线查询
/**
* 离线查询
* 离线：它是和在线对应的。
* Criteria对象是一个在线对象，它是由一个可用的（活动的）Session对象获取的出来的。当session失效时，就无法再获取该对象了。
*
* 有一个对象，它也可以用于设置条件，但是获取的时候并不需要Session对象。
* 该对象就叫做离线对象： DetachedCriteria对象使用该对象进行的查询就叫做：离线查询
*
* 如何获取该对象 DetachedCriteria dCriteria =DetachedCriteria.forClass(要查询的实体类字节码);
*/
@Test
public void test6() {
List list = servletFindAllCustomer();
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}

/**
 * 模拟查询所有客户的servlet
 * 
 * @return
 */
public List<Customer> servletFindAllCustomer() {
	DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
	detachedCriteria.add(Restrictions.like("cust_name", "%李%"));
	detachedCriteria.add(Restrictions.eq("cust_level", "普通客户"));
	List<Customer> list = serviceFindAllCustomer(detachedCriteria);
	return list;
}

/**
 * 模拟service
 * 
 * @param detachedCriteria
 * @return
 */
private List<Customer> serviceFindAllCustomer(DetachedCriteria detachedCriteria) {
	`
}

/**
 * 模拟dao
 * 
 * @param detachedCriteria
 * @return
 */
private List<Customer> daoFindAllCustomer(DetachedCriteria detachedCriteria) {
	Session session = HibernateUtils.getCurrentSession();
	Transaction tx = session.beginTransaction();
	Criteria criteria = detachedCriteria.getExecutableCriteria(session);
	List<Customer> list = criteria.list();
	tx.commit();
	return list;
}

5.附录：QBC常用查询条件说明
短语含义
Restrictions.eq 等于=
Restrictions.allEq 使用Map,使用key/value进行多个等于的判断
Restrictions.gt 大于>
Restrictions.ge 大于等于>=
Restrictions.lt 小于<
Restrictions.le 小于等于<=
Restrictions.between 对应sql的between子句
Restrictions.like 对应sql的like子句
Restrictions.in 对应sql的in子句
Restrictions.and and 关系
Restrictions.or or关系
Restrictions.sqlRestriction Sql限定查询
Restrictions.asc() 根据传入的字段进行升序排序
Restrictions.desc() 根据传入的字段进行降序排序

运算类型 HQL运算符 QBC运算方法
比较运算 = Restrictions.eq()
<> Restrictions.not(Restrictions.eq())
>= Restrictions.ge()
< Restrictions.lt()
<= Restrictions.le()
is null Restrictions.isNull()
is not null Restrictions.isNotNull()
范围运算符 in Restrictions.in()
not in Restrictions.not(Restrictions.in())
between Restrictions.between()
not between Restrictions.not(Restrictions.between())

运算类型 HQL运算符 QBC运算方法
字符串模式匹配 like Restrictions.like()
逻辑 and Restrictions.and()|
Restrictions.conjunction()
or Restrictions.or()|
Restrictions.disjunction()
not Restrictions.not()

Hibernat（2）