2021-07-08-spring 为啥使用三级代理

Posted 2023-04-25

参考技术A 1. 三级缓存解决循环依赖问题的关键是什么？为什么通过提前暴露对象能解决？

实例化和初始化分开，在中间过程中给其他对象赋值的时候，并不是一个完整对象，而是把半成品对象赋值给了其他对象。

2. 如果只是用一级缓存能否解决循环依赖问题？

不能。在整个处理过程中，缓存中放的是半成品和成品对象，如果只有一级缓存，那么成品和半成品都会放到一级缓存中，有可能在获取过程中获取到半成品对象，此时半成品对象是无法使用的，不能直接进行相关的处理，因此要把半成品和成品的存放空间分割开来。

3. 只使用二级缓存行不行？为什么需要三级缓存？

如果我能保证所有的bean对象都不去调用getEarlyBeanReference此方式，使用二级缓存可以么？是的，如果保证所有bean对象都不调用此方法，就可以只使用二级缓存。

使用三级缓存的本质在于解决aop代理问题！！！

4. 如果某个bean对象为代理对象，那么会不会创建普通的bean对象？

会，必须会。

5. 为什么使用了三级缓存就可以解决这个问题？

当一个对象需要被代理的时候，在整个创建过程中是包含两个对象吧。一个是普通对象，一个是代理生成的对象，bean默认都是单例，那么我在整个生命周期的处理环节中，一个beanName能对应两个对象吗？不能，既然不能的话，保证我在使用的时候加一层判断，判断一下是否需要进行代理的处理。

6. 我怎么知道你什么时候使用呢？

因为不知道什么时候会调用，所以通过一个匿名内部类的方式，在使用的时候直接对普通对象进行覆盖操作，保证全局唯一！！！

spring的循环依赖及使用三级缓存解决循环依赖；注入bean到spring容器中

循环依赖

循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。

Spring中循环依赖场景有：
（1）构造器的循环依赖
（2）field属性的循环依赖。

spring对循环依赖的解决（三级缓存）

Spring的循环依赖的理论依据其实是基于Java的引用传递，当我们获取到对象的引用时，对象的field或则属性是可以延后设置的(但是构造器必须是在获取引用之前)。

Spring的单例对象的初始化主要分为三步：

1. createBeanInstance：实例化，其实也就是调用对象的构造方法实例化对象
2. populateBean：填充属性，这一步主要是多bean的依赖属性进行填充
3. initializeBean：调用spring xml中的init 方法。

循环依赖主要发生在第一、第二部。也就是构造器循环依赖和field循环依赖；

对于单例来说，在Spring容器整个生命周期内，有且只有一个对象，所以很容易想到这个对象应该存在Cache中，Spring为了解决单例的循环依赖问题，使用了三级缓存。

这三级缓存分别指：
singletonFactories ： 单例对象工厂的cache
earlySingletonObjects ：提前暴光的单例对象的Cache
singletonObjects：单例对象的cache

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

三级缓存顺序
spring三级缓存不能解决构造器的循环依赖

创建中的对象提前曝光到三级缓存中，发生在bean创建之后还没被依赖注入；
文字流程：
A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步，并且将自己提前曝光到singletonFactories中，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存singletonFactories，由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全，但是总比没有好呀)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象完成了初始化。

看完就知道因为加入singletonFactories三级缓存的前提是执行了构造器，所以构造器的循环依赖没法解决。

参考了大佬的博文
https://blog.csdn.net/u010853261/article/details/77940767

注入bean到spring容器中

1-@Bean@Service等注解
2-手动注册

2-1 通过GenericBeanDefinition注册

public static void main(String[] args) {
        DefaultListableBeanFactory context =
                new DefaultListableBeanFactory();

        //在此构造bean定义
        GenericBeanDefinition gbd = new GenericBeanDefinition();
        //Message要被注入的class
        gbd.setBeanClass(Message.class);

        //设置属性注入
        MutablePropertyValues mpv = new MutablePropertyValues();
        //message属性名
        mpv.add("message", "this is a bean");

        //注册到环境上下文
        context.registerBeanDefinition("myBean", gbd);

        Message bean = context.getBean(Message.class);
        bean.print();
        Message myBean = (Message) context.getBean("myBean");
        myBean.print();
    }
	

2-2 通过BeanDefinitionBuilder注册和GenericBeanDefinition差不多的

public static void main(String[] args) {
        DefaultListableBeanFactory context =
                new DefaultListableBeanFactory();

        //用到了构建者模式
        BeanDefinitionBuilder b =
                BeanDefinitionBuilder.rootBeanDefinition(Message.class)
                        .addPropertyValue("message", "this is a bean");

        context.registerBeanDefinition("myBean", b.getBeanDefinition());

        Message bean = context.getBean(Message.class);
        bean.print();
        Message myBean = (Message) context.getBean("myBean");
        myBean.print();
    }

2-3 通过BeanFactoryPostProcessor

public class MessageBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

	@Override
	public void postProcessBeanFactory(
			ConfigurableListableBeanFactory beanFactory) throws BeansException {
		// TODO Auto-generated method stub
		GenericBeanDefinition gbd = new GenericBeanDefinition();
		gbd.setBeanClass(Message.class);

		MutablePropertyValues mpv = new MutablePropertyValues();
		mpv.add("message", "this is a BeanFactoryPostProcessor bean");
		gbd.setPropertyValues(mpv);

		((DefaultListableBeanFactory) beanFactory).registerBeanDefinition(
				"myBean", gbd);
	}
}

2-4 通过BeanDefinitionRegistryPostProcessor

public class MessageBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor  {

	@Override
	public void postProcessBeanFactory(
			ConfigurableListableBeanFactory beanFactory) throws BeansException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void postProcessBeanDefinitionRegistry(
			BeanDefinitionRegistry registry) throws BeansException {
		// TODO Auto-generated method stub
		GenericBeanDefinition gbd = new GenericBeanDefinition();
		gbd.setBeanClass(Message.class);

		MutablePropertyValues mpv = new MutablePropertyValues();
		mpv.add("message", "this is a BeanDefinitionRegistryPostProcessor bean");
		gbd.setPropertyValues(mpv);

		registry.registerBeanDefinition(
				"myBean", gbd);
	}
}

2-5 BeanFactoryAware

@Component
public class LocationRegister implements BeanFactoryAware {
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        DefaultListableBeanFactory listableBeanFactory = (DefaultListableBeanFactory) beanFactory;
　　　　  //方式1　Location location = new Location();　　　
        // 　listableBeanFactory.registerSingleton(Location.class.getName(),location);　　　　
        //方式2　　　　BeanDefinition locationBeanDefinition = new RootBeanDefinition(Location.class);　　　　
        // listableBeanFactory.registerBeanDefinition(Location.class.getName(),locationBeanDefinition);
    }
}

参考了大佬的博文
https://www.cnblogs.com/dongguangming/p/12792789.html