hibernate查询方式

Hibernate的查询方式：

*本文代码不支持复制
*多表查询内外连接 掌握不牢固（后面补上）

---

OID 检索：

get方法： load方法：
Customer cust = session.get(Customer.class,1L);
Customer cust = session.load(Customer.class,1L);

对象的导航检索：
对象导航检索：Hibernate根据一个已经查询到的对象，获得其关联的对象的一种查询方式。
Customer cust = session.get(Customer.class,1L);
List linksMan = cust.getLinkedMan();

 LinkMan linkman = session.get(LinkedMan.class, 1L); 
 Customer cust = linkman.getCustomer();

HQL检索：
HQL查询：Hibernate Query Language，Hibernate的查询语言，是一种面向对象的方式的查询语言，语法类似SQL。通过session.createQuery()，用于接收一个HQL进行查询方式。
准备数据：

/*
	 * 准备数据：
	 */
	@Test
	public void testName() throws Exception {
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//准备数据： 保存数据的时候， 设置为级联保存
		Customer cust = new Customer();
		cust.setCust_name("毕老师");
		for (int i = 0; i < 10; i++) {
			LinkMan linkman = new LinkMan();
			linkman.setLkm_name("凤姐"+i);
			cust.getLinkMans().add(linkman);
			session.save(linkman);
		}
		
		
		//保存cust： 
		session.save(cust);
		
		tx.commit();
	}

简单查询：


别名查询：

1、定义列表名

在SELECT子句中可以使用别名来代替原来的列名。可以通过以下四种方式来定义列别名：

a、使用AS关键字，SELECT name AS 姓名 FROM student；

b、带双引号的列别名，SELECT name “姓名” FROM student；

c、带单引号的列别名，SELECT name ‘姓名’ FROM student；

d、不带引号的列别名，SELECT name 姓名 FROM student；

如果列别名包含空、特殊符号等，那么必须将列别名放在双引号或者单引号内。

2、列别名的几种使用情况

a、字段为英文，为方便查看，可以使用中文列别名代替英文字段。

b、多表查询时出现相同的列名。如果对多个数据表进行查询，查询结果中可能会出现相同的列名，很容易出现误解，这时候应采用列别名来解决上述问题。

c、在查询结果中添加列，在表中出现计算产生新的列时，可以使用列别名。

d、同级结果中出现的列，使用聚合函数语句对数据查询时，需要对产生的统计字段使用列表名。

原文：https://blog.csdn.net/strivenoend/article/details/77930861

条件查询：

排序查询：

统计查询：

	 //分组统计查询： 
	 @Test
	public void testName4() throws Exception {
		 Session session = HibernateUtils.getCurrentSession();
		 Transaction tx = session.beginTransaction();
//		 HQL的分组统计查询Z:
		 
		 //聚合函数： count(*) max() min() sum() avg(); 
		/* Object num = session.createQuery("select count(*) from Customer").uniqueResult();
		 System.out.println(num);*/
		 
		 //分组统计：统计是广告的来源的数量： 
		 List<Object[]> list = session.createQuery("select cust_source, count(*) from Customer group by cust_source").list();
		 
		 //for循环： 
		for(Object [] objects: list){
			System.out.println(Arrays.toString(objects));
		}
		 tx.commit();
    }

分页查询：

投影查询：

分组统计查询：

多表查询：

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;
右外连接:right outer join(outer 可以省略)
select * from A right outer join B on A.id = B.aid;

子查询

HQL的多表查询
连接查询

1. 交叉连接
2. 内连接

显示内连接
隐式内连接
迫切内连接

3. 外连接

左外连接
右外连接
迫切左外连接

package com.yidongxueyuan.test;

import java.util.Arrays;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.yidongxueyuan.domain.Customer;
import com.yidongxueyuan.utils.HibernateUtils;

public class HibernateHQL02 {
	/*
	 * 查询： 用户信息和用户信息关联的联系人信息：
	 * 内连接： 
	 * 99:  sql：  select * from Customer c inner join LinkenMan l on c.cust_id = l.cust_id; 
	 *      hql:  from Customer c inner join c.linkedMans 
	 */
	@Test
	public void testName() throws Exception {
		//保存操作： 
		Session session = HibernateUtils.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//使用Hibernate完成多表的内连接查询： 
//		String hql ="from Customer c inner join c.linkMans "; 
		
		/*
		 *  运行结果： 6
		 *  返回的值的类型：Object[] 
		 *  Customer表当中的数据： 封装了Customer 实体当中： 
		 * 表当中的数据， 封装了LinkMan 实体当中： 
		 *  LinkMan 
		 */
	/*	List< Object[] > list = session.createQuery(hql).list();
		
		//遍历： 
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}*/
		
		
		/*
		 * 左外连接： 
		 *  sql： 99  ： select * from Customer c left join LinkMan l on c.cust_id = l.cust_id; 
		 *  hql :     from Customer c left outer join c.linkMans  
		 *  运行的结果： Customer 表当中的记录肯定会出现在结果集当中：  
		 */
		
		/*String hql = " from Customer c left outer join c.linkMans "; 
		List<Object[] > list = session.createQuery(hql).list();
		for (Object[] objects : list) {
			System.out.println(Arrays.toString(objects));
		}
		
		tx.commit();*/
		
		
		/*
		 * 迫切内连接： 
		 *  Hql：   from Customer c inner join fetch  c.linkMans
		 *  迫切内连接： 和内连接的区别： 
		 *  相同点： 都是内连接，发送的sql 语句完全相同， 只是封装数据时候不同： 
		 *  内连接： 查询了Customer Linkman 将数据分别封装到不同的对象当中。 最终返回的是Object[] ; 
		 *  迫切内连接： 将Customer 和LinkMan 的数据都封装到了Customer对象， 最终返回的类型： List<Customer>:
		 */
		
		/*String hql = " from Customer c inner join fetch c.linkMans "; 
		List<Customer> list = session.createQuery(hql).list();
		for (Customer customer : list) {
			System.out.println(customer);
		}*/
		
	    /*
	     * 迫切左外连接： 
	     *  外链接：   from Customer c left outer join c.linkMans  
	     *  迫切左外连接：  from Customer c left join fetch c.linkMans ; 
	     *  去掉重复记录， 使用distinct关键字： 
	     *   
	     */
		String hql = " select distinct c  from Customer c left outer join fetch c.linkMans "; 
		List<Customer> list = session.createQuery(hql).list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		
		
		
		
	}
	
}

QBC检索（和上面差不多 另一套而已）
QBC查询：Query By Criteria，条件查询。是一种更加面向对象化的查询的方式。
QBC是Hibernate提供的另外一种检索对象的方式， 他主要由Criteria接口， Criterion接口和表达式组成。
Criteria是HibernateAPI提供的一个查询接口， 他是需要由Session进行创建。Criterion是Criteria的查询条件，在Criteria中提供了add(Criterion criterion)方法来添加查询条件。

1简单查询


2排序查询

3分页查询

4条件查询

.5统计查询

6离线条件查询（SSH）—DetachedCriteria
离线条件检索：
DetachedCriteria翻译为离线条件查询， 因为他是可以脱离Session来使用的一种条件查询对象，我们都知道Criteria对象必须由Session对象创建， 那么也就是说必须现有Session才能生成Criteria对象。 二DetachedCriteria对象可以在其他的层对条件进行封装。
这个对象是一个比较有用的对象， 尤其在SSH整合后这个对象会经常使用。他的主要优点就是做一些特别复杂的条件查询的时候， 往往会在业务层传递很多参数， 业务层右会将这些参数传递给DAO层， 最后在dao层进行拼接， 完成SQL的查询。有了离线条件查询对象， 那么这些工作就都不用担心了， 我们可以在web层将数据封装好， 传递到业务层， 再由业务层传递给DAO层，完成查询。