spring中的bean依赖有大体上可以分为两类，共3中形式，下面简单介绍一下。
第一类是构造方法中的循环依赖，这种会报错
@Service
public class ServiceA {
private ServiceB serviceB;
public ServiceA(ServiceB serviceB) {
this.serviceB = serviceB;
}
public void methodA(){
System.out.println("a");
}
}
@Service
public class ServiceB {
private ServiceA serviceA;
public ServiceB(ServiceA serviceA) {
this.serviceA = serviceA;
}
public void methodB(){
System.out.println("b");
}
}
//错误提示
Description:
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
| serviceA defined in file [C:\demo\target\classes\com\example\demo\ServiceA.class]
↑ ↓
| serviceB defined in file [C:\demo\target\classes\com\example\demo\ServiceB.class]
└─────┘
第二类是field循环依赖，它分为两种，第一类循环依赖的作用域scope默认是singleton，启动不会报错
@Service
public class ServiceA {
@Autowired
private ServiceB serviceB;
public void methodA(){
System.out.println("a");
}
}
@Service
public class ServiceB {
@Autowired
private ServiceA serviceA;
public void methodB(){
System.out.println("b");
}
}
第二种作用域scope为prototype，在这种情况下bean是多例的，按理说这种启动也会报错，但是它成功了。。我也不知道为啥
@Service
@Scope("prototype")
public class ServiceA {
@Autowired
private ServiceB serviceB;
public void methodA(){
System.out.println("a");
}
}
@Service
@Scope("prototype")
public class ServiceB {
@Autowired
private ServiceA serviceA;
public void methodB(){
System.out.println("b");
}
}
据我在网上查找的资料，spring可以帮我们处理bean的scope为singleton的field循环依赖，个人感觉应该也是这样，下面说一下它的处理过程。
简单说一下bean的加载过程，当spring启动的时候，首先加载进beanFactory的是beanDefinition，之后会根据beanDefinition判断其是否为sington并且为非抽象类非懒加载，那么之后会去创建bean，
1.调用构造方法创建对象实例(这一步完成之后其它对象实例就可以引用它)
2.填充实例内部属性(会依次从三级缓存中获取依赖的bean，如果没有找到，则会先去创建依赖的bean，之后再返回继续填充属性)
3.执行initializeBean方法，进行初始化
当bean进行创建时，会先调用getbean方法->执行doGetBean方法，在doGetBean方法中会调用getSingleton方法，这一步就是从三级缓存中获取对象缓存，因为是刚开始创建bean所以缓存中肯定没有，之后会调用createBean方法，在createBean方法中会调用doCreateBean执行bean的创建过程就是上面的那三步，当bean创建成功之后会将其放入一级缓存之中，此时会将它从三级和二级缓存中删除。
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
doGetBean(final String name, @Nullable final Class requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//从缓存中获取实例
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//省略代码
} else {
//省略代码
createBean(beanName, mbd, args);
}
//将创建完成的bean放入一级缓存
addSingleton(beanname，object)
}
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//省略代码
doCreateBean()
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
//根据构造方法创建对象实例
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
//将对象实例放入第三级缓存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
//实例内部属性填充
populateBean(beanName, mbd, instanceWrapper);
//初始化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
return exposedObject;
}
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
其中我们可以看到当第一步执行完毕后会将刚刚创建的实例放入singletonFactories(第三级缓存)中，那么我们下面了解下到底什么是spring的三级缓存。处于最上层的缓存是singletonObjects，它其中存储的对象是完成创建好，可以正常使用的bean，二级缓存叫做earlySingletonObjects，它其中存储的bean是仅执行了第一步通过构造方法实例化，并没有填充属性和初始化，第三级缓存singletonFactories是一个工场。
京公网安备 11010802041100号