十一、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属性，把值改为false
20 * lazy取值:true 延迟加载（默认值）。false是立即加载。
21 * 例如：
22 * <class name="Customer" table="T_CUSTOMERS" lazy="false">
23 * query的list方法:
24 * 永远都是立即加载。
25 *
26 * @author zhy
27 *
28 */
29 public class HibernateDemo1 {
30
31 /*
32 * 不管用不用，都立即查询出一个客户的所有字段数据
33 */
34 @Test
35 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 @Test
49 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<Customer> 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、检索关联多的一方
应用场景：
一对多：根据客户查询订单
多对多：根据老师查询学生
配置：
1 <hibernate-mapping package="cn.itcast.domain"> 2 <class name="Customer" table="T_CUSTOMERS"> 3 <id name="id" column="id"> 4 <generator class="native"></generator> 5 </id> 6 <property name="name" column="NAME"></property> 7 <property name="age" column="AGE"></property> 8 <!-- 一对多关系映射： 9 set元素： 10 作用：映射集合元素 11 属性： 12 name：映射实体类中的集合属性 13 table：指定对应的表 14 key元素：它是set的子元素 15 作用：就是用于指定外键的 16 属性： 17 column：指定外键字段的名称 18 one-to-many元素：它是set的子元素 19 作用：描述当前实体映射文件和set中指定属性之间的关系。 20 属性： 21 class:指定是从表的实体类名称 22 --> 23 <set name="orders" table="T_ORDERS" lazy="true" fetch="join"> 24 <key column="CUSTOMER_ID"></key> 25 <one-to-many class="Order"/> 26 </set> 27 </class> 28 </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 * 关联级别的检索策略
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 * <set name="orders" table="T_ORDERS" lazy="true" fetch="subselect">
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<Customer> 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 zhy
38 *
39 * 第二种情况：lazy=proxy fetch=join
40 * <many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="proxy" fetch="join"/>
41 *
42 */
43 public class HibernateDemo11 {
44
45
46 /* 当fetch取值是join时，一下就查询2张表。就不管lazy属性如何配置。
47 *
48 * 需求：
49 * 查询一个订单，根据订单获取该订单的客户
50 * 查询的时机：
51 * lazy属性失效
52 * 查询的方式：
53 * 左外连接
54 *
55 */
56 @Test
57 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 <hibernate-mapping package="cn.itcast.domain"> 2 <class name="Order" table="T_ORDERS"> 3 <id name="id" column="id"> 4 <generator class="native"></generator> 5 </id> 6 <property name="ordernum" column="ORDERNUM"></property> 7 <property name="money" column="MONEY"></property> 8 9 <!-- 多对一关系映射 10 使用的元素：many-to-one 11 属性： 12 name：指定的是在实体类中要映射的属性 13 class：指定该属性所对应的类 14 column：指定外键字段。 15 --> 16 <many-to-one name="customer" class="Customer" column="CUSTOMER_ID" lazy="proxy" fetch="join"/> 17 </class> 18 </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，多态，排序，具名，命名，分页）
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<Order> 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<Order> orders = findOrderByCustomerid(1);
40 System.out.println(orders);
41 }
42
43 public List<Order> 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<Order> 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 * 使用的关键字：limit
103 * 关键字中的必要条件：firstResult（开始记录索引），maxResults（最大的结果集数）
104 * sql语句：select * from t_orders limit firstResult,maxResults;
105 *
106 * HQL语句：from Order
107 *
108 * 在hibernate中分页只有
109 * setFirstResult
110 * setMaxResults
111 * 不管使用什么数据库都是这两个方法
112 */
113 @Test
114 public void test9(){
115 List<Order> orders = findAllOrder(4,2);
116 for(Order o : orders){
117 System.out.println(o);
118 }
119 }
120 //QBC
121 public List<Order> 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<Order> list = criteria.list();
128 tx.commit();
129 s.close();
130 return list;
131 }
132 //HQL
133 public List<Order> 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_orders
137 //hibernate提供的方法：
138 query.setFirstResult(firstResult);//开始记录的索引
139 query.setMaxResults(maxResults);//每页要查询的条数
140 List<Order> orders = query.list();
141 tx.commit();
142 s.close();
143 return orders;
144 }
145 /*
146 * 命名查询
147 * 把sql或者HQL在映射文件中配置起来。提供一个名称。
148 * 名称和语句之间是键值对的对应关系。
149 * 在程序使用根据名称获取语句的方法，叫做命名查询
150 */
151 @Test
152 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 @Test
173 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 @Test
189 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 * desc
206 */
207 @Test
208 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 @Test
228 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 = 28
239
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 @Test
249 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 criteria
267 * QBC能实现的HQL都能实现。反之亦然。
268 * 它更加面向对象
269 */
270 @Test
271 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 @Test
291 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 @Test
29 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<Object[]> 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 @Test
18 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 @Test
30 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() |
|
时间： 2024-08-08 05:37:51