hibernate加载策略之lazy

蔚落 2022-06-12 11:26 474阅读 0赞

hibernate的加载策略有两种：

1）即时加载：get加载

  1.   使用get加载数据，会立即查找，先到缓存中找，找不到再去数据库中找。

2）延迟加载（也叫懒加载lazy）：laod加载

  1.   不会立即查找，当需要的时候才会查找。
  3.   容易造成异常：org.hibernate.LazyInitializationException: could not initialize proxy - no Session

at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:165)
at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:286)
at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:185)
at com.myeclipse.pojo.Book__jvstdc3_0.getName(Book__jvstdc3_0.java)
at com.ghibernate.test.HibernateTest.testLoad(HibernateTest.java:106)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.runners.BlockJUnit4ClassRunner.runNotIgnored(BlockJUnit4ClassRunner.java:79)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:71)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197) 

  1.     如果出现上面这个异常，大部分是因为session被关闭了，还要从session中取数据造成的。

但是懒加载也有优势：那就是效率高，因为

3）class的lazy

  1.   class默认情况下是支持懒加载的（在\*.hbm.xml中的class中有一个属性lazy=“true”），所以在load方法时，是懒加载，但是当我们把lazy=“false”时，就不支持懒加载了，这是即使是使用load方法，也会是即时加载。

Center

项目结构如下：

Center 1

jar包和hibernate官网配置参见《Hibernate环境搭建和配置》

Book实体类代码：

  1. package com.myeclipse.pojo;
  3. import java.util.Date;
  4. public class Book {
  6.     private int id;
  7.     private String author;
  8.     private String name;
  9.     private double price;
  10.     private Date pubDate;
  12.     public int getId() {
  13.         return id;
  14.     }
  15.     public void setId(int id) {
  16.         this.id = id;
  17.     }
  18.     public String getAuthor() {
  19.         return author;
  20.     }
  21.     public void setAuthor(String author) {
  22.         this.author = author;
  23.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30.     public double getPrice() {
  31.         return price;
  32.     }
  33.     public void setPrice(double price) {
  34.         this.price = price;
  35.     }
  36.     public Date getPubDate() {
  37.         return pubDate;
  38.     }
  39.     public void setPubDate(Date pubDate) {
  40.         this.pubDate = pubDate;
  41.     }
  42.     @Override
  43.     public String toString() {
  44.         return "Book [id=" + id + ", author=" + author + ", name=" + name
  45.                 + ", price=" + price + ", pubDate=" + pubDate + "]";
  46.     }
  49. }

Book.hbm.xml代码：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping package="com.myeclipse.pojo">
  7.     <class name="Book" table="t_book" lazy="false">
  8.         <id name="id">
  9.             <generator class="identity" />
  10.         </id>
  11.         <property name="author" />
  12.         <property name="name" column="book_name" />
  13.         <property name="price" />
  14.         <property name="pubDate" />
  15.     </class>
  17. </hibernate-mapping>

HibernateUtil代码： 

  1. package com.robert.util;
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
  6. import org.hibernate.cfg.Configuration;
  8. /**
  9.  * hibernate工具类
  10.  */
  11. public class HibernateUtil {
  13.     private static Configuration cfg = null;
  14.     private static SessionFactory factory = null;
  15.     private static Session session = null ;
  17.     static {
  18.         init();
  19.     }
  21.     /**
  22.      * 初始化获得Configuration和SessionFacroty对象
  23.      */
  24.     public static void init() {
  25.         cfg = new Configuration().configure();
  26.         factory = cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
  27.                 .applySettings(cfg.getProperties()).build());
  28.     }
  30.     /**
  31.      * 获得Session对象
  32.      * @return
  33.      */
  34.     public static Session getSession() {
  35.         if (factory != null){
  36.             return session = factory.openSession();
  37.         }
  40.         init();
  41.         return session = factory.openSession();
  42.     }
  44.     /**
  45.      * 关闭Session
  46.      */
  47.     public static void closeSession() {
  48.         if(session!=null && session.isOpen())
  49.             session.close();
  50.     }
  52. }

hibernate.cfg.xml代码：

  1. <!DOCTYPE hibernate-configuration PUBLIC
  2.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  3.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6. <session-factory>
  7.     <!-- 配置数据库连接信息 -->
  8.     <property name="connection.driver_class">
  9.         com.mysql.jdbc.Driver
  10.     </property>
  11.     <property name="connection.url">jdbc:mysql:///hibernate4</property>
  12.     <property name="connection.username">root</property>
  13.     <property name="connection.password">root</property>
  14.     <!-- 数据库方言 -->
  15.     <property name="hibernate.dialect">
  16.         org.hibernate.dialect.MySQL5Dialect
  17.     </property>
  18.     <!-- 是否打印sql语句 -->
  19.     <property name="show_sql">true</property>
  20.     <!-- 格式化sql语句 -->
  21.     <property name="format_sql">true</property>
  22.     <!-- 数据库更新方式： 
  23.         1、create：每次更新都先把原有数据库表删除，然后创建该表；
  24.         2、create-drop:使用create-drop时，在显示关闭SessionFacroty时（sessionFactory.close()），将drop掉数据库Schema（表） 
  25.         3、validate：检测；
  26.         4、update（常用）：如果表不存在则创建，如果存在就不创建
  27.     -->
  28.     <property name="hbm2ddl.auto">update</property>
  29.     <!-- hbm映射文件 -->
  30.     <mapping resource="com/myeclipse/pojo/Book.hbm.xml" />
  32. </session-factory>
  33. </hibernate-configuration>

HibernateTest代码：

  1. package com.ghibernate.test;
  3. import java.util.Date;
  4. import java.util.List;
  6. import org.hibernate.Query;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.hibernate.cfg.Configuration;
  10. import org.hibernate.tool.hbm2ddl.SchemaExport;
  11. import org.junit.Test;
  13. import com.myeclipse.pojo.Book;
  14. import com.robert.util.HibernateUtil;
  16. public class HibernateTest {
  18.     @Test
  19.     public void testCreateDB() {
  20.         Configuration cfg = new Configuration().configure();
  21.         SchemaExport se = new SchemaExport(cfg);
  22.         // 第一个参数：是否生成ddl脚本
  23.         // 第二个参数：是否执行到数据库中
  24.         se.create(true, true);
  25.     }
  27.     @Test
  28.     public void testSave() {
  30.         Session session = HibernateUtil.getSession();
  31.         Transaction tx = session.beginTransaction();
  33.         Book book = new Book();
  34.         book.setName("读者");
  35.         book.setPrice(5.6);
  36.         book.setAuthor("众人");
  37.         book.setPubDate(new Date());
  39.         Book book1 = new Book();
  40.         book1.setName("傲慢与偏见");
  41.         book1.setPrice(80.0);
  42.         book1.setAuthor("简.奥斯汀");
  43.         book1.setPubDate(new Date());
  45.         Book book2 = new Book();
  46.         book2.setName("中国历史");
  47.         book2.setPrice(30.0);
  48.         book2.setAuthor("人民出版社");
  49.         book2.setPubDate(new Date());
  51.         Book book3 = new Book();
  52.         book3.setName("翩眇之旅");
  53.         book3.setPrice(70.0);
  54.         book3.setAuthor("萧鼎");
  55.         book3.setPubDate(new Date());
  57.         Book book4 = new Book();
  58.         book4.setName("蓝血人");
  59.         book4.setPrice(60.0);
  60.         book4.setAuthor("卫斯理");
  61.         book4.setPubDate(new Date());
  63.         Book book5 = new Book();
  64.         book5.setName("我的大学");
  65.         book5.setPrice(60.5);
  66.         book5.setAuthor("高尔基");
  67.         book5.setPubDate(new Date());
  69.         session.save(book);
  70.         session.save(book1);
  71.         session.save(book2);
  72.         session.save(book3);
  73.         session.save(book4);
  74.         session.save(book5);
  76.         tx.commit();
  77.         HibernateUtil.closeSession();
  79.     }
  81.     @Test
  82.     public void testGet() {
  84.         Session session = HibernateUtil.getSession();
  85.         Transaction tx = session.beginTransaction();
  87.         Book book = (Book) session.get(Book.class, 1);
  88.         System.out.println("book_name=" + book.getName());
  90.         tx.commit();
  91.         HibernateUtil.closeSession();
  92.         System.out.println("book_name=" + book.getName());
  93.     }
  95.     @Test
  96.     public void testLoad() {
  98.         Session session = HibernateUtil.getSession();
  99.         Transaction tx = session.beginTransaction();
  101.         Book book = (Book) session.load(Book.class, 1);
  102.         System.out.println("book_id=" + book.getId());
  104.         tx.commit();
  105.         HibernateUtil.closeSession();
  106.         //当Book.hbm.xml中的class中的lazy参数是ture时，这里会报错，错误见博客开头
  107.         System.out.println("book_name=" + book.getName());
  109.     }
  111. }

=========================================================================

还有一种情况是get的懒加载，如下：

新建一个项目，结构如下：

Center 2

hibernate项目搭建，参见《Hibernate环境搭建和配置》

实体类Book如下：

  1. package com.myeclipse.pojo;
  3. import java.util.Date;
  4. public class Book {
  6.     private int id;
  7.     private String author;
  8.     private String name;
  9.     private double price;
  10.     private Date pubDate;
  11.     private Category category;
  13.     public int getId() {
  14.         return id;
  15.     }
  16.     public void setId(int id) {
  17.         this.id = id;
  18.     }
  19.     public String getAuthor() {
  20.         return author;
  21.     }
  22.     public void setAuthor(String author) {
  23.         this.author = author;
  24.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  31.     public double getPrice() {
  32.         return price;
  33.     }
  34.     public void setPrice(double price) {
  35.         this.price = price;
  36.     }
  37.     public Date getPubDate() {
  38.         return pubDate;
  39.     }
  40.     public void setPubDate(Date pubDate) {
  41.         this.pubDate = pubDate;
  42.     }
  43.     public Category getCategory() {
  44.         return category;
  45.     }
  46.     public void setCategory(Category category) {
  47.         this.category = category;
  48.     }
  49.     @Override
  50.     public String toString() {
  51.         return "Book [id=" + id + ", author=" + author + ", name=" + name
  52.                 + ", price=" + price + ", pubDate=" + pubDate + "]";
  53.     }
  56. }

Book.hbm.xml代码： 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  6. <hibernate-mapping package="com.myeclipse.pojo">
  7.     <class name="Book" table="t_book">
  8.         <id name="id">
  9.             <generator class="identity" />
  10.         </id>
  11.         <many-to-one name="category" class="Category" column="category_id" cascade="save-update" />
  12.         <property name="author" />
  13.         <property name="name" column="book_name" />
  14.         <property name="price" />
  15.         <property name="pubDate" />
  16.         <!-- 使用过滤器 -->
  17.         <filter name="bookFilter" condition="id=:id"></filter>
  19.     </class>
  20.     <!-- 过滤器定义 : 定义参数 -->
  21.     <filter-def name="bookFilter">
  22.         <filter-param name="id" type="integer" />
  23.     </filter-def>
  25. </hibernate-mapping>

Category实体类代码：

  1. package com.myeclipse.pojo;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. public class Category{
  8.     private int id;
  9.     private String name;
  10.     private Set<Book> books = new HashSet<Book>();
  12.     public int getId() {
  13.         return id;
  14.     }
  15.     public void setId(int id) {
  16.         this.id = id;
  17.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  24.     public Set<Book> getBooks() {
  25.         return books;
  26.     }
  27.     public void setBooks(Set<Book> books) {
  28.         this.books = books;
  29.     }
  31. }

Category.hbm.xml代码：

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  7. <hibernate-mapping package="com.myeclipse.pojo">
  8.     <class name="Category" >
  9.         <id name="id" >
  10.             <generator class="identity" />
  11.         </id>
  12.         <property name="name" />
  13.         <set name="books" inverse="true" lazy="true">
  14.             <key>
  15.                 <column name="category_id" />
  16.             </key>
  17.             <one-to-many class="Book" />
  18.         </set>
  19.     </class>
  21. </hibernate-mapping>

HIbernateUtil和hibernate.cfg.xml和上面一样。

HibernateTest代码： 

  1. package com.ghibernate.test;
  3. import java.util.Date;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. import org.hibernate.Query;
  8. import org.hibernate.Session;
  9. import org.hibernate.Transaction;
  10. import org.hibernate.cfg.Configuration;
  11. import org.hibernate.tool.hbm2ddl.SchemaExport;
  12. import org.junit.Test;
  14. import com.myeclipse.pojo.Book;
  15. import com.myeclipse.pojo.Category;
  16. import com.robert.util.HibernateUtil;
  18. public class HibernateTest {
  20.     @Test
  21.     public void testCreateDB() {
  22.         Configuration cfg = new Configuration().configure();
  23.         SchemaExport se = new SchemaExport(cfg);
  24.         // 第一个参数：是否生成ddl脚本
  25.         // 第二个参数：是否执行到数据库中
  26.         se.create(true, true);
  27.     }
  29.     @Test
  30.     public void testSave() {
  32.         Session session = HibernateUtil.getSession();
  33.         Transaction tx = session.beginTransaction();
  35.         Category category = new Category();
  36.         category.setName("文学");
  37.         Category category1 = new Category();
  38.         category1.setName("历史");
  39.         Category category2 = new Category();
  40.         category2.setName("仙侠");
  41.         Category category3 = new Category();
  42.         category3.setName("科幻");
  43.         Category category4 = new Category();
  44.         category4.setName("恐怖");
  46.         Book book = new Book();
  47.         book.setName("读者");
  48.         book.setPrice(5.6);
  49.         book.setAuthor("众人");
  50.         book.setPubDate(new Date());
  51.         book.setCategory(category);
  53.         Book book1 = new Book();
  54.         book1.setName("傲慢与偏见");
  55.         book1.setPrice(80.0);
  56.         book1.setAuthor("简.奥斯汀");
  57.         book1.setPubDate(new Date());
  58.         book1.setCategory(category1);
  60.         Book book2 = new Book();
  61.         book2.setName("中国历史");
  62.         book2.setPrice(30.0);
  63.         book2.setAuthor("人民出版社");
  64.         book2.setPubDate(new Date());
  65.         book2.setCategory(category1);
  67.         Book book3 = new Book();
  68.         book3.setName("翩眇之旅");
  69.         book3.setPrice(70.0);
  70.         book3.setAuthor("萧鼎");
  71.         book3.setPubDate(new Date());
  72.         book3.setCategory(category2);
  74.         Book book4 = new Book();
  75.         book4.setName("蓝血人");
  76.         book4.setPrice(60.0);
  77.         book4.setAuthor("卫斯理");
  78.         book4.setPubDate(new Date());
  79.         book4.setCategory(category3);
  81.         Book book5 = new Book();
  82.         book5.setName("我的大学");
  83.         book5.setPrice(60.5);
  84.         book5.setAuthor("高尔基");
  85.         book5.setPubDate(new Date());
  86.         book5.setCategory(category);
  88.         session.save(book);
  89.         session.save(book1);
  90.         session.save(book2);
  91.         session.save(book3);
  92.         session.save(book4);
  93.         session.save(book5);
  94.         session.save(category4);
  96.         tx.commit();
  97.         HibernateUtil.closeSession();
  99.     }
  101.     @Test
  102.     public void testGet() {
  104.         Session session = HibernateUtil.getSession();
  105.         Transaction tx = session.beginTransaction();
  107.         //当Category.hbm.xml中的set中的lazy属性是true（默认是true）时，先查询一端的Category，只会先查询Category数据，
  108.         //当执行下面for中的category.getBooks时才会去查询Book数据，这时就是懒加载
  109.         //但是当我们把Category.hbm.xml中的set中的lazy属性改为false时，会在查询Category的时候，把Book也查询出来，这时就是即时加载
  110.         Category category = (Category) session.get(Category.class, 1) ;
  111.         System.out.println("category_name="+category.getName());
  112.         for (Iterator<Book> iter = category.getBooks().iterator();iter.hasNext();) {
  113.             System.out.println(iter.next().getName());
  114.         }
  116.         tx.commit();
  117.         HibernateUtil.closeSession();
  119.     }
  122. }

在HibernateTest类中增加一个方法

  1. @Test
  2.     public void testLoad() {
  4.         Session session = HibernateUtil.getSession();
  5.         Transaction tx = session.beginTransaction();
  7.         Category category = (Category) session.load(Category.class, 1) ;
  8.         System.out.println("category_name="+category.getName());
  9.         System.out.println("书籍数量："+category.getBooks().size());
  11.         tx.commit();
  12.         HibernateUtil.closeSession();
  14.     }

断点运行，可以看到，执行完

Category category = (Category) session.load(Category.class, 1) ;

这句，并没有查询数据的sql语句

当执行

  1. System.out.println("category_name="+category.getName());

这句后，打印sql语句如下：

  1. Hibernate: 
  2.     select
  3.         category0_.id as id1_0_0_,
  4.         category0_.name as name2_0_0_ 
  5.     from
  6.         Category category0_ 
  7.     where
  8.         category0_.id=?
  9. category_name=文学

继续运行

  1. System.out.println("书籍数量："+category.getBooks().size());

这句后，打印sql语句

  1. Hibernate: 
  2.     select
  3.         books0_.category_id as category2_0_0_,
  4.         books0_.id as id1_1_0_,
  5.         books0_.id as id1_1_1_,
  6.         books0_.category_id as category2_1_1_,
  7.         books0_.author as author3_1_1_,
  8.         books0_.book_name as book_nam4_1_1_,
  9.         books0_.price as price5_1_1_,
  10.         books0_.pubDate as pubDate6_1_1_ 
  11.     from
  12.         t_book books0_ 
  13.     where
  14.         books0_.category_id=?
  15. 书籍数量：2

当把Category.hbm.xml中set的lazy更改为extra时，代码如下：

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
  7. <hibernate-mapping package="com.myeclipse.pojo">
  8.     <class name="Category" >
  9.         <id name="id" >
  10.             <generator class="identity" />
  11.         </id>
  12.         <property name="name" />
  13.         <set name="books" inverse="true" lazy="extra">
  14.             <key>
  15.                 <column name="category_id" />
  16.             </key>
  17.             <one-to-many class="Book" />
  18.         </set>
  19.     </class>
  21. </hibernate-mapping>

HibernateTest中的testLoad代码：

  1. @Test
  2.     public void testLoad() {
  4.         Session session = HibernateUtil.getSession();
  5.         Transaction tx = session.beginTransaction();
  7.         Category category = (Category) session.load(Category.class, 1) ;
  8.         System.out.println("category_name="+category.getName());
  9.         System.out.println("书籍数量："+category.getBooks().size());
  11.         tx.commit();
  12.         HibernateUtil.closeSession();
  14.     }

打印的sql语句如：

  1. Hibernate: 
  2.     select
  3.         category0_.id as id1_0_0_,
  4.         category0_.name as name2_0_0_ 
  5.     from
  6.         Category category0_ 
  7.     where
  8.         category0_.id=?
  9. category_name=文学
  10. Hibernate: 
  11.     select
  12.         count(id) 
  13.     from
  14.         t_book 
  15.     where
  16.         category_id =?
  17. 书籍数量：2

4）总结：

set和list默认下都是lazy=true，默认支持懒加载。但是当使用size()的时候，依然会查询整个set集合的内容。

lazy=false时，立即查询所有集合的内容。

lazy=extra时，比较智能，支持懒加载，当使用size()的时候，不会查询整个集合，仅仅查询集合中元素的个数，当需要使用集合元素的内容时，再去查询。

5）单端关联上的lazy：（many-to-one，one-to-one）,默认是支持懒加载的lazy=proxy

Center 3

6）property上的懒加载lazy，需要用到第三方增加，且大部分情况下用不到property懒加载，只有当是大对象时Blob，Clob才会用到

发表评论

表情：
评论列表 （有 0 条评论，474人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Hibernate（一） 之 延迟加载

    Hibernate延迟加载，又叫懒加载。 延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernat

    野性酷女野性酷女/ 0 赞/ 450 阅读

    相关 hibernate加载策略之lazy

    hibernate的加载策略有两种： 1）即时加载：get加载       使用get加载数据，会立即查找，先到缓存中找，找不到再去数据库中找。 2）延迟加载（

    蔚落蔚落/ 0 赞/ 475 阅读