哪个网站的地图可以做分析图/百度关键词优化技巧

在文章开始之前，先来看一张spring IOC加载过程的脑图吧

Spring IOC的加载过程

首先,当我们去new了一个applicationContext,它底层呢就会把我们配置的bean进行扫描,然后创建成一个一个的beanDefinition放在我们的beanDefinitionMap中,此时就有了一切创造bean的原料信息,然后就会去循环beanDefinition,去调用beanfactory.getBean方法,先尝试在一级缓存中获取,获取不到呢就会进行创建,先进行实例化,然后进行依赖注入,最后初始化,放入到一级缓存中.

手写源码

package cn.edu.hunau;import cn.edu.hunau.service.AService;
import cn.edu.hunau.service.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;/*** @Author SuJ* @Date 2024 04 12 15 13.* 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。**/
public class SuJApplicationContext {private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();// 一级缓存 单例池private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();public SuJApplicationContext() throws Exception{// 加载ioc容器  创建所有的beanrefersh();finishBeanFactoryInitialization();}//一个个的创建beanprivate void finishBeanFactoryInitialization() {//循环所有的beanDefinitionbeanDefinitionMap.keySet().forEach(beanName -> {try {getBean(beanName);} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}});}private Object getBean(String beanName) throws InstantiationException, IllegalAccessException {// 1.尝试在一级缓存中获取Object bean = getSingleton(beanName);//如果存在 直接放回if(bean != null){return bean;}// 2.创建  ---> 实例化RootBeanDefinition beanDefinition = (RootBeanDefinition)beanDefinitionMap.get(beanName);Class<?> beanClass = beanDefinition.getBeanClass();bean = beanClass.newInstance();//3. 依赖注入for (Field declaredField : beanClass.getDeclaredFields()){//当前属性有注解if(declaredField.getAnnotation(Autowired.class) != null){String name = declaredField.getName();Object dependBean = getBean(name);declaredField.setAccessible(true);declaredField.set(bean, dependBean);}}//4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}//5.放入一级缓存singletonObjects.put(beanName, bean);return bean;}
//获取单例池中的beanprivate Object getSingleton(String beanName) {if(singletonObjects.containsKey(beanName)){return singletonObjects.get(beanName);}return null;}//ioc容器加载public void refersh() throws Exception{//1.解析配置 支持BeanDefinitionloadBeanDefinitions();}/**** 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton*/private void loadBeanDefinitions(){// 创建A BeanDefinitionRootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);//创建B BeanDefinitionRootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);beanDefinitionMap.put("aService",aBeanDefinition);beanDefinitionMap.put("bService",bBeanDefinition);}
}

当我们手写完IOC容器的创建过程,会发现其实在一级缓存就可以解决循环依赖的问题,只需要增加一行代码。

我们可以发现程序正常执行

那为什么spring的设计人员不采取这种方式，而是要通过三级缓存来解决循环依赖的问题呢？

这是因为只通过一级缓存来解决循环依赖问题会造成线程安全问题，例如线程1先实例化A,直接放到一级缓存，这时线程2从一级缓存中获取到了实例，调用B实例的方法，由于没有进行依赖注入，我们的B实例为null，会造成空指针异常。

为了解决这个问题，我们引入了二级缓存，专门用于存储不完整的bean，使用二级缓存获取到的bean作为出口，并且将临界资源锁住（这里借用了单例模式的思想），果然解决了线程安全的问题。

package cn.edu.hunau;import cn.edu.hunau.service.AService;
import cn.edu.hunau.service.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;/*** @Author SuJ* @Date 2024 04 12 15 13.* 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。**/
public class SuJApplicationContext {private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();// 一级缓存 单例池private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// 二级缓存 ---->  并发获取不完整bean------dclprivate final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();public SuJApplicationContext() throws Exception {// 加载ioc容器  创建所有的beanrefersh();finishBeanFactoryInitialization();}//一个个的创建beanprivate void finishBeanFactoryInitialization() {//循环所有的beanDefinitionbeanDefinitionMap.keySet().forEach(beanName -> {try {getBean(beanName);} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}});}private Object getBean(String beanName) throws InstantiationException, IllegalAccessException {// 1.尝试在一级缓存中获取Object bean = getSingleton(beanName);//如果存在 直接放回if (bean != null) {return bean;}synchronized (singletonObjects) {bean = getSingleton(beanName);//如果存在 直接返回if (bean != null) {return bean;}// 2.创建  ---> 实例化RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);Class<?> beanClass = beanDefinition.getBeanClass();bean = beanClass.newInstance();earlySingletonObjects.put(beanName, bean);//3. 依赖注入for (Field declaredField : beanClass.getDeclaredFields()) {//当前属性有注解if (declaredField.getAnnotation(Autowired.class) != null) {String name = declaredField.getName();Object dependBean = getBean(name);declaredField.setAccessible(true);declaredField.set(bean, dependBean);}}//4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}//5.放入一级缓存singletonObjects.put(beanName, bean);earlySingletonObjects.remove(beanName);  //二级缓存是临时的需要清楚return bean;}}//获取单例池中的beanprivate Object getSingleton(String beanName) {if (singletonObjects.containsKey(beanName)) {return singletonObjects.get(beanName);}//出口synchronized (singletonObjects) {if (earlySingletonObjects.containsKey(beanName)) {return earlySingletonObjects.get(beanName);}}return null;}//ioc容器加载public void refersh() throws Exception {//1.解析配置 支持BeanDefinitionloadBeanDefinitions();}/*** 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton*/private void loadBeanDefinitions() {// 创建A BeanDefinitionRootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);//创建B BeanDefinitionRootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);beanDefinitionMap.put("aService", aBeanDefinition);beanDefinitionMap.put("bService", bBeanDefinition);}
}

那三级缓存用来干什么的？

三级缓存主要是处理我们涉及到需要代理的Bean的情况的。一般来说，动态代理需要Bean的初始化过程中进行创建，但是在循环依赖的这种特殊情况下，程序根本无法走到初始化这一步，所以我们需要在实例化后就进行Bean的增强。假如说我们只使用二级缓存（如下图这样写的话）,对于需要进行增强的Bean会造成两个问题

1.没有遵循规范（初始化再增强

2.循环依赖多次会创建多次（A和B循环依赖，A和C循环依赖

为了解决这些问题，spring的底层引入了三级缓存（存储一个Bean工厂对象，对于需要做增强的Bean返回代理类，不需要的返回原始类）

package cn.edu.hunau;import cn.edu.hunau.service.impl.AService;
import cn.edu.hunau.service.impl.BService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;/*** @Author SuJ* @Date 2024 04 12 15 13.* 手写spring IOC底层源码来模拟spring如何利用多级缓存解决循环依赖的问题。**/
public class SuJApplicationContext {private Map<String, BeanDefinition> beanDefinitionMap = new LinkedHashMap<>();// 一级缓存 单例池private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();// 二级缓存 ---->  并发获取不完整bean------dclprivate final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();//三级缓存private final Map<String, ObjectFactory> factoriesEarlySingletonObjects = new ConcurrentHashMap<>();public SuJApplicationContext() throws Exception {// 加载ioc容器  创建所有的beanrefersh();finishBeanFactoryInitialization();}//一个个的创建beanprivate void finishBeanFactoryInitialization() {//循环所有的beanDefinitionbeanDefinitionMap.keySet().forEach(beanName -> {try {getBean(beanName);} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}});}public Object getBean(String beanName) throws InstantiationException, IllegalAccessException {// 1.尝试在一级缓存中获取Object bean = getSingleton(beanName);//如果存在 直接放回if (bean != null) {return bean;}synchronized (singletonObjects) {bean = getSingleton(beanName);//如果存在 直接返回if (bean != null) {return bean;}// 2.创建  ---> 实例化RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);Class<?> beanClass = beanDefinition.getBeanClass();Object beanNew = beanClass.newInstance();//1.没有遵循规范  2.循环依赖多次会创建多次Object beanAop = new JdkProxyBeanPostProcessor().getEarlyBeanReference(bean, beanName);factoriesEarlySingletonObjects.put(beanName, ()->{return new JdkProxyBeanPostProcessor().getEarlyBeanReference(beanNew,beanName );});// 首先将早期引用放入二级缓存
//            earlySingletonObjects.put(beanName, beanNew);//3. 依赖注入for (Field declaredField : beanClass.getDeclaredFields()) {//当前属性有注解if (declaredField.getAnnotation(Autowired.class) != null) {String name = declaredField.getName();Object dependBean = getBean(name);declaredField.setAccessible(true);declaredField.set(beanNew, dependBean);}}//4.初始化
//if(bean instanceof InitializingBean){
//    ((InitializingBean)bean).afterPropertiesSet();
//}//5.放入一级缓存singletonObjects.put(beanName, beanNew);earlySingletonObjects.remove(beanName);  //二级缓存是临时的需要清除factoriesEarlySingletonObjects.remove(beanName);    //三级缓存是临时的需要清除return beanNew;}}private Object getSingleton(String beanName) {if (singletonObjects.containsKey(beanName)) {return singletonObjects.get(beanName);}//出口  -- 当前是循环依赖synchronized (singletonObjects) {if (earlySingletonObjects.containsKey(beanName)) {return earlySingletonObjects.get(beanName);}if (factoriesEarlySingletonObjects.containsKey(beanName)) {ObjectFactory objectFactory = factoriesEarlySingletonObjects.get(beanName);// aopObject object = objectFactory.getObject();earlySingletonObjects.put(beanName, object); //解决循环依赖多次会创建多次的问题return object;}}return null;}//ioc容器加载public void refersh() throws Exception {//1.解析配置 支持BeanDefinitionloadBeanDefinitions();}/*** 根据配置信息创建BeanDefinition  底层是通过解析配置类注册beandefiniton*/private void loadBeanDefinitions() {// 创建A BeanDefinitionRootBeanDefinition aBeanDefinition = new RootBeanDefinition(AService.class);//创建B BeanDefinitionRootBeanDefinition bBeanDefinition = new RootBeanDefinition(BService.class);beanDefinitionMap.put("aService", aBeanDefinition);beanDefinitionMap.put("bService", bBeanDefinition);}
}

其实三级缓存的思想就是：在实例化后不是直接动态代理，而是其函数式接口放入三级缓存中，出现循环依赖时在进行调用创建代理的函数。

以上是我个人的见解，请大家多指教