十一、Hibernate的检索策略
1、概述：
查询的时机：什么时候去查？
/**
* 一张表的检索策略我们称之为：
* 类级别的检索策略。
* 注意：只要是说类级别的检索策略，就一定不涉及关联对象。
*
* 类级别检索策略解决的问题：
* 1、查询的时机：
* 分为两种情况
* 立即加载：不管用不用，都马上查询出来
* 延迟加载：什么时候用，什么时候去查询。（懒加载，惰性加载） *
*常用方法：
* get：
* 永远都是立即加载。返回的当前实体类的对象。
* load
* 默认情况下是延迟加载。返回的当前实体类的代理对象。
* 它可以改为立即加载。
* 在对应的映射文件中，class元素使用lazy属性，把值改为false
* lazy取值:true 延迟加载（默认值）。false是立即加载。
* 例如：
* <class name="Customer" table="T_CUSTOMERS" lazy="false">
* query的list方法:
* 永远都是立即加载。
*
* @author zhy
*
*/
public class HibernateDemo1 { /*
* 不管用不用，都立即查询出一个客户的所有字段数据
*/
@Test
public void test1(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询id为1的客户
Customer c1 = s.get(Customer.class, 1);
System.out.println(c1);
tx.commit();
s.close(); }
/*
* 什么时候用什么时候真正去查询
*/
@Test
public void test2(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询id为1的客户
Customer c1 = s.load(Customer.class, 1);
System.out.println(c1);
tx.commit();
s.close(); }
}
2、类级别的检索策略
只影响Session的load()方法
Session.get()方法：永远都是立即加载。
/*
* 不管用不用，都立即查询出一个客户的所有字段数据
*/
@Test
public void test1(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询id为1的客户
Customer c1 = s.get(Customer.class, 1);
System.out.println(c1);
tx.commit();
s.close(); }
Query.list()方法：立即检索。
Session.load()方法：默认是延迟加载。（load可以改为立即加载，lazy="false"）
@Test
public void test2(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询所有客户
Query query = s.createQuery("from Customer");
List<Customer> cs = query.list();
//获取每个客户的所有订单
for(Customer c : cs){
System.out.println(c);
System.out.println(c.getOrders());
}
tx.commit();
s.close();
}
/*
* 什么时候用什么时候真正去查询
*/
@Test
public void test2(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询id为1的客户
Customer c1 = s.load(Customer.class, 1);
System.out.println(c1);
tx.commit();
s.close(); }
3、关联级别的检索策略
概念：比如查询客户（类级别），所关联的订单的查询（关联级别）。
3.1、检索关联多的一方
应用场景：
一对多：根据客户查询订单
多对多：根据老师查询学生
配置：
<hibernate-mapping package="cn.itcast.domain">
<class name="Customer" table="T_CUSTOMERS">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="name" column="NAME"></property>
<property name="age" column="AGE"></property>
<!-- 一对多关系映射：
set元素：
作用：映射集合元素
属性：
name：映射实体类中的集合属性
table：指定对应的表
key元素：它是set的子元素
作用：就是用于指定外键的
属性：
column：指定外键字段的名称
one-to-many元素：它是set的子元素
作用：描述当前实体映射文件和set中指定属性之间的关系。
属性：
class:指定是从表的实体类名称
-->
<set name="orders" table="T_ORDERS" lazy="true" fetch="join">
<key column="CUSTOMER_ID"></key>
<one-to-many class="Order"/>
</set>
</class>
</hibernate-mapping>
lazy:查询的时机（何时真正去查）。取值如下:
true：延迟加载
false：立即加载
fetch：查询的语句的形式。取值如下：
select:多条查询语句。
subselect：子查询。推荐
join：左外连接查询
说明：（必须搞明白）
序号 | lazy的取值 | fetch的取值 | 说明（都是以客户订单的一对多关系为例） |
1 | true（默认值） | select（默认值） | 时机：用时才真正去查询订单。 语句形式：有1条查询客户的和多条查询订单的select语句。 Batch-size:设置批量检索的深度。（建议3~10之间） |
2 | false | select（默认值） | 时机：不管用不用订单，查询客户时都立即查询订单。 语句形式：有1条查询客户的和多条查询订单的select语句。 Batch-size:设置批量检索的深度。（建议3~10之间） |
3 | extra | select（默认值） | 时机：用什么信息，查什么信息。只查询必要的。 语句形式：有1条查询客户的和多条查询订单的select语句。 batch-size:设置批量检索的深度。（建议3~10之间） |
4 | true | subselect | 时机：用时才真正去查询订单。 语句形式：子查询 batch-size：无效 |
5 | false | subselect | 时机：不管用不用订单，查询客户时都立即查询订单。 语句形式：子查询 batch-size：无效 |
6 | extra | subselect | 时机：用什么信息，查什么信息。只查询必要的。 语句形式：子查询 batch-size：无效 |
7 | true|false|extra | join（当join有效时，根本不看lazy属性） | 时机：无效。因为连接查询，一次就是两张表及以上。 语句：left outer join batch-size：无效 注意：Query查询会忽略join的存在。当join无效时，lazy就有效了。 |
/**
* 关联级别的检索策略
* 注意：
* 它永远说的是查询当前实体类时，要不要查询那个关联的对象。
* 涉及的是：一对多，多对一，多对多和一对一。
* 举例：
* 一对多和多对一
* 查询客户的时候要不要查询订单：一对多的情况
* 查询订单的时候要不要查询客户：多对一的情况
* 多对多
* 查询教师的时候要不要查询学生：多对多的情况
* 一对一
* 查询人员的时候要不要查询身份证号：一对一的情况
*
* 解决的问题：
* 1、查询的时机
* 立即加载：不管用不用，都马上查询出来
* 延迟加载：什么时候用，什么时候真正去查询
* 2、查询的方式（怎么查）
* 多条SQL语句
* 子查询
* 表连接
* 关于关联级别的检索策略,有如下配置
* 明确：是有少的一方，根据少的一方，去检索多的一方
* 举例说明：
* 我们有客户，根据客户获取订单。/ 我们有一个教师，根据这个教师获取学生
* 配置涉及的属性：
* lazy：加载的时机
* true：延迟加载（默认值）
* false：立即加载
* extra：极懒加载 （用什么查什么，不用的都不查）
* fetch：检索的方式
* select：多条SQL语句(默认值)
* subselect：子查询
* join：左外连接
*
* 我们现在是在映射文件的set元素上配置！
*
* @author zhy
*
* 第四种情况：lazy="true" fetch="subselect"
* <set name="orders" table="T_ORDERS" lazy="true" fetch="subselect">
*
*/
public class HibernateDemo5 { /*
* 需求：
* 查询所有客户，获取每个客户的所有订单
* 查询的时机：
* 延迟加载
* 查询的方式：
* 子查询
* select * from T_ORDERS where CUSTOMER_ID in (select id from T_CUSTOMERS )
* 注意：
* 当使用了子查询之后，batch-size属性就失效了。
*
*/
@Test
public void test2(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询所有客户
Query query = s.createQuery("from Customer");
List<Customer> cs = query.list();
//获取每个客户的所有订单
for(Customer c : cs){
System.out.println(c);
System.out.println(c.getOrders());
}
tx.commit();
s.close();
} /*当我们的fetch属性是subselect时，查询一个客户，并且获取该客户的订单，和取默认值没有区别。
* 因为：
* select * from t_orders where customer_id = 1;
select * from t_orders where customer_id in (1);
是一回事。
*
*
* 需求：
* 查询一个客户，获取该客户的所有订单
* 查询的时机：
* 查询的方式：
*/
@Test
public void test1(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询一个客户
Customer c1 = s.get(Customer.class, 1);//客户说的是类级别的检索策略
System.out.println(c1);
//获取当前客户的所有订单
System.out.println(c1.getOrders());
tx.commit();
s.close();
}
}
/**
* 关联级别的检索策略
* 注意：
* 它永远说的是查询当前实体类时，要不要查询那个关联的对象。
* 涉及的是：一对多，多对一，多对多和一对一。
* 举例：
* 一对多和多对一
* 查询客户的时候要不要查询订单：一对多的情况
* 查询订单的时候要不要查询客户：多对一的情况
* 多对多
* 查询教师的时候要不要查询学生：多对多的情况
* 一对一
* 查询人员的时候要不要查询身份证号：一对一的情况
*
* 明确： 有多的一方要不要查询少的一方
* 举例说明：
* 有订单，要不要查询客户/有人员，要不要查询身份证号。
* 解决的问题：
* 1、查询的时机
* 立即加载：不管用不用，都马上查询出来
* 延迟加载：什么时候用，什么时候真正去查询
* 2、查询的方式（怎么查）
* 多条SQL语句
* 表连接
* 关于关联级别的检索策略,有如下配置
* 配置涉及的属性：
* lazy：加载的时机
* false：立即加载。不管对方类级别的检索策略
* proxy：不确定。原因是要看对方类级别的检索策略。
* 如果对方类级别检索策略是延迟加载，则proxy就是延迟加载。
* 如果对方类级别检索策略是立即记载，则proxy就是立即加载。
* fetch：检索的方式
* select：多条SQL语句
* join：左外连接
*
* 我们以多对一为例：配置都是在many-to-one上!
* @author zhy
*
* 第二种情况：lazy=proxy fetch=join
* <many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="proxy" fetch="join"/>
*
*/
public class HibernateDemo11 { /* 当fetch取值是join时，一下就查询2张表。就不管lazy属性如何配置。
*
* 需求：
* 查询一个订单，根据订单获取该订单的客户
* 查询的时机：
* lazy属性失效
* 查询的方式：
* 左外连接
*
*/
@Test
public void test1(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//查询订单
Order o1 = s.get(Order.class, 1);
System.out.println(o1);
//根据订单，获取客户信息
System.out.println(o1.getCustomer());
tx.commit();
s.close();
}
}
3.2、检索关联少的一方
应用场景：（开发经验，少的一方，查出来就得了）
多对一：根据订单查询客户
一对一：根据人查询身份证
配置：
<hibernate-mapping package="cn.itcast.domain">
<class name="Order" table="T_ORDERS">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="ordernum" column="ORDERNUM"></property>
<property name="money" column="MONEY"></property> <!-- 多对一关系映射
使用的元素：many-to-one
属性：
name：指定的是在实体类中要映射的属性
class：指定该属性所对应的类
column：指定外键字段。
-->
<many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="proxy" fetch="join"/>
</class>
</hibernate-mapping>
十二、检索方式
1、检索方式概述
a) 对象导航方式：通过对象间的引用关系。例如：customer.getOrder();
b) OID的检索方式：通过OID获取对象get和load。
c) HQL检索方式：使用面向对象的HQL查询语言。
HQL：Hibernate Query Language 类似SQL。表明换类名
d) QBC检索方式：Query By Criteria，更加面向对象。了解。
e) 本地SQL检索方式：原生态的JDBC+SQL语句。了解。
2、单表各种查询（HQL条件，QBC条件，QBC特例，原始SQL，多态，排序，具名，命名，分页）
/**
* hibernate中提供的查询方式
* @author zhy
*
*/
public class HibernateDemo1 { /*
* 对象导航查询
*
* 明确：
* 思想的转变。我们在需要某些数据时，是否还要单独去写一个方法来实现。
*
* 对象导航的思想
*/
@Test
public void test17(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Order o1 = s.get(Order.class, 1);
Customer c = o1.getCustomer();//对象导航的方式
System.out.println(c);
tx.commit();
s.close();
}
@Test
public void test15(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Customer c1 = s.get(Customer.class, 1);
Set<Order> orders = c1.getOrders();//对象导航的方式
System.out.println(orders);
tx.commit();
s.close();
}
/*原来JDBC时，留下的思想
@Test
public void test16(){
List<Order> orders = findOrderByCustomerid(1);
System.out.println(orders);
} public List<Order> findOrderByCustomerid(int customerid){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//select * from t_orders where customer_id = ?;
Query query = s.createQuery("from Order o where o.customer.id = ?");
query.setInteger(0, customerid);
List<Order> orders = query.list();
tx.commit();
s.close();
return orders;
}
*/ /*
* 原生SQL查询
* 使用的是session的createSQLQuery方法
* 它的执行list结果是一个由Object数组组成的集合。
*
* 在实际开发中，我们一般不会使用Object数组来操作。
* 而是在执行list()方法之前，调用addEntity方法，给sqlquery添加一个实体，
* 从而得到的就是实体对象的集合 select
sum(
case when score between 0 and 59 then 1 else 0 end
) as E,
sum(
case when score between 60 and 69 then 1 else 0 end
) as D,
sum(
case when score between 70 and 79 then 1 else 0 end
) as C,
sum(
case when score between 80 and 89 then 1 else 0 end
) as B,
sum(
case when score between 90 and 99 then 1 else 0 end
) as A
from t_students */
@Test
public void test14(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
SQLQuery sqlquery = s.createSQLQuery("select * from t_customers");//参数就是SQL语句
//给SQLQuery添加一个实体
sqlquery.addEntity(Customer.class);
List list = sqlquery.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
} }
/*
* 分页查询
* mysql中的分页查询：
* 使用的关键字：limit
* 关键字中的必要条件：firstResult（开始记录索引），maxResults（最大的结果集数）
* sql语句：select * from t_orders limit firstResult,maxResults;
*
* HQL语句：from Order
*
* 在hibernate中分页只有
* setFirstResult
* setMaxResults
* 不管使用什么数据库都是这两个方法
*/
@Test
public void test9(){
List<Order> orders = findAllOrder(4,2);
for(Order o : orders){
System.out.println(o);
}
}
//QBC
public List<Order> findAllOrder2(int firstResult,int maxResults){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Criteria criteria = s.createCriteria(Order.class);
criteria.setFirstResult(firstResult);//开始记录的索引
criteria.setMaxResults(maxResults);//每页要查询的条数
List<Order> list = criteria.list();
tx.commit();
s.close();
return list;
}
//HQL
public List<Order> findAllOrder(int firstResult,int maxResults){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Order");//select * from t_orders
//hibernate提供的方法：
query.setFirstResult(firstResult);//开始记录的索引
query.setMaxResults(maxResults);//每页要查询的条数
List<Order> orders = query.list();
tx.commit();
s.close();
return orders;
}
/*
* 命名查询
* 把sql或者HQL在映射文件中配置起来。提供一个名称。
* 名称和语句之间是键值对的对应关系。
* 在程序使用根据名称获取语句的方法，叫做命名查询
*/
@Test
public void test8(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.getNamedQuery("findCustomerByCondition");
//给条件赋值
query.setString("name", "testD");
query.setInteger("age", 28);
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
/*
* 具名查询
* 具名其实就是给查询的参数占位符提供一个名称，使我们在查询时，使用名称而不是索引来给参数赋值
* 书写规范：
* 必须用 :名称
*/
@Test
public void test7(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Customer where age > :age and name=:name");
//给条件赋值
query.setString("name", "testD");
query.setInteger("age", 28);
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
//多态查询：了解一下
@Test
public void test6(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from java.io.Serializable ");
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
/*
* 排序查询
* 关键字和SQL是一样的。
* order by
* asc
* desc
*/
@Test
public void test5(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Customer order by age desc ");
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
/*
* QBC特例查询
* 特例：
* 用实体对象创建一个例子，查询语句的条件就会根据实体对象中提供的例子进行条件的拼装。
* 注意：
* 1、条件只会用等于
* 2、在拼装条件时，它只涉及不为null的字段，同时不会把OID作为条件。
*/
@Test
public void test4(){
//我的例子
Customer c = new Customer();
c.setAge(28);
c.setName("testA");
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//创建查询对象。参数是要查询的实体
Criteria criteria = s.createCriteria(Customer.class);
//添加条件
criteria.add(Example.create(c));//select * from t_customes where age = 28 List list = criteria.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
//QBC带条件查询
@Test
public void test3(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//创建查询对象。参数是要查询的实体
Criteria criteria = s.createCriteria(Customer.class);
//添加条件
criteria.add(Restrictions.gt("age", 28)); List list = criteria.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
/*
* QBC查询
* QBC:query by criteria
* QBC能实现的HQL都能实现。反之亦然。
* 它更加面向对象
*/
@Test
public void test2(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
//创建查询对象。参数是要查询的实体
Criteria criteria = s.createCriteria(Customer.class);
List list = criteria.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
/*
* HQL带条件查询
* hiberante中HQL使用条件，也是where关键字。
* 条件的参数占位符也是用的问号
* 注意事项：
* hibernate中查询语句的参数占位符索引是从0开始的。
*/
@Test
public void test1(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Customer where age > ?");
//给条件赋值
query.setInteger(0, 28);
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
}
3、多表查询
3.1、交叉连接（cross join）
显示交叉连接：
select t1.*, t2.* from tabel1 t1 cross join table t2
隐式交叉连接：
select t1.*, t2.* from tabel1 t1, table t2
返回结果：两张表的笛卡尔积
3.2、内连接（inner join）
显示内连接：SQL写法
select * from tabel1 t1 inner join table t2 on t1.primary_key = t2.foregin_key
隐式内连接：SQL写法
select * from tabel1 t1, table t2where t1.primary_key = t2.foregin_key
返回结果：是在笛卡尔积的基础上，返回符合条件的结果。
HQL写法：select * from Customer t1 inner join c.orders;
HQL写法：select * from Customer t1 inner join fetch c.orders;
返回结果：
inner join：Object[]
inner join fetch：实体对象
3.3、外连接（outer join 左外和右外其实是一样的）
左外连接： left outer join
select * from customers c left outer join orders o on c.id=o.customer_id;
返回结果：除了满足条件的记录外，左外连接还会返回左表剩余记录。
右外连接： right outer join
select * from customers c right outer join orders o on c.id=o.customer_id;
返回结果：除了满足条件的记录外，右外连接还会返回右表剩余记录。
HQL写法：select * from Customer t1 inner join c.orders;
HQL写法：select * from Customer t1 inner join fetch c.orders;
返回结果：
inner join：Object[]
inner join fetch：实体对象
全外连接：（MySQL不支持） full outer join。返回结果了解一下：除了满足条件的之外，还会返回左表和右表不满足条件的记录。
/*
* 迫切左外连接查询
*
* 返回的是一个集合，集合中的每个元素都是左表实体对象。
* 有可能重复。重复的原因是看迫切左外连接查询的条件。
*/
@Test
public void test11(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Customer c left outer join fetch c.orders ");
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
} /*
* 左外连接查询
*
* 返回值是一个集合，集合的每个元素是Object数组。
* 数组中包含2个Object对象。
* 其中一个左表对象和一个右表对象。
* 左表对象有可能重复，右表对象不会重复
*/
@Test
public void test10(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("from Customer c left outer join c.orders ");
List<Object[]> list = query.list();
tx.commit();
s.close();
for(Object[] os : list){
System.out.println("----------------------");
for(Object o : os){
System.out.println(o);
}
}
}
3.4、投影查询
/*
* 投影查询
* 就想实现
* 查询客户时，只有客户的id和name
* 查询订单时，只有订单id和money
* 投影查询就是：
* 在实际开发中，我们只需要一个实体类中的某个或者某些字段，当查询完成后还想使用该实体对象来操作。
* 需要把查询的某个或某些字段投射到实体类上，这种查询方式叫投影查询。
* 在使用投影查询时的要求：
* 实体类必须提供对应参数列表的构造函数。
* 在写HQL语句时，需要使用new关键字
*
* 注意事项：
* 在使用投影查询时，如果直接写类名，需要确定该类在工程中唯一。
* 如果不唯一的话，需要些类全名。包名.类名
*/
@Test
public void test13(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("select new cn.itcast.domain.Order(o.id,o.money) from Order o");
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
@Test
public void test12(){
Session s = HibernateUtil.getSession();
Transaction tx = s.beginTransaction();
Query query = s.createQuery("select new Customer(c.id,c.name) from Customer c");
List list = query.list();
tx.commit();
s.close();
for(Object o : list){
System.out.println(o);
}
}
三、附录：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() | |