java web hibernate自学三

查询方式

OID查询

根据对象的OID主键检索。

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

对象导航检索

根据一个已经查询到的对象，获得关联的对象的一种查询
```
A a = session.get(A,1L)
B b = a.getB()
```

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);

多表查询

交叉连接
```
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
```
  右边表的全部和左边表的公共部分

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());
        }
    }

SQL检索

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

离线条件查询（需要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的配置结果效果一致，默认值为查询关联对象且为懒加载。