Hibernate之HQL_QBC查询详解、抓取策略优化机制
Hibernate学习笔记04——HQL_QBC查询详解--抓取策略优化机制
- 查询方式
- OID查询
- 对象导航检索
- HQL检索
- 初始化数据
- HQL简单查询
- HQL别名查询
- HQL排序查询
- HQL条件查询
- HQL投影查询
- HQL分组统计查询
- HQL分页查询
- QBC查询
- 离线条件查询（SSM）
- SQL查询
- 抓取策略
- 延迟加载
- 抓取策略概述
- set集合上的fetch和lazy_rec
- many-to-one上的fetch和lazy_rec
查询方式
Hibernate 提供了五种查询方式
OID查询
通过对象的OID（主键）进行检索。
- 使用get方法
session.get(Class c,Serializable id); - 使用load方法
session.load(Class c,Serializable id);
对象导航检索
通过一个已经查询到的对象，获取其关联的对象进行查询。
LInkMan linkMan = session.get(LinkMan.class,1l); Customer customer = linkMan.getCustomer()
HQL检索
Hibernate Query Language，Hibernate查询语言，一种面向对象的查询语言，语法与SQL类似，通过session.createQuery()用于接收一个HQL进行查询。
初始化数据
HQL简单查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
Query query = session.createQuery("from Customer");
List<Customer> list = query.list();
for(Customer customer : list){
System.out.println(customer);
}
tx.commit();
注意，需要在Cutomer实体类中创建toString方法，但不能两边都toString,即toString时不能有集合。HQL不支持 * 符号号的使用。
HQL别名查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
Query quer = session.createQuery("select c from Customer c");
List<Customer> list() = query.list;
for(Customer customer : list){
System.out.println(customer);
}
tx.commit();
HQL排序查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
//默认情况,升序
//List list() = session.createQuery("from Customer order by cust_id").list();
//降序查询(desc) 升序(asc)
List<Customer> list() = session.createQuery("from Customer order by cust_id desc").list();
for(Customer customer : list){
System.out.println(customer);
}
tx.commit();
HQL条件查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
//按位置绑定:根据参数的位置进行绑定
//单个条件
//Query query = session.createQuery(“from Customer where cust_name=?");
//query.setParamenter(0,"ZS");
//List list = query.list();
//多个条件
//Query query = session.createQuery(“from Customer where cust_name=? and cust_age=?");
//query.setParameter(0,"ZS");
//query.setParameter(1,"男");
//List list = query.list();
//按名称绑定:将需要参数的位置一个名称。
Query query = session.createQuery("from Customer where cust_name= :ZS and age= :bbb ");
query.setParameter("aaa","ZS");
query.setParameter("bbb","男");
List<Customer> list = query.list();
for(Customer customer : list){
System.out.println(customer);
}
tx.commit();
HQL投影查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
//单个属性
/*
List
//多个属性
/*
session.createQuery("select c.cust_name ,c.cust_age from Customer c").list();
for(Customer customer : list){
System.out.println(Arrays.toString(objects));
}
*/
//查询多个属性，封装到对象当中，那么首先需要在实体类中添加有参构造方法，方法中的参数为这里需的参数
List<Customer> list = session.createQuery("select new Customer(cust_name,cust_surce) from Customer");
for(Customer customer : list){
System.out.println(customer);
}
tx.commit();
HQL分组统计查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
//注意，统计查询返回的是一个long类型,uniquerResult表示唯一结果
/*使用聚合函数，这里只用了count()，还可以用max()、min()、avg()、sum()等
Object object = session.createQuery("select count(*) from LinkMan").uniqueResult();
query.setFirstResult(0);
query.setMaxResults(10);
List list = query.list();
System.out.println(object);
*/
//分组统计
List<Object[]> list = session.createQuery("select cust_soure,count(*) from Customer group by cust_source").uniqueResult();
for(Object[] objects : list){
System.out.println(Arrarys.toString(objects));
}
tx.commit();
HQL分页查询
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
Query query = session.createQuery("from LinkMan");
query.setFirstResult(0);
query.setMaxResults(10);
List<linkMan> list = query.list();
for(LinkMan linkMan : list){
System.out.println(linkMan);
}
tx.commit();
QBC查询
Query By Criterla，条件查询。是一种更加面向对象化的查询方式。
Session session = HibernateUtiles.getCurrentSession();
Transaction tx = session.beginTransaction();
//获取Criteria的对象
Criteria criteria = session.createCriteria(Customer.class);
//简单查询
/*
List list = criteria.list();
for(Customer customer : list){
System.out.println(customer);
}
*/
//排序查询
/*
//升序
Criteria.addOrder(Order.asc("cust_id"));
//降序
Criteria.addOrder(Order.desc("cust_id"));
listj list = criteria.list();
for(Customer customer : list){
System.out.println(customer);
}
*/
//分页查询
/*
criteria.setFirstResult(0);
criteria.setMaxResults(10);
List list = criteria.list();
list list = criteria.list();
for(LinkMan linkMan: list){
System.out.println(linkMan);
}
*/
//条件查询
/*
//设置条件， == eq >gt >= ge < lt <= le <> ne like in and or
criteria.add(Restrictions.like("cust_name","Z%"));
criteria.add(Restrictions.eq("cust_age","男"))
list list = criteria.list();
for(Customer customer: list){
System.out.println(customer);
}
*/
//统计查询
/*
criteria.setProjection(Projections.rowCount());
Long num = (Long)criteria.uniqueResult();
System.out.println(num);
*/
tx.commit();
离线条件查询（SSM）
可以脱离session使用
//先在web层创建一个DatachedCriteria对象
DatachedCriteria dc = DatachedCriteria.forClass(Customer.css);
//设置条件
dc.add(Restriotions.eq());
//在service层中向dao传入对象 dao.query(dc);
Dao1{
//因为已经在web层设置了条件，所以在dao中不需要拼SQL
xxx(dc){
//绑定session
Criteria criteria = datachedCriteria.getExecutableCriteria(session);
List<> list = criteria.list();
}
}
- 子查询
SQL查询
SQL多表查询
- 连接查询
-
- 交叉查询：笛卡尔积
select * from A,B;
- 交叉查询：笛卡尔积
-
- 内连接：inner join(inner 可以省略)
-
-
- 隐式内连接
select * from A,B where A.id=B.aid;
- 隐式内连接
-
-
-
- 显示内连接
select * from A inner join B on A.id=B.aid;
- 显示内连接
-
-
- 外连接:
-
-
- 左外连接 left outer join (outer 可以省略)
select * from A left outer join B on A.id = B.aid
- 左外连接 left outer join (outer 可以省略)
-
-
-
- 右外链接 reght outer join (outer 可以省略)
select * from A reghtouter join B on A.id = B.aid
- 右外链接 reght outer join (outer 可以省略)
-
- 子查询
DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
detachedCriteria.add(Restrictions.like("
cust_name","W%:));
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
抓取策略
延迟加载
延迟加载概述
lazy(懒加载)。执行到该行代码时不会发送语句进行查询，当真正使用这个对象的属性时才发送SQl语句进行查询
延迟加载的分类
- 类级别的延迟加载
通过load方法查询某个对象时是否采用延迟。
在的标签上配置lazy。
session.load(Customer.class,1l); -
- 使lazy失效
-
-
- 将lazy设置为false;
-
-
-
- 将持久化类使用final修饰
-
-
-
- Hibernate.initialize();
-
- 关联级别的延迟加载
在查询某个对象时,查询其关联的对象,是否采用延迟加载
Customer customer = session.get(Customer.class,1l); customer.getLinkMans();·
抓取策略概述
通过一个对象抓取到关联对象需要发送SQL语句，SQL语句如何发送，发送成什么样格式通过策略进行配置。
- 通过< set >或者< many-to-one >上通过fetch属性进行设置
- fetch和这些标签上的lazy如何设置优化发送SQL语句。
set集合上的fetch和lazy_rec
fetch：抓取策略，控制SQL语句格式
- select：默认值，发送普通selec语句，查询关联对象
- join：发送一条迫切左外连接查询关联对象
- subselect：发送一条子查询查询关联对象
lazy:延迟加载，控制查询关联对象的时候是否采用延迟
- ture：默认值，查询关联对象的时候，采用延迟加载
- false：查询关联对象的时候，不再用延迟加载
- extra：极其懒惰。
many-to-one上的fetch和lazy_rec
fetch：抓取策略，控制SQL语句格式
- select：默认值，发送普通selec语句，查询关联对象
- join：发送一条迫切左外连接查询关联对象
lazy:延迟加载，控制查询关联对象的时候是否采用延迟
- proxy：默认值，具体的取值，取决于另一端< class >上的lazy的值
- false：查询关联对象，不采用延迟
- no-proxy（基本不使用）