spring源码学习 从循环依赖注入学习IoC & Bean注入的五种方式和FactoryBean & AoP

最新推荐文章于 2023-10-15 15:18:06 发布
最新推荐文章于 2023-10-15 15:18:06 发布
阅读量531 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shine_guo_star/article/details/102778290
版权

详解InitializingBean、initMethod和@PostConstruct

AbstractApplicationContext.refresh() : line512

// Allows post-processing of the bean factory in context subclasses.
//允许在上下文子类中对bean工厂进行后处理。
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
//调用上下文中注册为bean的工厂处理器。【扫描bean】
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
//注册拦截bean创建的bean处理器。
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
//初始化此上下文的消息源。
initMessageSource();

// Initialize event multicaster for this context.
//初始化上下文的事件委托（监听）。
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
//初始化特定上下文子类中的其他特殊bean。
//批注：当前版本spring-context-5.1.2.RELEASE.jar中是空壳，没有任何代码
onRefresh();

// Check for listener beans and register them.
//检查侦听器bean并注册它们。
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
//实例化所有剩余的（非lazy init）单例。
//批注：由于onRefresh是空壳，那么应该能推理结论：当前版本实例化了所有非懒汉模式的单例。
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
//最后一步：发布对应的事件。
finishRefresh();

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	...
	...
	//最后一步调用了preInstantiateSingletons接口实例化单例。接口由defaultListableBeanFactory实现。
	beanFactory.preInstantiateSingletons();
}

register() : 把配置类和后置处理器等spring内部类放到beanDefinitionMap中，包括appconfig，CommonAnnotationBeanPostProcesser，AutowiredAnnotationBeanPostProcesser等
refresh()中的

invokeBeanFactoryPostProcessers：扫描解析

属性注入后：
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialtion : 执行@PostConstruct#初始化回调 //同时也执行了其他的后置处理器
AbstractAutowireCapableBeanFactory#invokeinitmethods ： 执行@Override#afterProperties()#初始化回调
两者代码是顺序的，中间没有夹杂其他代码。如果只有一种，可以理解为一样，如果有两种，他们是有先后的。
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization ：执行代理等后置处理器。其中AnnotationAwareAspectJAutoProxyCreator完成了代理。
生命周期：扫描、解析、getbean、实例化、依赖注入、lifecycle callbacks、代理（未完）
从getBean开始，java对象实例化、填充装配、唤醒Aware方法、BeanPostProcessor后置处理（before)、初始化、BeanPostProcessor后置处理(after)、生成bean、销毁

关于后置处理器
BeanPostProcessor是个接口，有两个方法：

  1. postProcessBeforeInitialization
  2. postProcessAfterInitialization

Spring中有个方法getBeanPostProcessors()方法，可以获取所有的后置处理器。
对后置处理器的使用，就是调用它接口的方法。
最广为人知的后置处理器，就是指遍历BeanPostProcessor的所有实现类，并调用BeanPostProcessor自己的2个接口方法(中的任意一个)
事实上BeanPostProcessor还有许多实现子类，比如CommonAnnotationBeanPostProcesser，AutowiredAnnotationBeanPostProcesser，InstantiationAwareBeanPostProcessor等等。
每个子类都有自己私有的方法。spring在bean创建/初始化的过程中，有许多次遍历了(List)beanPostProcessors, 然后选择了特定的实现子类，执行了特定的子类私有方法。
这个过程大约有9次(或以上)，整个过程遍布了整个bean生命周期，从扫描解析，到自动装配，回调等待。

关于spring boot AOP
springFramework中默认spring.aop.proxy-target-class = false，所以接口默认jdk动态代理
springBoot2.0中默认spring.aop.proxy-target-class = true, 所以接口和类都默认cglib代理

Proxy作用方法的可见域（cglib）：public、protected、default；不允许的：final、static、private

FactoryBean是什么？
FactoryBean是一个特殊Bean
可以通过实现FactoryBean的getObject方法，通过FactoryBean对象，拿到getObject返回的bean(另一个bean)。
同时getObject会把返回的java对象注册成bean。
比如：


@Component
public class MyFactoryBean implements FactoryBean{

    @Override
    public Object getObject() throws Exception {
        return new MyBean();
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

class MyBean{

}

这样的代码会注册2个bean，一个在单例池中<“myFactoryBean”, (MyFactoryBean) object>, 另一个在factoryBeanObjectCache中<“myFactoryBean”, (MyBean) object>
通过getBean("&myFactoryBean")会拿到MyFactoryBean
通过getBean(“myFactoryBean”)会拿到MyBean
通过getBean(MyFactoryBean.class)会拿到myFactoryBean，具体见下文

导入bean的四种方法
https://blog.csdn.net/panchao888888/article/details/82882279

  1. @Import(MyBean.class) 注解，注入MyBean
  2. @ComponentScan(“gxj.study”)、@SpringBootApplication(scanBasePackages = {“gxj.study.config”}) 注解，注入扫描的包下所有@Component
  3. FactoryBean生成
    注意：
    a.FactoryBean不能注入getObject的bean对象（因为注入时未实例化），只能注入FactoryBean本身
    b. 当FactoryBean和@Component共存时，对目标Class会有2个不同bean实例，分别存在单例池和factoryBeanObjectCache中。分别通过beanName和factoryBean的Name获取（applicationContext.getBean)
    c. 当FactoryBean和@Component共存时, 注入属性的类型无论写Bean或者FactoryBean，最后都会注入Bean对象（单例池中的那个）
    d. FactoryBean的getObject的Bean对象会在首次被getBean时创建(懒加载)，并纳入factoryBeanObjectCache的管理中。
    e. FactoryBean的getBean，会判断beanName是否包含"&"前缀、以及instance.class是否是factoryBean，决定是从单例池还是factoryBeanObjectCache中获取bean实例
  4. ImportSelector的实现类注入
    注入beanName为从包名开始的全路径，如com.xxx.xxx.MyBean
    当与@Component共存时，不会注入“com.xxx.xxx.MyBean”，只会注入"myBean"
    当与ImportBeanDefinitionRegistrar共存时，会注入2个Bean实例
  5. ImportBeanDefinitionRegistrar的实现类注入
    与@Component一样，如果同时存在，不允许注入同名Bean。注入不同名的Bean会在单例池注入2个实例，并且无法通过.class获取（报bean类型的实例不唯一错误）。

@Resource
后置处理器：CommonAnnotationBeanPostProcessor
@Autowired
后置处理器：AutowiredAnnotationBeanPostProcessor

两次 getSingleton,
第一次：从单例池中获取单体 || 从singletonFactories缓存(bean处于创建中状态)中获取java对象
第二次：创建新对象（createBean)

原型默认不支持循环引用

doCreateBean方法中：

 boolean earlySingletonExposure = (mbd.isSingleton() 
       && this.allowCircularReferences &&
         isSingletonCurrentlyInCreation(beanName));
当原型时，boolen表达式是false

singletonfactories存<beanName,生成对象的工厂方法>

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

正常流程：
spring首先从第一个map中拿a这个bean
拿不到，从第三个map当中拿a这个对象
拿不到，从第二个map拿a这个对象或者工厂
拿到之后放到第三个map，移除第二个map里面的表达式、或者工厂

问题：
为什么在addSingletonFactory方法中：
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);

循环依赖的bean实例化链路

  1. AbstractBeanFactory line246：Object sharedInstance = getSingleton(beanName);
    批注：A 获得null

  2. AbstractBeanFactory line318：sharedInstance = getSingleton(beanName, () -> {… return createBean(beanName, mbd, args); …})

  3. DefaultSingletonBeanRegistry line215: IN METHOD - getSingleton : beforeSingletonCreation(beanName);
    批注：在判断语句中，A加入set singletonsCurrentlyInCreation【状态1】

  4. AbstractAutowireCapableBeanFactory line534-539 : METHOD - createBean CALL doCreateBean :
    if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    批注1：DefaultSingletonBeanRegistry line222 singletonObject = singletonFactory.getObject(); 触发函数doGetBean函数。
    批注2：创建了A的java对象

  5. AbstractAutowireCapableBeanFactory line562-563、569 ： boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); 与 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    批注：代码allowCircularReferences=true写死，set中有A，布尔值为真。
    5.1 addSingletonFactory ：if (!this.singletonObjects.containsKey(beanName)) {
    this.singletonFactories.put(beanName, singletonFactory);
    this.earlySingletonObjects.remove(beanName);
    this.registeredSingletons.add(beanName);//这个set不用在意
    }
    批注：singletonFactories：{A}，earlySingletonObjects：{}，registeredSingletons：{A}【状态2】

  6. AbstractAutowireCapableBeanFactory line575：populateBean(beanName, mbd, instanceWrapper);
    批注：AbstractAutowireCapableBeanFactory line1378：遍历beanPostProcessors，注入属性(这里包括了CommonAnnotationBeanPostProcesser和AutowiredAnnotationBeanPostProcesser等，不同bean不一样）

【重点】
7. 注入属性B，发现B也没有，递归getSingleton，生成Bean B
批注: singletonFactories：{A、B}，earlySingletonObjects：{}，registeredSingletons：{A、B}，singletonsCurrentlyInCreation : {A、B}【状态3】

  1. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    synchronized (this.singletonObjects) {
    singletonObject = this.earlySingletonObjects.get(beanName);
    if (singletonObject == null && allowEarlyReference) {
    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    if (singletonFactory != null) {
    singletonObject = singletonFactory.getObject();
    this.earlySingletonObjects.put(beanName, singletonObject);
    this.singletonFactories.remove(beanName);
    }
    }
    }
    }
    return singletonObject;
    }

批注：B注入属性A，getSingleton，这次 isSingletonCurrentlyInCreation(beanName) == true
singletonFactories：{B}，earlySingletonObjects：{A}，registeredSingletons：{A、B}，singletonsCurrentlyInCreation : {A、B}【状态4】

【题外话-延申】
9. AutowiredAnnotationBeanPostProcessor的inject方法中
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter); //这句调用getSingleton通过singletonFactories取了A的java对象
field.set(bean, value); // 这句话把属性A注入到了java对象B中。此时A的属性B还是null

9.* AbstractAutowireCapableBeanFactory line576：exposedObject = initializeBean(beanName, exposedObject, mbd);
批注：这里也触发了其他后置处理器，但在这里不重要

  1. AbstractAutowireCapableBeanFactory line589：Object earlySingletonReference = getSingleton(beanName, false);
    批注：这里在递归B，getSingleton传的是false，只会从earlySingletonObjects里取对象，earlySingletonObjects里只有A没有B，返回null

【阶段小结】
至此，递归B的，第二次getSingleton的createBean(即调用的doCreateBean)完成，返回注入了属性的java对象B
DefaultSingletonBeanRegistry line222 singletonObject = singletonFactory.getObject(); 触发函数doGetBean函数。
之前A运行到这里，执行工厂方法，需要注入B，递归了B。执行到这里，成功注入A，回了B对象。

  1. DefaultSingletonBeanRegistry line223 ：newSingleton = true;
    批注：标记beanB创建成功。

  2. DefaultSingletonBeanRegistry line245：afterSingletonCreation(beanName);
    批注：在判断语句中，!this.singletonsCurrentlyInCreation.remove(beanName)，在set中移除了B
    singletonFactories：{B}，earlySingletonObjects：{A}，registeredSingletons：{A}，singletonsCurrentlyInCreation : {A、B}【状态5】

  3. DefaultSingletonBeanRegistry line248：addSingleton(beanName, singletonObject);
    protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
    this.singletonObjects.put(beanName, singletonObject);
    this.singletonFactories.remove(beanName);
    this.earlySingletonObjects.remove(beanName);
    this.registeredSingletons.add(beanName);
    }
    }
    批注：此时 B 成为了一个完全体的bean
    singletonObjects : {B}, singletonFactories：{}，earlySingletonObjects：{A}，registeredSingletons：{A}，singletonsCurrentlyInCreation : {A、B}【状态6】

此时，A的inject调用的getSingleton(B) 返回了B，B注入了A

  1. AbstractAutowireCapableBeanFactory line589：Object earlySingletonReference = getSingleton(beanName, false);
    批注：这里回到了A，getSingleton传的是false，只会从earlySingletonObjects里取对象，earlySingletonObjects里只有A，返回A

  2. 之后与B相同
    singletonObjects : {B}, singletonFactories：{}，earlySingletonObjects：{A}，registeredSingletons：{A}，singletonsCurrentlyInCreation : {A、B}【状态6】
    批注：至此，A的第二个getSingleton走完了，获得了A的bean

几次调用doCreateBean

  1. getBean(A) -> A第二次getSingleton的工厂方法 -> A注入属性B的时候，递归getBean(B）
    -> B第二次getSingleton的工厂方法 -> B注入属性A的时候，递归getBean(A）
    ->B注入属性完毕->B加入单例池->A注入属性完毕->A加入单例池
shine_guo_star
关注
“掌握Spring IoC和AOP：30道面试必备问题解析！“
weixin_44976692的博客
01-03 2万+
在面试过程中，Spring的IoC（控制反转）和AOP（面向切面编程）是被频繁问及的重要主题。掌握这两个核心概念和技术，对于成为一名优秀的Java开发者至关重要。本篇博客将为你提供一份包含20个关键问题的面试指南，助你在面试中游刃有余，展现出对Spring IoC和AOP的深刻理解。无论你是初学者还是有经验的开发者，这20个问题将覆盖IoC和AOP的核心知识点，帮你更好地准备面试。让我们一同深入探讨，揭秘Spring的IoC和AOP的奥秘，为你的面试之路加分不少！🚀💻。
Spring5.0源码学习系列之浅谈循环依赖问题（八）
Nicky's blog
11-22 2756
所谓的循环依赖就是指两个及以上的类互相调用依赖，形成闭环，Spring框架检测到这种场景会抛 BeanCurrentlyInCreationException，提前暴露对象的方法
关于spring 源码书籍的合集
05-28
包含SPRING技术内幕：深入解析SPRING架构与设计原理(第2版)【带书签】，spring揭秘(完整)，深入剖析Spring Web源码 (第二版) ，这几本有关spring 源码解析的书籍，看了挺不错的
Sping BeanFactory FactoryBean AOP IOC DI之间的内在联系
燃木刀法
02-09 1102
一. Spring的两个核心接口：BeanFactory和FactoryBean介绍 1.  BeanFactory和IOC之间的关系 BeanFactory是Spring的bean工厂，主要负责管理Spring的bean的声明周期。原始java对象的管理是我们自己在管理的在类中或方法中声明、实例化的，这种方式使类以及对象之间的耦合性大大增加。此时引入Spring框架帮助我们管理Bean,就是
来电通java版_Java开发你一定要懂Spring，推荐一份书单送你
weixin_39631467的博客
11-08 375
对于Java程序员来说，这是一个很好的时代。在Java近20年的历史中，它经历过很好的时代，也经历过饱受诟病的时代。尽管有很多粗糙的地方，如applet、企业级JavaBean（Enterprise JavaBean，EJB）、Java数据对象（Java Data Object，JDO）以及无数的日志框架，但是作为一个平台，Java的历史是丰富多彩的，有很多的企业级软件都是基于这个平台构建的。Sp...
Spring AOP创建代理的方式ProxyFactoryBean、ProxyFactory、AspectJProxyFactory
最新发布
weixin_37862824的博客
10-15 460
这三个类本身没有什么关系，但都继承自：ProxyCreatorSupport，创建代理对象的核心逻辑都是在ProxyCreatorSupport中实现的AspectJProxyFactory,ProxyFactoryBean,ProxyFactory 大体逻辑都是：1、填充AdvisedSupport的，然后交给父类ProxyCreatorSupport得到JDK或者CGLIB的AopProxy2、代理调用时候被intercept方法拦截，这个拦截操作都是在JDK代理和Cglib代理生成时设置好的。
书籍推荐：Spring源码深度解析（第2版）
AlwaysBeCoding
01-28 635
Spring源码深度解析（第2版）》从核心实现、企业应用和Spring Boot这3个方面，由浅入深、由易到难地对Spring源码展开了系统的讲解，包括Spring 整体架构和环境搭建、容器的基本实现、默认标签的解析、自定义标签的解析、bean的加载、容器的功能扩展、AOP、数据库连接JDBC、整合MyBatis、事务、SpringMVC、远程服务、Spring消息、Spring Boot体系原理等内容。Spring源码学习必读书籍。
spring的IOC和AOP图解
陌上人如玉，公子世无双
09-12 787
spring的IOC和AOP图解 bean的生命周期 DI依赖注入
【Spring源码：循环依赖】一文弄懂Spring循环依赖
骏马逸动，心随你动的博客
01-15 2061
1. 什么是循坏依赖 很简单，其实就是互相依赖对方，比如，有一个A对象依赖了B对象，B对象又依赖了A对象。 // A依赖了B public class A{ private B b; } // B依赖了A public class B{ private A a; } 但是，在我们普通的java开发中，循坏依赖会出现问题吗？ 如果不考虑Spring，循环依赖并不是问题，因为对象之间相互依赖注入是很正常的事情。 比如： 这样，A,B就互相依赖上了。 但是，在Spring
Spring——IOC操作Bean管理的两种方式
weixin_45480995的博客
07-03 666
IOC操作Bean管理的两种方式Bean管理操作有两种方式IOC操作Bean管理（基于xml方式、基于注解方式）
Java五年工作经验深刻推荐的书籍，有设计模式，Java并发编程，Spring源码解析，大型网站..等
04-18
里面的书籍都是设计模式，Java并发编程，Spring源码解析，从PAXOS到ZOOKEEPER分布式一致性原理与实践，深入理解Java虚拟机 等多个pdf的压缩资源。
Spring中的IOC、DI、 aop以及bean的装配
Y200219的博客
07-01 157
1.1 控制反转Ioc 1.2 DI IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。 通俗点解释就是，当对象a需要一个对象b，或者需要b的一个方法，spring就会在系统运行到一定的时候，将需要的东西注入到a中,因此就形成了a依赖于b的依赖关系。1.3 aop AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运
书籍摘要-spring源码深度解析
weixin_30556959的博客
08-27 156
第 1 章：spring 整体架构和环境搭建 　　spring 是分层的，主要分为网络层、数据库连接层、核心容器层、 AOP 层和测试层。 　　核心容器中实现了 IOC 和依赖注入，方法是 BeanFactory。数据库连接层封装了 JDBC，兼容多种 ORM 框架。 第 2 章：容器的基本实现 　　DefaultListableBeanFactory 是加载 Bean 的核心类，Xm...
spring处理循环依赖时序图_推荐一本Spring源码解析的书籍！
weixin_39966163的博客
11-21 515
点击上方“猿程之家”，选择“置顶公众号”关键时刻，第一时间送达！阅读本文需要5分钟书籍封面内容简介《Spring源码深度解析(第2版)》从核心实现、企业应用和Spring Boot这3个方面，由浅入深、由易到难地对Spring源码展开了系统的讲解，包括Spring 整体架构和环境搭建、容器的基本实现、默认标签的解析、自定义标签的解析、bean的加载、容器的功能扩展、AOP、数据库连接JD...
SPring源码分析- - - 一书读感
有才而性缓，定属大才。有智而气和，斯为大智。
01-14 290
1.@Transactional（propagation=Propagation.REQUIRED） 标注的是事务传播类型，如果当前没有事务，就新建一个事务，如果已经存在一个事务，就加入到这个事务中！ https://www.bbsmax.com/A/l1dyKnbJem/ 2.默认情况下Spring中的事务处理只对RunTimeException方法进行回滚，所以，如果此处将Runtime...
【Spring】Spring源码阅读推荐资料
后端研发工程师Marion的博客
04-05 672
一、参考资料 Spring的DefaultListableBeanFactory_Taylar_where的博客-CSDN博客_defaultlistablebeanfactory Spring的爬坑之路（三）DefaultlistableBeanFactory_Solution.的博客-CSDN博客
“Spring Boot精粹：深入理解依赖注入、AOP、IOC和Bean生命周期“
来自上海的这位朋友
04-28 541
本文详细探讨了Spring Boot中的依赖注入、AOP、IOC和Bean生命周期的关键概念。文章通过实际案例和讲解，阐述了依赖注入的实现方法，如@Autowired、@Resource注解以及Java配置类；AOP的应用，如日志记录、事务管理和权限控制等功能；IOC的核心思想，即通过将对象的创建、配置和管理交给容器来实现；以及Bean生命周期的各个阶段，包括实例化、属性设置、初始化、使用和销毁。此外，文章还介绍了如何解决依赖注入歧义性、进行环境配置和启用特定功能等扩展主题。掌握这些概念并在实际项目中应用，
Spring源码解析——从Web项目启动过程分析开始
zhanghj07409的专栏
10-06 2177
一、源码阅读 首先，在工程右键，属性中，添加必要的jar包。 　　选中必要的jar包，上面给出的源码jar包中，导入spring3.0.5中的所有jar包。 　　其中lib内的是spring的jar包，用到哪个导入哪个，不知道的话，全部导入就行了。 　　外面的几个jar包，用于日志以及mysql的驱动。commons-logging jar包是必须的，其他的随意吧。 　　不确定的
成为Java顶尖程序员 ，看这11本书就够了
一念轮回君千殇的博客
05-31 107
“学习的最好途径就是看书“，这是我自己学习并且小有了一定的积累之后的第一体会。个人认为看书有两点好处： 1.能出版出来的书一定是经过反复的思考、雕琢和审核的，因...
Spring6深度解析：IoC、依赖注入与Bean生命周期
4.x章节详细讲解了IoC和依赖注入的概念，包括set注入和构造注入，并探讨了多种类型的注入方式，如注入Bean、简单类型、数组、集合、Map、Properties以及null和空字符串。此外，还介绍了p、c和util命名空间的使用，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值