查询总结、HQL语法、QBC(QueryByCriteria)深入学习
1.查询总结
在之前的批量查询练习的时候练习基本五种查询方法的使用:
1.OID查询---根据对象ID进行查询
2.对象属性导航查询: obj.getXXX
3.HQL查询:Query对象查询
4.QBC(QueryByCriteria)：Criteria对象查询
5.原生SQL查询:SQLQuery查询
测试代码如下:
package cn.qlq.query; import java.util.Set; import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.junit.Test; import cn.qlq.domain.Customer;
import cn.qlq.domain.LinkMan;
import cn.qlq.util.HibernateUtil; /**
* 之前的查询总结
* @author liqiang
*
*/
public class HibernateQuery {
@Test
/**
* OID查询(get方法)
*/
public void fun1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Customer customer = session.get(Customer.class, 7l);
System.out.println(customer); tx.commit();
session.close();
} @Test
/**
* 属性导航语言(对象.getXXX)
*/
public void fun2(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Customer customer = session.get(Customer.class, 7l);
Set<LinkMan> linkMens = customer.getLinkMens();
System.out.println(linkMens); tx.commit();
session.close();
} @Test
/**
* HQL查询(Query对象进行查询)
*/
public void fun3(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); String hql = "from cn.qlq.domain.Customer";//如果整个项目只有一个类名，可以省去包名
Query query = session.createQuery(hql);
System.out.println(query.list()); tx.commit();
session.close();
} @Test
/**
* Criteria查询(也被叫做QBC---query by criteria)
*/
public void fun4(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); Criteria criteria = session.createCriteria(Customer.class);
// criteria.add(Restrictions.ilike("name", "xxx"));//添加过滤条件
System.out.println(criteria.list()); tx.commit();
session.close();
} @Test
/**
* 原生SQL查询(SQLQuery对象进行查询)
*/
public void fun5(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); String sql = "select * from cst_customer";
SQLQuery sqlQuery = session.createSQLQuery(sql);
sqlQuery.addEntity(Customer.class);
System.out.println(sqlQuery.list()); tx.commit();
session.close();
}
}
补充:也可以用query对象将查询结果映射为Map
@Test
/**
* 原生SQL查询(SQLQuery映射查询结果为map)
*/
public void fun6(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction(); String sql = "select * from cst_customer";
SQLQuery sqlQuery = session.createSQLQuery(sql);
sqlQuery.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
System.out.println(sqlQuery.list()); tx.commit();
session.close();
}
结果：
[{cust_phone=null, cust_name=测试名称1, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=7}, {cust_phone=null, cust_name=测试名称2, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=8}, {cust_phone=null, cust_name=测试名称3, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=9}, {cust_phone=null, cust_name=测试名称4, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=10}, {cust_phone=null, cust_name=测试名称5, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=11}, {cust_phone=null, cust_name=测试名称6, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=12}, {cust_phone=null, cust_name=测试名称7, cust_mobile=null, cust_linkman=null, cust_industry=null, cust_level=null, cust_source=null, cust_id=13}]
2.HQL深入学习(Hibernate query language)
1.HQL介绍
HQL是面向对象的查询语言，它和SQL查询有些类似，但它使用的是类、对象、属性的概念，而没有表和字段的概念，也就是在HQL中如果出现DB中的表和字段名是错误的。在Hibernate的各种检索方式中，官方推荐的是HQL检索，也是使用最广泛的一种查询方式。它具有如下功能:
- 在查询中设定各种查询条件
- 支持投影查询，即检索对象的部分属性
- 支持分页查询
- 支持分组查询，允许使用group by关键字和having关键字
- 提供内置聚集函数。如sum、avg、min、max、count等函数
- 能够调用用户定义的SQL函数
- 支持子查询，即嵌套查询
- 支持动态参数绑定
Hibernate提供的Query接口是专门的HQL查询接口，它能够执行各种复杂的HQL查询语句。完整的SQL语句结构如下:
Select ... from... where ... group by ... having...order by ...desc/asc
HQL非常类似于SQL。通常情况下如果查询表中的所有记录的时候，查询语句中可省略select关键字，如下:
from Customer
如果执行该语句，则会返回应用程序中的所有的Customer对象，需要注意的是Customer是类名而不是对象名，类名区分大小写，from不区分大小写，如果项目中有多个相同的类名需要加包名。
补充:如果希望查询结果映射为map，可以采用:
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
2.HQL学习
1.基本检索-检索所有
@Test
// HQL查询所有数据
public void fun1() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
// String hql = "from cn.qlq.domain.Customer";// from 类名全路径
String hql1 = "from Customer";//整个项目只有一个类名可以省略包名
// String hql2 = "from java.lang.Object";//写Object的时候会查询项目中的所有类,切勿使用，浪费内存
// 3.根据hql创建查询对象
// Query query = session.createQuery(hql);
Query query = session.createQuery(hql1);
// Query query = session.createQuery(hql2);
// 4.根据查询对象获取查询结果
List<Customer> objs = query.list();
System.out.println(objs);
}
结果:
Hibernate:
select
customer0_.cust_id as cust_id1_0_,
customer0_.cust_name as cust_nam2_0_,
customer0_.cust_source as cust_sou3_0_,
customer0_.cust_industry as cust_ind4_0_,
customer0_.cust_level as cust_lev5_0_,
customer0_.cust_linkman as cust_lin6_0_,
customer0_.cust_phone as cust_pho7_0_,
customer0_.cust_mobile as cust_mob8_0_
from
cst_customer customer0_
[Customer [cust_id=7, cust_name=测试名称1], Customer [cust_id=8, cust_name=测试名称2], Customer [cust_id=9, cust_name=测试名称3], Customer [cust_id=10, cust_name=测试名称4], Customer [cust_id=11, cust_name=测试名称5], Customer [cust_id=12, cust_name=测试名称6], Customer [cust_id=13, cust_name=测试名称7]]
2.排序
@Test
//排序查询
public void fun2() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "from Customer order by cust_id asc,cust_name desc";//整个项目只有一个类名可以省略包名
// 3.根据hql创建查询对象
Query query = session.createQuery(hql1);
// 4.根据查询对象获取查询结果
List<Customer> objs = query.list();
System.out.println(objs);
}
结果:
Hibernate:
select
customer0_.cust_id as cust_id1_0_,
customer0_.cust_name as cust_nam2_0_,
customer0_.cust_source as cust_sou3_0_,
customer0_.cust_industry as cust_ind4_0_,
customer0_.cust_level as cust_lev5_0_,
customer0_.cust_linkman as cust_lin6_0_,
customer0_.cust_phone as cust_pho7_0_,
customer0_.cust_mobile as cust_mob8_0_
from
cst_customer customer0_
order by
customer0_.cust_id asc,
customer0_.cust_name desc
[Customer [cust_id=7, cust_name=测试名称1], Customer [cust_id=8, cust_name=测试名称2], Customer [cust_id=9, cust_name=测试名称3], Customer [cust_id=10, cust_name=测试名称4], Customer [cust_id=11, cust_name=测试名称5], Customer [cust_id=12, cust_name=测试名称6], Customer [cust_id=13, cust_name=测试名称7]]
3.条件检索
(1)?占位符查询
类似于JDBC的占位符，只是hibernate的?下标从0开始，而JDBC的下标从1开始，基本上所有的编程索引都从0开始，唯独JDBC从1开始。。。。
@Test
// HQL的?占位符查询
public void fun3() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
// String hql = "from cn.qlq.domain.Customer";// from 类名全路径
String hql = "from Customer where cust_id = ?";// 如果整个项目中只有这一个类名可以直接写名字
// 3.根据hql创建查询对象
Query query = session.createQuery(hql);
// query.setLong(0, 1l);//类似于JDBC的占位符，只是JDBC的占位符下标从0开始，hibernate从1开始
query.setParameter(0, 1l);//这种写法不用管类型
// 4.根据查询对象获取查询结果
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);
}
(2)命令占位符 ：name格式的查询，固定格式，name随便起，习惯性的起做和条件名字一样
@Test
// HQL的命令占位符查询
public void fun4() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
// String hql = "from cn.qlq.domain.Customer";// from 类名全路径
String hql = "from Customer where cust_id = :cust_id";// :cust_id的名字随便起，只不过习惯性的起做一样
// 3.根据hql创建查询对象
Query query = session.createQuery(hql);
// query.setLong(0, 1l);//类似于JDBC的占位符，只是JDBC的占位符下标从0开始，hibernate从1开始
query.setParameter("cust_id",1l);
// 4.根据查询对象获取查询结果
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);
}
4.排序查询
@Test
// HQL分页查询
public void fun5() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.书写HQL语句
// String hql = "from cn.qlq.domain.Customer";// from 类名全路径
String hql = "from Customer order by cust_id desc";// 3.根据hql创建查询对象
Query query = session.createQuery(hql);
/**
* 类似于 limit start,pageSize;
* 假设页大小是2
* 页号 起始值 页大小
* 1 0 2
* 2 2 2
*/
//例如取第二页数据
query.setFirstResult(2);
query.setMaxResults(2);
// 4.根据查询对象获取查询结果
List<Customer> customers = query.list();
System.out.println(customers);
}
5.聚合函数的使用:
@Test
//聚集函数的使用
public void fun3() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "select count(*) from Customer";//统计总数
String hql2 = "select avg(cust_id) from Customer";//平均
String hql3 = "select sum(cust_id) from Customer";//和
String hql4 = "select max(cust_id) from Customer";//最大
String hql5 = "select min(cust_id) from Customer";//最小
// 3.根据hql创建查询对象
Query query = session.createQuery(hql4);
// 4.根据查询对象获取查询结果
Number number = (Number) query.uniqueResult();//Number是所有数字类型的父类
System.out.println(number);
}
6.投影检索---查询指定的属性，不查全部
(1)投影单个属性
@Test
//投影单个
public void fun7() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "select cust_name from Customer";//整个项目只有一个类名可以省略包名
// 3.根据hql创建查询对象
Query query = session.createQuery(hql1);
// 4.根据查询对象获取查询结果
List<String> objs = query.list();//那一列是什么类型用什么类型，也可以省去不写
System.out.println(objs);
}
结果:
Hibernate:
select
customer0_.cust_name as col_0_0_
from
cst_customer customer0_
[测试名称1, 测试名称2, 测试名称3, 测试名称4, 测试名称5, 测试名称6, 测试名称7]
(2)投影多列---映射为数组
@Test
//投影多列
public void fun7() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "select cust_id,cust_name from Customer";//整个项目只有一个类名可以省略包名
// 3.根据hql创建查询对象
Query query = session.createQuery(hql1);
// 4.根据查询对象获取查询结果
List<Object[]> objs = query.list();//那一列是什么类型用什么类型，也可以省去不写
System.out.println(objs);
}
结果:
Hibernate:
select
customer0_.cust_id as col_0_0_,
customer0_.cust_name as col_1_0_
from
cst_customer customer0_
[[Ljava.lang.Object;@29bd3793, [Ljava.lang.Object;@458ba94d, [Ljava.lang.Object;@541821e6, [Ljava.lang.Object;@7c59ae2b, [Ljava.lang.Object;@63b9c8d4, [Ljava.lang.Object;@3a300972, [Ljava.lang.Object;@27bc3936]
(3)将投影映射为对象:(构造方式查询)
在原来的类中创建需要投影的属性的构造方法，同时需要显示的创建无参构造函数:
测试代码:
@Test
//投影多列---映射为JavaBean
public void fun7() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "select new Customer(cust_id,cust_name) from Customer";//整个项目只有一个类名可以省略包名
// 3.根据hql创建查询对象
Query query = session.createQuery(hql1);
// 4.根据查询对象获取查询结果
List<Customer> objs = query.list();//那一列是什么类型用什么类型，也可以省去不写
System.out.println(objs);
}
结果
Hibernate:
select
customer0_.cust_id as col_0_0_,
customer0_.cust_name as col_1_0_
from
cst_customer customer0_
[Customer [cust_id=7, cust_name=测试名称1], Customer [cust_id=8, cust_name=测试名称2], Customer [cust_id=9, cust_name=测试名称3], Customer [cust_id=10, cust_name=测试名称4], Customer [cust_id=11, cust_name=测试名称5], Customer [cust_id=12, cust_name=测试名称6], Customer [cust_id=13, cust_name=测试名称7]]
7.查询结果映射为map
@Test
public void fun8() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.书写HQL语句
String hql1 = "select cust_id,cust_name from Customer";//整个项目只有一个类名可以省略包名
// 3.根据hql创建查询对象
Query query = session.createQuery(hql1);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
// 4.根据查询对象获取查询结果
List<Map<String,Object>> objs = query.list();//那一列是什么类型用什么类型，也可以省去不写
System.out.println(objs);
}
结果：
[{1=测试名称1, 0=7}, {1=测试名称2, 0=8}, {1=测试名称3, 0=9}, {1=测试名称4, 0=10}, {1=测试名称5, 0=11}, {1=测试名称6, 0=12}, {1=测试名称7, 0=13}]
3.HQL多表查询
多表查询分为交叉连接(笛卡尔积)、内连接(隐士内连接、显示内连接)，外链接（左外连接和右外连接），测试语句如下:
package cn.qlq.HQL; import java.util.Arrays;
import java.util.List; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test; import cn.qlq.domain.Customer;
import cn.qlq.util.HibernateUtil; //学习HQL语法(不常用) - 多表查询语法
public class Demo2 {
//回顾-原生SQL
// 交叉连接-笛卡尔积(避免)
// select * from A,B
// 内连接
// |-隐式内连接
// select * from A,B where b.aid = a.id
// |-显式内连接
// select * from A inner join B on b.aid = a.id
// 外连接
// |- 左外
// select * from A left [outer] join B on b.aid = a.id
// |- 右外
// select * from A right [outer] join B on b.aid = a.id
//---------------------------------------------------------------------
//HQL的多表查询
//内连接(迫切)
//外连接
// |-左外(迫切)
// |-右外(迫切) @Test
//HQL 内连接 => 将连接的两端对象分别返回.放到数组中.
public void fun0(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join c.linkMens "; Query query = session.createQuery(hql); List<Object[]> list = query.list(); for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close(); } @Test
//HQL 内连接 => 带查询条件，查询cust_id为9的数据
public void fun1(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join c.linkMens where cust_id = 9l"; Query query = session.createQuery(hql); List<Object[]> list = query.list(); for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close(); } @Test
//HQL 迫切内连接 => 帮我们进行封装.返回值就是一个对象
public void fun2(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c inner join fetch c.linkMens "; Query query = session.createQuery(hql); List<Customer> list = query.list(); System.out.println(list);
//----------------------------------------------------
tx.commit();
session.close(); } @Test
//HQL 左外连接 => 将连接的两端对象分别返回.放到数组中.
public void fun3(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c left join c.linkMens "; Query query = session.createQuery(hql); List<Object[]> list = query.list(); for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close(); }
@Test
//HQL 右外连接 => 将连接的两端对象分别返回.放到数组中.
public void fun4(){
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
String hql = " from Customer c right join c.linkMens "; Query query = session.createQuery(hql); List<Object[]> list = query.list(); for(Object[] arr : list){
System.out.println(Arrays.toString(arr));
}
//----------------------------------------------------
tx.commit();
session.close(); } }
3.QBC深入学习
1.在线Criteria(由Session创建)
QBC（Query By Criteria）是Hibernate创提供的另一种检索对象的方式，它主要由Criteria接口、Criterion接口和Expression类组成。Criteria是HibernateAPI中的一个查询接口，它需要由session进行创建(由session创建的Criteria称为在线Criteria对象,查询哪个实体将哪个实体的class字节码对象传给session)。Criterion是Criteria的查询条件，在Criteria中提供了add(Criterion c)方法来添加查询条件。使用QBC检索对象的示例代码如下:
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("cust_id", 1l));
Customer customer = (Customer) criteria.uniqueResult();
1.基本的查询所有
@Test
// 查询所有
public void test1() {
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
System.out.println(list);
}
2. 条件查询单个:
@Test
// 根据ID查询单个,条件查询
public void test2() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("cust_id", 1l));
Customer customer = (Customer) criteria.uniqueResult();
System.out.println(customer);
}
结果:
Customer [cust_id=1, cust_name=程序员111]
条件列表:
补充:QBC也可以传SQL条件，例如:
@Test
// 根据ID查询单个,条件查询
public void test2() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.sqlRestriction("cust_id = 1"));
criteria.add(Restrictions.sqlRestriction("cust_name = '张三'"));
Customer customer = (Customer) criteria.uniqueResult();
System.out.println(customer);
}
结果:
user创建对象
Hibernate:
select
this_.cust_id as cust_id1_0_0_,
this_.cust_name as cust_nam2_0_0_,
this_.cust_source as cust_sou3_0_0_,
this_.cust_industry as cust_ind4_0_0_,
this_.isPerson as isPerson5_0_0_,
this_.cust_level as cust_lev6_0_0_,
this_.cust_linkman as cust_lin7_0_0_,
this_.cust_phone as cust_pho8_0_0_,
this_.cust_mobile as cust_mob9_0_0_
from
cst_customer this_
where
cust_id = 1
and cust_name = '张三'
Customer [cust_id=1, cust_name=张三]
3.分页查询:
@Test
// 分页查询
public void test3() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
/**
* 类似于 limit start,pageSize;
* 假设页大小是2
* 页号 起始值 页大小
* 1 0 2
* 2 2 2
*/
criteria.setFirstResult(2);
criteria.setMaxResults(2);
List<Customer> list = criteria.list();
System.out.println(list);
}
结果:
[Customer [cust_id=3, cust_name=测试名称222], Customer [cust_id=4, cust_name=测试名称222]]
4.排序分组使用
@Test
// 排序和分组
public void test5() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.排序
Criteria criteria = session.createCriteria(Customer.class);
criteria.addOrder(Order.desc("cust_id"));
List<Customer> list = criteria.list();
System.out.println(list);
System.out.println();
// 2.分组
Criteria criteria1 = session.createCriteria(Customer.class);
criteria1.setProjection(Projections.groupProperty("cust_name"));
List<Customer> list1 = criteria1.list();
System.out.println(list1);
}
结果：
[Customer [cust_id=4, cust_name=测试名称222], Customer [cust_id=3, cust_name=测试名称222], Customer [cust_id=2, cust_name=新增数据], Customer [cust_id=1, cust_name=程序员111]]
[新增数据, 测试名称222, 程序员111]
5.聚集函数查询总数
@Test
// 查询总数（聚集函数的使用）
public void test4() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.聚集函数查询总数
Criteria criteria = session.createCriteria(Customer.class);
criteria.setProjection(Projections.rowCount());
Long count = (Long) criteria.uniqueResult();
System.out.println(count);
// 3.聚集函数查询总数第二种方法
Criteria criteria1 = session.createCriteria(Customer.class);
criteria1.setProjection(Projections.count("cust_id"));
Long count1 = (Long) criteria.uniqueResult();
System.out.println(count1);
// 4.聚集函数查询几个不同的姓名
Criteria criteria2 = session.createCriteria(Customer.class);
criteria2.setProjection(Projections.countDistinct("cust_name"));
Long count2 = (Long) criteria2.uniqueResult();
System.out.println(count2);
}
结果:
4
4
3
6. Criteria 实现or语句查询
@Test
// 根据ID查询单个,条件查询
public void test22() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.or(Restrictions.eq("cust_name", "李四1"), Restrictions.eq("cust_name", "李四2")));
criteria.add(Restrictions.isNotNull("cust_name"));
List list = criteria.list();
System.out.println(list);
}
结果: (这种写法是一个 or ,相当于 where xxx=xx and ( xxx = xxx or xxxx=xxxx or ....) )
user创建对象
Hibernate:
select
this_.cust_id as cust_id1_0_0_,
this_.cust_name as cust_nam2_0_0_,
this_.cust_source as cust_sou3_0_0_,
this_.cust_industry as cust_ind4_0_0_,
this_.isPerson as isPerson5_0_0_,
this_.cust_level as cust_lev6_0_0_,
this_.cust_linkman as cust_lin7_0_0_,
this_.cust_phone as cust_pho8_0_0_,
this_.cust_mobile as cust_mob9_0_0_
from
cst_customer this_
where
(
this_.cust_name=?
or this_.cust_name=?
)
and this_.cust_name is not null
[Customer [cust_id=3, cust_name=李四1], Customer [cust_id=4, cust_name=李四2]]
第二种写法:(建议这种---多个or的时候清晰)
@Test
// 根据ID查询单个,条件查询
public void test222() {
// 1 获得session
Session session = HibernateUtils.openSession();
// 2.創建criteria进行查询
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.isNotNull("cust_name")); Disjunction disjunction = Restrictions.disjunction();
disjunction.add(Restrictions.eq("cust_name", "李四1"));
disjunction.add(Restrictions.eq("cust_name", "李四2"));
criteria.add(disjunction); List list = criteria.list();
System.out.println(list);
}
结果:
user创建对象
Hibernate:
select
this_.cust_id as cust_id1_0_0_,
this_.cust_name as cust_nam2_0_0_,
this_.cust_source as cust_sou3_0_0_,
this_.cust_industry as cust_ind4_0_0_,
this_.isPerson as isPerson5_0_0_,
this_.cust_level as cust_lev6_0_0_,
this_.cust_linkman as cust_lin7_0_0_,
this_.cust_phone as cust_pho8_0_0_,
this_.cust_mobile as cust_mob9_0_0_
from
cst_customer this_
where
this_.cust_name is not null
and (
this_.cust_name=?
or this_.cust_name=?
)
[Customer [cust_id=3, cust_name=李四1], Customer [cust_id=4, cust_name=李四2]]
所以当只需要一个or条件时可以用Restrictions.or();当用到多个or条件时，就需要用到Restrictions.disjunction();
2.离线Criteria(DetachedCriteria--可以凭空创建)
补充:
Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria来返回查询结果。
1.DetachedCriteria介绍以及简单用法
应用场景一般是动态条件查询，我们可以在web层或者service层根据业务创建DetachedCriteria对象并封装动态条件传到dao层，dao层根据DetachedCriteria对象获取在线Criteria查询数据库,实现解耦。使用步骤大概如下:
(1)创建DetachedCriteria对象的方式有两种:
//第一种方法:传入class
DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);//查询哪个对象将哪个对象的字节码传进去
//第二种方法:传入全类名(必须携带包名)
DetachedCriteria dc = DetachedCriteria.forEntityName("cn.qlq.domain.Customer");//
(2)DetachedCriteria对象封装查询条件与Criteria对象一样:
dc.add(Restrictions.idEq(7l));
(3)通过DetachedCriteria构造在线Criiteria对象方法:(需要Session环境)
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.通过DetachedCriteria构造Criteria对象
Criteria criteria = dc.getExecutableCriteria(session);//获取在线criteria对象
(4)通过Criteria进行查询:（与原来一样）
//1.查询集合
// List<Customer> list = criteria.list();
//2.查询单个对象
Object uniqueResult = criteria.uniqueResult();
2.在线Criteria与线下Criteria(DetachedCriteria)区别:
在线Criteria的查询图解如下:
离线Criteria图解如下:
线下Criteria测试代码:
@Test
public void test1() {
/*******************S Web层或者service层 **************************/
//0.构造DetachedCriteria对象封装查询条件
//第一种方法:传入class
// DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);//查询哪个对象将哪个对象的字节码传进去
//第二种方法:传入全类名(必须携带包名)
DetachedCriteria dc = DetachedCriteria.forEntityName("cn.qlq.domain.Customer");//
dc.add(Restrictions.idEq(7l));
/*******************E Web层或者service层 **************************/ /********************S Dao层************************************/
// 1 获得session
Session session = HibernateUtil.openSession();
// 2.通过DetachedCriteria构造Criteria对象
Criteria criteria = dc.getExecutableCriteria(session);//获取在线criteria对象
List<Customer> list = criteria.list();
System.out.println(list);
/********************E Dao层************************************/
}
结果:
Hibernate:
select
this_.cust_id as cust_id1_0_0_,
this_.cust_name as cust_nam2_0_0_,
this_.cust_source as cust_sou3_0_0_,
this_.cust_industry as cust_ind4_0_0_,
this_.cust_level as cust_lev5_0_0_,
this_.cust_linkman as cust_lin6_0_0_,
this_.cust_phone as cust_pho7_0_0_,
this_.cust_mobile as cust_mob8_0_0_
from
cst_customer this_
where
this_.cust_id = ?
[Customer [cust_id=7, cust_name=测试名称1]]
user创建对象Hibernate: select this_.cust_id as cust_id1_0_0_, this_.cust_name as cust_nam2_0_0_, this_.cust_source as cust_sou3_0_0_, this_.cust_industry as cust_ind4_0_0_, this_.isPerson as isPerson5_0_0_, this_.cust_level as cust_lev6_0_0_, this_.cust_linkman as cust_lin7_0_0_, this_.cust_phone as cust_pho8_0_0_, this_.cust_mobile as cust_mob9_0_0_ from cst_customer this_ where cust_id = 1 and cust_name = '张三'Customer [cust_id=1, cust_name=张三]
查询总结、HQL语法、QBC(QueryByCriteria)深入学习的更多相关文章
- hibernate框架学习之数据查询（HQL）
lHibernate共提供5种查询方式 •OID数据查询方式 •HQL数据查询方式 •QBC数据查询方式 •本地SQL查询方式 •OGN数据查询方式 OID数据查询方式 l前提:已经获取到了对象的OI ...
- Hibernate 检索查询的几种方式（HQL，QBC，本地SQL，集成Spring等）
1.非集成Spring hibernate的检索方式,主要有以下五种. 1.导航对象图检索方式.(根据已经加载的对象,导航到其他对象.) 2.OID检索方式.(按照对象的OID来检索对象.) 3.HQ ...
- jpa 联表查询 返回自定义对象 hql语法 原生sql 语法 1.11.9版本
-----业务场景中经常涉及到联查,jpa的hql语法提供了内连接的查询方式(不支持复杂hql,比如left join ,right join). 上代码了 1.我们要联查房屋和房屋用户中间表,通过 ...
- Hibernate —— HQL、QBC检索方式
一.HQL 检索方式 以双向的一对多来测试 HQL 检索方式.以 Department 和 Employee 为例. 建表语句: CREATE TABLE department ( dept_id ) ...
- Hibernate 框架 -HQL 语法
HQL ( Hibernate Query Language ) 查询语言是面向对象的查询语言,也是在 Hibernate 中最常见的.其语法和 SQL 语法有一些相似,功能十分强大,几乎支持除特殊 ...
- Hibernate 查询：HQL查询(Hibernate Query Languge)
HQL是一种面向对象的查询语言,其中没有表和字段的概念,只有类,对象和属性的概念. 使用HQL查询所有学生: public static void main(String[] args) { Sess ...
- 八、hibernate的查询（HQL）
HQL:Hibernate Query Language 提供更加丰富灵活.更为强大的查询能力 HQL更接近SQL语句查询语法 面向对象的查询 "from Children where ci ...
- NHibernate系列文章二十二：NHibernate查询之HQL查询（附程序下载）
摘要 NHibernate提供了多种查询方式,最早的HQL语言查询.Criteria查询和SQL Query,到NHibernate 3.0的Linq NHibernate,NHIbernate 4. ...
- 快速查询Python脚本语法
/********************************************************************* * 快速查询Python脚本语法 * 说明: * Char ...
随机推荐
- 软件项目第一次sprint评分表
- java调用不了你本以为有的方法的问题
大部分是因为你的jar版本不对引起的,我就试过
- [OSChina]VirtualBox 6.0.0 发布，改进对高端显示器的 HiDPI 支持--尝试一下
VirtualBox 6.0.0 发布,改进对高端显示器的 HiDPI 支持 https://www.oschina.net/news/102838/virtualbox-6-0-0-released ...
- Windows 下 Docker 的简单学习使用过程之一 dockertoolbox
1. Windows 下面运行 Docker 的两个主要工具1): Docker for Windows2): DockerToolbox区别:Docker For Windows 可以理解为是新一代 ...
- Android DatePickerDialog和TimePickerDialog显示样式
可以用DatePickerDialog显示选取日期的对话框.可以设置显示的样式 1.通过构造方法设置显示样式. 可以通过DatePickerDialog(Context context, int th ...
- synchronized、Lock、ReentrantLock、ReadWriteLock
synchronized:同步锁,是java内置的关键字.当一个线程A执行到被synchronized修饰的方法时,其他线程B如果也要执行这个方法,那么B只能等A执行完方法释放锁后才能获取资源锁执行s ...
- CentOS下部署Jupyter
目录 安装 配置 准备密码密文 生成配置文件 修改配置 启动 参考:在服务器搭建Jupyter notebook 安装 为了环境比较轻,使用pip安装,非Anaconda: # 创建Python虚拟环 ...
- Tomcat源码解析-整体流程介绍
一.架构 下面谈谈我对Tomcat架构的理解 总体架构: 1.面向组件架构 2.基于JMX 3.事件侦听 1)面向组件架构 tomcat代码看似很庞大,但从结构上看却很清晰和简单,它主要由一堆组件组成 ...
- 【BZOJ1228】[SDOI2009]E&D（博弈论）
[BZOJ1228][SDOI2009]E&D(博弈论) 题面 BZOJ 洛谷 题解 这种打表找规律的题目真的不知道可以说什么好啊... #include<iostream> #i ...
- 【BZOJ1032】[JSOI2007]祖玛（动态规划）
[BZOJ1032][JSOI2007]祖玛(动态规划) 题面 BZOJ 洛谷 题解 听说是道假题,假的原因是因为出题人可能没有考虑到祖玛的骚套路,比如可以先打几个球进去再一波消掉.也就是出题人基本默 ...