Java实战之02Hibernate-05检索策略、检索方式

阅读量：5040 次

发布时间：2019-06-12

本文共 20978 字，大约阅读时间需要 69 分钟。

十一、Hibernate的检索策略

1、概述：

查询的时机：什么时候去查？

1 /** 2  * 一张表的检索策略我们称之为： 3  *     类级别的检索策略。 4  *  注意：只要是说类级别的检索策略，就一定不涉及关联对象。 5  *  6  * 类级别检索策略解决的问题： 7  * 1、查询的时机： 8  *         分为两种情况 9  *             立即加载：不管用不用，都马上查询出来10  *             延迟加载：什么时候用，什么时候去查询。（懒加载，惰性加载）11 12  *  13  *常用方法：14  *    get：15  *        永远都是立即加载。返回的当前实体类的对象。16  *    load  17  *      默认情况下是延迟加载。返回的当前实体类的代理对象。18  *      它可以改为立即加载。19  *      在对应的映射文件中，class元素使用lazy属性，把值改为false20  *      lazy取值:true 延迟加载（默认值）。false是立即加载。21  *      例如：22  *      
     
      23  * query的list方法:24  *         永远都是立即加载。25  * 26  * @author zhy27  *28  */29 public class HibernateDemo1 {30     31     /*32      * 不管用不用，都立即查询出一个客户的所有字段数据33      */34     @Test35     public void test1(){36         Session s = HibernateUtil.getSession();37         Transaction tx = s.beginTransaction();38         //查询id为1的客户39         Customer c1 = s.get(Customer.class, 1);40         System.out.println(c1);41         tx.commit();42         s.close();43         44     }    45     /*46      * 什么时候用什么时候真正去查询47      */48     @Test49     public void test2(){50         Session s = HibernateUtil.getSession();51         Transaction tx = s.beginTransaction();52         //查询id为1的客户53         Customer c1 = s.load(Customer.class, 1);54         System.out.println(c1);55         tx.commit();56         s.close();57 58     }59 }

2、类级别的检索策略

只影响Session的load()方法

Session.get()方法：永远都是立即加载。

1 /* 2      * 不管用不用，都立即查询出一个客户的所有字段数据 3      */ 4     @Test 5     public void test1(){ 6         Session s = HibernateUtil.getSession(); 7         Transaction tx = s.beginTransaction(); 8         //查询id为1的客户 9         Customer c1 = s.get(Customer.class, 1);10         System.out.println(c1);11         tx.commit();12         s.close();13         14     }

Query.list()方法：立即检索。

Session.load()方法：默认是延迟加载。（load可以改为立即加载，lazy="false"）

1 @Test 2     public void test2(){ 3         Session s = HibernateUtil.getSession(); 4         Transaction tx = s.beginTransaction(); 5         //查询所有客户 6         Query query = s.createQuery("from Customer"); 7         List
     
       cs = query.list(); 8         //获取每个客户的所有订单 9         for(Customer c : cs){10             System.out.println(c);11             System.out.println(c.getOrders());12         }    13         tx.commit();14         s.close();15     }

1 /* 2      * 什么时候用什么时候真正去查询 3      */ 4     @Test 5     public void test2(){ 6         Session s = HibernateUtil.getSession(); 7         Transaction tx = s.beginTransaction(); 8         //查询id为1的客户 9         Customer c1 = s.load(Customer.class, 1);10         System.out.println(c1);11         tx.commit();12         s.close();13 14     }

3、关联级别的检索策略

概念：比如查询客户（类级别），所关联的订单的查询（关联级别）。

3.1、检索关联多的一方

应用场景：

一对多：根据客户查询订单

多对多：根据老师查询学生

配置：

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  * 关联级别的检索策略  3  * 注意：  4  *      它永远说的是查询当前实体类时，要不要查询那个关联的对象。  5  *     涉及的是：一对多，多对一，多对多和一对一。   6  *     举例：  7  *       一对多和多对一  8  *         查询客户的时候要不要查询订单：一对多的情况  9  *         查询订单的时候要不要查询客户：多对一的情况 10  *   多对多 11  *       查询教师的时候要不要查询学生：多对多的情况 12  *   一对一 13  *       查询人员的时候要不要查询身份证号：一对一的情况 14  *    15  * 解决的问题： 16  *     1、查询的时机 17  *         立即加载：不管用不用，都马上查询出来 18  *         延迟加载：什么时候用，什么时候真正去查询 19  *  2、查询的方式（怎么查） 20  *      多条SQL语句 21  *      子查询 22  *      表连接 23  * 关于关联级别的检索策略,有如下配置 24  *     明确：是有少的一方，根据少的一方，去检索多的一方  25  *     举例说明： 26  *         我们有客户，根据客户获取订单。/ 我们有一个教师，根据这个教师获取学生 27  * 配置涉及的属性： 28  *     lazy：加载的时机 29  *         true：延迟加载（默认值） 30  *         false：立即加载 31  *         extra：极懒加载 （用什么查什么，不用的都不查） 32  *     fetch：检索的方式 33  *         select：多条SQL语句(默认值) 34  *         subselect：子查询 35  *         join：左外连接 36  *  37  * 我们现在是在映射文件的set元素上配置！ 38  *  39  * @author zhy 40  *  41  * 第四种情况：lazy="true" fetch="subselect" 42  * 
     
       43  * 44  */ 45 public class HibernateDemo5 { 46      47     /* 48      * 需求： 49      *     查询所有客户，获取每个客户的所有订单 50      * 查询的时机： 51      *     延迟加载 52      * 查询的方式： 53      *     子查询 54      *      select * from T_ORDERS  where CUSTOMER_ID in (select id from T_CUSTOMERS ) 55      * 注意： 56      *     当使用了子查询之后，batch-size属性就失效了。 57      *      58      */ 59     @Test 60     public void test2(){ 61         Session s = HibernateUtil.getSession(); 62         Transaction tx = s.beginTransaction(); 63         //查询所有客户 64         Query query = s.createQuery("from Customer"); 65         List
      
        cs = query.list(); 66         //获取每个客户的所有订单 67         for(Customer c : cs){ 68             System.out.println(c); 69             System.out.println(c.getOrders()); 70         }     71         tx.commit(); 72         s.close(); 73     } 74      75      76     /*当我们的fetch属性是subselect时，查询一个客户，并且获取该客户的订单，和取默认值没有区别。 77      * 因为： 78      *     select * from t_orders where customer_id = 1; 79         select * from t_orders where customer_id in (1); 80            是一回事。 81      *  82      *  83      * 需求： 84      *     查询一个客户，获取该客户的所有订单 85      * 查询的时机： 86      * 查询的方式：   87     */ 88     @Test 89     public void test1(){ 90         Session s = HibernateUtil.getSession(); 91         Transaction tx = s.beginTransaction(); 92         //查询一个客户 93         Customer c1 = s.get(Customer.class, 1);//客户说的是类级别的检索策略 94         System.out.println(c1); 95         //获取当前客户的所有订单 96         System.out.println(c1.getOrders()); 97         tx.commit(); 98         s.close(); 99     }100 }

1 /** 2  * 关联级别的检索策略 3  * 注意： 4  *      它永远说的是查询当前实体类时，要不要查询那个关联的对象。 5  *     涉及的是：一对多，多对一，多对多和一对一。  6  *     举例： 7  *       一对多和多对一 8  *         查询客户的时候要不要查询订单：一对多的情况 9  *         查询订单的时候要不要查询客户：多对一的情况10  *   多对多11  *       查询教师的时候要不要查询学生：多对多的情况12  *   一对一13  *       查询人员的时候要不要查询身份证号：一对一的情况14  * 15  * 明确： 有多的一方要不要查询少的一方16  * 举例说明：17  *         有订单，要不要查询客户/有人员，要不要查询身份证号。18  * 解决的问题：19  *     1、查询的时机20  *         立即加载：不管用不用，都马上查询出来21  *         延迟加载：什么时候用，什么时候真正去查询22  *  2、查询的方式（怎么查）23  *      多条SQL语句24  *      表连接25  * 关于关联级别的检索策略,有如下配置26  * 配置涉及的属性：27  *     lazy：加载的时机28  *         false：立即加载。不管对方类级别的检索策略29  *         proxy：不确定。原因是要看对方类级别的检索策略。30  *                   如果对方类级别检索策略是延迟加载，则proxy就是延迟加载。31  *                   如果对方类级别检索策略是立即记载，则proxy就是立即加载。32  *     fetch：检索的方式33  *         select：多条SQL语句34  *         join：左外连接35  * 36  * 我们以多对一为例：配置都是在many-to-one上!37  * @author zhy38  * 39  * 第二种情况：lazy=proxy fetch=join40  * 
     41  * 42  */43 public class HibernateDemo11 {44     45     46     /* 当fetch取值是join时，一下就查询2张表。就不管lazy属性如何配置。47      * 48      * 需求：49      *     查询一个订单，根据订单获取该订单的客户50      * 查询的时机：51      *         lazy属性失效52      * 查询的方式：53      *         左外连接54      *     55      */    56     @Test57     public void test1(){58         Session s = HibernateUtil.getSession();59         Transaction tx = s.beginTransaction();60         //查询订单61         Order o1 = s.get(Order.class, 1);62         System.out.println(o1);63         //根据订单，获取客户信息64         System.out.println(o1.getCustomer());65         tx.commit();66         s.close();67     } 68 }

3.2、检索关联少的一方

应用场景：（开发经验，少的一方，查出来就得了）

多对一：根据订单查询客户

一对一：根据人查询身份证

配置：

1 
     
       2     
      
        3         
       
         4             
         5         
        6         
        7         
        8          9         
           16         
       17     
      18

十二、检索方式

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，多态，排序，具名，命名，分页）

1 /**  2  * hibernate中提供的查询方式  3  * @author zhy  4  *  5  */  6 public class HibernateDemo1 {  7       8     /*  9      * 对象导航查询 10      *      11      * 明确： 12      *     思想的转变。我们在需要某些数据时，是否还要单独去写一个方法来实现。 13      *  14      * 对象导航的思想 15      */ 16     @Test  17     public void test17(){ 18         Session s = HibernateUtil.getSession(); 19         Transaction tx = s.beginTransaction(); 20         Order o1 = s.get(Order.class, 1); 21         Customer c = o1.getCustomer();//对象导航的方式 22         System.out.println(c); 23         tx.commit(); 24         s.close(); 25     } 26     @Test 27     public void test15(){ 28         Session s = HibernateUtil.getSession(); 29         Transaction tx = s.beginTransaction(); 30         Customer c1 = s.get(Customer.class, 1); 31         Set
     
       orders = c1.getOrders();//对象导航的方式 32         System.out.println(orders); 33         tx.commit(); 34         s.close(); 35     } 36     /*原来JDBC时，留下的思想 37     @Test 38     public void test16(){ 39         List
      
        orders = findOrderByCustomerid(1); 40         System.out.println(orders); 41     } 42      43     public List
       
         findOrderByCustomerid(int customerid){ 44         Session s = HibernateUtil.getSession(); 45         Transaction tx = s.beginTransaction(); 46         //select * from t_orders where customer_id = ?; 47         Query query = s.createQuery("from Order o where o.customer.id = ?"); 48         query.setInteger(0, customerid); 49         List
        
          orders = query.list(); 50         tx.commit(); 51         s.close(); 52         return orders;     53     } 54     */ 55      56     /* 57      * 原生SQL查询 58      *     使用的是session的createSQLQuery方法 59      *     它的执行list结果是一个由Object数组组成的集合。 60      *  61      * 在实际开发中，我们一般不会使用Object数组来操作。 62      * 而是在执行list()方法之前，调用addEntity方法，给sqlquery添加一个实体， 63      * 从而得到的就是实体对象的集合 64      65     select  66     sum( 67         case when score between 0 and 59 then 1 else 0 end 68     )  as E, 69     sum( 70         case when score between 60 and 69 then 1 else 0 end 71     ) as D, 72     sum( 73         case when score between 70 and 79 then 1 else 0 end 74     ) as C, 75     sum( 76         case when score between 80 and 89 then 1 else 0 end 77     ) as B, 78     sum( 79         case when score between 90 and 99 then 1 else 0 end 80     ) as A     81  from t_students 82      83      */ 84     @Test 85     public void test14(){ 86         Session s = HibernateUtil.getSession(); 87         Transaction tx = s.beginTransaction(); 88         SQLQuery sqlquery = s.createSQLQuery("select * from t_customers");//参数就是SQL语句 89         //给SQLQuery添加一个实体 90         sqlquery.addEntity(Customer.class); 91         List list = sqlquery.list(); 92         tx.commit(); 93         s.close(); 94         for(Object o : list){ 95             System.out.println(o); 96         } 97          98     } 99     /*100      * 分页查询101      *     mysql中的分页查询：102      *         使用的关键字：limit103      *         关键字中的必要条件：firstResult（开始记录索引），maxResults（最大的结果集数）104      * sql语句：select * from t_orders limit firstResult,maxResults;105      * 106      * HQL语句：from Order 107      * 108      * 在hibernate中分页只有109      *     setFirstResult110      *     setMaxResults111      * 不管使用什么数据库都是这两个方法112      */113     @Test114     public void test9(){115         List
         
           orders = findAllOrder(4,2);116         for(Order o : orders){117             System.out.println(o);118         }119     }120     //QBC121     public List
          
            findAllOrder2(int firstResult,int maxResults){122 Session s = HibernateUtil.getSession();123 Transaction tx = s.beginTransaction();124 Criteria criteria = s.createCriteria(Order.class);125 criteria.setFirstResult(firstResult);//开始记录的索引126 criteria.setMaxResults(maxResults);//每页要查询的条数127 List
           
             list = criteria.list();128 tx.commit();129 s.close();130 return list;131 }132 //HQL133 public List
            
              findAllOrder(int firstResult,int maxResults){134 Session s = HibernateUtil.getSession();135 Transaction tx = s.beginTransaction();136 Query query = s.createQuery("from Order");//select * from t_orders137 //hibernate提供的方法：138 query.setFirstResult(firstResult);//开始记录的索引139 query.setMaxResults(maxResults);//每页要查询的条数140 List
             
               orders = query.list();141 tx.commit();142 s.close();143 return orders;144 }145 /*146 * 命名查询147 * 把sql或者HQL在映射文件中配置起来。提供一个名称。148 * 名称和语句之间是键值对的对应关系。149 * 在程序使用根据名称获取语句的方法，叫做命名查询150 */151 @Test152 public void test8(){153 Session s = HibernateUtil.getSession();154 Transaction tx = s.beginTransaction();155 Query query = s.getNamedQuery("findCustomerByCondition");156 //给条件赋值157 query.setString("name", "testD");158 query.setInteger("age", 28);159 List list = query.list();160 tx.commit();161 s.close();162 for(Object o : list){163 System.out.println(o);164 }165 }166 /*167 * 具名查询168 * 具名其实就是给查询的参数占位符提供一个名称，使我们在查询时，使用名称而不是索引来给参数赋值169 * 书写规范：170 * 必须用 :名称171 */172 @Test173 public void test7(){174 Session s = HibernateUtil.getSession();175 Transaction tx = s.beginTransaction();176 Query query = s.createQuery("from Customer where age > :age and name=:name");177 //给条件赋值178 query.setString("name", "testD");179 query.setInteger("age", 28);180 List list = query.list();181 tx.commit();182 s.close();183 for(Object o : list){184 System.out.println(o);185 }186 }187 //多态查询：了解一下188 @Test189 public void test6(){190 Session s = HibernateUtil.getSession();191 Transaction tx = s.beginTransaction();192 Query query = s.createQuery("from java.io.Serializable ");193 List list = query.list();194 tx.commit();195 s.close();196 for(Object o : list){197 System.out.println(o);198 }199 }200 /*201 * 排序查询202 * 关键字和SQL是一样的。203 * order by 204 * asc 205 * desc206 */207 @Test208 public void test5(){209 Session s = HibernateUtil.getSession();210 Transaction tx = s.beginTransaction();211 Query query = s.createQuery("from Customer order by age desc ");212 List list = query.list();213 tx.commit();214 s.close();215 for(Object o : list){216 System.out.println(o);217 }218 }219 /*220 * QBC特例查询221 * 特例：222 * 用实体对象创建一个例子，查询语句的条件就会根据实体对象中提供的例子进行条件的拼装。223 * 注意：224 * 1、条件只会用等于225 * 2、在拼装条件时，它只涉及不为null的字段，同时不会把OID作为条件。226 */227 @Test228 public void test4(){229 //我的例子230 Customer c = new Customer();231 c.setAge(28);232 c.setName("testA");233 Session s = HibernateUtil.getSession();234 Transaction tx = s.beginTransaction();235 //创建查询对象。参数是要查询的实体236 Criteria criteria = s.createCriteria(Customer.class);237 //添加条件238 criteria.add(Example.create(c));//select * from t_customes where age = 28239 240 List list = criteria.list();241 tx.commit();242 s.close();243 for(Object o : list){244 System.out.println(o);245 }246 }247 //QBC带条件查询248 @Test249 public void test3(){250 Session s = HibernateUtil.getSession();251 Transaction tx = s.beginTransaction();252 //创建查询对象。参数是要查询的实体253 Criteria criteria = s.createCriteria(Customer.class);254 //添加条件255 criteria.add(Restrictions.gt("age", 28));256 257 List list = criteria.list();258 tx.commit();259 s.close();260 for(Object o : list){261 System.out.println(o);262 }263 }264 /*265 * QBC查询266 * QBC:query by criteria267 * QBC能实现的HQL都能实现。反之亦然。268 * 它更加面向对象269 */270 @Test271 public void test2(){272 Session s = HibernateUtil.getSession();273 Transaction tx = s.beginTransaction();274 //创建查询对象。参数是要查询的实体275 Criteria criteria = s.createCriteria(Customer.class);276 List list = criteria.list();277 tx.commit();278 s.close();279 for(Object o : list){280 System.out.println(o);281 }282 }283 /*284 * HQL带条件查询285 * hiberante中HQL使用条件，也是where关键字。286 * 条件的参数占位符也是用的问号287 * 注意事项：288 * hibernate中查询语句的参数占位符索引是从0开始的。289 */290 @Test291 public void test1(){292 Session s = HibernateUtil.getSession();293 Transaction tx = s.beginTransaction();294 Query query = s.createQuery("from Customer where age > ?");295 //给条件赋值296 query.setInteger(0, 28);297 List list = query.list();298 tx.commit();299 s.close();300 for(Object o : list){301 System.out.println(o);302 }303 }304 }

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。返回结果了解一下：除了满足条件的之外，还会返回左表和右表不满足条件的记录。

1     /* 2      * 迫切左外连接查询 3      *  4      * 返回的是一个集合，集合中的每个元素都是左表实体对象。 5      * 有可能重复。重复的原因是看迫切左外连接查询的条件。 6      */ 7     @Test 8     public void test11(){ 9         Session s = HibernateUtil.getSession();10         Transaction tx = s.beginTransaction();11         Query query = s.createQuery("from Customer c left outer join fetch c.orders ");12         List list = query.list();13         tx.commit();14         s.close();15         for(Object o : list){16             System.out.println(o);17         }18     }19     20     /*21      * 左外连接查询22      * 23      * 返回值是一个集合，集合的每个元素是Object数组。24      * 数组中包含2个Object对象。25      * 其中一个左表对象和一个右表对象。26      * 左表对象有可能重复，右表对象不会重复27      */28     @Test29     public void test10(){30         Session s = HibernateUtil.getSession();31         Transaction tx = s.beginTransaction();32         Query query = s.createQuery("from Customer c left outer join c.orders ");33         List
     
       list = query.list();34         tx.commit();35         s.close();36         for(Object[] os : list){37             System.out.println("----------------------");38             for(Object o : os){39                 System.out.println(o);40             }41         }42     }

3.4、投影查询

1 /* 2      * 投影查询 3      *     就想实现 4      *         查询客户时，只有客户的id和name 5      *         查询订单时，只有订单id和money 6      * 投影查询就是： 7      *     在实际开发中，我们只需要一个实体类中的某个或者某些字段，当查询完成后还想使用该实体对象来操作。 8      *     需要把查询的某个或某些字段投射到实体类上，这种查询方式叫投影查询。 9      * 在使用投影查询时的要求：10      *     实体类必须提供对应参数列表的构造函数。11      *  在写HQL语句时，需要使用new关键字12      * 13      * 注意事项：14      *     在使用投影查询时，如果直接写类名，需要确定该类在工程中唯一。15      *     如果不唯一的话，需要些类全名。包名.类名16      */17     @Test18     public void test13(){19         Session s = HibernateUtil.getSession();20         Transaction tx = s.beginTransaction();21         Query query = s.createQuery("select new cn.itcast.domain.Order(o.id,o.money) from Order o");22         List list = query.list();23         tx.commit();24         s.close();25         for(Object o : list){26             System.out.println(o);27         }28     }29     @Test30     public void test12(){31         Session s = HibernateUtil.getSession();32         Transaction tx = s.beginTransaction();33         Query query = s.createQuery("select new Customer(c.id,c.name) from Customer c");34         List list = query.list();35         tx.commit();36         s.close();37         for(Object o : list){38             System.out.println(o);39         }40     }

三、附录：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()