java之hibernate之加载策略和抓取策略

1.加载策略：指hibernate查询数据时，采用什么样的方式将数据写入内存。Hibernate中提供了两种方式来加载数据：懒加载和即时加载。

2.懒加载又称延迟加载，指使用hiberante API查询数据时，不会立即将数据写入内存。而是等到真正使用数据时才会发出sql语句，到数据中查询数据。

3.即时加载：指使用hibernate API查询数据时，会立即发出sql语句，查询数据。并将数据写入内存。

4.get方法是采用的即时加载，如果数据不存在，返回 null ,；load方法采用的懒加载，如果数据不存在，将抛出异常：ObjectNotFoundException 。

get 方法测试

　　@Test
    public void testGet(){
        Session session = HibernateUtil.getSession();
        Book book = (Book)session.get(Book.class, 1);
        System.out.println("------------------");
        System.out.println(book.getName()+"---"+book.getAuthor());
        HibernateUtil.close();
    }

load 方法测试

　　@Test
    public void testLoad(){
        Session session = HibernateUtil.getSession();
        Book book = (Book)session.load(Book.class, 8);
        System.out.println("------------------");
        System.out.println(book.getName()+"---"+book.getAuthor());
        HibernateUtil.close();
    }

5. list 方法是即时加载； iterate 是懒加载，先将要查询数据的主键查询出来，当真正使用数据时，根据 id 将数据查询出来，发出了n+1条sql语句。(1 和 n+1 问题)

list 方法测试

@Test
    public void testList(){
        Session session = HibernateUtil.getSession();
        //使用hql语句 查询所有书籍  from后写的是类名称
        List<Book> list = session.createQuery("from Book").list();
        System.out.println("------------------");
        System.out.println(list.size());
        HibernateUtil.close();
    }

Iterate 方法测试

@Test
    public void testIterate(){
        Session session = HibernateUtil.getSession();
        //使用hql语句 查询所有书籍  from后写的是类名称
        Iterator<Book> list = session.createQuery("from Book").iterate();
        System.out.println("------------------");
        while(list.hasNext()){
            Book b=list.next();
            System.out.println(b.getName()+"----"+b.getAuthor());
        }
        HibernateUtil.close();
    }

注意：上面的测试方法，是通过观察打印出来sql语句与------的位置，来判断是懒加载还是即时加载的。

6.映射文件，标签上是lazy:

class 默认是懒加载的

property 默认是即时加载的

many_to_one 默认是 proxy 采用代理实现懒加载，如果是false , 在查询book时会将关联对象立即查出。no-proxy 懒加载

@Test
    public void testManyToOne(){
        Session session = HibernateUtil.getSession();
        Book b = (Book)session.get(Book.class, 1);
        System.out.println(b.getName()+"----"+b.getAuthor());
        System.out.println("===============");
        System.out.println(b.getCategory().getName());
        HibernateUtil.close();
    }

Set集合标签上 lazy 默认是true, 采用懒加载，false 表示即时加载，extra 智能的加载方式， 根据调用不同的方法执行不同的sql 语句。如果只查询大小，那么发出的sql是select count(XX) from table;

@Test
    public void testSet(){
        Session session = HibernateUtil.getSession();
        Category c1 = (Category)session.get(Category.class, 1);
        System.out.println(c1.getBooks().size());
        System.out.println("------------------");
        for(Book b:c1.getBooks()){
            System.out.println(b.getName()+"---"+b.getAuthor());
        }
        HibernateUtil.close();
    }

注意：懒加载必须在同一个session中，session 关闭后，懒加载不起作用。

7.抓取策略：抓取策略指在管理查询时，hibernate采用什么样的sql 语句进行查询，是采用select 还是采用 join。所以典型的抓取策略是select 抓取和join 抓取：

@Test
    public void testSelect(){
        Session session = HibernateUtil.getSession();
        Book book = (Book)session.get(Book.class, 1);
        System.out.println(book.getName()+"---"+book.getAuthor()+"---"+book.getCategory().getName());
        HibernateUtil.close();
    }

结果：

Hibernate: 
    select
        book0_.id as id1_0_0_,
        book0_.name as name2_0_0_,
        book0_.author as author3_0_0_,
        book0_.price as price4_0_0_,
        book0_.pubDate as pubDate5_0_0_,
        book0_.cid as cid6_0_0_ 
    from
        t_book book0_ 
    where
        book0_.id=?
Hibernate: 
    select
        category0_.id as id1_1_0_,
        category0_.name as name2_1_0_ 
    from
        t_category category0_ 
    where
        category0_.id=?

<many-to-one name="category" column="cid" fetch="join"/>

结果

Hibernate: 
    select
        book0_.id as id1_0_0_,
        book0_.name as name2_0_0_,
        book0_.author as author3_0_0_,
        book0_.price as price4_0_0_,
        book0_.pubDate as pubDate5_0_0_,
        book0_.cid as cid6_0_0_,
        category1_.id as id1_1_1_,
        category1_.name as name2_1_1_ 
    from
        t_book book0_ 
    left outer join
        t_category category1_ 
            on book0_.cid=category1_.id 
    where
        book0_.id=?

注意：当使用join抓取时，懒加载不起作用