网站推广公司渠道,电子政务网站建设背景,西安网站建设新闻,北京哪家做网站优化Spring循环依赖问题 什么是循环依赖问题示例项目结构项目代码运行结果 Async注解导致的问题使用Lazy注解解决Async注解导致的问题开启Aop使用代理对象示例项目结构项目代码运行结果 Spring是如何解决循环依赖问题的原理源码解读 什么情况下Spring无法解决循环依赖问题 什么是循… Spring循环依赖问题 什么是循环依赖问题示例项目结构项目代码运行结果 Async注解导致的问题使用Lazy注解解决Async注解导致的问题开启Aop使用代理对象示例项目结构项目代码运行结果 Spring是如何解决循环依赖问题的原理源码解读 什么情况下Spring无法解决循环依赖问题 什么是循环依赖问题
多个bean之间相互依赖形成了一个闭环。 比如A依赖于B、B依赖于C、C依赖于A
通常来说如果问Spring容器内部如何解决循环依赖问题一定是指默认的单例Bean中属性相互引用的场景。也就是说Spring的循环依赖是Spring容器注入时出现的问题。
示例
项目结构 项目代码
pom.xml
?xml version1.0 encodingUTF-8?
project xmlnshttp://maven.apache.org/POM/4.0.0xmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsdmodelVersion4.0.0/modelVersiongroupIdcom/groupIdartifactIdspring-circular-dependency/artifactIdversion1.0-SNAPSHOT/versionpropertiesmaven.compiler.source8/maven.compiler.sourcemaven.compiler.target8/maven.compiler.target/propertiesdependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-core/artifactIdversion5.2.1.RELEASE/version/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-beans/artifactIdversion5.2.1.RELEASE/version/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion5.2.1.RELEASE/version/dependencydependencygroupIdorg.aspectj/groupIdartifactIdaspectjrt/artifactIdversion1.8.9/version/dependencydependencygroupIdorg.apache.geronimo.bundles/groupIdartifactIdaspectjweaver/artifactIdversion1.6.8_2/version/dependency/dependencies/projectBean01.java
package com.spring.bean;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;/*** author honey* date 2023-08-23 17:50:53*/
Component
public class Bean01 {Autowiredprivate Bean02 bean02;
}Bean02.java
package com.spring.bean;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;/*** author honey* date 2023-08-23 17:52:55*/
Component
public class Bean02 {Autowiredprivate Bean01 bean01;
}SpringConfig01.java
package com.spring.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** author honey* date 2023-08-23 17:59:37*/
Configuration
ComponentScan(value {com.spring.bean})
public class SpringConfig01 {
}SpringTest01.java
package com.spring.test;import com.spring.bean.Bean01;
import com.spring.bean.Bean02;
import com.spring.config.SpringConfig01;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;/*** author honey* date 2023-08-23 18:00:24*/
public class SpringTest01 {public static void main(String[] args) {AnnotationConfigApplicationContext applicationContext new AnnotationConfigApplicationContext(SpringConfig01.class);Bean01 bean01 applicationContext.getBean(bean01, Bean01.class);Bean02 bean02 applicationContext.getBean(bean02, Bean02.class);System.out.println(bean01);System.out.println(bean02);}
}运行结果 Spring默认情况下已经解决了循环依赖问题单例Bean Async注解导致的问题
在SpringConfig01类上加上EnableAsync注解 在Bean01类中使用Async注解修饰的异步方法 Bean01.java
package com.spring.bean;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;/*** author honey* date 2023-08-23 17:50:53*/
Component
public class Bean01 {Autowiredprivate Bean02 bean02;Asyncpublic void test() {System.out.println(Thread.currentThread().getName() Bean01测试中...);}
}运行结果 C:\Program Files\Java\jdk1.8.0_191\bin\java.exe -javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar57456:C:\Program Files\JetBrains\IntelliJ IDEA 2021.1.1\bin -Dfile.encodingUTF-8 -classpath C:\Program Files\Java\jdk1.8.0_191\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\rt.jar;E:\知识点资料第四年\Spring源码解读\代码\spring-circular-dependency\target\classes;D:\maven_jar\org\springframework\spring-core\5.2.1.RELEASE\spring-core-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-jcl\5.2.1.RELEASE\spring-jcl-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-beans\5.2.1.RELEASE\spring-beans-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-context\5.2.1.RELEASE\spring-context-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-aop\5.2.1.RELEASE\spring-aop-5.2.1.RELEASE.jar;D:\maven_jar\org\springframework\spring-expression\5.2.1.RELEASE\spring-expression-5.2.1.RELEASE.jar;D:\maven_jar\org\aspectj\aspectjrt\1.8.9\aspectjrt-1.8.9.jar;D:\maven_jar\org\apache\geronimo\bundles\aspectjweaver\1.6.8_2\aspectjweaver-1.6.8_2.jar com.spring.test.SpringTest01
八月 23, 2023 7:07:05 下午 org.springframework.context.support.AbstractApplicationContext refresh
警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name bean01: Bean with name bean01 has been injected into other beans [bean02] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using getBeanNamesOfType with the allowEagerInit flag turned off, for example.
Exception in thread main org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name bean01: Bean with name bean01 has been injected into other beans [bean02] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using getBeanNamesOfType with the allowEagerInit flag turned off, for example.at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:624)at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:517)at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:323)at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:321)at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:879)at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:878)at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:550)at org.springframework.context.annotation.AnnotationConfigApplicationContext.init(AnnotationConfigApplicationContext.java:89)at com.spring.test.SpringTest01.main(SpringTest01.java:15)Process finished with exit code 1Spring在扫描bean发现某个类方法被Async修饰时会通过后置处理器AsyncAnnotationBeanPostProcessor生成代理对象而该后置处理器的顺序比处理AOP的后置处理器还靠后因此会导致Spring处理不了循环依赖。 使用Lazy注解解决Async注解导致的问题
在Bean01类中循环依赖的属性上使用Lazy注解 运行结果 开启Aop使用代理对象示例
项目结构 项目代码
AspectAop.java
package com.spring.aop;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;/*** author honey* date 2023-08-23 18:26:33*/
Component
Aspect
public class AspectAop {Pointcut(execution (* com.spring.bean.*.*(..)))public void pointcut() {}Around(value pointcut())public Object doAround(ProceedingJoinPoint point) throws Throwable {System.out.println(doAround advice start);Object result point.proceed();System.out.println(doAround advice end);return result;}
}需要在Bean01和Bean02中加上一个普通方法如 package com.spring.bean;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;/*** author honey* date 2023-08-23 17:52:55*/
Component
public class Bean02 {Autowiredprivate Bean01 bean01;public void add() {}
}SpringConfig01.java
package com.spring.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;/*** author honey* date 2023-08-23 17:59:37*/
Configuration
ComponentScan(value {com.spring.bean, com.spring.aop})
EnableAspectJAutoProxy
public class SpringConfig01 {
}运行结果 Spring是如何解决循环依赖问题的
Spring底层通过三级缓存解决了循环依赖问题。
一级缓存singletonObjects也叫作单例池存放已经经历了完整生命周期的Bean对象
/** Cache of singleton objects: bean name to bean instance. */
private final MapString, Object singletonObjects new ConcurrentHashMap(256);二级缓存earlySingletonObjects存放早期暴露出来的Bean对象Bean的生命周期未结束属性还未填充完整
/** Cache of early singleton objects: bean name to bean instance. */
private final MapString, Object earlySingletonObjects new HashMap(16);三级缓存singletonFactories存放可以生成Bean的工厂
/** Cache of singleton factories: bean name to ObjectFactory. */
private final MapString, ObjectFactory? singletonFactories new HashMap(16);原理
假设有两个对象分别是A和B其中A依赖于BB依赖于A
在创建A对象时需要B对象于是将A对象存入三级缓存再去创建B对象在创建B对象时发现需要A对象于是先查一级缓存没有再查二级缓存还是没有再查三级缓存找到了A对象然后把三级缓存里面的A对象存入二级缓存并删除三级缓存里面的A对象B对象创建完成将B对象存入一级缓存此时B对象依赖的A对象依然是创建中状态获取到B对象后回来接着创建A对象直到创建完成并将A对象存入一级缓存中如果其它对象依赖于A对象和B对象可以直接从一级缓存里面获取
源码解读 在创建A对象时A对象完成实例化后会将A对象封装成ObjectFactory存入三级缓存。 AbstractBeanFactory.java AbstractAutowireCapableBeanFactory.java ObjectFactory.java 如果该对象是单例对象且开启了循环依赖且该对象正在创建中则会将该对象封装成ObjectFactory对象存入三级缓存。其中ObjectFactory是一个函数接口在调用getObject()方法时才会真正去执行lambda语句调用getEarlyBeanReference()方法。 // Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure (mbd.isSingleton() this.allowCircularReferences isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace(Eagerly caching bean beanName to allow for resolving potential circular references);}addSingletonFactory(beanName, () - getEarlyBeanReference(beanName, mbd, bean));
}DefaultSingletonBeanRegistry.java 在为A对象设置属性时发现A对象依赖于B对象则会去尝试获取B对象由于此时B对象还未被创建所以B对象也会走和A对象一样的创建逻辑不同的是在为B对象设置属性时发现B对象依赖于A对象可以从三级缓存中获取得到A对象。 AbstractBeanFactory.java DefaultSingletonBeanRegistry.java 此时存入二级缓存的是不完整对象调用singletonFactory.getObject()方法实际上是在调用getEarlyBeanReference(beanName, mbd, bean)方法。 如果是正常情况下返回原始对象
InstantiationAwareBeanPostProcessorAdapter.java 如果是开启了Aop的情况下返回Aop代理对象
AbstractAutoProxyCreator.java 将获取到的A对象设置为B对象的属性并执行完B对象的完整生命周期后将B对象存入一级缓存中并从二级缓存、三级缓存中移除。此处也使用了ObjectFactory这个函数接口。 AbstractBeanFactory.java DefaultSingletonBeanRegistry.java 获取得到B对象后接着执行A对象的生命周期执行完成后和B对象一样存入一级缓存中。 什么情况下Spring无法解决循环依赖问题
构造器注入的循环依赖问题非单例对象的循环依赖问题
