介绍

记录Spring IOC的源码解析

结构关系

常用的两个加载配置文件的类 ClassPathXmlApplicationContextAnnotationConfigApplicationContext的继承关系图:

image20191220142326074-2020-08-31-13:51:10.png

  • ClassPathXmlApplicationContext 通过xml的方式加载容器
  • AnnotationConfigApplicationContext 通过注解的方式加载容器

这两个类都是 AbstractApplicationContext抽象类的子类,调用其子类构建bean容器时,都会调用其父类的 refresh方法,在 refresh方法中就完成了bean容器的创建

环境搭建

创建一个Maven项目,在pom文件中添加Spring-Context依赖即可,代码如下:

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.2.1.RELEASE</version>
</dependency>

编写一个启动类,代码如下:

@ComponentScan("test") //标记需要扫描的包
public class Application {
  public static void main(String[] args) {
    //创建一个注解配置的Context,把自身传入(因为在该类中通过注解指明了需要扫描哪个包)
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Application.class);
    //从容器中获取bean
    TestBean testBean = (TestBean) context.getBean("testBean");
    System.out.println(testBean);
  }
}

创建bean,代码如下:

@Component //标记需要添加到ioc容器中
public class TestBean {
    public TestBean() {
        System.out.println("初始化bean");
    }
}

创建 AwareBean类,实现了 InstantiationAwareBeanPostProcessor接口

用于调试bean的生命周期,也方便debug源码

代码如下:

@Component
public class AwareBean implements InstantiationAwareBeanPostProcessor {
    /**
     * 顺序1,在bean实例化前被调用
     * @param beanClass 对应bean的类型
     * @param beanName 对应bean的名称
     * @return 如果返回null则继续进行实例化bean;如果返回对应bean,则不继续实例化bean,而直接将返回的bean放入到容器中
     * @throws BeansException
     */
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
      return null;
    }

    /**
     * 顺序2,在bean实例化后被调用,判断bean是否需要被自动注入属性
     * @param bean 对应的bean
     * @param beanName 对应的bean的名称
     * @return 如果返回true则允许自动注入属性到该bean中;如果返回false,则跳过该bean的属性注入
     * @throws BeansException
     */
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
      return true;
    }

    /**
     * 顺序3,给对应的bean初始化(设置属性),将PropertyValues中的值设置到bean中
     * @param pvs 需要设置的参数
     * @param bean 要初始化的bean
     * @param beanName bean的名称
     * @return 返回给bean初始化用的参数配置;如果返回null,则使用已经存在的参数
     * @throws BeansException
     */
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
      return null;
    }

    /**
     * 顺序4,在bean初始化(设置属性)完成后的before回调
     * @param bean 设置完属性后的bean
     * @param beanName bean的名称
     * @return 返回对应bean实例;如果返回null,则不会执行后续的BeanPostProcessors
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      return bean;
    }

    /**
     * 顺序5,在bean初始化(设置属性)完成后的after回调
     * @param bean 设置完属性后的bean
     * @param beanName bean的名称
     * @return 返回对应的bean实例;如果返回null,则不会执行后续的BeanPostProcessors
     * @throws BeansException
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

源码调试技巧

AwareBean类的方法中添加断点,运行启动类即可

因为在上述代码中,AwareBean类实现了 InstantiationAwareBeanPostProcessor接口,而该接口在Spring容器初始化时,会回调该接口的方法

主要概念

  • 所谓的IOC容器,其实就是一个ConcurrentHashMap(),它以一个BeanName对于Bean进行存放
  • 对象和bean的区别: 对象经过Spring为其设置的一些系列生命周期之后,才能够成为bean,并存放到IOC容器中
  • Class和BeanDefinition的区别: Class记录了一个类具体的信息,而BeanDefinition是Spring编写的类,是用来记录Bean的具体信息
  • beanDefinitionMap: 存放BeanName和Bean定义

SpringIOC的宏观流程图

为了更好的理解SpringIOC的整体流程,所以特别的画了宏观的流程图

转载时请注明转载地址:http://luyingjie.cn ,感谢!

总结归纳宏观流程图

  1. 如果我们有实现了BeanFactoryPostProcessor接口的类,那么spring会首先去实例化并注册这些实现类,然后并循环调用他们的postProcessBeanFactory(ConfigurableListableBeanFactory var1)方法,在该方法中可以获取到所有bean的定义,可以进行动态的修改
  2. 接下来实例化并注册实现了InstantiationAwareBeanPostProcessor接口的类,该接口中包含了很多bean生命周期回调一些方法,如实例化前后的回调,初始化前后的回调,自动装配前后的回调 (该接口继承了BeanPostProcessor接口,因此具有了初始化前后的回调的方法) 3.接下来循环所有的单例bean,挨个的进行实例化初始化,并在实例化前后,初始化前后回调我们之前已经设置的后置处理器
    1. 实例化前回调(postProcessBeforeInstantiation)
    2. 执行构造方法进行实例化
    3. 实例化后回调(postProcessAfterInstantiation)
    4. 自动装配
    5. 初始化前回调(postProcessBeforeInitialization)

      其中会执行@PostStructure标注的方法

    6. 执行bean的初始化操作

      执行InitializingBean接口的afterPropertiesSet方法

    7. 初始化后回调(postProcessAfterInitialization)

源码解析

接下来会通过 AnnotationConfigApplicationContext类举例进行解析,其他的类基本上大同小异

AnnotationConfigApplicationContext类中,主要有三个重要的方法,如下所示:

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
	//调用自身构造方法,主要功能为创建注解的BeanDefinition
	this(); 

	//主要功能为注册指定的组件配置类,这些类是在Application主启动类中传入的入口类,可以传入多个
	register(componentClasses);

	//主要功能为创建对应的bean
	refresh();
}

this

主要作用: 创建并注册处理注解相关的处理器

在该方法中,调用了 AnnotatedBeanDefinitionReader类的构造方法,代码如下:

//根据指定的环境创建注解相关的处理器,并添加到ioc容器中
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
	//...
	this.registry = registry;

	//创建条件执行器,之后用来判断是否已存在对应的bean,若存在则不再创建对应的bean
	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);

	//注册默认的注解配置处理器,保存在beanDefs中 
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

spring总共默认注册了5中注解配置处理器,分别为:

  1. org.springframework.context.annotation.internalConfigurationAnnotationProcessor:@Configuration注解处理器
  2. org.springframework.context.annotation.internalAutowiredAnnotationProcessor:@Autowired注解处理器
  3. org.springframework.context.annotation.internalCommonAnnotationProcessor
  4. org.springframework.context.event.internalEventListenerProcessor:事件监听处理器
  5. org.springframework.context.event.internalEventListenerFactory:事件监听工厂

register

主要作用为: 解析传入的类上的注解,将注解中指定类和传入的类解析成 BeanDefinition保存起来,用于后续的使用

该方法会调用 AnnotatedBeanDefinitionReader类的 register方法,代码如下:

//注册一个或多个组件
public void register(Class<?>... componentClasses) {
	for (Class<?> componentClass : componentClasses) {
		//主要功能为解析对应类上的注解,然后将指定的类和注解中指定的类解析成BeanDefinition并保存
		registerBean(componentClass);
	}
}

doRegisterBean

AOP相关: 如果开启了代理,则对应的bean代理类的BeanDefinition会在这个方法中被注册

registerBean方法中,会调用 AnnotatedBeanDefinitionReaderdoRegisterBean方法,代码如下:

private <T> void doRegisterBean(Class<T> beanClass, String name, Class<? extends Annotation>[] qualifiers,Supplier<T> supplier,BeanDefinitionCustomizer[] customizers) {
  //创建未注册注解的BeanDefinition,生成指定类的标注的注解信息
  AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
  
  //获取类的注解,判断是否有标注condition相关的注解,来判断是否需要跳过该bean的注册
  if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
    return;
  }

  abd.setInstanceSupplier(supplier);
  
  //获取该bean的作用域(单例或多例)
  ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
  
  abd.setScope(scopeMetadata.getScopeName());
  
  //生成bean的名称(规则为类名首字母小写),如果name有指定,则返回指定的name
  String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

  //主要功能是处理该类上标注的通用的注解
  //解析bean对应的类上的注解,并设置到bean的beanDefinition属性中
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	//判断是否传入Qualifiers相关的注解(如果没有在bean对应的类上标注注解,也支持通过注册bean时传入一些Qualifiers相关的信息来修改beanDefinition)
	if (qualifiers != null) {
		for (Class<? extends Annotation> qualifier : qualifiers) {
			//如果有传入Primary相关的,则设置为true
			if (Primary.class == qualifier) {
				abd.setPrimary(true);
			}
			//如果有传入Lazy相关的,则设置为true
			else if (Lazy.class == qualifier) {
				abd.setLazyInit(true);
			}
			else {
				abd.addQualifier(new AutowireCandidateQualifier(qualifier));
			}
		}
	}
  if (customizers != null) {
    for (BeanDefinitionCustomizer customizer : customizers) {
      customizer.customize(abd);
    }
  }

  //创建对应bean的一个包装类
  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
  
  //判断该bean是否需要被代理,如果不需要,则直接返回默认的BeanDefinition,如果需要,则创建代理类的BeanDefinition返回(AOP相关的内容)
  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
  
  //真正注册BeanDefinition,将bean的名称和定义注册到BeanDefinitionMap中
  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

如果有开启代理,则在 AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);中会创建代理类的BeanDefinition并返回

那么后续在 refresh方法中,创建对应的bean的时候,创建的就是该bean的代理类

refresh

非常重要的方法

@Override
public void refresh() throws BeansException, IllegalStateException {
	//在刷新之前准备好上下文环境(环境配置,监听器,事件触发等)
	prepareRefresh();

	//获取类型为DefaultListableBeanFactory的beanFactory
	ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

	//给beanFactory设置ClassLoader 和 post-processors
	prepareBeanFactory(beanFactory);

	//空方法,子类可以覆盖空方法,并可以在方法中操作beanFactory
	postProcessBeanFactory(beanFactory);

	//获取并执行BeanFactoryPostProcessor的回调(根据优先级来先后回调)
	//第一次回调:用于修改或添加beanDefinition(BeanDefinitionRegistryPostProcessor的回调)
	invokeBeanFactoryPostProcessors(beanFactory);

	//在bean实例化之前,实例化并注册beanPostProcessor
	registerBeanPostProcessors(beanFactory);

	//为上下文初始化信息源(目前还不知道是干什么的)
	initMessageSource();

	//为上下文初始化广播事件(目前还不知道是干什么的)
	initApplicationEventMulticaster();

	//空方法,容器子类可以覆盖该方法,用来初始化一些特殊的bean
	onRefresh();

	//注册所有的事件监听器(包括早期的事件监听器和实现了ApplicationListener接口的事件监听器)
	registerListeners();

	//实例化所有剩下的非懒加载的单例bean
	finishBeanFactoryInitialization(beanFactory);

	//最后一步,发送应用启动完成的消息事件
	finishRefresh();
}

prepareBeanFactory

给beanFactory设置ClassLoader 和 post-processors

会调用 AbstractApplicationContext类的 prepareBeanFactory方法,部分重要代码如下:

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	//设置bean的类加载器信息
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	//设置beanPostProcessor并用于上下文的回调
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);


	//注册早期的post-processor,用于早期的bean回调
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	//...

}

invokeBeanFactoryPostProcessors

获取并执行BeanFactoryPostProcessor的回调(根据优先级来先后回调) 第一次回调:用于修改获取添加beanDefinition(BeanDefinitionRegistryPostProcessor的回调)

重要:

在bean实例化之前,Spring会通过 BeanFactoryPostProcessor先进行一次回调,在此期间,还有机会修改指定的 BeanDefinition

会调用 AbstractApplicationContext类的 invokeBeanFactoryPostProcessors方法,部分重要代码如下:

//执行BeanFactory的后置处理器
public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	Set<String> processedBeans = new HashSet<>();

	//+++++++++++++++++++++++++先执行类型为BeanDefinitionRegistry的回调+++++++++++++++++++++++++
	//如果beanFactory属于BeanDefinitionRegistry类型
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		//如果默认存在(默认没有,所以直接跳过),则先调用对应的postProcessBeanDefinitionRegistry
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		//接下来会执行所有的beanPostProcessor相关的回调,用于在bean实例化进行人为的干预
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		//===========先回调实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor=========
		//拿到所有的BeanDefinitionRegistryPostProcessor类型的beanName
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		//遍历所有beanName,并将实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor先加到RegistryProcessors中
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				//通过bean的名称和类型注册并实例化相关的BeanDefinitionRegistry后置处理器
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//并将已经添加的名称保存,用于接下来不重复执行回调
				processedBeans.add(ppName);
			}
		}
		//将实现PriorityOrdered接口的postProcessBeanDefinitionRegistry进行排序
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		//将所有的排好序并且优先级较高的先全部添加到registryProcessors中
		registryProcessors.addAll(currentRegistryProcessors);
		//执行优先级较高的postProcessBeanDefinitionRegistry回调
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		//执行完之后,将已经执行的postProcessor全部清空
		currentRegistryProcessors.clear();

		//=========再回调实现了Ordered接口的BeanDefinitionRegistryPostProcessor========
		//拿到实现了Ordered接口的所有beanName,进行遍历回调
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				//并将已经添加的名称保存,用于接下来不重复执行回调
				processedBeans.add(ppName);
			}
		}
		//这里和之前上面的逻辑是一样的,就是先排序,再回调,最后清空
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		//===========最后,回调剩下的BeanDefinitionRegistryPostProcessor===========
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//如果之前都没有执行过该对应的回调,那么就添加
				if (!processedBeans.contains(ppName)) {
					//通过bean的名称和类型注册并实例化相关的BeanDefinitionRegistry后置处理器
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			//这里和之前上面的逻辑是一样的,就是先排序,再回调,最后清空
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		//执行所有的BeanFactoryPostProcessors的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
	}
	//如果不属于BeanDefinitionRegistry类型
	else {
		//执行所有默认的BeanFactoryPostProcessors的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	//+++++++++++执行类型为BeanFactoryPostProcessor的回调(BeanFactoryPostProcessor是上面的BeanDefinitionRegistry类型的父类,所以可能会获取到更多的内容)++++++++++
	//获取到所有类型为BeanFactoryPostProcessor的beanName
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	//===========下面的套路和上面是一样的,就是先排序,再执行,再清空==========
	//下面将不同的还未执行过的BeanFactoryPostProcessor分发到不同的集合中
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		//如果之前已经回调过了,那么这里就跳过
		if (processedBeans.contains(ppName)) {

		}
		//如果实现了PriorityOrdered接口,则添加到对应的集合中
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		//如果实现了Ordered接口,则添加到对应的集合中
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		//剩下的都添加到nonOrdered的集合中
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	//===========首先,将实现PriorityOrdered接口的进行在priorityOrderedPostProcessors集合中排序===========
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	//再挨个执行排序后的集合中的postProcessBeanFactory回调
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	//===========接着,将实现Ordered接口并且是BeanFactoryPostProcessor类型的进行在orderedPostProcessors集合中排序==========
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	//再挨个执行排序后的集合中的postProcessBeanFactory回调
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	//===========最后,将BeanFactoryPostProcessor类型的保存到nonOrderedPostProcessors集合中==========
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	//再挨个执行nonOrderedPostProcessors集合中的postProcessBeanFactory回调
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

	//清除缓存
	beanFactory.clearMetadataCache();
}

所以,通过上述源码可知:

BeanFactoryPostProcessor的回调优先级如下:

  • BeanDefinitionRegistryPostProcessor的优先级大于普通的BeanFactoryPostProcessor

对于同类型的 PostProcessor来说:

  • 实现了PriorityOrdered接口的PostProcessor优先级 > 实现了Ordered接口的PostProcessor优先级 > 普通的PostProcessor

registerBeanPostProcessors

在bean实例化之前,实例化并注册beanPostProcessor,用于之后bean实例化之后的回调

该方法会调用 PostProcessorRegistrationDelegate类的 registerBeanPostProcessors方法代码如下:

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

	//获取所有类型为BeanPostProcessor的后置处理器的name数组
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	//注册BeanPostProcessorChecker,用于打印bean创建的日志,并校验bean的数量等
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	//比较BeanPostProcessors的优先级并进行排序(总的顺序是按照PriorityOrdered>Ordered>普通的)
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();

	//将实现了不同接口的类进行分发,分发到不同的集合中,然后再按照每个集合中每个类的优先级去执行回调
	for (String ppName : postProcessorNames) {
		//如果实现了PriorityOrdered接口
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			//如果属于BeanPostProcessor类型
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			//将该PostProcessor添加到priorityOrderedPostProcessors集合中
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				//如果该PostProcessor又属于MergedBeanDefinitionPostProcessor类型,则再添加到internalPostProcessors集合中
				internalPostProcessors.add(pp);
			}
		}
		//如果实现了Ordered接口
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			//则添加到orderedPostProcessorNames集合中
			orderedPostProcessorNames.add(ppName);
		}
		//将剩下的全部添加到nonOrderedPostProcessorNames集合中
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	//========首先,先注册实现了PriorityOrdered接口的BeanPostProcessors===========
	//将全都实现了PriorityOrdered接口的BeanPostProcessors再进行排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	//将排好序的BeanPostProcessors全部注册到beanFactory中
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	//接下来,再注册实现了Ordered接口的BeanPostProcessors,套路和上面的相同,先排序,然后再全部注册到beanFactory中===========
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);//添加
		}
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);//排序
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);//注册

	//注册所有普通BeanPostProcessors(剩下的所有BeanPostProcessors),套路和上面略微不同,直接全部注册,因为没有顺序要求
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);//注册

	//internalPostProcessors保存着用于合并bean定义的后处理器回调接口
	//BeanPostProcessor实现可以实现这个子接口,用于在创建bean实例时的合并beanDefinition的回调(原始bean定义的已处理副本)
	//最后,重新注册所有的属于MergedBeanDefinitionPostProcessor类型的后置处理器
	sortPostProcessors(internalPostProcessors, beanFactory);//排序
	registerBeanPostProcessors(beanFactory, internalPostProcessors);//注册

	//将ApplicationListenerDetector注册到最后面
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

所以,通过上述源码可知:

BeanPostProcessor的回调优先级如下:

  • 实现了PriorityOrdered接口的PostProcessor优先级 > 实现了Ordered接口的PostProcessor优先级 > 普通的PostProcessor

finishBeanFactoryInitialization

最重要的一个方法,用于完成单例bean的实例化

该方法代码如下:

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	//...

	//实例化所有剩下的非懒加载的单实例bean(重点)
	beanFactory.preInstantiateSingletons();
}

在上述方法中,会调用 DefaultListableBeanFactory类的 preInstantiateSingletons方法,代码如下:

public void preInstantiateSingletons() throws BeansException {

	//复制并将所有的beanDefinitionNames转化成List集合,用于之后的迭代
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	//迭代并调用所有的非懒加载单实例bean的initialization方法
	for (String beanName : beanNames) {
		//获取到对应beanName合并后的beanDefinition
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

		//================如果bean不是抽象的,并且是单例的,并且不是懒加载的=================
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
	
			//---------------如果是FactoryBean-----------------
			if (isFactoryBean(beanName)) {
				//则通过Factory创建bean实例
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					//...
			
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			//---------------如果不是FactoryBean----------------
			else {
				//直接创建并获取对应的bean(基本上我们的bean都会在这里被创建)
				getBean(beanName);
			}
		}
	}

	//在单例预实例化阶段结束时调用,并保证已经创建了所有常规的单例bean。
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

getBean->doGetBean

getBean方法的主要作用是: 先从缓存中获取bean,如果有,则直接返回,如果没有,则创建bean,然后将bean再放入缓存中(在创建bean的过程中顺便进行bean的生命周期回调)

直到for循环将所有需要加载的bean都调用一遍 getBean方法,那么所有的bean就都加载完毕了

在上述方法中,最重要的就是 getBean方法,该方法又会调用 AbstractBeanFactory类的 doGetBean方法,代码如下:

doGetBean才是真正的代码核心 doGetBean方法有很多重载方法,需要仔细的看一下

//根据传入的不同参数注册并创建一个对应的bean实例,然后返回
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

	//规范beanName
	final String beanName = transformedBeanName(name);
	Object bean;

	//先从单例缓存中获取对应的单实例bean
	Object sharedInstance = getSingleton(beanName);

	//=========================如果缓存中有=========================
	//如果从缓存中获取到了bean,并且args为null
	if (sharedInstance != null && args == null) {
		//获取对应的bean实例的对象(如果是FactoryBean,返回的则是FactoryBean创建的对象,如果不是,那么返回的就是该bean实例本身)
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	//=========================如果缓存中没有=========================
	//那么spring就假定现在处于一个循环引用中(一般我们自己的bean基本上都会进入到这个条件中)
	else {
		//获取parentBeanFactory
		BeanFactory parentBeanFactory = getParentBeanFactory();

		//=================如果BeanFactory存在=================
		//并且beanDefinitionMap中不存在对应的beanDefinition,则创建bean并返回
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			//如果没找到,则查找父类工厂,再通过BeanFactory创建并返回对应的bean实例

			//获取到原始的bean名称
			String nameToLookup = originalBeanName(name);

			//如果parentBeanFactory属于AbstractBeanFactory类型
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				//则按照所有参数去创建并获取bean
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			//如果不是AbstractBeanFactory类型,且args不为空
			else if (args != null) {
				//则按照原始的bean名称和args去创建并获取bean
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			//如果不是AbstractBeanFactory类型,且args为空,且该bean是必须要装配的
			else if (requiredType != null) {
				//则按照原始的bean名称和是否必须的类型,交给标准的getBean方法去创建并返回bean
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				//如果什么条件都不符合,则按照名称去创建并返回bean
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		//=================如果BeanFactory不存在=================
		//获取合并后的beanDefinition
		//重要:在该方法中会将当前bean标记为已经创建
		final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
		//检查合并后的beanDefinition是否合法
		checkMergedBeanDefinition(mbd, beanName, args);

		//获取到当前bean所依赖的beanName数组
		String[] dependsOn = mbd.getDependsOn();

		//=============如果当前bean依赖于其他bean==============
		//先创建好其所有依赖的bean
		if (dependsOn != null) {
			//迭代需要依赖bean的集合,把他们都注册和创建好
			for (String dep : dependsOn) {
				//注册依赖的bean
				registerDependentBean(dep, beanName);

				//创建并获取依赖的bean实例
				getBean(dep);
			}
		}

		//=============如果当前bean没有依赖于其他bean==============
		//=======如果是单例=======
		if (mbd.isSingleton()) {
			//先从单例缓存中获取对应的bean实例,如果没有则注册并创建一个新的单例对象,并缓存到单实例缓存中
			//重点:在该方法中会标记当前的bean正在创建
			sharedInstance = getSingleton(beanName, () -> {
				try {
					//如果没有从单例缓存中获取到bean实例,则执行该方法创建bean实例
					return createBean(beanName, mbd, args);
				}
				catch (BeansException ex) {
					//如果异常,则销毁bean
					destroySingleton(beanName);
					throw ex;
				}
			});
			//获取对应的bean实例的对象(如果是FactoryBean,返回的则是FactoryBean创建的对象,如果不是,那么返回的就是该bean实例本身)
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
		//=======如果是原型=======
		else if (mbd.isPrototype()) {
			// It's a prototype -> create a new instance.
			Object prototypeInstance = null;
			try {
				//原型创建之前的回调,默认实现是将原型注册为当前正在创建的状态
				beforePrototypeCreation(beanName);
				//创建对应的bean实例
				prototypeInstance = createBean(beanName, mbd, args);
			}
			finally {
				//原型创建后的回调,默认实现是将原型标记为不在创建中
				afterPrototypeCreation(beanName);
			}
			//获取对应的对应的bean实例的对象(如果是FactoryBean,返回的则是FactoryBean创建的对象,如果不是,那么返回的就是该bean实例本身)
			bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
		}
		//=======如果是其他作用域=======
		else {
			//获取到bean的作用域名称
			String scopeName = mbd.getScope();
			//从map中获取到对应的作用域
			final Scope scope = this.scopes.get(scopeName);
			//如果为空则报错
			if (scope == null) {
				throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
			}
			//如果获取到的作用域不为空,根据不同作用域来创建bean实例并返回
			Object scopedInstance = scope.get(beanName, () -> {
				//原型创建之前的回调,默认实现将原型注册为当前正在创建的状态。
				beforePrototypeCreation(beanName);
				try {
					//创建对应的bean实例
					return createBean(beanName, mbd, args);
				}
				finally {
					//原型创建后的回调,默认实现将原型标记为不在创建中。
					afterPrototypeCreation(beanName);
				}
			});
			//获取对应的对应的bean实例的对象(如果是FactoryBean,返回的则是FactoryBean创建的对象,如果不是,那么返回的就是该bean实例本身)
			bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
		}
	}

	return (T) bean;//返回从单例缓存获取或者新创建的bean
}
getSingleton

在上述代码中,doGetBean方法中有两次调用了 getSingleton方法,且两次调用的分别是不同的重载方法,如下所示:

  • 第一次调用:
Object sharedInstance = getSingleton(beanName);
  • 第二次调用:
sharedInstance = getSingleton(beanName, () -> {
	return createBean(beanName, mbd, args);
});

7.1 第一次调用

具体的 getSingleton(beanName)方法代码如下:

public Object getSingleton(String beanName) {
	//从单例缓存中获取对应的bean实例,并且允许早期引用
	return getSingleton(beanName, true);
}

然后就又调用了 getSingleton(String beanName, boolean allowEarlyReference)的重载方法,代码如下:

//通过指定beanName和是否允许早期引用(解决循环引用)来获取单例bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	//从保存单实例bean的ConcurrentHashMap中获取实例
	Object singletonObject = this.singletonObjects.get(beanName);
	//如果没有获取到,并且该bean当前正在创建状态
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			//从早期的缓存单实例bean的HashMap中获取实例
			singletonObject = this.earlySingletonObjects.get(beanName);
			//如果没有获取到,并且允许早期引用
			if (singletonObject == null && allowEarlyReference) {
				//从缓存单例工厂的HashMap中获取对应的单例工厂
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				//如果获取到了单例工厂
				if (singletonFactory != null) {
					//从单例工厂获取一个对应的单实例bean
					singletonObject = singletonFactory.getObject();
					//将获取到的单实例对象缓存到早期的缓存单实例bean的HashMap中
					this.earlySingletonObjects.put(beanName, singletonObject);
					//将缓存单例工厂的HashMap中的对应的单例工厂删除
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	//返回对应的单例对象
	return singletonObject;
}

7.2 第二次调用

代码如下:

//通过指定beanName和单例工厂来获取单例bean
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {

	synchronized (this.singletonObjects) {
		//获取对应beanName的单实例bean
		Object singletonObject = this.singletonObjects.get(beanName);//从ConcurrentHashMap中获取
		//如果没有找到
		if (singletonObject == null) {

			//将该bean标记为正在创建
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}

			//通过工厂创建一个bean实例
			//========重要========
			singletonObject = singletonFactory.getObject();//该方法会调用在外部传入的createBean(beanName, mbd, args)方法
			newSingleton = true;

			afterSingletonCreation(beanName);
	
			//如果创建成功
			if (newSingleton) {
				//缓存创建的bean实例
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;//返回单实例bean(如果单例缓存中存在,则直接返回,如果不存在,则创建后,缓存并返回)
	}
}

8. createBean

重要:在该方法中,就开始了一个bean的生命周期回调

在第二次的 getSingleton方法中,会调用 AbstractAutowireCapableBeanFactory类的 createBean方法进行创建bean实例和生命周期的回调,具体代码如下:

/**
 * 核心方法,主要功能为:
 * 		1.执行postProcessBeforeInstantiation回调
 * 		2.创建对应的bean实例,并返回bean实例(doCreateBean()方法)
 * 			- 实例化bean
 * 			- 初始化的一系列回调
 */
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	RootBeanDefinition mbdToUse = mbd;

	//解析并获取bean的类信息
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	//如果获取到了类信息,并且beanDefinition中没有类信息,请求beanDefinition中的类名称不为空
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		//把对应的类信息添加到beanDefinition中
		mbdToUse.setBeanClass(resolvedClass);
	}

	//准备方法覆盖
	mbdToUse.prepareMethodOverrides();

	//=============第一次回调:实例化前回调=============
	//回调postProcessBeforeInstantiation方法,提供了直接返回bean的代理类实例的机会
	//该方法默认返回null,如果返回代理类,则在该方法中会回调postProcessAfterInitialization方法
	Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
	if (bean != null) {
		//如果不为null,则直接返回bean实例
		return bean;
	}

	//=============实例化bean============
	//如果在第一次回调时没有返回bean,则在此进行实例化bean
	Object beanInstance = doCreateBean(beanName, mbdToUse, args);

	//返回实例化并初始化后的bean实例
	return beanInstance;
}

9. doCreateBean

实例化bean,并进行一系列的bean的生命周期回调

代码如下:

/**
 * 该方法的主要作用:
 * 		1.实例化bean
 * 		2.执行MergedBeanDefinitionPostProcessors回调
 * 		3.初始化bean
 * 			- 初始化bean的属性值(自动装配)
 * 				1.执行postProcessAfterInstantiation回调
 * 				2.自动装配
 * 				3.执行postProcessProperties回调
 * 			- 调用bean的初始化方法
 * 				1.执行初始化之前的回调:postProcessBeforeInitialization
 * 				2.执行实现了InitializingBean接口的初始化方法
 * 				3.执行初始化之后的回调:postProcessAfterInitialization
 * 		4.解决循环引用的问题
 * 		5.返回bean
 */
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	//===========================实例化bean===========================
	BeanWrapper instanceWrapper = null;
	//如果bean是单例
	if (mbd.isSingleton()) {
		//将beanName从未完成的bean的缓存中删除并返回删除的对应,在该方法后继续之前未完成的bean的实例化操作
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	//如果该bean不存在未完成的bean的缓存中
	if (instanceWrapper == null) {
		//创建bean实例的包装类(在这里调用bean的构造方法来创建bean)
		//在这里会选择使用哪个构造方法来创建bean实例
		instanceWrapper = createBeanInstance(beanName, mbd, args);//会调用对象的构造方法
	}
	//获取包装类中的bean实例
	final Object bean = instanceWrapper.getWrappedInstance();
	//获取bean实例的类型
	Class<?> beanType = instanceWrapper.getWrappedClass();
	//如果bean的类型不为NullBean
	if (beanType != NullBean.class) {
		//则将bean的类型设置到beanDefinition中保存
		mbd.resolvedTargetType = beanType;
	}
	//===========================实例化bean===========================

	//执行所有合并后的BeanDefinition的后置处理器
	synchronized (mbd.postProcessingLock) {
		//如果未执行该回调
		if (!mbd.postProcessed) {
			//执行回调
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

			//标记已经执行了回调
			mbd.postProcessed = true;
		}
	}

	//==========如果当前的bean是单例,并且允许循环引用,并且正在被创建===========
	//急切的缓存单例以便解决循环引用的问题
	//判断是否需要提前创建并缓存单例
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		//将当前的bean先添加到单例工厂中
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	//===========================初始化bean(重要)===========================
	//设置属性并调用初始化方法
	Object exposedObject = bean;
	//设置bean的属性
	populateBean(beanName, mbd, instanceWrapper);
	//执行bean的初始化方法和后置处理器的回调方法
	exposedObject = initializeBean(beanName, exposedObject, mbd);

	//=========================解决循环引用的问题==========================
	//如果提前创建并缓存单例了
	if (earlySingletonExposure) {
		//从单例缓存中获取bean
		Object earlySingletonReference = getSingleton(beanName, false);
		//如果获取到了
		if (earlySingletonReference != null) {
			//如果包装类中bean对象和从缓存中获取的bean的引用相等
			if (exposedObject == bean) {
				//则把当前缓存中的bean的引用赋值给初始化完成后的bean实例对象
				exposedObject = earlySingletonReference;
			}
			//在循环引用中不注入原始bean实例,并且当前bean依赖其他bean
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				//获取当前bean的所有依赖的名称
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				//遍历当前bean所依赖的名称
				for (String dependentBean : dependentBeans) {
					//从保存已创建bean的集合列表中删除当前bean所依赖的beanName,如果本来就没有缓存
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						//将当前bean依赖的beanName添加到真实依赖的bean的集合中
						actualDependentBeans.add(dependentBean);
					}
				}
			}
		}
	}

	// 将当前bean注册为一次性的,在bean关闭时执行销毁
	registerDisposableBeanIfNecessary(beanName, bean, mbd);

	//返回执行初始化方法后返回的bean实例
	return exposedObject;
}

10.1 populateBean

该方法会执行 postProcessAfterInstantiation回调,再进行属性注入,再执行 postProcessProperties回调

doCreateBean方法中,会调用 AbstractAutowireCapableBeanFactory类的 populateBean方法

具体代码如下:

/**
 * 自动装配:将BeanDefinition中的属性设置到实例化后的bean中
 *
 * 获取自动装配的类型,总共有5种类型:
 * 		1.AUTOWIRE_NO:值为0;
 * 			- 没有明确的指定注入类型
 * 		2.AUTOWIRE_BY_NAME:值为1
 * 			- 指定通过名称进行注入
 * 		3.AUTOWIRE_BY_TYPE:值为2
 * 			- 指定通过类型进行注入
 * 		4.AUTOWIRE_CONSTRUCTOR:值为3
 * 			- 指定通过构造函数进行注入
 * 		5.AUTOWIRE_AUTODETECT:值为4
 * 			- 自动选择适当的方式进行注入
 */
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {

	//=========================调用postProcessAfterInstantiation方法======================
	//在自动装配之前,通过postProcessAfterInstantiation回调可以修改当前bean的马上要设置的属性值
	//如果不是合成的,并且有InstantiationAware后置处理器
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				//回调后置处理器,默认返回true,如果返回false,则不接下来的自动装配,而是直接返回;如果返回true,则继续接下来的自动装配
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}
	}

	//===============================属性装配(即自动装配)=================================

	//获取需要进行装配的参数
	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) {
			//执行按名称的自动注入(只是将默认需要注入的属性添加到MutablePropertyValues中,在之后postProcessPropertyValues回调中可以修改自动注入的值)
			autowireByName(beanName, mbd, bw, newPvs);
		}
		//如果按类型注入
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			//执行按类型的自动注入(只是将默认需要注入的属性添加到MutablePropertyValues中,在之后postProcessPropertyValues回调中可以修改自动注入的值)
			autowireByType(beanName, mbd, bw, newPvs);
		}
		//保存通过默认的自动注入方式需要注入的属性值(在后面可能会被后置处理器回调中修改)
		pvs = newPvs;
	}

	//==============如果是其他的注入类型================
	//判断是否有InstantiationAware的后置处理器
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	//判断是否需要依赖检查
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	//如果有InstantiationAware的后置处理器
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		//===============执行postProcessProperties回调==============
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				//主要回调:执行postProcessProperties回调,并返回修改后的参数集合类
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					//如果为null,则返回,不进行接下来的自动装配
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;//保存需要注入的属性值
			}
		}
	}

}

10.2 initializeBean

先执行实现了Aware接口的方法,再执行初始化前回调,再执行初始化方法(先执行InitializingBean接口的afterPropertiesSet方法,后执行标注有@PostConstruct注解的方法),再执行初始化后回调

doCreateBean方法中,会调用 AbstractAutowireCapableBeanFactory类的 initializeBean方法,代码如下:

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

	//执行实现了Aware接口的方法
	invokeAwareMethods(beanName, bean);

	//保存bean实例的引用
	Object wrappedBean = bean;

	//执行初始化前回调:postProcessBeforeInitialization
	wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

	//执行初始化方法方法(如果存在的话)
	//先执行实现了InitializingBean接口的afterPropertiesSet方法
	//后执行标注有@PostConstruct注解的方法
	invokeInitMethods(beanName, wrappedBean, mbd);

	//执行初始化之后回调:postProcessAfterInitialization
	wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

	//返回包装bean
	return wrappedBean;
}

BeanPostProcessor的执行顺序

  1. 回调所有的postProcessBeforeInstantiation

    在此期间执行bean的构造方法

  2. 回调所有的postProcessMergedBeanDefinition
  3. 回调所有的postProcessAfterInstantiation
  4. 回调所有的postProcessProperties
  5. 回调所有的postProcessBeforeInitialization
  6. 回调所有的afterPropertiesSet
  7. 回调所有的postProcessAfterInitialization
  8. 当调用close方法时,回调所有的postProcessBeforeDestruction

如何解决循环引用

A依赖B,B依赖A

  1. 先创建A实例,第一次调用getSingleton方法时,标记A正在创建,然后调用A的无参构造方法创建A实例,然后正常的初始化A,在自动装配的时候发现需要B,此时发现B还没有被创建,则去创建B
  2. 创建B实例,第一次调用getSingletion方法时,标记B正在创建,然后调用B的无参构造方法创建B实例,然后正常的初始化B,在自动装配的时候发现需要A,发现A已经被创建(因为之前已经标记A正在创建,所以不会再继续创建A,而是可以直接获取到A实例),然后就把A装配到B中,那么B就创建好了
  3. 当B创建好之后,A继续自动装配,将B装配到A中,那么A就创建好了

总结

Spring的源码的调用层次非常的深,上面的记录的内容只是把重要的核心内容进行了摘抄和概括

0条评论
头像
ICP证 : 浙ICP备18021271号