几个直击灵魂的Spring拷问。

分手后的思念是犯贱 2022-12-30 13:45 217阅读 0赞

今天这一篇主要想围绕着Spring的循环依赖问题以及终极灵魂拷问如何手写Spring的问题讲讲。  
作者：千淘萬漉  
链接：https://www.jianshu.com/p/e68df1bfbaf6

## 一、Spring循环依赖 ##

**1.什么是循环依赖**

Spring中的循环依赖一直是Spring中一个很重要的话题，一方面是因为源码中为了解决循环依赖做了很多处理，另外一方面是因为面试的时候，如果问到Spring中比较高阶的问题，那么循环依赖必定逃不掉。所以还是可以看一下这块的源码，看看Spring是如何解决循环依赖的问题的。

Spring中之所以会出现循环依赖跟Bean的生命周期有关系，在创建一个Bean的过程中如果依赖的另外一个Bean还没有创建，就会需要去创建依赖的那个Bean，而如果两个Bean相互依赖的话，就会出现循环依赖的问题。体现到代码层次就是像下面这个样子的，比如两个对象相互依赖：

@Component
    public class A {
        
        // A中注入了B
        @Autowired
        private B b;
    }
    
    @Component
    public class B {
        
        // B中也注入了A
        @Autowired
        private A a;
    }

或者自己依赖自己

@Component
    public class A {
        
        // A中注入了A
        @Autowired
        private A a;
    }

**2.三级缓存方案**

假设按照上面代码Class A 和 B，按照从A->B的顺序来实例化，Spring创建bean的过程可以分为三个阶段：

1、实例化，对应方法：AbstractAutowireCapableBeanFactory \# createBeanInstance方法  
2、属性注入，对应方法：AbstractAutowireCapableBeanFactory \# populateBean方法  
3、初始化，对应方法：AbstractAutowireCapableBeanFactory \# initializeBean

所以执行顺序是先在这个类中的 AbstractBeanFactory 按调用链执行如下三个方法：

//AbstractBeanFactory 
    1、getBean("a")
    2、doGetBean("a")
    3、getSingleton("a")

在调用getSingleton(a)方法，这个方法又会调用getSingleton(beanName, true)，所以才进入到下面这个方法：

//DefaultSingletonBeanRegistry
    public Object getSingleton(String beanName) {
        
        return getSingleton(beanName, true);
    }

**getSingleton(beanName, true)**  
这是个重点方法，该方法实际上就是到缓存中尝试去获取Bean，整个缓存分为三级  
singletonObjects，一级缓存，存储的是所有创建好了的单例Bean  
earlySingletonObjects，完成实例化，但是还未进行属性注入及初始化的对象  
singletonFactories，提前暴露的一个单例工厂，二级缓存中存储的就是从这个工厂中获取到的对象

//DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)
        protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
            //一级缓存中获取-->完整bean
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
                synchronized (this.singletonObjects) {
        
                    //二级缓存中-->获取未属性注入的bean
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null && allowEarlyReference) {
        
                        //三级缓存中-->获取工厂
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
        
                            singletonObject = singletonFactory.getObject();
                            //三级缓存中的工厂getObject的对象-->放入二级缓存中
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
            return singletonObject;
        }

因为是第一次创建，因此上面的三级缓存都未命中，此时会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)。这里我们知道 singletonFactory 是需要等待createBean(beanName, mbd, args) 方法的返回，然后作为第二个输入参数给到下面 getSingleton 方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70]

createBean 方法的返回将作为 getSingleton 的输入，然后会进入到下面这段代码中：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        
            Assert.notNull(beanName, "Bean name must not be null");
            synchronized (this.singletonObjects) {
        
                Object singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
        
                    //省略...
                    try {
        
                        //入参的lambda会提供一个singletonFactory
                        //调用createBean方法创建一个Bean后返回
                        singletonObject = singletonFactory.getObject();
                        newSingleton = true;
                    }
                    //省略...
                    if (newSingleton) {
        
                        //添加到一级缓存singletonObjects中
                        addSingleton(beanName, singletonObject);
                    }
                }
                return singletonObject;
            }
        }

上面的代码主要实现了：**将已经完全创建好了的单例Bean放入一级缓存中**。在前面一步 createBean()方法的创建实例过程中还有一个 doCreateBean 方法，里面还有这样一段代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 1]

这个也就是在Bean实例化后，属性注入之前Spring将Bean包装成一个工厂添加进了三级缓存中，addSingletonFactory 对应源码如下：

// 这里传入的参数也是一个lambda表达式，() -> getEarlyBeanReference(beanName, mbd, bean)
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
        
            if (!this.singletonObjects.containsKey(beanName)) {
        
                // 添加到三级缓存中
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

那么getEarlyBeanReference方法又做了什么呢？进入源码看下：

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;
    }

**非AOP的二级缓存**

这个地方的BeanPostProcessor后置处理器，只在处理AOP的实例对象时才会发挥作用，如果不考虑AOP，代码就是：

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        
        Object exposedObject = bean;
        return exposedObject;
    }

可见，对于非Aop实例对象，**这个工厂直接将实例化阶段创建的对象返回了**！

现在整体来梳理一下，继续走A对象创建的流程，通过this.singletonFactories.put(beanName, singletonFactory)这个方法只是添加了一个工厂，通过这个工厂（ObjectFactory）的getObject方法可以得到一个对象。

当A完成了实例化并添加进了三级缓存后，就要开始为A进行属性注入了，在注入时发现A依赖了B，那么这个时候Spring又会去getBean(b)，然后反射调用setter方法完成属性注入。

因为B需要注入A，所以在创建B的时候，又会去调用getBean(a)，这个时候就又回到之前的流程了，但是不同的是，之前的getBean是为了创建Bean，而此时再调用getBean不是为了创建了，而是要从缓存中获取，因为之前A在实例化后已经将其放入了三级缓存singletonFactories中，此时getBean(a)的二级缓存会通过调用三级缓存的facotry，通过工厂的getObject方法将对象放入到二级缓存中并返回。

所以此时getBean(a)的流程就是这样子了，一个清晰的流程图如下（非AOP的普通循环依赖）：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 2]  
**结合了AOP的循环依赖**

如果在开启AOP的情况下，那么就是调用 getEarlyBeanReference 方法对应的源码如下：

public Object getEarlyBeanReference(Object bean, String beanName) {
        
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        this.earlyProxyReferences.put(cacheKey, bean);
        // 如果需要代理，返回一个代理对象，不需要代理，直接返回当前传入的这个bean对象
        return wrapIfNecessary(bean, beanName, cacheKey);
    }

对A进行了AOP代理的话，那么此时getEarlyBeanReference将返回一个代理后的对象，而不是实例化阶段创建的对象，这样就意味着B中注入的A将是一个代理对象而不是A的实例化阶段创建后的对象。整个注入的流程图就变成了如下（AOP的循环依赖）：

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

## 3.循环依赖的总结 ##

**1、Spring到底是如何解决循环依赖的呢，这里来一波文字的总结：**

Spring通过三级缓存解决了循环依赖，其中一级缓存为单例池（singletonObjects）,二级缓存为早期曝光对象earlySingletonObjects，三级缓存为早期曝光对象工厂（singletonFactories）。

当A、B两个类发生循环引用时，在A完成实例化后，就使用实例化后的对象去创建一个对象工厂，并添加到三级缓存中，如果A被AOP代理，那么通过这个工厂获取到的就是A代理后的对象，如果A没有被AOP代理，那么这个工厂获取到的就是A实例化的对象。当A进行属性注入时，会去创建B，同时B又依赖了A，所以创建B的同时又会去调用getBean(a)来获取需要的依赖，此时的getBean(a)会从缓存中获取，第一步，先获取到三级缓存中的工厂；第二步，调用对象工工厂的getObject方法来获取到对应的对象，得到这个对象后将其注入到B中。

紧接着B会走完它的生命周期流程，包括初始化、后置处理器等。当B创建完后，会将B再注入到A中，此时A再完成它的整个生命周期。至此，循环依赖结束！

**2、为啥要用三级缓存，是否可以用二级缓存**

在普通的循环依赖的情况下，三级缓存没有任何作用。三级缓存实际上跟Spring中的AOP相关。AOP场景下的getEarlyBeanReference 会拿到一个代理的对象，但是不确定有没有依赖，需不需要用到这个依赖对象，所以先给一个工厂放到三级缓存里。

这个工厂的目的在于延迟对实例化阶段生成的对象的代理，只有真正发生循环依赖的时候，才去提前生成代理对象，否则只会创建一个工厂并将其放入到三级缓存中，但是不会去通过这个工厂去真正创建对象。

## 二、如何手写一个Spring框架 ##

**1、一个手写IoC容器的思路**

IOC的实现思路如下:

*  首先有一个配置文件定义了应用的基础包, 也就是Java源码路径.
 *  读取基础包名, 然后通过类加载器获取到应用中所有的Class对象, 存储到一个集合中.
 *  获取应用中所有Bean (Controller和Service) 的Class对象, 通过反射创建实例, 然后存储到 Bean容器中.
 *  遍历Bean容器中的所有Bean, 为所有带 @Autowired 注解的属性注入实例.
 *  IOC操作要在应用启动时就完成, 所以必须写在静态代码块中.

**2、一个手写SpringMVC的思路**

**（1）读取配置**  
SpringMVC本质上是一个Servlet,这个 Servlet 继承自 HttpServlet。FrameworkServlet负责初始化SpringMVC的容器，并将Spring容器设置为父容器。因为本文只是实现SpringMVC，对于Spring容器不做过多讲解。

为了读取web.xml中的配置，我们用到ServletConfig这个类，它代表当前Servlet在web.xml中的配置信息。通过web.xml中加载我们自己写的MyDispatcherServlet和读取配置文件。

**（2）初始化阶段**  
在前面我们提到DispatcherServlet的initStrategies方法会初始化9大组件，但是这里将实现一些SpringMVC的最基本的组件而不是全部，按顺序包括：

*  加载配置文件
 *  扫描用户配置包下面所有的类
 *  拿到扫描到的类，通过反射机制，实例化。并且放到ioc容器中(Map的键值对 beanName-bean) beanName默认是首字母小写
 *  初始化HandlerMapping，这里其实就是把url和method对应起来放在一个k-v的Map中,在运行阶段取出

**（3）运行阶段**  
每一次请求将会调用doGet或doPost方法，所以统一运行阶段都放在doDispatch方法里处理，它会根据url请求去HandlerMapping中匹配到对应的Method，然后利用反射机制调用Controller中的url对应的方法，并得到结果返回。按顺序包括以下功能：

*  异常的拦截
 *  获取请求传入的参数并处理参数
 *  通过初始化好的handlerMapping中拿出url对应的方法名，反射调用

**3、一个手写SpringMVC的思路**

1 .扫描 aop 包， 获取 aspect 的类  
2 .根据 切点 获取该切点的 类 和 方法  
3 .根据配置的 类 和 方法 为该类生成一个代理对象  
4 .将改代理对象放入 bean Map 中  
5 .调用的时候 将代理对象 转换成需要的对象

## 最后 ##

我整理了Java架构学习资料，学习技术内容包含有：Spring，Dubbo，MyBatis, RPC,源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。

## 需要的朋友可以点击：[点这个！点这个！][Link 1]，暗号：csdn ##

还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70]: /images/20221120/46d6e94c118445be8d3fb70584c024b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201225211214296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020122521135519.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201225211644229.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg==,size_16,color_FFFFFF,t_70
[Link 1]: https://jq.qq.com/?_wv=1027&k=oJrVNokR
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201225212044871.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201225212111441.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhcmRlclhpbg==,size_16,color_FFFFFF,t_70