Hibernate3入门之第四章Hibernate的检索方式

Hibernate的检索方式

Hibernate的检索方式:

检索方式:查询的方式:

• 导航对象图检索方式 ：根据已经加载的对象导航到其他对象

  Customer customer = (Customer)session.get(Customer.class,1);//得到用户的实例化对象
  customer.getOrders();// 获得到客户的订单
  

• OID 检索方式 ：按照对象的 OID 来检索对象

  Customer customer1 = (Customer) session.get(Customer.class, 1);//得到OID为1的实例化对象
  

• HQL 检索方式 ：使用面向对象的HQL查询语言

  Query query = session.createQuery("HQL");
  

• QBC 检索方式 ：使用 QBC(Query By Criteria) API 来检索对象. 这种 API 封装了基于字符串形式的查询语句, 提供了更加面向对象的查询接口

  Criteria criteria = session.createCriteria(Customer.class);//获得Criteria对象
  

• **本地 SQL 检索方式：**使用本地数据库的SQL查询语句

  QLQuery query = session.createSQLQuery("SQL");
  

• 表的实体对象

  Customer.java

  	private Integer cid;
  	private String cname;
  	private Set<Order> orders = new HashSet<>();
  

  Order.java

  	private Integer oid;
  	private String addr;
  	private Customer customer;
  

HQL

特点：

1. 面向对象的查询
2. 支持方法链编程

使用：

1. 创建Query接口

• 查询所有记录

  	Session session = Hibernate3Utils.openSession();
  	Transaction ts = session.beginTransaction();
  	
  	// 使用HQL查询所有客户信息
  		List<Customer> list = session.createQuery("from Customer").list();
  		for (Customer customer : list) {
  			System.out.println(customer);
  		}
  
  	ts.commit();
  

• 查询使用别名

  // 1.使用别名  别名as可以省略	
  // List<Customer> list = session.createQuery("from Customer as c").list();
  
  // 2.使用别名带参数
  List<Customer> list = 
  session.createQuery("from Customer as c where c.cname=? ").setString(0,"小明").list();
  
  // 3.不支持带* select * from Customer写法.可以写成 select 别名 from Customer as 别名;
  List<Customer> list = session.createQuery("select c from  Customer c").list();
  
  

• 多态检索

  //配置映射里所有继承自该类的都可得到
  List<Object> list = session.createQuery("from java.lang.Object").list();
  

• 排序（按照Order的oid进行排序）

  //from 表名 别名 order by 别名.字段 desc
  List<Order> list = session.createQuery("from Order c order by c.oid desc").list();
  

• 分页查询

  	Query query = session.createQuery("from Order");
      query.setFirstResult(0);//任意值开始（小于最大数）
      query.setMaxResults(10);//每页的最大数量
  

• 检索单个对象

  //取出cname为青雉的Customer对象
  Customer customer = (Customer) session.createCriteria(Customer.class).add(Restrictions.eq("cname", "青雉"))
  				.uniqueResult();
  

• 参数绑定

  // HQL单个参数绑定（setParameter或者根据属性的类型使用setInteger/setString等）
  	Customer customer = (Customer) session.createQuery("from Customer where cname = ?").setParameter(0, "青雉").uniqueResult();
  
  // HQL多个参数绑定
  	Customer customer = (Customer) session.createQuery("from Customer where cname = ? and  cid = ?").setParameter(0, "青雉").setParameter(1, 3).uniqueResult();
  
  // 使用名称绑定
  	List<Customer> list = session.createQuery("from Customer where cname =:name and cid = :id").setString("name", "青雉").setInteger("id", 3).list();
  
  // 绑定实体 使用对象作为参数(查询订单所属的客户)
  	Customer customer = (Customer) session.get(Customer.class, 1);
  	List<Order> list = session.createQuery("from  Order o  where o.customer = ?").setEntity(0, customer).list();
  

• 投影操作

  // 1。只查询名称的
  	List<Object> list = session.createQuery("select c.cname from Customer c").list();
  
  // 2.查询名称和id
  	List<Object[]> list = session.createQuery("select c.cid,c.cname  from Customer c").list();
  
  // 3.将查询到的几个属性也包装到对象中（Customer的id和name）
  // 在Customer类中提供id和name属性的构造函数同时提供无参的构造
  	List<Customer> customers = session.createQuery("select new Customer(cid,cname) from Customer").list();
  

• 模糊查询

  // HQL的模糊查询
  	Customer customer = (Customer) session.createQuery("from Customer c  where c.cname like ?").setParameter(0, "青%").uniqueResult();
  

QBC

• 查询所有

  	Session session = Hibernate3Utils.openSession();
  	Transaction ts = session.beginTransaction();
  	
  	// 使用HBC查询所有客户信息
      List<Customer> list = session.createCriteria(Customer.class).list();
      for (Customer customer : list) {
          System.out.println(customer);
      }
  
      ts.commit();
  

• 排序

  	//addOrder()方法
  	List<Order> list = session.createCriteria(Order.class).addOrder(org.hibernate.criterion.Order.asc("oid"))
  				.list();
  

• 分页

      // QBC进行分页:
      Criteria criteria = session.createCriteria(Order.class);
      criteria.setFirstResult(0);//任意值开始（小于最大数）
      criteria.setMaxResults(10);//每页的最大数量
      List<Order> list = criteria.list();
  

• 检索单个对象

  	// QBC查询（查询出cname为青雉的Customer对象）
      Customer customer = (Customer) session.createCriteria(Customer.class).add(Restrictions.eq("cname", "青雉"))
              .uniqueResult();
  

• 条件查询

      // 查询出cname为红发的Customer对象
      // Customer customer = (Customer)
      // session.createCriteria(Customer.class).add(Restrictions.eq("cname", "红发"))
      // .uniqueResult();
      // System.out.println(customer);
      
      // 查询出cid小于等于2的Customer对象
      List<Customer> customers = session.createCriteria(Customer.class).add(Restrictions.le("cid", 2)).list();
  

• 模糊查询

  		List<Customer> customers = session.createCriteria(Customer.class).add(Restrictions.like("cname", "%发")).list();
  		for (Customer customer : customers) {
  			System.out.println(customer);
  		}
  

SQL

• 查询所有

  	Session session = Hibernate3Utils.openSession();
  	Transaction ts = session.beginTransaction();
  	
  	// 使用SQL查询所有用户信息
      // List<Object[]> list = session.createSQLQuery("select * from
      // customer").list();
      // for (Object[] objects : list) {
      // System.out.println(Arrays.toString(objects));
      // }
  
      // 使用SQL查询所有用户信息,并将记录封装到实体中（addEntity方法）
      List<Customer> list = session.createSQLQuery("select * from customer").addEntity(Customer.class).list();
      for (Customer customer : list) {
          System.out.println(customer);
      }
  
      ts.commit();
  

多表查询

• SQL多表查询:

  * 连接:
      * 交叉连接:
     	 	* select * from A,B;
      * 内连接:查询的是两个表的交集!
      	* select * from A inner join B on A.字段 = B.字段;
      	* 隐式内连接:
     			 * select * from A,B where A.字段 = B.字段;
      * 外连接:
      	* 左外连接:
     			 * select * from A left outer join B on  A.字段 = B.字段;
      	* 右外连接:
     			 * select * from A right outer join B on A.字段 = B.字段;
  

• HQL多表的查询:

  * 连接:
      * 交叉连接:
      * 内连接:
      * 隐式内连接:
      * 迫切内连接:
      * 左外连接:
      * 迫切左外连接:
      * 右外连接:
  
      * HQL的内连接和迫切内连接区别:
     		 * 内连接查询 :将数据封装一个List<Object[]>中.
     		 * 迫切内连接 :将数据封装一个List<Customer>中.但是迫切内连接,得到会有重复记录 ,需要使用distinct排重.
  

• 多表查询: 关于内连接和迫切内连接的区别

  ​ 1、内连接是将数据封装到数组中，迫切内连接是将数据封装到对象中
  ​ 2、存在的一个问题就是迫切内连接在封装数据的时候会存在很多重复的值
  ​ 3、原因：每次都将订单重复封装到客户中，相当于一个客户装了十次订单（并不是我们想要的）
  ​ 4、我们想要一个客户在订单中直接封装上十个订单distinct去重

  Session session = Hibernate3Utils.openSession();
  		Transaction ts = session.beginTransaction();
  		// 内连接查询（是两个表的交集部分）
  		// Query query = session.createQuery("from Customer c inner join c.orders");
  		// List<Object[]> list = query.list();
  		// for (Object[] objects : list) {
  		// System.out.println(Arrays.toString(objects));
  		// }
  		// 迫切内连接查询：使用关键字fetch（HQL）
  		List<Customer> list = session.createQuery("select distinct c from Customer c inner join fetch c.orders").list();
  		for (Customer customer : list) {// 一个客户十个订单（三行数据）
  			System.out.println(customer);
  		}
  		ts.commit();
  

• 聚合函数的查询

  Long count = (Long) session.createQuery("select count(*) from Order").uniqueResult();
  System.out.println(count);
  

• 命名查询

  在Customer.hbm.xml文件中配置

  <query name="findAll">	
      	from Customer 
  </query>
  

  在接下来就可以直接使用“findAll”来代替“from Customer ”

  List<Customer> list = session.getNamedQuery("findAll").list();
  

• 离线的条件查询

  针对于在web层数据的封装，解决不能很好的携带数据

  // 从web层获取数据封装然后通过service传递到DAO层
  		DetachedCriteria criteria = DetachedCriteria.forClass(Customer.class);
  		criteria.add(Restrictions.eq("cname", "小明"));
  		criteria.add(Restrictions.eq("cid", 2));
  		
  // 传递到DAO层获取数据
  		Session session = HibernateUtils.openSession();
  		Transaction tx = session.beginTransaction();
  		
  		Criteria c1 = criteria.getExecutableCriteria(session);
  		List<Customer> list = c1.list();
  		
  		System.out.println(list);
  		tx.commit();
  		session.close();
  

Restrictions、Order、Projections的常用方法

Restrictions类的常用方法（设置查询条件）

返回值类型	方法名称	描述
SimpleExpression	Restrictions.eq	等于（equal）
Criterion	Restrictions.allEq	使用Map,Key/Valu进行多个等于的比对
SimpleExpression	Restrictions.gt	大于（great than）
SimpleExpression	Restrictions.ge	大于等于（great than or equal）
SimpleExpression	Restrictions.lt	小于（less than）
SimpleExpression	Restrictions.le	小于等于（less than or equal）
Criterion	Restrictions.between	对应SQL的between
SimpleExpression	Restrictions.like	对应SQL的like
Criterion	Restrictions.in	对应SQL的in
LogicalExpression	Restrictions.and	and关系
LogicalExpression	Restrictions.or	or关系
Criterion	Restrictions.isNull	为空
Criterion	Restrictions.sqlRestriction	SQL限定查询

Order类的常用方法（设置排序方式）

返回值类型	方法名称	描述
Order	Order.asc	升序
Order	Order.desc	降序

Projections类的常用方法（统计和分组）

返回值类型	方法名称	描述
AggregateProjection	Projections.avg	求平均值
CountProjection	Projections.count	统计某属性的数量
CountProjection	Projections.countDistinct	统计某属性不同值的数量
PropertyProjection	Projections.groupProperty	指定某个属性为分组属性
AggregateProjection	Projections.max	求最大值
AggregateProjection	Projections.min	求最小值
ProjectionList	Projections.projectionList	创建一个ProjectionList对象
Projection	Projections.rowCount	查询结果集中的记录条数
AggregateProjection	Projections.sum	求某属性的合计