上面的代码结构很简单, 再看一下注释应该就能明白了. 这里就是模拟spring将配置类解析放入到beanDefinitionMap的过程.
=================================================================================
首先,我们已经知道, 创建bean一共有三个步骤: 实例化, 属性赋值, 初始化.
而在属性赋值的时候, 会判断是否引用了其他的Bean, 如果引用了, 那么需要构建此Bean. 下面来看一下代码
/**
- 获取bean, 根据beanName获取
*/
public static Object getBean(String beanName) throws Exception {/**
-
第一步: 实例化
-
我们这里是模拟, 采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
*/
RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
Class<?> beanClass = beanDefinition.getBeanClass();
// 调用无参的构造函数进行实例化
Object instanceBean = beanClass.newInstance();
/**
-
第二步: 属性赋值
-
instanceA这类类里面有一个属性, InstanceB. 所以, 先拿到 instanceB, 然后在判断属性头上有没有Autowired注解.
-
注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式, 一种是name, 一种是type
*/
Field[] declaredFields = beanClass.getDeclaredFields();
for (Field declaredField: declaredFields) {
// 判断每一个属性是否有@Autowired注解
Autowired annotation = declaredField.getAnnotation(Autowired.class);
if (annotation != null) {
// 设置这个属性是可访问的
declaredField.setAccessible(true);
// 那么这个时候还要构建这个属性的bean.
/*
-
获取属性的名字
-
真实情况, spring这里会判断, 是根据名字, 还是类型, 还是构造函数来获取类.
-
我们这里模拟, 所以简单一些, 直接根据名字获取.
*/
String name = declaredField.getName();
/**
- 这样, 在这里我们就拿到了 instanceB 的 bean
*/
Object fileObject = getBean(name);
// 为属性设置类型
declaredField.set(instanceBean, fileObject);
}
}
/**
-
第三步: 初始化
-
初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
*/
return instanceBean;
}
我们看到如上代码.
第一步: 实例化:使用反射的方式, 根据beanName查找构建一个实例bean.
第二步: 属性赋值:判断属性中是否有@Autowired属性, 如果有这个属性, 那么需要构建bean. 我们发现在为InstanceA赋值的时候, 里面引用了InstanceB, 所以去创建InstanceB, 而创建InstanceB的时候, 发现里面又有InstanceA, 于是又去创建A. 然后以此类推,继续判断. 就形成了死循环. 无法走出这个环. 这就是循环依赖
第三步: 初始化:调用init-method, 这个方法不是必须有, 所以,我们这里不模拟了
看看如下图所示
红色部分就形成了循环依赖.
=========================================================================================
我们知道上面进行了循环依赖了. 其实, 我们的目标很简单, 如果一个类创建过了, 那么就请不要在创建了.
所以, 我们增加一级缓存
// 一级缓存
private static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
/**
- 获取bean, 根据beanName获取
*/
public static Object getBean(String beanName) throws Exception {
// 增加一个出口. 判断实体类是否已经被加载过了
Object singleton = getSingleton(beanName);
if (singleton != null) {
return singleton;
}
/**
-
第一步: 实例化
-
我们这里是模拟, 采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
*/
RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
Class<?> beanClass = beanDefinition.getBeanClass();
// 调用无参的构造函数进行实例化
Object instanceBean = beanClass.newInstance();
/**
- 第二步: 放入到一级缓存
*/
singletonObjects.put(beanName, instanceBean);
/**
-
第三步: 属性赋值
-
instanceA这类类里面有一个属性, InstanceB. 所以, 先拿到 instanceB, 然后在判断属性头上有没有Autowired注解.
-
注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式, 一种是name, 一种是type
*/
Field[] declaredFields = beanClass.getDeclaredFields();
for (Field declaredField: declaredFields) {
// 判断每一个属性是否有@Autowired注解
Autowired annotation = declaredField.getAnnotation(Autowired.class);
if (annotation != null) {
// 设置这个属性是可访问的
declaredField.setAccessible(true);
// 那么这个时候还要构建这个属性的bean.
/*
-
获取属性的名字
-
真实情况, spring这里会判断, 是根据名字, 还是类型, 还是构造函数来获取类.
-
我们这里模拟, 所以简单一些, 直接根据名字获取.
*/
String name = declaredField.getName();
/**
- 这样, 在这里我们就拿到了 instanceB 的 bean
*/
Object fileObject = getBean(name);
// 为属性设置类型
declaredField.set(instanceBean, fileObject);
}
}
/**
-
第四步: 初始化
-
初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
*/
return instanceBean;
}
还是上面的获取bean的流程, 不一样的是, 这里增加了以及缓存. 当我们获取到bean实例以后, 将其放入到缓存中. 下次再需要创建之前, 先去缓存里判断,是否已经有了, 如果没有, 那么再创建.
这样就给创建bean增加了一个出口. 不会循环创建了.
如上图所示, 在@Autowired的时候, 增加了一个出口. 判断即将要创建的类是否已经存在, 如果存在了, 那么就直接返回, 不在创建
虽然使用了一级缓存解决了循环依赖的问题, 但要是在多线程下, 这个依赖可能就会出现问题.
比如: 有两个线程, 同时创建instanceA 和instanceB, instanceA和instanceB都引用了instanceC. 他们同步进行, 都去创建instanceC. 首先A去创建, A在实例化instanceC以后就将其放入到一级缓存了, 这时候, B去一级缓存里拿. 此时拿到的instanceC是不完整的. 后面的属性赋值, 初始化都还没有执行呢. 所以, 我们增加耳机缓存来解决这个问题.
==================================================================================================
public class MainStart {
private static Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
// 一级缓存
private static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存
private static Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
/**
-
读取bean定义, 当然在spring中肯定是根据配置 动态扫描注册的
-
InstanceA和InstanceB都有注解@Component, 所以, 在spring扫描读取配置类的时候, 会把他们两个扫描到BeanDefinitionMap中.
-
这里, 我们省略这一步, 直接将instanceA和instanceB放到BeanDefinitionMap中.
*/
public static void loadBeanDefinitions(){
RootBeanDefinition aBeanDefinition = new RootBeanDefinition(InstanceA.class);
RootBeanDefinition bBeanDefinition = new RootBeanDefinition(InstanceB.class);
beanDefinitionMap.put(“instanceA”, aBeanDefinition);
beanDefinitionMap.put(“instanceB”, bBeanDefinition);
}
public static void main(String[] args) throws Exception {
// 第一步: 扫描配置类, 读取bean定义
loadBeanDefinitions();
// 第二步: 循环创建bean
for (String key: beanDefinitionMap.keySet()) {
// 第一次: key是instanceA, 所以先创建A类
getBean(key);
}
// 测试: 看是否能执行成功
InstanceA instanceA = (InstanceA) getBean(“instanceA”);
instanceA.say();
}
/**
- 获取bean, 根据beanName获取
*/
public static Object getBean(String beanName) throws Exception {
// 增加一个出口. 判断实体类是否已经被加载过了
Object singleton = getSingleton(beanName);
if (singleton != null) {
return singleton;
}
/**
-
第一步: 实例化
-
我们这里是模拟, 采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
*/
RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
Class<?> beanClass = beanDefinition.getBeanClass();
// 调用无参的构造函数进行实例化
Object instanceBean = beanClass.newInstance();
/**
- 第二步: 放入到二级缓存
*/
earlySingletonObjects.put(beanName, instanceBean);
/**
-
第三步: 属性赋值
-
instanceA这类类里面有一个属性, InstanceB. 所以, 先拿到 instanceB, 然后在判断属性头上有没有Autowired注解.
-
注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式, 一种是name, 一种是type
*/
Field[] declaredFields = beanClass.getDeclaredFields();
for (Field declaredField: declaredFields) {
// 判断每一个属性是否有@Autowired注解
Autowired annotation = declaredField.getAnnotation(Autowired.class);
if (annotation != null) {
// 设置这个属性是可访问的
declaredField.setAccessible(true);
// 那么这个时候还要构建这个属性的bean.
/*
-
获取属性的名字
-
真实情况, spring这里会判断, 是根据名字, 还是类型, 还是构造函数来获取类.
-
我们这里模拟, 所以简单一些, 直接根据名字获取.
*/
String name = declaredField.getName();
/**
- 这样, 在这里我们就拿到了 instanceB 的 bean
*/
Object fileObject = getBean(name);
// 为属性设置类型
declaredField.set(instanceBean, fileObject);
}
}
/**
-
第四步: 初始化
-
初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
*/
/**
- 第二步: 放入到一级缓存
*/
singletonObjects.put(beanName, instanceBean);
return instanceBean;
}
/**
-
判断是否是循环引用的出口.
-
@param beanName
-
@return
*/
private static Object getSingleton(String beanName) {
// 先去一级缓存里拿,如果一级缓存没有拿到,去二级缓存里拿
if (singletonObjects.containsKey(beanName)) {
return singletonObjects.get(beanName);
} else if (earlySingletonObjects.containsKey(beanName)){
return earlySingletonObjects.get(beanName);
} else {
return null;
}
}
}
如上图所示,增加了一个二级缓存. 首先, 构建出instanceBean以后, 直接将其放入到二级缓存中. 这时只是一个纯净的bean, 里面还没有给属性赋值, 初始化. 在给属性赋值完成, 初始化完成以后, 在将其放入到一级缓存中.
我们判断缓存中是否有某个实例bean的时候, 先去一级缓存中判断是否有完整的bean, 如果没有, 就去二级缓存中判断有没有实例化过这个bean.
=====================================================================================
一级缓存: 解决循环依赖的问题
二级缓存: 在创建实例bean和放入到一级缓存之间还有一段间隙. 如果在这之间从一级缓存拿实例, 肯定是返回null的. 为了避免这个问题, 增加了二级缓存.
我们都知道spring中有一级缓存, 二级缓存, 三级缓存. 一级缓存和二级缓存的作用我们知道了, 那么三级缓存有什么用呢?
==============================================================================
三级缓存有什么作用呢? 这个问题众说纷纭, 有说代理, 有说AOP. 其实AOP的问题可以用二级缓存来解决. 下面就来看看AOP如何用二级缓存解决.
创建AOP动态代理 (不是耦合的, 采用解耦的, 通过BeanPostProcessor bean的后置处理器来创建). 之前讲过, 如下图
在初始化之后, 调用Bean的后置处理器去创建的AOP的动态代理
如上图. 我们在创建bean 的时候, 会有很多Bean的后置处理器BeanPostProcessor. 如果有AOP, 会在什么时候创建呢? 在初始化以后, 调用BeanPostProcessor创建动态代理.
结合上面的代码, 我们想一想, 其实在初始化以后创建动态代理就晚了. 为什么呢? 因为, 如果有循环依赖, 在初始化之后才调用, 那就不是动态代理. 其实我们这时候应该在实例化之后, 放入到二级缓存之前调用
面试题: 在创建bean的时候, 在哪里创建的动态代理, 这个应该怎么回答呢?
很多人会说在初始化之后, 或者在实例化之后.
其实更严谨的说, 有两种情况: 第一种是在初始化之后调用 . 第二种是出现了循环依赖, 会在实例化之后调用
我们上面说的就是第二种情况. 也就是说,正常情况下是在初始化之后调用的, 但是如果有循环依赖, 就要在实例化之后调用了.
下面来看看如何在二级缓存加动态代理.
首先, 我们这里有循环依赖, 所以将动态代理放在实例化之后,
/**
- 获取bean, 根据beanName获取
*/
public static Object getBean(String beanName) throws Exception {
// 增加一个出口. 判断实体类是否已经被加载过了
Object singleton = getSingleton(beanName);
if (singleton != null) {
return singleton;
}
/**
-
第一步: 实例化
-
我们这里是模拟, 采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
*/
RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
Class<?> beanClass = beanDefinition.getBeanClass();
// 调用无参的构造函数进行实例化
Object instanceBean = beanClass.newInstance();
/**
-
创建AOP动态代理 (不是耦合的, 采用解耦的, 通过BeanPostProcessor bean的后置处理器得来的. 之前讲过,
-
在初始化之后, 调用Bean的后置处理器去创建的AOP的动态代理 )
*/
instanceBean = new JdkProxyBeanPostProcessor().getEarlyBeanReference(instanceBean, “instanceA”);
/**
- 第二步: 放入到二级缓存
*/
earlySingletonObjects.put(beanName, instanceBean);
/**
-
第三步: 属性赋值
-
instanceA这类类里面有一个属性, InstanceB. 所以, 先拿到 instanceB, 然后在判断属性头上有没有Autowired注解.
-
注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式, 一种是name, 一种是type
*/
Field[] declaredFields = beanClass.getDeclaredFields();
for (Field declaredField: declaredFields) {
// 判断每一个属性是否有@Autowired注解
Autowired annotation = declaredField.getAnnotation(Autowired.class);
if (annotation != null) {
// 设置这个属性是可访问的
declaredField.setAccessible(true);
// 那么这个时候还要构建这个属性的bean.
/*
-
获取属性的名字
-
真实情况, spring这里会判断, 是根据名字, 还是类型, 还是构造函数来获取类.
-
我们这里模拟, 所以简单一些, 直接根据名字获取.
*/
String name = declaredField.getName();
/**
- 这样, 在这里我们就拿到了 instanceB 的 bean
*/
Object fileObject = getBean(name);
// 为属性设置类型
declaredField.set(instanceBean, fileObject);
}
}
/**
-
第四步: 初始化
-
初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
*/
// 正常动态代理创建的时机
/**
- 第五步: 放入到一级缓存
*/
singletonObjects.put(beanName, instanceBean);
return instanceBean;
}
这里只是简单模拟了动态代理.
我们知道动态代理有两个地方. 如果是普通类动态代理在初始化之后执行, 如果是循环依赖, 那么动态代理是在实例化之后.
上面在实例化之后创建proxy的代码不完整, 为什么不完整呢, 因为没有判断是否是循环依赖.
==================================================================================================================
我们简单模拟一个动态代理的实现.
public class JdkProxyBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
/**
-
假设A被切点命中 需要创建代理 @PointCut(“execution(* …InstanceA.(…))”)
-
@param bean the raw bean instance
-
@param beanName the name of the bean
-
@return
-
@throws BeansException
*/
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
// 假设A被切点命中 需要创建代理 @PointCut(“execution(* …InstanceA.(…))”)
/**
-
这里, 我们简单直接判断bean是不是InstanceA实例, 如果是, 就创建动态代理.
-
这里没有去解析切点, 解析切点是AspectJ做的事.
*/
if (bean instanceof InstanceA) {
JdkDynimcProxy jdkDynimcProxy = new JdkDynimcProxy(bean);
return jdkDynimcProxy.getProxy();
}
return bean;
}
}
这里直接判断, 如果bean是InstanceA的实例, 那么就调用bean的动态代理. 动态代理的简单逻辑就是: 解析切面, 然后创建类, 如果类不存在就新增, 如果存在则不在创建, 直接取出来返回.
在来看看动态代理,放在实例化之后. 创建AOP, 但是, 在这里创建AOP动态代理的条件是循环依赖.
======================================================================================
二级缓存中bean不是null.
如果一个类在创建的过程中, 会放入到二级缓存, 如果完全创建完了, 会放入到一级缓存, 然后删除二级缓存. 所以, 如果二级缓存中的bean只要存在, 就说明这个类是创建中, 出现了循环依赖.
=================================================================================
应该在getSingleton()判断是否是循环依赖的时候判断. 因为这时候我们刚好判断了二级缓存中bean是否为空.
/**
-
判断是否是循环引用的出口.
-
@param beanName
-
@return
*/
private static Object getSingleton(String beanName) {
// 先去一级缓存里拿,如果一级缓存没有拿到,去二级缓存里拿
if (singletonObjects.containsKey(beanName)) {
return singletonObjects.get(beanName);
} else if (earlySingletonObjects.containsKey(beanName)){
/**
-
第一次创建bean是正常的instanceBean. 他并不是循环依赖. 第二次进来判断, 这个bean已经存在了, 就说明是循环依赖了
-
这时候通过动态代理创建bean. 然后将这个bean在放入到二级缓存中覆盖原来的instanceBean.
*/
Object obj = new JdkProxyBeanPostProcessor()
.getEarlyBeanReference(earlySingletonObjects.get(beanName), beanName);
earlySingletonObjects.put(beanName, obj);
return earlySingletonObjects.get(beanName);
} else {
return null;
}
}
这样我们在循环依赖的时候就完成了AOP的创建. 这是在二级缓存里创建的AOP,
==========================================================================================
那么,来找问题. 这里有两个问题:
问题1: 我们发现在创建动态代理的时候, 我们使用的bean的后置处理器JdkProxyBeanPostProcessor.这有点不太符合规则,
因为, spring在getBean()的时候并没有使用Bean的后置处理器, 而是在createBean()的时候才去使用的bean的后置处理器.
问题2: 如果A是AOP, 他一直都是, 最开始创建的时候也应该是. 使用这种方法, 结果是第一次创建出来的bean不是AOP动态代理.
对于第一个问题: 我们希望在实例化的时候创建AOP, 但是具体判断是在getSingleton()方法里判断. 这里通过三级缓存来实现. 三级缓存里面放的是一个接口定义的钩子方法. 方法的执行在后面调用的时候执行.
对于第二个问题: 我们的二级缓存就不能直接保存instanceBean实例了, 增加一个参数, 用来标记当前这个类是一个正在创建中的类. 这样来判断循环依赖.
下面先来看看创建的三个缓存和一个标识
// 一级缓存
private static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存: 为了将成熟的bean和纯净的bean分离. 避免读取到不完整的bean.
private static Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
// 三级缓存:
private static Map<String, ObjectFactory> singletonFactories = new ConcurrentHashMap<>();
// 循环依赖的标识—当前正在创建的实例bean
private static Set singletonsCurrectlyInCreation = new HashSet<>();
然后在来看看循环依赖的出口
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。
为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的
并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）
66个Java面试知识点
架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）
算法刷题（PDF）
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-EFf4107I-1712436705435)]
[外链图片转存中…(img-1blFRgV3-1712436705435)]
[外链图片转存中…(img-yPTXwVBt-1712436705436)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
总结
谈到面试，其实说白了就是刷题刷题刷题，天天作死的刷。。。。。
为了准备这个“金三银四”的春招，狂刷一个月的题，狂补超多的漏洞知识，像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的
并且我也将自己刷的题全部整理成了PDF或者Word文档（含详细答案解析）
[外链图片转存中…(img-EOQ8KSd4-1712436705436)]
66个Java面试知识点
架构专题（MySQL，Java，Redis，线程，并发，设计模式，Nginx，Linux，框架，微服务等）+大厂面试题详解（百度，阿里，腾讯，华为，迅雷，网易，中兴，北京中软等）
[外链图片转存中…(img-nf9rXfjh-1712436705436)]
算法刷题（PDF）
[外链图片转存中…(img-6XVwF25H-1712436705436)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
3903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
