java web hibernate自学三

查询方式

1. OID查询

   根据对象的OID主键检索。

   session.get(Customer.class,1L)
   session.load(Customer.class,1L)
   

2. 对象导航检索

   根据一个已经查询到的对象，获得关联的对象的一种查询

   A a = session.get(A,1L)
   B b = a.getB()
   

3. HQL检索

   通过session.createQuery()接受一个HQL查询方式

   • 简单查询

     Query query = session.createQuery("from Customer")
     List<Customer> list = query.list()
     

   • 排序查询

     • 默认是升序

     Query query = session.createQuery("from Customer orderby 属性名")
     Query query = session.createQuery("from Customer orderby 属性名 desc")
     

   • 条件查询

     1. 按位置绑定
     Query query = session.createQuery("from Custoer where name=?0");
     query.setParameter(0,"jack")
     
     Query query = session.createQuery("from Custoer where name=?0 and age=?1");
     query.setParameter(0,"wells")
     query.setParameter(0,32)
     
     2. 按名称绑定
     Query query = session.createQuery("from Custoer where name=:aaa and company like:bbb);
     query.setParameter("aaa":"jack")
     query.setParameter("bbbb":"杭州%")
     

   • 投影查询

     Query query = session.createQuery("select c.name from Customer c where name=:aaa and company like:bbb);
     
     查询多个属性封装到对下个闹钟功能
     1.类中要新建一个构造方法，参数自定
     2.session.createQuery("select new Customer(自定义属性1,自定义属性2)")
     

   • 分页查询

     Query query = session.createQuery("from Custoer where name=?0");
     query.setFirstResult(0);
     query.setMaxResults(10);
     

   • 分组统计查询

     聚合函数
     Query query = session.createQuery("select count(*) from Customer");
     
     分组统计
     Query query = session.createQuery("select count(*) from Customer" group by name);
     

   4. 多表查询

      • 交叉连接

        select * from A,B
        

      • 内连接 : inner join (inner 可以省略)

        • 隐式内连接

          select * A,B where A.id = B.aid
          

        • 显示内连接

          select * from A join B on A.id=B.aid
          HQL: session.createQuery("from Customer c inner join c.link") 直接inner join 关联的字段
          迫切内连接:inner join fetch，把连接对象的数据装到Customer的集合里
          

      • 外连接

        • 左外连接

          select * from A left outer join B on A.id = B.aid
          

          左边表的可以全部查询和右边表的公共部分

        • 右外连接

          right outer join
          

          右边表的全部和左边表的公共部分

4. QBC检索

   • 简单查询

             Session session = HibernateUtils.getCurrentSession();
             Transaction tx = session.beginTransaction();
     
             CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
             CriteriaQuery<Customer> query = criteriaBuilder.createQuery(Customer.class);
             query.from(Customer.class);
             List<Customer> resultList = session.createQuery(query).getResultList();
             for (Customer customer : resultList) {
                 System.out.println(customer);
             }
     
             tx.commit();
     

   • 排序查询

             Root<Customer> root = query.from(Customer.class);
             query.orderBy(criteriaBuilder.asc(root.get("id")));
     

   • 分页查询

     	@Test
         public void test05() {
         	//1. 获取CriteriaQuery对象
             CriteriaQuery<Emp> criteria = criteriaBuilder.createQuery(Emp.class);
             //2. 指定根条件
             Root<Emp> empRoot = criteria.from(Emp.class);
             //3. 设置orderBy的字段
             criteria.orderBy(criteriaBuilder.desc(empRoot.get("sal")));
     		//4. 设置分页的基本属性
             int pageSize = 3;
             int pageNow = 2;
             int pageIndex = (pageNow - 1) * pageSize;
     		//5. 执行查询，这里需要指定查询的起始索引和查询的记录数量
             List<Emp> list = session.createQuery(criteria).setFirstResult(pageIndex).setMaxResults(pageSize).list();
             //6. 打印查询结果
             for (Emp emp : list) {
                 System.out.println(emp.getEmp_id() + " " + emp.getSal());
             }
         }
     

   • 条件查询

     	@Test
     	// 查询部门号为2，且薪水大于2000.00的所有雇员，或者job是CLERK的雇员
         public void test03(){
             CriteriaQuery<Emp> criteria = criteriaBuilder.createQuery(Emp.class);
             Root<Emp> root = criteria.from(Emp.class);
             //创建两个条件
             Predicate dept = criteriaBuilder.equal(root.get("dept"), new Dept(2, null, null));
             Predicate sal = criteriaBuilder.gt(root.get("sal"), 2000.00);
             Predicate job = criteriaBuilder.equal(root.get("job"), "CLERK");
             //到这里上面部分都与上一个案例类似
             //注意在将多个条件且或嵌套时，可以使用or/and方法嵌套的方式进行
             criteria.where(criteriaBuilder.or(criteriaBuilder.and(dept, sal), job));
     
             List<Emp> list = session.createQuery(criteria).getResultList();
             for (Emp emp : list) {
                 System.out.println("name = " + emp.getEname() + "		sal = " + emp.getSal() +
                         "		dept_id = " + emp.getDept().getDept_id() +
                         "		job = " + emp.getJob());
             }
         }
     

5. SQL检索

   SQLQuery sqlQuery = session.createSQLQuery("select * from 数据库表名")
   sqlQuery.addEntity(A.class) // 会将查询到的关联数据封装到A类中
   

6. 离线条件查询（需要google最新的）

   DetachedCriteria dc = DetachedCriterai.forClass(Customer.class)
   dc.add(Restrictions.eq()) // 设置条件
   service.query(dc)
   

Hibernate抓取策略

• 懒加载

  • 类级别的延迟加载

    session.load(Customer.class,1L)
    1. 可以靠持久化类映射文件中class标签 lazy属性控制，lazy=false关闭懒加载
    2. 可以把持久化类用final修饰
    

  • 关联级别的延迟加载

    Customer customer = session.get(Customer.class,1L)
    customer.getLinkmans() 通过客户获得联系人的时候，联系人对象是否采用了延迟加载,可以在关联的set标签上配置lazy,成为关联级别的延迟
    

• 上的fetch和lazy

  • Fetch:抓取策略，控制sql语句格式
    • select：默认值，发送普通的select语句，查询关联对象
    • join：发送一条迫切左外连接查询关联对象
    • subselect ：发送一条子查询查询其关联对象
  • Lazy:延迟加载

• 和set的配置结果效果一致，默认值为查询关联对象且为懒加载。