hibernate 抓取策略（优化）

最新推荐文章于 2020-08-04 13:38:27 发布

bruobuqi

最新推荐文章于 2020-08-04 13:38:27 发布

阅读量312

点赞数

分类专栏： hibernate

本文链接：https://blog.csdn.net/bruobuqi/article/details/78980182

版权

hibernate 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.1 检索方式

l 立即检索：立即查询，在执行查询语句时，立即查询所有的数据。

l 延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

1.2 检查策略

l 类级别检索：当前的类的属性获取是否需要延迟。

l 关联级别的检索：当前类关联另一个类是否需要延迟。

1.1 类级别检索

l get：立即检索。get方法一执行，立即查询所有字段的数据。

l load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询。 Customer.hbm.xml <class lazy="true | false">

lazy 默认值true，表示延迟检索，如果设置false表示立即检索。

代码：

@Test
public void  TestDemo1(){
    Session session=   HibernateUtils.openSession();
    Transaction transaction=  session.beginTransaction();
  //  Customer customer=(Customer) session.get(Customer.class,5);
    Customer customer=(Customer) session.load(Customer.class,5);
    System.out.println(customer.getCid());
    System.out.println(customer.getCname());
    System.out.println(customer.getOrderSet());//所谓懒加载是因为是否加载关联对象
    transaction.commit();
    session.close();
}

结果：

2.1 关联级别检索

2.1.1 一对多或多对多

l 容器<set> 提供两个属性：fetch、lazy

fetch：确定使用sql格式

lazy：关联对象是否延迟。

l fetch：join、select、subselect

join：底层使用迫切左外连接

select：使用多个select语句（默认值）

subselect：使用子查询

l lazy：false、true、extra

false：立即

true：延迟（默认值）

extra：极其懒惰

------------------------------------------

2.1.1.1 fetch="join"

l fetch="join" ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

代码：

Session session=   HibernateUtils.openSession();
Transaction transaction=  session.beginTransaction();
//  Customer customer=(Customer) session.get(Customer.class,5);
Customer customer=(Customer) session.load(Customer.class,5);
System.out.println(customer.getCid());
System.out.println(customer.getCname());
System.out.println(customer.getOrderSet().toString());
transaction.commit();
session.close();

结果：

Hibernate: select customer0_.id as id2_1_, customer0_.name as name2_1_, orderset1_.cid as cid2_3_, orderset1_.id as id3_, orderset1_.id as id1_0_, orderset1_.price as price1_0_, orderset1_.cid as cid1_0_ from t_customer customer0_ left outer join t_order orderset1_ on customer0_.id=orderset1_.cid where customer0_.id=?//使用一条select将所有内容全部查询。
ssml002
[com.ssml.dentity.Order@57af006c, com.ssml.dentity.Order@1cbb87f3, com.ssml.dentity.Order@20f5239f]

2.1.1.2 fetch="select"

l 当前对象和关联对象使用多条select语句查询。

l lazy="false" , 立即，先查询客户select，立即查询订单select

l lazy="true",延迟，先查询客户select，需要订单时，再查询订单select

l lazy="extra"，极其懒惰（延迟），先查询客户select，如果只需要订单数，使用聚合函数（不查询详情）

代码：

@Test
public void  TestDemo2(){
    Session session=   HibernateUtils.openSession();
    Transaction transaction=  session.beginTransaction();
    //  Customer customer=(Customer) session.get(Customer.class,5);
    Customer customer=(Customer) session.load(Customer.class,5);
    System.out.println(customer.getCid());
    System.out.println(customer.getCname());
    System.out.println(customer.getOrderSet().toString());
    transaction.commit();
    session.close();
}

结果：

3.1.1.1 fetch="subselect"

l 将使用子查询。注意：必须使用Query否则看不到效果。

l lazy= 同上

代码：

//将使用子查询。注意：必须使用Query否则看不到效果。
@Test
public void  TestDemo3(){
    Session session=   HibernateUtils.openSession();
    Transaction transaction=  session.beginTransaction();
    List<Customer> list=   session.createQuery("from Customer").list();
    for (Customer c:list
         ) {
        System.out.println(c.toString());
    }
    transaction.commit();
    session.close();
}

结果：

Hibernate: select customer0_.id as id2_, customer0_.name as name2_ from t_customer customer0_
Hibernate: select orderset0_.cid as cid2_1_, orderset0_.id as id1_, orderset0_.id as id1_0_, orderset0_.price as price1_0_, orderset0_.cid as cid1_0_ from t_order orderset0_ where orderset0_.cid in (select customer0_.id from t_customer customer0_)

4.1.1 多对一

l <many-to-one fetch="" lazy=""> (<one-to-one>)

l fetch取值：join、select

join：底层使用迫切左外连接

select：多条select语句

l lazy取值：false、proxy、no-proxy

false：立即

proxy：采用关联对象类级别检索的策略。

订单关联客户（多对一）

订单立即获得客户，需要在客户Customer.hbm.xml <class lazy="false">

订单延迟获得客户，需要在客户Customer.hbm.xml <class lazy="true">

4.1.2.1 fetch="join"

l fecth="join" select语句使用左外连接，此时lazy无效。

结果：

Hibernate: select order0_.id as id1_1_, order0_.price as price1_1_, order0_.cid as cid1_1_, customer1_.id as id2_0_, customer1_.name as name2_0_ from t_order order0_ left outer join t_customer customer1_ on order0_.cid=customer1_.id where order0_.id=?

4.1.3.1 fetch="select"

l 将采用多条select语句，lazy="proxy"是否延迟，取决关联对象类级别检索策略。

结果：

Hibernate: select order0_.id as id1_0_, order0_.price as price1_0_, order0_.cid as cid1_0_ from t_order order0_ where order0_.id=?
Hibernate: select customer0_.id as id2_0_, customer0_.name as name2_0_ from t_customer customer0_ where customer0_.id=?