spring源码分析

核心注解

注解	功能
@Bean	容器中注册组件
@Primary	同类组件如果有多个，标注主组件
@DependsOn	组件之间声明依赖关系
@Lazy	组件懒加载（最后使用的时候才创建）
@Scope	声明组件的作用范围(SCOPE_PROTOTYPE,SCOPE_SINGLETON)
@Configuration	声明这是一个配置类，替换以前配置文件
@Component	@Controller、@Service、@Repository
@Indexed	加速注解，所有标注了 @Indexed 的组件，直接会启动快速加载
@Order	数字越小优先级越高，越先工作
@ComponentScan	包扫描
@Conditional	条件注入
@Import	导入第三方jar包中的组件，或定制批量导入组件逻辑
@ImportResource	导入以前的xml配置文件，让其生效
@Profile	基于多环境激活
@PropertySource	外部properties配置文件和JavaBean进行绑定.结合ConfigurationProperties
@PropertySources	@PropertySource组合注解
@Autowired	自动装配
@Qualifier	精确指定
@Value	取值、计算机环境变量、JVM系统。xxxx。@Value(“${xx}”)
@Lookup	单例组件依赖非单例组件，非单例组件获取需要使用方法

注：@Indexed 需要引入依赖

<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-context-indexerartifactId>
  <optional>trueoptional>
dependency>

@Lookup用途：

@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Component
public class Cat {}

@Component
public class Person{

    // @Autowired：容器在启动时，创建Person，属性注入时创建Cat，用的cat是容器启动时首次创建那个，依赖的组件是多实例就不能Autowired
	private Cat cat;

	@Lookup  //去容器中找。@Bean的这种方式注册的Person @Lookup不生效
	public Cat getCat() {
		return cat;
	}
}

整体架构

• 基础接口
  • Resource+ResourceLoader 资源+资源加载器
  • BeanFactory 想成飞机制造工厂
  • BeanDefinition 造飞机的图纸
  • BeanDefinitionReader 图纸解析器
  • BeanDefinitionRegistry 图纸档案馆
  • SingletonBeanRegistry 单例档案馆
  • ApplicationContextAware
• 生命周期-后置处理器
  • BeanFactoryPostProcessor
  • InitializingBean
  • BeanPostProcessor
  • SmartInitializingSingleton
    

核心接口

基础接口

Resource+ResourceLoader

这儿使用了策略模式

BeanFactory

• 核心BeanFactory介绍
  1. HierarchicalBeanFactory：定义父子工厂（父子容器）-
  2. ListableBeanFacotory：的实现是DefaultListableBeanFactory，保存了ioc容器中的核心信息-
  3. AutowireCapableBeanFactory：提供自动装配能力
  4. AnnotationApplicationContext组合了档案馆，他有自动装配能力

ApplicationContext和BeanFactory什么区别？

1. EnvironmentCapable 获取环境变量的功能（操作系统、jvm等环境变量）
2. MessageSource 实现国际化
3. ApplicationEventpublisher 时间发布器
4. ResourcePatternResolver 资源解析器

二、ApplicationContenxt虽然是Beanfactory但是他管理bean或者说去实现那些功能并不是自己去完成的。而是靠DefaultListableBeanFactory去实现的。所以DefaultListableBeanFactory成了ApplicationContenxt组合模式中的叶子节点。所以，ApplicationContext更能说是ioc容器

BeanDefinition

BeanDefinition的设计初衷：spring可以通过xml、注解等方式将bean初始化当IOC容器中，每种方式对bean的描述都有区别，故而需要统一描述信息，BeanDefinition就诞生了

属性	描述
beanClass	表示一个bean的类型，比如UserService.class，Spring在创建Bean的过程中会根据此属性来实例化得到对象
scope	表示一个bean的作用域，比如：scope等于singleton，该bean就是一个单例Bean; scope等
prototype	该bean就是一个原型Bean
isLazy	表示一个bean是不是需要懒加载，原型bean的isLazy属性不起作用，懒加载的单例bean，会在第一次getBean的时候生成该bean，非懒加载的单例bean，会在Spring启动过程中直接生成好
dependsOn	表示一个bean在创建之前所依赖的其他bean，在一个bean创建之前，它所依赖的这些bean得先全部创建好。
primary	表示一个bean是主bean，在Spring中一个类型可以有多个bean对象，在进行依赖注入时，如果根据类型找到了多个bean，此时会判断这些bean中是否存在一个主bean，如果存在，则直接将这个bean注入给属性。
initMethodName	表示一个bean的初始化方法，一个bean的生命周期过程中有一个步骤叫初始化，Spring会在这个步骤中去调用bean的初始化方法，初始化逻辑由程序员自己控制，表示程序员可以自定义逻辑对bean进行加工。

BeanDefinition的常见读取器：

1. AnnotatedBeanDefinitionReader:解析类上的注解,包含某些注解的时候会成为Bean
2. XmlBeanDefinitionReader:可以解析xml文件中的标签
3. ClassPathBeanDefinitionScanner:扫描包路径的读取器

BeanDefinition是如何存放的?

private final Map<String, BeanDefinition> beanDefinitionMap = newConcurrentHashMap<>(256)

当Bean注册完成后,会在spring容器中把扫描到的beanDefinition存放到beanDefinitionMap中,方便后续的使用。

BeanDefinitionReader

是用于读取Spring配置文件的内容，并转换为BeanDefinition

BeanDefinitionRegistry

1. registerBeanDefinition方法：注册beanDefinition到 Map属性中保存
2. removeBeanDefinition方法： 删除和beanDefiniation
3. getBeanDefinition方法：获取beanDefiniation
4. getBeanDefinitionCount方法：得到持有的beanDefiniation的数目

根据beanName 判断是否包含beanDefiniation

ApplicationContext

1. ioc事件派发器：ApplicationEventPublisher
2. 国际化解析：MessageSource
3. bean工厂功能：ListableBeanFactory（自动装配被组合进来的）
4. 资源解析功能：ResourceLoader
   

Aware接口

实现	描述
ApplicationContextAware	通过ApplicationContext，可以访问Spring容器中缓存的的其他Bean
EnvironmentAware	实现该接口，项目启动时，可以获取环境变量配置
BeanFactoryAware	获取加载该Bean的Bean工厂，可以动态加载Bean.
ApplicationEventPublisherAware	ApplicationEventPublisher可以用来发布事件，结合ApplicationListener来共同使用
ResourceLoaderAware	可以获取ResourceLoader，ResourceLoader可以获取classpath内所有的资源对象
BeanNameAware	注入Bean的名字
ServletContextAware	1. 可以获得ServletContext,ServletContext被称为域对象，是一个全局存储信息的空间。 2. 服务器会为每一个工程创建一个ServletContext对象，工程内所有Servlet都会共享这个Servlet上下文。 3. 应用被移除或服务器关闭时，才会被销毁，可以在整个应用过程中共享数据变量。

实现想要Aware接口就能拿到相应接口，如：

@Component
public class Person implements ApplicationContextAware, MessageSourceAware {
    //	@Autowired
    ApplicationContext context;  //可以要到ioc容器
	MessageSource messageSource;
    @Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		//利用回调机制，把ioc容器传入
		this.context = applicationContext;
	}

	@Override
	public void setMessageSource(MessageSource messageSource) {
		this.messageSource = messageSource;
	}
}

生命周期后置处理

BeanFactoryPostProcessor

InitializingBean、DisposableBean

name=“Zsth1”>

BeanPostProcessor

Spring启动流程

// 会调用父类实例化一个beanFactory
public AnnotationConfigApplicationContext(Class... componentClasses) {
    // this()断点调试技巧，将断掉打在RootBeanDefinition和AbstractBeanDefinition的构造方法中
    this(); 
    register(componentClasses);
    refresh(); //容器完整刷新（创建出所有组件，组织好所有功能）
}

AnnotationConfigApplicationContext父类->GenericApplicationContext父类->AbstractApplicationContext父类->DefaultResourceLoader

在构造中调用到父类GenericApplicationContext构造

This()

public AnnotationConfigApplicationContext() {
    StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    // 初始化reader
    this.reader = new AnnotatedBeanDefinitionReader(this);
    createAnnotatedBeanDefReader.end();
    // 初始化scanner
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

AnnotatedBeanDefinitionReder用途：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    // 注册相关BeanDefinition
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

registerAnnotationConfigProcessors(this.registry)：注册相关BeanDefinition

1. ConfigurationClassPostProcessor 用于对 @Configuration 类进行引导处理。
2. AutowiredAnnotationBeanPostProcessor 处理 @Autowired @Value 和 JSR-330的@Inject 还有 @Lookup 注解
3. CommonAnnotationBeanPostProcessor 用来处理 @PostConstruct @PreDestroy @Resource。
4. PersistenceAnnotationBeanPostProcessor 当支持 JPA 时添加这个。
5. EventListenerMethodProcessor 支持 @EventListener。
   

ClassPathBeanDefinitionScanner作用

ClassPathBeanDefinitionScanner：BeanDefinition扫描注册

1. 初始化扫描注册需要的组件，设置resourceLoader，environment，registry
2. 对外提供scan方法，根据传入的包名，自动扫描加载BeanDefinition并将BeanDefinition注册到registry
   

register(annotatedClasses)

通过AnnotatedBeanDefinitionReder注册配置类，将主配置类解析为BeanDefinition加入注册容器。后续通过ConfigurationClassPostProcessor解析加入容器

refresh()

@Override  //容器刷新的十二大步。模板模式
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
        //1. 准备上下文环境 Prepare this context for refreshing.
        prepareRefresh();
        //2. 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        //3. 给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);
        try {
            //4. 留给子类的模板方法，允许子类继续对工厂执行一些处理； Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);
            StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
            //5. 【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);
            //6. 【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            beanPostProcess.end();
            //7. 初始化国际化功能 Initialize message source for this context.
            initMessageSource();
            //8. 初始化事件多播功能（事件派发） Initialize event multicaster for this context.
            initApplicationEventMulticaster();
            //9. 初始化特定上下文子类中的其他特殊bean. Initialize other special beans in specific context subclasses.
            onRefresh();
            //10. 注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
            registerListeners();
            //实例化所有剩余的（非惰性初始化）单例 Instantiate all remaining (non-lazy-init) singletons.
            //11. 【大核心】bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
            finishBeanFactoryInitialization(beanFactory);
            //12. 发布事件 Last step: publish corresponding event.
            finishRefresh();
        }
        。。。
    }
}

工厂初始化阶段

1. prepareBeanFactory初始化Bean工厂属性：this()已经把工厂建好了，但是还不能投入使用，因为工厂里什么都没有，还需要配置一些东西。该步骤为Bean工厂添加了Bean后置处理器，用于Bean生命周期过程的增强操作
2. obtainFreshBeanFactory返回this()环节创建好的工厂
3. prepareBeanFactory：
   1. 设置beanFactory的类加载器为当前context的类加载器
   2. 设置beanfactory的表达式语言处理器
   3. 为beanFactory增加一个默认的PropertyEditor （这个主要是对bean的属性设置管理的一个属性工具类，比如date的format，我们也可以进行自定义）
   4. 添加默认的beanPostProcessor【ApplicationContextAwareProcessor】，此类用来完成某些aware对象的注入
   5. 添加ApplicationListenerDetector，事件观察者
   6. 设置忽略自动装配的aware接口
   7. 设置几个自动装配的特殊规则，当在进行IOC的时候，如果有多个实现，就按指定的对象注入（如果有多个beanFactory就注入该beanFactory）
   8. 增加aspectJ的支持
   9. 注册默认的系统环境bean【主配置文件解析为Environment、环境配置、properties】到一级缓存中
4. postProcessBeanFactory后置处理Bean工厂
   1. 模板方法，具体逻辑在子类中，主要用于为不同容器添加不同的Bean后置处理器
   2. 上面对bean工厂进行了许多配置，现在需要对bean工厂进行一些处理。不同的Spring容器做不同的操作。比如GenericWebApplicationContext容器的操作会在BeanFactory中添加ServletContextAwareProcessor用于处理ServletContextAware类型的bean初始化的时候调用setServletContext或者setServletConfig方法(跟ApplicationContextAwareProcessor原理一样)。
   3. AnnotationConfigServletWebServerApplicationContext#postProcessBeanFactory方法
      

工厂增强阶段

4. invokeBeanFactoryPostProcessors执行Bean工厂后置处理【重要，关系SpringBoot自动装配原理等】

1. 区分BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor，排序，顺序按实现这三个接口排序PriorityOrdered>Ordered>无前两接口实现
   1. 从Spring容器中找出BeanDefinitionRegistryPostProcessor类型的bean排序后依次执行
   2. 从Spring容器中找出BeanFactoryPostProcessor不是BeanDefinitionRegistryPostProcessor的
2. 需要说明的是ConfigurationClassPostProcessor后置处理器解析配置类（核心）

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {

后置处理器注册阶段

• 作用：从Spring容器中找出的BeanPostProcessor接口的bean，没找到实例化，并设置到BeanFactory的属性中。之后bean被实例化的时候会调用这个BeanPostProcessor。
• 原理：该方法委托给了PostProcessorRegistrationDelegate类的registerBeanPostProcessors方法执行。按PriorityOrdered>Ordered>无前两接口实现 顺序处理
• BeanPostProcessor来源：都是由AnnotationConfigUtils的registerAnnotationConfigProcessors方法注册的
• BeanPostProcessor包括：
  • AutowiredAnnotationBeanPostProcessor(处理被@Autowired修饰的bean并注入)
  • RequiredAnnotationBeanPostProcessor(处理被@Required修饰的方法)
  • CommonAnnotationBeanPostProcessor(处理@PreDestroy、@PostConstruct、@Resource等多个注解的作用)
  • 自定义的BeanPostProcessor，已经被ConfigurationClassPostProcessor注册到容器内
• 影响Bean生命周期的后置处理器
  • InstantiationAwarePostProcessors
  • SmartInstantiationAwarePostProcessors
  • BeanPostProcessor
    

其他处理

• linitMessageSource方法

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）,这个接口提供了消息处理功能。主要用于国际化/i18n。

• initApplicationEventMulticaster方法

在Spring容器中初始化事件广播器，事件广播器用于事件的发布。默认实现：SimpleApplicationEventMulticaster，可重新注入一个名称必须为applicationEventMulticaster

• onRefresh方法

一个模板方法，不同的Spring容器做不同的事情。如SpringBoot中web容器启动tomccat

• registerListeners方法

注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布给相匹配的监听器。

• finishBeanFactoryInitialization方法：实例化非懒加载的Bean
• finishRefresh方法：
  

后置处理器使用阶段

BeanDefinition信息注册流程和xxxAware是什么时候赋值进来的

BeanDefinition信息注册流程

• 入口new ClassPathXmlApplicationContext

	public static void main(String[] args) {
        // 入口
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
		Cat bean = context.getBean(Cat.class);
		System.out.println(bean);
	}

	public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {
		super(parent);
		setConfigLocations(configLocations);
		if (refresh) {
			refresh(); //刷新容器
		}
	}

• AbstractApplicationContext#refresh

@Override  //容器刷新的十二大步。模板模式
	public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
			//准备上下文环境 Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            .....

• 创建BenaFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory(); //刷新整个BeanFactory,注解模式下就是准备工厂，设置工厂id；xml模式下会解析xml
		return getBeanFactory(); // 创建BenaFactory
	}

• refreshBeanFactory()进入AbstractRefreshableApplicationContext#refreshBeanFactory

	@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
            //创建保存所有Bean定义信息的档案馆
			DefaultListableBeanFactory beanFactory = createBeanFactory(); 
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
            // 加载bean定义信息，说明档案馆BeanDefinitionRegistry创建好了
            // 入参为beanFactory，猜测beanFactory具备BeanDefinitionRegistry功能
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
    	....
	}

• 创建档案馆BeanDefinitionRegistry

loadBeanDefinitions(beanFactory);入参为beanFactory，猜测beanFactory具备BeanDefinitionRegistry功能

• 加载所有的Bean定义信息

...
// 逐个节点解析
loadBeanDefinitions(beanFactory);
...

逐个节点解析（非核心）

	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		initBeanDefinitionReader(beanDefinitionReader);
        // 核心
		loadBeanDefinitions(beanDefinitionReader);
	}

最后进入：XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource)
简单概述：就是通过Resource+ResourceLoader+dom解析，将xml中的bean标签解析为BeanDefinition

xxxAware是什么时候赋值进来的

查找入口断点打在：

@Component
public class Person implements ApplicationContextAware {
    //	@Autowired
    ApplicationContext context;  //可以要到ioc容器
	MessageSource messageSource;

	public Person(){
		System.out.println("person创建...."); // 断点
	}
    
    @Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		//利用回调机制，把ioc容器传入
		this.context = applicationContext;  // 断点
	}
}

堆栈信息发现关键调用顺序：

• AbstractApplicationContext#finishBeanFactoryInitialization：完成 BeanFactory 初始化
  1. beanFactory.preInstantiateSingletons()：初始化所有的非懒加载的单实例Bean
  2. AbstractBeanFactory#getBean(java.lang.String)

	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

3. AbstractBeanFactory#doGetBean下创建bean核心逻辑

// 创建bean的实例；Create bean instance.
if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, () -> {
        try { return createBean(beanName, mbd, args); } //创建bean对象的实例 
        ...
    }); 
    //看当前bean是否是FactoryBean
    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

4. DefaultSingletonBeanRegistry#getSingleton(String , ObjectFactory singletonFactory)

try {
    //会调用lamda表达式的内容，真正创建对象
    singletonObject = singletonFactory.getObject();
    newSingleton = true;
}

AbstractBeanFactory#doGetBean

// 创建bean的实例；Create bean instance.
if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, /**lamda表达式进入*/() -> {
        try { return createBean(beanName, mbd, args);   } //创建bean对象的实例
        ....
    }
}

进入

try { 
    //Spring真正自己创建对象
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    if (logger.isTraceEnabled()) {
        logger.trace("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}

5. AbstractAutowireCapableBeanFactory#doCreateBean

// 初始化bean实例 Initialize the bean instance.
Object exposedObject = bean;
try {
    populateBean(beanName, mbd, instanceWrapper); //给创建好的对象每个属性进行赋值，@Autowired发生在这里
    exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化bean
}

6. AbstractAutowireCapableBeanFactory#initializeBean(Object, RootBeanDefinition)

if (mbd == null || !mbd.isSynthetic()) {
    //执行后置处理器的BeforeInitialization方法
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

7. AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    // 遍历所有bean后置处理器，执行后置处理器的postProcessBeforeInitialization方法
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) { //不管null的东西
            return result;
        }
        result = current;
    }
    return result;
}

ApplicationContextAwareProcessor为aware接口的后置处理器，最后会执行到ApplicationContextAwareProcessor.postProcessBeforeInitialization

invokeAwareInterfaces(bean); //执行aware接口规定的方法

8. ApplicationContextAwareProcessor#invokeAwareInterface

private void invokeAwareInterfaces(Object bean) {
....
if (bean instanceof ApplicationContextAware) {
    //   执行Aware接口回到
    ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}

@Autowired是怎么完成的？引出后置处理器

通过ApplicationContextAware接口，applicationContext属性注入分析，我们知道是通过后置处理器ApplicationContextAwareProcessor最后为applicationContext回调赋值。
思考：@Autowired原理，猜测应该也是有相应的后置处理器进行属性注入。

通过断点跟踪堆栈，分析@Autowired

@Autowired  //去发现一下.....
public void setCat(Cat cat) {
    this.cat = cat;
}

	public static void main(String[] args) {
		ApplicationContext applicationContext =
				new AnnotationConfigApplicationContext(MainConfig.class);
		Person bean = applicationContext.getBean(Person.class);
    }}

回溯堆栈信息发现入口：发现@Autowired对应的后置处理器是AutowiredAnnotationBeanPostProcessor

AbstractAutowireCapableBeanFactory#populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    ...
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    ...
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        //使用后置处理器处理属性
        PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
            if (filteredPds == null) {
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
                return;
            }
        }
        pvs = pvsToUse; //封装了当前bean的所有属性名和值，可以由后置处理器处理得到
    }
}

AutowiredAnnotationBeanPostProcessor#postProcessProperties

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    //找到自动装配的元信息
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        // 元数据注入，最后会通过反射将属性值注入
        metadata.inject(bean, beanName, pvs);
    }
    ...
    return pvs;
}

总结：

1. Spring的底层通过后置增强机制,完成很多功能
2. 这个功能Spring在启动的时候注入了什么组件
3. 这个功能牵扯到的组件在什么位置被什么后置增强器增强成了什么样子? spring设计扩展点为bean做功能增强，扩展点实现就是后置处理器，扩展点都在那儿呢？ 接下来探讨Bean的生命周期，看在那些位置能操作bean
   

Bean生命周期

核心容器源码-组件创建流程
后置处理器的创建先不做讨论，在beanFactory创建后执行prepareBeanFactory(beanFactory)会初始化一些后置处理器。
后置处理器调用时机参考：
后置处理介绍参考：

Bean初始化流程-GetBean()

IOC阶段

解析BeanDefinition，通过反射创建bean，创建bean的过程交给了spring容器

DI阶段

早期单例池【二级缓存】中bean存在依赖，会挨个创建依赖bean进行注入

属性注入源码： AbstractAutowireCapableBeanFactory#populateBean

PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
        autowireByName(beanName, mbd, bw, newPvs); // 会调用到getBean获取注入的实际对象
    }
    if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }
    pvs = newPvs;
}

....
if (pvs != null) { //把以前处理好的PropertyValues给bean里面设置一下。主要是上面步骤没有给bean里面设置的属性
    applyPropertyValues(beanName, mbd, bw, pvs); //xml版的所有配置会来到这里给属性赋值
}

DefaultSingletonBeanRegistry#getSingleton()

@Nullable  //双检查锁
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 快速检查现有实例，没有完整的单例锁 Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName); //一级缓存:先检查单例缓存池，获取当前对象 
    //如果当前bean正在创建过程中，而且缓存中没有则继续
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
        singletonObject = this.earlySingletonObjects.get(beanName); //二级
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); //三级
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

postProcessBeanFactory执行顺序分析

UML结构

源码图解

流程分析

1. BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
2. BeanDefinitionRegistryPostProcessor#postProcessBeanFactory
3. BeanFactoryPostProcessor#postProcessBeanFactory

核心实现：ConfigurationClassPostProcess【配置类后置处理器】工厂准备好后就得解析配置类的信息
执行时机：PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors

ConfigurationClassPostProcess解析配置类

1. 拿到工厂所有的bean定义信息，遍历，找到所有配置类，并对配置类排序
2. 由ConfigurationClassParser解析每一个配置类

@Override //把配置类中所有bean的定义信息导入进来
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    ...
    processConfigBeanDefinitions(registry); //处理配置的BeanDefinition信息
}

PostProcessorRegistrationDelegate原理：

//执行工厂的后置处理器
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    	...
        // 首先：从工厂中获取所有的实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor； First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); //拿到系统中每一个组件的BD信息，进行类型对比，是否匹配指定的类型
    	...//下面利用优先级排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        ...
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); //执行这些BeanDefinitionRegistryPostProcessor的
        currentRegistryProcessors.clear();
        // 接下来，获取所有实现了Ordered接口的 BeanDefinitionRegistryPostProcessor Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
    	// 【核心】invokeBeanDefinitionRegistryPostProcessors方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); //执行
        currentRegistryProcessors.clear(); //防止重复执行
        // 最后，我们自定义的一般没有任何优先级和排序接口   Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    	...
        // 接下来，再来执行postProcessBeanFactory的回调， Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }
}

1. 首先：从工厂中获取所有的实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor
2. 利用优先级排序：PriorityOrder>Ordered>没有实现任何排序接口
3. 【核心】invokeBeanDefinitionRegistryPostProcessors方法

private static void invokeBeanDefinitionRegistryPostProcessors( Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {
    for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
        StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process").tag("postProcessor", postProcessor::toString);
		//核心，配置类的后置处理器会在此解析配置类
        postProcessor.postProcessBeanDefinitionRegistry(registry); 
        postProcessBeanDefRegistry.end();
    }
}

执行postProcessBeanFactory的回调【执行后置处理方法】

private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    // 此处重点关注：ConfigurationClassPostProcess
    for (BeanFactoryPostProcessor postProcessor : postProcessors) {
        StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process").tag("postProcessor", postProcessor::toString);
        // 执行后置处理器回调
        postProcessor.postProcessBeanFactory(beanFactory);
        postProcessBeanFactory.end();
    }
}

BeanPostProcessor执行顺序分析

UML结构

源码图解

注冊后置处理器

流程分析

1. martInstantiationAwareBeanPostProcessor#predictBeanType

作用：预测bean的类型，最后一次改变组件类型
执行时机：

2. InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation

执行时机：AbstractAutowireCapableBeanFactory#createBean#resolveBeforeInstantiation，bean实例化前

//初始化之前进行后置处理，Spring留给我们给这个组件创建对象的回调。
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>"+beanClass+"--"+beanName); //if(class.isAssFrom(Cat.class)){return new Dog()}
    return null; //如果我们自己创建了对象返回。Spring则不会帮我们创建对象，用我们自己创建的对象？ 我们创建的这个对象，Spring会保存单实例？还是每次getBean都调到我们这里创建一个新的？
}

3. SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors

作用：返回我们要使用的构造器候选列表
执行时机：AbstractAutowireCapableBeanFactory#createBeanInstance：bean实例化时

4. MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition

作用：
执行时机：

5. InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation

public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessAfterInstantiation=>"+bean+"--"+beanName); //提前改变一些Spring不管的bean里面的属性
    return true; //返回false则bean的赋值全部结束
}

作用：
执行时机：AbstractAutowireCapableBeanFactory#populateBean

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            return; // 中断springbean的赋值
        }
    }
}

6. InstantiationAwareBeanPostProcessor#postProcessProperties

作用：解析自定义注解进行属性值注入；pvs 封装了所有的属性信息
执行时机：

7. BeanPostProcessor#postProcessBeforeInitialization

执行时机：

8. MergedBeanDefinitionPostProcessor#postProcessBeforeInitialization

执行时机：AbstractAutowireCapableBeanFactory#initializeBean(Object, RootBeanDefinition)

9. BeanPostProcessor#postProcessAfterInitialization

执行时机：AbstractAutowireCapableBeanFactory#initializeBean(Object, RootBeanDefinition)

10. MergedBeanDefinitionPostProcessor#postProcessAfterInitialization

执行时机：AbstractAutowireCapableBeanFactory#initializeBean(Object, RootBeanDefinition)

11. InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation

执行时机：AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])

循环依赖

参考：
核心：提前暴露未完全创建的Bean
三级缓存：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    //【一级缓存】（单例池）享元模式的单例。用于保存实例化、注入、初始化完成的bean实例
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    //【三级缓存】(单例工厂池)三级缓存用于保存bean创建工厂，以便后面扩展有机会创建代理对象
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    //【二级缓存】(早期单例池)二级缓存，存放早期暴露出来的 Bean 对象，Bean 的生命周期未结束（属性还未填充完）
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    
    // 一组已注册的单实例，按注册顺序包含bean名称 Set of registered singletons, containing the bean names in registration order.
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
    //当前正在创建的bean的名称 Names of beans that are currently in creation.
    private final Set<String> singletonsCurrentlyInCreation =
    Collections.newSetFromMap(new ConcurrentHashMap<>(16));
}

A依赖B，B依赖A：

1. A创建过程中，依赖注入发现需要B，于是将A放入三级缓存，去实例化B
2. B实例化过程发现需要A，检查1级缓存（没有），检查二级缓存（没有），检查三级缓存（发现A），将A从三级缓存放入二级缓存，并删除三级缓存中的A
3. B初始化完成，将自己放入一级缓存（此时B中的A依然是创建状态），然后回来接着创建A，此时B创建创建结束，

A的创建

1. AbstractBeanFactory#doGetBean#getSingleton检查一级缓存，返回null
2. DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory)：
   1. 检查一级缓存，返回null
   2. 将a标记为正在创建，放入singletonsCurrentlyInCreation容器
   3. singletonObject = singletonFactory.getObject()调用lamda表达式：createBean(beanName, mbd, args) 创建A对象
3. AbstractAutowireCapableBeanFactory#doCreateBean创建A，判断A是否早期暴露（是），将A放入三级缓存
4. bstractAutowireCapableBeanFactory#populateBean初始化A，发现依赖B，进入B的获取流程（所有自动注入的属性都是beanFactory.getBean(beanName)的结果）【进入B创建流程】
5. 返回B，A进行注入
6. addSingleton(beanName, singletonObject)：将B添加到一级缓存，删除二级、三级缓存中的B
   

B的创建

1. AbstractBeanFactory#doGetBean#getSingleton检查一级缓存，返回null
2. DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory)：
   1. 检查一级缓存，返回null
   2. 将a标记为正在创建，放入singletonsCurrentlyInCreation容器
   3. singletonObject = singletonFactory.getObject()调用lamda表达式：createBean(beanName, mbd, args) 创建B对象
      1. AbstractAutowireCapableBeanFactory#doCreateBean创建B，判断B是否早期暴露（是），将B放入三级缓存
      2. 【B的注入】bstractAutowireCapableBeanFactory#populateBean初始化B，发现依赖A，进入A的获取流程（所有自动注入的属性都是beanFactory.getBean(beanName)的结果）
      3. 依次 检查123缓存，发现三级缓存有A。调用ObjectFactory的getObject方法触发lamda回调获取A，将A放入二级缓存，并删除三级缓存：() -> getEarlyBeanReference(beanName, mbd, bean)

@Nullable  //双检查锁
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //先检查单例缓存池，获取当前对象  Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName); //一级缓存
    //如果当前bean正在创建过程中，而且缓存中没有则继续
    if (singletonObject == null  // 一级缓存没有
            && isSingletonCurrentlyInCreation(beanName) /*是否正在创建*/) {
        // 从【二级缓存】早期单例对象的缓存中获取
        singletonObject = this.earlySingletonObjects.get(beanName); //二级
        if (singletonObject == null && allowEarlyReference /*是否应创建早期引用，解决循环依赖*/) {
            synchronized (this.singletonObjects) { // 锁定一级缓存
                // 在完全单例锁中一致地创建早期引用 Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        // 【三级缓存】(单例工厂池)
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); //三级
                        if (singletonFactory != null) {
                            // 单例对象
                            singletonObject = singletonFactory.getObject();
                            // 放入【二级缓存】早期单例对象的缓存
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 从【三级缓存】(单例工厂池)移除
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

  4. 返回A，最后B完成A注入
  5. initializeBean完成B的初始化

4. DefaultSingletonBeanRegistry#addSingleton(beanName, singletonObject)：将B添加到一级缓存，删除二级、三级缓存中的B

AbstractAutowireCapableBeanFactory#doCreateBean创建B使用后置处理器处理属性

//使用后置处理器处理属性
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
    PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    if (pvsToUse == null) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
        if (pvsToUse == null) {
            return;
        }
    }
    pvs = pvsToUse; //封装了当前bean的所有属性名和值，可以由后置处理器处理得到
}

DefaultListableBeanFactory#doResolveDependency

if (instanceCandidate instanceof Class) {
    instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;

DependencyDescriptor#resolveCandidate获取A

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
    throws BeansException {
    return beanFactory.getBean(beanName); //所有自动注入的属性都是beanFactory.getBean(beanName);的结果
}

AOP原理分析

入口：@EnableAspectJAutoProxy

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {}

ConfiqurationClassPostProcessor后置处理器会解析配置类中的@Import导入AspectJAutoProxyRegistrar

@Override
public void registerBeanDefinitions(
    AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    //注册切面的基于注解的自动代理创建器
    AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    ....
}

// 最后调用到，注册AnnotationAwareAspectJAutoProxyCreator
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        BeanDefinitionRegistry registry, @Nullable Object source) {
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

AnnotationAwareAspectJAutoProxyCreator是自动代理创建器。容器刷新中registerBeanPostProcessors(beanFactory)注册后置处理器，会在Bean创建的时候发现所有的Advisor并进行拦截代理。

spring中设计模式

创建型

结构型

行为型