菜单

hibernate延迟加载org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.javakc.hibernate.onetomany.entity.DeptEntity.emp, could not initialize proxy – no Session

2019年3月12日 - 金沙编程资讯

 

 结果:

设置lazy=”false”,当然在非常的境况下,大家不可能不要吊销延迟加载的时候,我们就把lazy=”false”,就能够了

dao层代码:

public Object get(Class clazz,Serializable id){
           Object result= HibernateUtils.currentSession().load(clazz, id);
           return result;
    }

filter层代码:

public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {            
        Session session = null;
        Transaction tx = null;
        try {

            session = HibernateUtils.currentSession();
            System.out.println("filter\t"+session.hashCode());        
            tx = session.beginTransaction();                        
            // 执行请求处理链    双向过滤
            chain.doFilter(request, response);
            // 返回响应时,提交事务
            tx.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            // 关闭session
            HibernateUtils.closeSession();
        }
    }

public static void main(String[] args) {
 
  DeptEntity dept = getDept(“402882e762ae888d0162ae888e420000”);

 

代码:

biz层代码:

HibernateDao dao=new HibernateDao();
    public Object get(Class clazz,Serializable id){
           Object obj= dao.get(clazz, id);return obj;
    }

Exception in thread “main” org.hibernate.LazyInitializationException:
failed to lazily initialize a collection of role:
com.javakc.hibernate.onetomany.entity.DeptEntity.emp, could not
initialize proxy – no Session
at
org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:566)
at
org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:186)
at
org.hibernate.collection.internal.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:545)
at
org.hibernate.collection.internal.AbstractPersistentCollection.read(AbstractPersistentCollection.java:124)
at
org.hibernate.collection.internal.PersistentSet.toString(PersistentSet.java:326)
at java.lang.String.valueOf(String.java:2827)
at java.io.PrintStream.println(PrintStream.java:771)
at
com.javakc.hibernate.onetomany.action.TestAction.main(TestAction.java:74)

User实体类

测试代码一:

Hibernnate延迟加载策略(这么详细你还看不懂),hibernnate延迟

漫长没有认真写过博客了,后天就完美的写一篇吧!!!!!!!!!

当Hibernate
从数据库中加载某些对象(例如:Dept对象)时,假使还要自动加载全体的关系的有些对象(例如:Emp对象),而先后实际上然而要求拜访Dept对象,那么这么些关系的Emp对象就白白浪费了不少内部存款和储蓄器空间。爆发那种场地包车型大巴缘由是:正是当时加载的难题。

1.怎么是及时加载呢?

Hibernate 查询 Dept
对象时,立刻加载并加载与之提到的Emp对象,那种查询策略称为 立时加载。

眼看加载存在两大不足:

1.select 语句的数目太多,须求频仍地拜会数据库,会潜移默化查询质量。

2.在应用程序只须求拜访Dept对象时,而不要求访问Emp对象的地方,加载Emp对象完全是剩下的操作,那一个剩余的Emp对象就白白的浪费了众多内部存款和储蓄器空间。

 

那就是说大家无法不要缓解那么些题材,所以就要谈到了“延迟加载”的学问了,延迟加载策略能幸免加载应用程序不须求拜访的涉嫌对象,以优化查询品质。

可是大家要领悟有二种查询策略,接下去大家就一路来分析每一个查询策略的加载难点。

首先种:类级别的询问策略

金沙娱乐平台 1

类级别可选的加载策略包括立刻加载和延缓加载,暗中认可是延迟加载,假若,<class>成分的lazy的性质为true,表示选取延迟加载;要是lazy
属性 为 false,表示选用当下加载。

我们明日以代码来表达是最好的方法。

1.立马加载策略

我们在Dept.hbm.xml文件中 加 lazy=“false”  属性,即可。

金沙娱乐平台 2

表结构:

 金沙娱乐平台 3

测试代码:

    Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称"+dept.getdName());

        System.out.println("===================");

        Dept dept2 = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称"+dept2.getdName());

        session.getTransaction().commit();

        HibernateUtil.closeSessio();

测试结果:

 金沙娱乐平台 4

我们了然使用Load方法加载的是代理对象,只会在质量里保存一个OID,可是一旦在Dept映射文件中安顿了类级其他lazy为false就表示加载该目的时立即加载,也正是立时寻找3次数据库,发出了一条sql语句。

2.延迟加载

类级别的私下认可加载策略便是延迟加载。在在Dept.hbm.xml文件中
,以下三种方法都意味延迟加载策略。

 金沙娱乐平台 5

或是

 金沙娱乐平台 6

假设程序加载1个持久化对象的目标是为了访问它的属性,这是大家得以应用即时加载,但是借使程序加载一个持久化对象的指标是为了取得它的引用,那是大家得以采用延迟加载,无须访问Dept对象的天性。

看例子:

   

   Dept dept = (Dept)session.load(Dept.class, 1);

        System.out.println("部门名称"+dept.getdName());

        Employee emp=new Employee();

        emp.setEname("李四");

        emp.setDept(dept);

        session.save(emp);

 

这段代码向数据库保存了 多少个Employee
对象,它与已经存在的二个Dept持久化对象关系。尽管在Dept 类级别
选用延迟加载,则 session.load()方法不会执行访问DEPT 表的select
语句,只回去一个Dept的代办对象,它的deptNo的属性值为1,其他属性都为NULL。session.save()方法执行的sql语句:

 金沙娱乐平台 7

之所以当,<class>元素的lazy属性为true时,会潜移默化session.load()方法的种种运维时作为。举例表达:

1.假设加载的Dept对象在数据库中不设有时,不会抛出特别,只有运营dept.getxxx()时,才会抛出11分。

测试代码:

    Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 3);

        System.out.println("部门名称"+dept.getdName());

        Employee emp=new Employee();

        emp.setEname("李四");

        emp.setDept(dept);

        session.save(emp);

 

当 deptNo为3不存在时,会抛出以下分外:

 金沙娱乐平台 8

2.万一在在整个Session范围内,应用程序没有访问过的Dept对象,那么Dept代理类的实例向来不会被初阶化,Hibernater
不会进行其它的select语句。以下代码试图在闭馆Session后走访的Dept游离对象:

测试代码:

Session session = HibernateUtil.currentSession();

        session.beginTransaction();

        Dept dept = (Dept)session.load(Dept.class, 3);

        HibernateUtil.closeSessio();

        System.out.println("部门名称"+dept.getdName());

        session.getTransaction().commit();

        HibernateUtil.closeSessio();

 

从代码中大家得以见见,session被提前关闭,所以dept引用的Dept代理类的实例在Session范围内始终未曾被起始化,所以当执行到
 System.out.println(“部门名称”+dept.getdName())时,会抛出以下万分:

金沙娱乐平台 9

 

 

综上说述,Dept代理类的实例唯有在当下的Session范围内才能被伊始化。

js55金沙娱乐,3.import
org.hibernate.Initialized()静态方法,用于在Session范围内显式开头化代理类实例,isInitialized()方法用于判断代理类实例是或不是曾经被发轫化。

代码:

Dept dept = (Dept)session.load(Dept.class, 1);

if(!Hibernate.isInitialized(dept)){

Hibernate.initialize(dept);

HibernateUtil.closeSessio();

System.out.println("部门名称"+dept.getdName());

}

 

以上代码在Session范围内经过Hibernate
类的Initialized()方法显式开端化了Dept代理类实例,因此关门Session关闭后,能够健康访问Dept的游离对象。

4.当主次访问代理类实例的getDeptNo()方法时,不会触发Hibernate 开端化
代理类实例的一举一动。例如:

代码:

Dept dept = (Dept)session.load(Dept.class, 1);

      System.out.println("编号:"+ dept.getDeptNo());

HibernateUtil.closeSessio();

System.out.println("部门名称"+dept.getdName());

 

当程序访问dept.getDeptNo()方法时,该情势间接回到Dept代理类的实例OID值,无须查询数据库。由于变量dept始终引用的是尚未初叶化的Dept代理类的实例,因而当Session关闭后再实施dept.getdName()方法,会抛出以下格外。

 金沙娱乐平台 10

可是值得大家注意的是:不管Dept.hbm.xml文件的<class>成分的属性是true依旧false,Session
的get方法及Query对象的list方法在Dept类级别总是采用即时加载策略。举例表达:

金沙娱乐平台,1.Session的get方法总是马上到数据库中询问Dept查询对象,假如在数据库中不存在对应的数额,就会回去NULL,例如:

代码:

 

Session session = HibernateUtil.currentSession();
        session.beginTransaction();
        Dept dept = (Dept)session.get(Dept.class, 3);
        System.out.println(dept);

 

结果:

金沙娱乐平台 11

 

想来,get方法永远不会实施Dept的代理类实例。

2.Query的list方法总是马上到数据库中询问Dept对象

 

代码:

List<Dept> query = session.createQuery("from Dept").list();
        for (Dept dept : query) {
            System.out.println(dept.getdName());
        }

结果:

金沙娱乐平台 12

 

到了此间,算是把第三体系级别的查询策略写的大半了。

第两种:一对多和多对一提到的询问策略

金沙娱乐平台 13

丰盛1个小知识点:

01.一对多依旧多对多搜索策略由lazy和fetch共同分明

 

02.fetch取值

    Join:热切    Lazy:决定涉及对象初步化时机

左外连接

    Select:多条简单SQL(默许值)

    Subselect:子查询

03.fetch和lazy组合

  解析:fetch=”join” lazy会被忽视,殷切左外连接的当下寻找

        Fetch=”s    Fetch:决定SQL语句营造情势

elect” lazy=”false”  多条简单SQL立时寻找

        Fetch=”select” lazy=”true”  多条语句延迟检索

        Fetch=”select” lazy=”extra”  多条语句及其懒惰检索

        Fetch=”subselect” lazy=”false”  子查询马上寻找

        Fetch=”subselect” lazy=”true”  子查询延迟检索

        Fetch=”subselect” lazy=”extra”  子查询及其懒惰检索

Extra:及其懒惰,唯有访问集合对象的性午时才会加载,访问集合自个儿的属性时(例如,集合大小,生成count),不会即时加载。

专注:query的list()会忽略映射文件配置的左外连接查询,fetch,此时lazy属性重新生效。

 

 

在炫耀文件中,用<SET>成分来布局一对多关系及多对一涉嫌关系的加载策略。Dept.hbm.xml文件中的一下代码用于配置Dept和Employee类的一对多涉及关系:

  <!-- 双向     cascade:级联     inverse:反转 -->
           <!--set表明Dept类的emps属性为set集合类型  -->
           <!--order-by 对集合排序  order-by="dName asc   order-by="dName desc-->
           <set name="emps" inverse="true" lazy="true">
           <!--employee表的外键 deptNo  -->
           <key column="deptNo"></key>
           <!--一对多    class 属性设定与所关联的持久化类 为employee -->
           <one-to-many class="Employee"/>
           </set>

 

此地的<set>成分有lazy属性,首要取决于emps集合被开端化的空子,到底是在加载Dept对象时就被开头化,照旧在先后访问emps集合时被开始化。

1.应声加载

Dept.hbm.xml的布置文件:

金沙娱乐平台 14

测试代码:

        Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

结果:执行Session的get方法时,对于Dept对象选用类级其他即时加载策略,对于Dept对象的emps集合(Dept关联全部的employee对象),选拔一对多涉及的立即加载策略。

金沙娱乐平台 15

 

 从这几个结果大家得以看看,Hibernate加载了三个Dept对象和Employee对象,然则大家领悟许多情况下,不须求访问Employee对象,所以我们就得用了
延迟加载策略。

2.延迟加载

对此<set>元素,应该先行考虑采用的默许延迟加载策略。

金沙娱乐平台 16

 

测试代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

结果:

金沙娱乐平台 17

很明朗,只进行了一条sql语句,即单独加载了Dept对象。

Session的get方法,再次回到的是Dept对象的emps属性引用3个不曾被开首化的聚众代理类实例。换句话说,此时的emps集合中绝非存扬弃何Emp对象,惟有emps集合代理类实例被起首化时,才再次回到数据库查询全体与Dept关联的Emp对象。

测试代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        System.out.println(dept.getdName());

        for (Employee emp : dept.getEmps()) {
            System.out.println(emp.getEname());
        }

结果:

金沙娱乐平台 18

 

那就是说,Dept对象的emps属性引用的集结代理类实例曾几何时被开首化呢?首要包涵以下二种意况:

01.当应用程序第2次访问它时,如调用
iterator(),size(),isEmpty(),或是 contains()方法时:

代码:

    Dept dept = (Dept)session.get(Dept.class, 1);
        Set<Employee> emp=dept.getEmps();
        System.out.println(dept.getdName());

        Iterator<Employee> itee=emp.iterator();//emps被初始化

02.通过hibernate的静态方法initialize()来开头化它。

    Dept dept = (Dept)session.get(Dept.class, 1);
        Set<Employee> emp=dept.getEmps();
        System.out.println(dept.getdName());
        Hibernate.initialize(emp);//emps被初始化

3.抓实延迟加载

lazy=”extra”

布局如下:

 金沙娱乐平台 19

提升延迟加载策略能更进一步延迟Dept对象的emps集合代理类实例初阶化时机。当应用程序第②次访问emps属性的iterator()时,会导致emps集合代理类的实例开始化。可是当当应用程序第二遍size(),isEmpty(),或是
contains()方法时,emps不会开头化emps集合代理实例。仅仅经过询问select语句须要音信。

测试代码:

Dept dept = (Dept)session.get(Dept.class, 1);
//不会发轫化emps集合代理类实例
int size = dept.getEmps().size();
System.out.println(size);

//会起首化emps集合代理类实例
Iterator<Employee> iterator = dept.getEmps().iterator();
System.out.println(iterator);

结果:

金沙娱乐平台 20

未来是第两种:多对一涉及的查询策略

lazy=proxy

 Employee.hbm.xml中但自个儿计划:

金沙娱乐平台 21

1.延缓加载策略。

测试代码:

Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句
        Dept dept = em.getDept();
        System.out.println(dept.getdName());//执行Dept对象

当Sesson执行get()方法时,仅仅霎时执行查询Employee对象的select语句。当Employee
对象引用Dept代理类实例,这几个代理类实例的IOD由Employee
表的DeptNo外键值决定。 当执行dept.getdName()时,hibernate
开头化Dept代理类实例,执行以下select语句到数据库中加载Dept对象。

结果:

金沙娱乐平台 22

 

无代理延迟加载:

lazy=”no-proxy” 

金沙娱乐平台 23

测试代码:

        Employee em=(Employee) session.get(Employee.class, 21);//仅仅执行em对象的sql语句
        Dept dept = em.getDept();
        System.out.println(dept.getdName());//执行Dept对象

假诺Employee对象的dept属性使用无代理延迟加载,即<many-to-many>成分的lazy属性为no-proxy,当执行
get方法时,加载的Employee的dept属性为NULL,当执行到  em.getDept()时,将触发hibernate执行查询Dept
表的select 语句,从而加载Dept对象。

结果:

金沙娱乐平台 24

有鉴于此,当lazy为proxy 时,能够延长延迟加载
Dept对象的时辰,而当lazy属性为no-proxy时,则可避防止使用由hibernate
提供的Dept代理类实例,使用hibernate 对先后 提供更为透明的持久化服务。

眼看加载:

lazy=“false”

金沙娱乐平台 25

测试:

    Employee em=(Employee) session.get(Employee.class, 21);

结果:

金沙娱乐平台 26

能够看来,执行了两条sql语句。 

Open Session In View 模式9

Open Session In View 情势的效应:

 Hibernate
允许对关系对象、属性实行延期加载,不过必须确定保障延迟加载的操作限于同一个Hibernate Session 范围以内进行。借使 Service层重返二个启用了延期加载效用的领域对象给 Web 层,当 Web
层访问到这么些急需延期加载的数码时,由于加载领域对象的 Hibernate Session
已经关门,这么些导致延迟加载数据的拜会卓殊。

在Java Web 应用中,平日需求调用ibernate API
获取到显示的某部要彰显的某部对象并传给相应但的视图JSP,
并在JSP中从那么些目的导航到与之提到的目的或集合数据。那么些关乎对象或集合数据如若是被推移加载的,hibernate
就会抛出以下万分:

金沙娱乐平台 27

那是因为在调用完hibernate完未来,Session
对象已经关闭了。针对这几个题材,hibernate 社区提供了Open Session In View
情势 的化解方案!!

代码示例:

private static DeptEntity getDept(String did){
  Session session = sessionFactory.openSession();
  DeptEntity dept = (DeptEntity)session.get(DeptEntity.class, did);
  session.close();
  return dept;
}

 

测试代码:

HibernateUtil代码

 private static final ThreadLocal<Session> sessionTL=new ThreadLocal<Session>();
//私有的静态的配置对象
 private static Configuration configuration;
//私有的静态的工厂对象
 private final static SessionFactory sessionFactory;
 //静态代码块,负责给成员变量赋值
 static{
     configuration=new Configuration().configure();
     sessionFactory=configuration.buildSessionFactory();
 }
 //从SessionFactory  连接池            获取一个和当前thread bind session
 public static Session currentSession(){
    //2.返回当前的线程其对应的线程内部变量

      //sessionTL的get()方法根据最近线程重临其相应的线程内部变量,

   
 //也正是我们须要的Session,二十八线程情状下共享数据库连接是不安全的。

       //ThreadLocal保障了各类线程都有温馨的Session.

     Session session=sessionTL.get();
     //如果当前线程是session 为空=null ,则打开一个新的Session
     if(session==null){
         //创建一个session对象
         session=sessionFactory.openSession();
         //保存该Sessioon对象到ThreadLocal中
         sessionTL.set(session);     
     } 
     return session;
 }
 //关闭Session
 public  static void closeSessio(){
     Session session=sessionTL.get();
     sessionTL.set(null);
     session.close();

 }

运维结果:

  1. org.hibernate.service.spi.ServiceException: Unable to create requested service [org.hibernate.engine.spi.CacheImplementor]  
  2.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.createService(AbstractServiceRegistryImpl.java:186)  
  3.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:150)  
  4.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:131)  
  5.     at org.hibernate.internal.SessionFactoryImpl.<init>(SessionFactoryImpl.java:264)  
  6.     at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1790)  
  7.     at com.test.pojo.UserTest.beforeClass(UserTest.java:28)  
  8.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
  9.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
  10.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
  11.     at java.lang.reflect.Method.invoke(Method.java:597)  
  12.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:45)  
  13.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)  
  14.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:42)  
  15.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:27)  
  16.     at org.junit.runners.ParentRunner.run(ParentRunner.java:300)  
  17.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)  
  18.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  19.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)  
  20.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)  
  21.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)  
  22.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)  
  23. Caused by: org.hibernate.cache.NoCacheRegionFactoryAvailableException: Second-level cache is used in the application, but property hibernate.cache.region.factory_class is not given, please either disable second level cache or set correct region factory class name to property hibernate.cache.region.factory_class (and make sure the second level cache provider, hibernate-infinispan, for example, is available in the classpath).  
  24.     at org.hibernate.cache.internal.NoCachingRegionFactory.buildTimestampsRegion(NoCachingRegionFactory.java:87)  
  25.     at org.hibernate.cache.spi.UpdateTimestampsCache.<init>(UpdateTimestampsCache.java:62)  
  26.     at org.hibernate.internal.CacheImpl.<init>(CacheImpl.java:72)  
  27.     at org.hibernate.engine.spi.CacheInitiator.initiateService(CacheInitiator.java:40)  
  28.     at org.hibernate.engine.spi.CacheInitiator.initiateService(CacheInitiator.java:35)  
  29.     at org.hibernate.service.internal.SessionFactoryServiceRegistryImpl.initiateService(SessionFactoryServiceRegistryImpl.java:91)  
  30.     at org.hibernate.service.internal.AbstractServiceRegistryImpl.createService(AbstractServiceRegistryImpl.java:176)  
  31.     … 20 more  

/**
 *
 * @author XHW
 *
 * @date 2011-7-18
 *
 */
public class HibernateTest {
 public static void main(String[] args) {
  new HibernateTest().update();
 }
 public void update(){
  Session
session=HibernateSessionFactoryUtil.getSessionFactory().getCurrentSession();
  session.beginTransaction();
  Category category=(Category)session.get(Category.class, 1);
  System.out.println(“id:”+category.getId()+” 
,name:”+category.getName()+”,
description:”+category.getDescription());
  
  Set<Product> products=category.getProducts();
  for(Product product:products){
   System.out.println(“ID:  “+product.getId()+” 
name:”+product.getName()+” price: “+product.getPrice());
  }  
  session.getTransaction().commit();  
 }
 
 
}

过滤器在网站xml中的配置:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <display-name></display-name>    
 <!-- 过滤器 -->
 <filter>
   <filter-name>openSessionInView</filter-name>
   <filter-class>cn.happy.filter.OpenSessionInViewFilter</filter-class>
 </filter>
 <filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
 </filter-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

index.jsp页面包车型地铁代码:

<body>
    <%
          HibernateBiz biz=new HibernateBiz();
        Emp emp=(Emp)biz.get(Emp.class,1);
      %>
     <%=emp.getEmpName() %>
  </body>

那一个代码只是3个事例而已,你能够写别样的代码。那样便是成功了Open
Session In View 形式。

再总括一次:

有关No Session的这一个难题,有了八种的缓解方案:

方案一
在biz层 把load 改成get
方案二
/* if (!Hibernate.isInitialized(obj)) {
Hibernate.initialize(obj);
}*/
方案 三 :在 映射文件中 ,类级别 <set> 中加上 lazy =“false”
方案四: 在biz 层 先用一道 要求的UI使用 到的属性 ,然后在biz关闭
方案五:把实体类 改成 用 final 修饰,大家知晓,延迟加载的原因是 内存中
有代理对象 (其实是emp 类的子类),所以当大家设为 该类 不能够 有子类

方案六:Open Session In View 模式。

在下边都早就用代码做例子了,够清楚了的。

好久没有认真写过博客了,昨日就美丽的写一篇吧!!!!!!!!! 当
H…

}

转载:

log4j:WARN No appenders could be found for logger
(org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    select
        category0_.id as id1_0_,
        category0_.name as name1_0_,
        category0_.description as descript3_1_0_
    from
        users.category category0_
    where
        category0_.id=?
id:1  ,name:java,
description:java好啊

会师延迟加载初叶化战败,无法初始化1个代理。便是汇集在非一对一对象关系中,为了省去能源是暗许延迟加载,而get方法又是非延迟加载,所以在实施完3遍数据库查询后就实施session.close();关闭了session,而集合是延迟加载,在使用集合时再加载,此时session已经关闭,所以得不到代办。消除措施:能够在主表的hbm配置文件中,在<set>标签里设置lazy=”false”,集合就不推迟加载了,由此在实践get方法时,集合也博得到了,就不会并发延迟加载难题了。

  1. <?xml version=”1.0″ encoding=”UTF-8″?>  
  2. <ehcache xmlns:xsi=””  
  3.     xsi:noNamespaceSchemaLocation=””  
  4.     updateCheck=”false”>  
  5.     <!–  
  6.         name:cache唯一标识   
  7.         eternal:缓存是或不是永久有效   
  8.         maxElementsInMemory:内部存款和储蓄器中最大缓存对象数  
  9.         overflowToDisk(true,false):缓存对象达到最大数后,将缓存写到硬盘中  
  10.         diskPersistent:硬盘持久化  
  11.         timeToIdleSeconds:缓存清除时间   
  12.         timeToLiveSeconds:缓存存活时间  
  13.         memoryStoreEvictionPolicy:缓存清空策略  
  14.         1.FIFO:first in first out 先讲先出  
  15.         2.LFU: Less Frequently Used 平素以来最少被采纳的  
  16.         3.LRU:Least Recently Used  方今至少使用的  
  17.     –>  
  18.     <defaultCache maxElementsInMemory=”1000″ eternal=”false”  
  19.         timeToIdleSeconds=”120″ timeToLiveSeconds=”120″ overflowToDisk=”true” />  
  20.     <cache name=”userCache” eternal=”false” maxElementsInMemory=”1000″  
  21.         overflowToDisk=”false” diskPersistent=”false” timeToIdleSeconds=”3600″  
  22.         timeToLiveSeconds=”3600″ memoryStoreEvictionPolicy=”LFU” />  
  23. </ehcache>  

log4j:WARN No appenders could be found for logger
(org.hibernate.cfg.Environment).
log4j:WARN Please initialize the log4j system properly.
Hibernate:
    select
        category0_.id as id1_0_,
        category0_.name as name1_0_,
        category0_.description as descript3_1_0_
    from
        users.category category0_
    where
        category0_.id=?
Hibernate:
    select
        products0_.category_id as category2_1_,
        products0_.id as id1_,
        products0_.id as id0_0_,
        products0_.category_id as category2_0_0_,
        products0_.name as name0_0_,
        products0_.price as price0_0_,
        products0_.descripton as descripton0_0_
    from
        users.product products0_
    where
        products0_.category_id=?
id:1  ,name:java, description:java好啊
和测试代码一的运作结果互相相比较,大家会意识,本次运转结果用了两条select语句。不过大家会发觉

 

注:hibernate
4.2.5版本ehcache缓存不重视commons-logging-1.1.1.jar,须求的是slf4j-api-1.6.1.jar

运维作效果果:

  //dept.getEmp()得到子表的记录集合
  System.out.println(dept.getEmp());

 说是hibernate.cache.region.factory_class属性没有配备,推测官方文书档案里从未把质量改过来。。。

代码:

品类协会如下
 
金沙娱乐平台 28
 

测试代码二:

  1. <property name=”hibernate.cache.region.factory_class”>org.hibernate.cache.ehcache.EhCacheRegionFactory</property>  

/**
 *
 */
package com.b510.examples;

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图