做合成照片的国外网站,网页制作全过程视频,网站优化推广服务,小米手机网站建设总结在文章开始之前#xff0c;先来看一张spring IOC加载过程的脑图吧 Spring IOC的加载过程
首先,当我们去new了一个applicationContext,它底层呢就会把我们配置的bean进行扫描,然后创建成一个一个的beanDefinition放在我们的beanDefinitionMap中,此时就有了一切创造bean的原料信…在文章开始之前先来看一张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 MapString, BeanDefinition beanDefinitionMap new LinkedHashMap();// 一级缓存 单例池private final MapString, 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 MapString, BeanDefinition beanDefinitionMap new LinkedHashMap();// 一级缓存 单例池private final MapString, Object singletonObjects new ConcurrentHashMap();// 二级缓存 ---- 并发获取不完整bean------dclprivate final MapString, 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 MapString, BeanDefinition beanDefinitionMap new LinkedHashMap();// 一级缓存 单例池private final MapString, Object singletonObjects new ConcurrentHashMap();// 二级缓存 ---- 并发获取不完整bean------dclprivate final MapString, Object earlySingletonObjects new ConcurrentHashMap();//三级缓存private final MapString, 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);}
}其实三级缓存的思想就是在实例化后不是直接动态代理而是其函数式接口放入三级缓存中出现循环依赖时在进行调用创建代理的函数。 以上是我个人的见解请大家多指教
