踩坑日记（Open-Session-In-View And Hibernate LazyInitializationException，AOP 失效）

冷不防 2023-06-30 15:55 14阅读 0赞

## Hibernate 懒加载 的LazyInitializationException 的坑 ##

关于jpa的session：

> The [open session in view][] anti-pattern is enabled by default in Spring Boot(both 1.x and 2.x),where a Hibernate session is created and bound to the request(thread) at the very beginning of the request processing chain.The merit is that we can use the session to query or update database during the whole life cycle of the request(thread),including in the view layer

使用Spring data jpa 的时候

使用懒加载获取关联属性时，

若把查询放在另一个线程里去异步处理，当在主对象上获取关联对象时，会报懒加载异常，no session  
[https://blog.csdn.net/u013815546/article/details/73637759][https_blog.csdn.net_u013815546_article_details_73637759]

解决方案：  
在需要进行懒加载的前后手动获取EntityManagerFactory，再手动开启session，这是一种不太优雅的解决方案

EntityManagerFactory entityManagerFactory = applicationContext.getBean(EntityManagerFactory.class);
                EntityManager entityManager = entityManagerFactory.createEntityManager();
                EntityManagerHolder entityManagerHolder = new EntityManagerHolder(entityManager);
                TransactionSynchronizationManager.bindResource(entityManagerFactory,entityManagerHolder);
    
    //执行数据库查询
    
    TransactionSynchronizationManager.unbindResource(entityManagerFactory);
                EntityManagerFactoryUtils.closeEntityManager(entityManager);

实验发现，若在配置文件里设置

# 关闭这个东西，则会使得懒加载失效
    spring.jpa.open-in-view=false

则懒加载在任何时候都会失效，报错

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.igola.search.data.entity.TaskInfo.airwayInfoList, could not initialize proxy - no Session

默认情况这个开关是true的，这样在普通的线程里就可以正常使用懒加载，但是另起一个线程的话，就会出现LazyInitializationException的错误，必须要用上面的粗暴方式强制手动开启session

打开这个开关会在每一个request请求进来前，开辟一个session，这个session的生命周期和request的生命周期绑定，也即在这个request请求的整个链路中，都是在同一个session里。而hibernate的延迟加载，跟mybatis一样，也是通过一个代理对象去实现的。而创建这个代理对象，需要session上下文。当一个request进来时，服务器会开启一个线程去处理，request处理完毕后，这个线程也就走到了生命尽头。所以在处理这个request的过程中，去查询数据库，取出一个主对象，后在这个主对象上获取关联对象，因为open-session-in-view，此时是在一个session的上下文中，所以可以成功创建proxy，去进行关联查询，得到关联对象。而我在ScheduledThreadPool中进行的关联查询，已经不在这个request的生命周期内了，而是在另一个线程中执行的，所以这时执行的方法，不在一个session上下文中。当调用repository的find，去查询主对象，打开debug日志可以看得到，查询时开启了session，查询完毕就关闭了session，所以再查出主对象后，调用主对象的get方法去获取关联对象时，由于session已经关闭，所以无法初始化proxy，故报错LazyInitializationException。

> However, a LAZY association needs the `Session` to be opened in order to initialize the Proxy. If the Persistence Context is closed, when trying to access a non-initialized LAZY association, the infamous [`LazyInitializationException`][LazyInitializationException] is thrown.
> 
> For multiple `one-to-many` associations, to avoid a Cartesian Product, it’s necessary to use secondary queries. These secondary queries can be fired when the association is accessed for the first time, which can be done with the [`Hibernate.initialize(proxy)`][Hibernate.initialize_proxy] utility.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZjajEwMDk3ODQ4MTQ_size_16_color_FFFFFF_t_70]

>  *  The `OpenSessionInViewFilter` calls the `openSession` method of the underlying `SessionFactory` and obtains a new `Session`.
>  *  The `Session` is bound to the [`TransactionSynchronizationManager`][TransactionSynchronizationManager].
>  *  The `OpenSessionInViewFilter` calls the `doFilter` of the `javax.servlet.FilterChain` object reference and the request is further processed
>  *  The [`DispatcherServlet`][DispatcherServlet] is called, and it routes the HTTP request to the underlying `PostController`.
>  *  The `PostController` calls the `PostService` to get a list of `Post` entities.
>  *  The `PostService` opens a new transaction, and the `HibernateTransactionManager` reuses the same `Session` that was opened by the `OpenSessionInViewFilter`.
>  *  The `PostDAO` fetches the list of `Post` entities without initializing any lazy association.
>  *  The `PostService` commits the underlying transaction, but the `Session` is not closed because it was opened externally.
>  *  The `DispatcherServlet` starts rendering the UI, which, in turn, navigates the lazy associations and triggers their initialization.
>  *  The `OpenSessionInViewFilter` can close the `Session`, and the underlying database connection is released as well.

hibernate apply the lazy load behavior upon entities and associations **by providing a proxy implementation** of them

As we know that hibernate can only access the database via a session, So If an entity is detached from the session and when we try to access an association (via a proxy or collection wrapper) that has not yet been loaded, **Hibernate throws a LazyInitializationException**.

参考连接：

[Spring Open Session In View - Baeldung - ps : Very Good Blog][Spring Open Session In View - Baeldung - ps _ Very Good Blog]

[The Open Session In View Anti-Pattern][open session in view]

[Spring Boot OSIV Cause Cache Problem][]

[Spring Boot Best Practice - Disable OSIV to start receiving LazyInitializationException][]

[Best Way to handle LazyInitializationException][LazyInitializationException]

[Tutorial of Lazy Load in Hibernate][]

出于对数据库连接池资源的考虑，应尽可能的关闭OSIV

在SpringBoot里，默认开启了`spring.jpa.open-in-view = true`，OSIV 是默认开启的，这会使得在一个request的整个生命周期，都使用同一个session，这是通过*OpenSessionInViewInterceptor* 这个类来实现的，这是一个Servlet的Filter实现类

How Spring manage Hibernate Sessions ?

> By default, Spring Boot applies transaction management at the repository level. In this case, when calling a `JpaRepository` method (or in general any `Repository` method), Spring will:
> 
>  *  Ask the `SessionFactory` to create a new session
>  *  Open this session
>  *  Open a transaction
>  *  Perform the called `Repository` method
>  *  Close the transaction
>  *  Close the session
> 
> However, if you apply `@Transactional` to the service class or method, Spring will open the session and the transaction on entry to the service method, and the repository method will be performed within the existing transaction.

How Not to handle LazyInitializationException

> Unfortunately, there are also bad ways of handling the `LazyInitializationException` like:
> 
>  *  [Open Session in View][open session in view]
>  *  [hibernate.enable\_lazy\_load\_no\_trans][hibernate.enable_lazy_load_no_trans]
> 
> These two Anti-Patterns are very inefficient from a database perspective, so you should never use them in your enterprise application.

## Spring AOP 无法对方法内部调用的方法进行切面 ##

如果是直接调用类中的某个方法，则可以拦截。

若调用了类中的方法A，A中调用了方法B，如果设置对方法B的拦截，则无法完成拦截

[https://blog.csdn.net/java\_OnTheWay\_kouhao/article/details/88964857][https_blog.csdn.net_java_OnTheWay_kouhao_article_details_88964857]

[https://segmentfault.com/a/1190000008379179][https_segmentfault.com_a_1190000008379179]

**因为aop是基于接口或者是基于类创建代理,而不是基于方法创建代理**

这是由于 Spring AOP (包括动态代理和 CGLIB 的 AOP) 的限制导致的. Spring AOP 并不是扩展了一个类(目标对象), 而是使用了一个代理对象来包装目标对象, 并拦截目标对象的方法调用. 这样的实现带来的影响是: 在目标对象中调用自己类内部实现的方法时, 这些调用并不会转发到代理对象中, 甚至代理对象都不知道有此调用的存在.

比如

@Service
    public class MyService{ 
        public void external(){ 
            System.out.println("external");
            internal();
        }
        
        @Haha
        public void internal(){ 
            System.out.println("internal");
        }
    }
    
    @RestController
    public class Test{ 
        @Autowired
        private MyService service;
        
        @GetMapping("/aop")
        public String testAop(){ 
            service.external();
            return "yes";
        }
    }

如果配置对`@Haha` 进行拦截，则 访问 `/aop` 的路径，触发不了

解决方案：在MyService内部注入一个MyService变量，自己注入自己

@Service
    public class MyService{ 
        @Autowired
        private MyService self;
        //这里注入的实际是经过AOP加强的代理对象
        
        public void external(){ 
            System.out.println("external");
            self.internal();
            System.out.println(this == self);  //false
        }
        
        @Haha
        public void internal(){ 
            System.out.println("internal");
        }
    }

或者调用`AopContext.currentProxy()`得到一个当前的代理对象，注意此种方式需要配置`@EnableAspectJAutoProxy(exposeProxy = true)`

另外，如果被aop的方法是private，则会出现Autowired进来的其他repository之类的bean都为null了

[https://blog.csdn.net/h2604396739/article/details/102610610][https_blog.csdn.net_h2604396739_article_details_102610610]

另外：关于jackson的一个bug

若属性的命名为，第一个字母是小写，紧接着是大写字母

如 `iLoveYou`，在转换成Object时，属性会自动变为`iloveYou`，导致解析失败

至少是2个小写字母开头，然后接大写字母，就不会出现这种问题

或者在属性上加`@JsonPrperty("iLoveYou")`

[open session in view]: https://vladmihalcea.com/the-open-session-in-view-anti-pattern/
[https_blog.csdn.net_u013815546_article_details_73637759]: https://blog.csdn.net/u013815546/article/details/73637759
[LazyInitializationException]: https://vladmihalcea.com/the-best-way-to-handle-the-lazyinitializationexception/
[Hibernate.initialize_proxy]: https://docs.jboss.org/hibernate/orm/current/javadocs/org/hibernate/Hibernate.html#initialize-java.lang.Object-
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZjajEwMDk3ODQ4MTQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200118165534237.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZjajEwMDk3ODQ4MTQ=,size_16,color_FFFFFF,t_70
[TransactionSynchronizationManager]: http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/transaction/support/TransactionSynchronizationManager.html
[DispatcherServlet]: http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html
[Spring Open Session In View - Baeldung - ps _ Very Good Blog]: https://www.baeldung.com/spring-open-session-in-view
[Spring Boot OSIV Cause Cache Problem]: https://www.changchao.me/?p=782
[Spring Boot Best Practice - Disable OSIV to start receiving LazyInitializationException]: https://code.danielfrak.com/spring-boot-best-practice-disable-osiv-to-start-receiving-lazyinitializationexception-warnings-again/
[Tutorial of Lazy Load in Hibernate]: https://howtodoinjava.com/hibernate/lazy-loading-in-hibernate/
[hibernate.enable_lazy_load_no_trans]: https://vladmihalcea.com/the-hibernate-enable_lazy_load_no_trans-anti-pattern/
[https_blog.csdn.net_java_OnTheWay_kouhao_article_details_88964857]: https://blog.csdn.net/java_OnTheWay_kouhao/article/details/88964857
[https_segmentfault.com_a_1190000008379179]: https://segmentfault.com/a/1190000008379179
[https_blog.csdn.net_h2604396739_article_details_102610610]: https://blog.csdn.net/h2604396739/article/details/102610610