SpringBoot源码分析
Springboot源码分析
1、SpringApplication初始化
从run()方法进入，可以看到Springboot首先创建了SpringApplication，然后调用SpringApplication的run()方法。
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
return (new SpringApplication(primarySources)).run(args);
}
创建SpringApplication，首先要执行它的构造方法。
//SpringApplication.class
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.sources = new LinkedHashSet();
this.bannerMode = Mode.CONSOLE;
this.logStartupInfo = true;
this.addCommandLineProperties = true;
this.addConversionService = true;
this.headless = true;
this.registerShutdownHook = true;
this.additionalProfiles = new HashSet();
this.isCustomEnvironment = false;
this.lazyInitialization = false;
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
//webApplication类型一般是servlet
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//设置初始化器，加载spring.factories文件中的ApplicationContextInitializer
this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
//设置监听器，加载spring.factories文件中的ApplicationListener
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
//启动类的类型，我们的是com.example.demo.DemoApplication
this.mainApplicationClass = this.deduceMainApplicationClass();
}
1.1 & 1.2 设置初始化器和监听器
上面的setInitializers和setListeners去初始化spring.factories文件中对应的类，然后放入ArrayList中。比如这些：
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
1.2.1 getSpringFactoriesInstances
在getSpringFactoriesInstances()方法中，springboot首先去所有spring.factories找到对应的类，然后通过反射创建类的实例。
//SpringApplication.class
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
return this.getSpringFactoriesInstances(type, new Class[0]);
}
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
ClassLoader classLoader = this.getClassLoader();
//获取spring.factories中对应类的类名，以ApplicationListenser为例，springboot会去文件中找到所有ApplicationListener对应的类，放入Set中。
Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
//反射创建类的实例对象，放到List中返回
List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}
private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
List<T> instances = new ArrayList(names.size());
Iterator var7 = names.iterator();
while(var7.hasNext()) {
String name = (String)var7.next();
try {
//获取类信息
Class<?> instanceClass = ClassUtils.forName(name, classLoader);
Assert.isAssignable(type, instanceClass);
//获取构造器
Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
//创建实例
T instance = BeanUtils.instantiateClass(constructor, args);
instances.add(instance);
} catch (Throwable var12) {
throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
}
}
return instances;
}
1.2.2 loadFactoryNames()
进入SpringFactoriesLoader.loadFactoryNames(type, classLoader)看一下，这里还是以ApplicationListener为例，这时的type是org.springframework.context.ApplicationListener，classLoader是AppClassLoader。
//SpringFactoriesLoader.class
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
String factoryTypeName = factoryType.getName();
return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
MultiValueMap<String, String> result = new LinkedMultiValueMap();
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Map.Entry<?, ?> entry = (Map.Entry)var6.next();
String factoryTypeName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryImplementationName = var9[var11];
result.add(factoryTypeName, factoryImplementationName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var13) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
}
}
}
loadSpringFactories()方法会遍历所有的spring.factories文件，把所有的类的名字保存到map中，然后调用getOrDefault()方法就可以获取到所有的ApplicationListner对应的类名了。
SpringApplication初始化完了，接下来该执行run()方法了
2、SpringApplication执行run()方法
//SpringApplication.class
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
//这里是Spring的上下文
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
this.configureHeadlessProperty();
//获取运行监听器，获取到的是EventPublishingRunListener，这是springboot的启动监听器
SpringApplicationRunListeners listeners = this.getRunListeners(args);
//启动监听器
listeners.starting();
Collection exceptionReporters;
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
//2.1 准备环境
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
this.configureIgnoreBeanInfo(environment);
//Banner打印类
Banner printedBanner = this.printBanner(environment);
//2.2 创建应用上下文
context = this.createApplicationContext();
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
//2.3 准备上下文
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
//2.4 刷新上下文
this.refreshContext(context);
//刷新上下文后置处理
this.afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
}
//发布上下文启动完成事件
listeners.started(context);
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
this.handleRunFailure(context, var10, exceptionReporters, listeners);
throw new IllegalStateException(var10);
}
try {
listeners.running(context);
return context;
} catch (Throwable var9) {
this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
2.1 prepareEnvironment()准备环境
//SpringApplication.class
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
//根据前面推断的webApplicationType创建对应的环境，servlet对应的是StandardServletEnvironment()
ConfigurableEnvironment environment = this.getOrCreateEnvironment();
//根据参数配置环境，包括命令行参数，启动类传入的参数
this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
ConfigurationPropertySources.attach((Environment)environment);
//执行完这个，配置文件中的配置进行就被加载到环境中了
listeners.environmentPrepared((ConfigurableEnvironment)environment);
//环境和SpringApplication绑定起来
this.bindToSpringApplication((ConfigurableEnvironment)environment);
if (!this.isCustomEnvironment) {
environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
}
ConfigurationPropertySources.attach((Environment)environment);
return (ConfigurableEnvironment)environment;
}
2.1.1 根据参数配置环境configureEnvironment()
//SpringApplication.class
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
if (this.addConversionService) {
ConversionService conversionService = ApplicationConversionService.getSharedInstance();
environment.setConversionService((ConfigurableConversionService)conversionService);
}
//配置命令行中的参数
this.configurePropertySources(environment, args);
//激活相应的配置文件，例如application.propertires或者application-dev.properties等
this.configureProfiles(environment, args);
}
如果我启动的dev环境，执行完上面的代码后环境中是这样的
2.1.2 listeners.environmentPrepared()
执行完这句代码后，配置文件中的信息就被加载到环境中了，如下图。具体怎么做到的还没看懂
2.2 创建应用上下文createApplicationContext()
//SpringApplication.class
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
} catch (ClassNotFoundException var3) {
throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
}
}
return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
这个函数也是根据前面的webApplicationType创建应用上下文，servlet对应的是AnnotationConfigServletWebServerApplicationContext，当初始化完这个类时，其实也会创建一个IOC容器beanFactory，如下图所示。这是因为AnnotationConfigServletWebServerApplicationContext会继承GenericApplicationContext，当执行完这个类的构造函数，会创建一个DefaultListableBeanFactory()的beanFactory，这个就是IOC容器。
2.3 准备上下文prepareContext()
//SpringApplication.class
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
//设置上下文环境
context.setEnvironment(environment);
this.postProcessApplicationContext(context);
//初始化所有的ApplicationContextInitializer
this.applyInitializers(context);
//发布上下文准备完成事件
listeners.contextPrepared(context);
if (this.logStartupInfo) {
this.logStartupInfo(context.getParent() == null);
this.logStartupProfileInfo(context);
}
//获取IOC容器beanFactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//将springApplicationArguments和springBootBanner注册成单例
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
//2.3.1 获取资源，其中primarySources就是我们定义的启动类DemoApplication
Set<Object> sources = this.getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
//2.3.2 加载启动类，注入IOC容器
this.load(context, sources.toArray(new Object[0]));
//发布完成加载事件
listeners.contextLoaded(context);
}
2.3.1 & 2.3.2 获取启动类，注入IOC容器
当执行完getAllSources()，可以获取到启动类DemoApplication
重点看load()方法，进入load()。
//SpringApplication.class
protected void load(ApplicationContext context, Object[] sources) {
if (logger.isDebugEnabled()) {
logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
}
//创建BeanDefinitionLoader
BeanDefinitionLoader loader = this.createBeanDefinitionLoader(this.getBeanDefinitionRegistry(context), sources);
if (this.beanNameGenerator != null) {
loader.setBeanNameGenerator(this.beanNameGenerator);
}
if (this.resourceLoader != null) {
loader.setResourceLoader(this.resourceLoader);
}
if (this.environment != null) {
loader.setEnvironment(this.environment);
}
//加载启动类
loader.load();
}
其中getBeanDefinitionRegistry(context)方法会将之前的上下文context强转成BeanDefinitionRegistry，他们之间的继承关系很复杂，可以转换成不同的类完成不同的方法。createBeanDefinitionLoader()方法创建了一个BeanDefinitionLoader()，点进去看看。
//BeanDefinitionLoader.class
BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
Assert.notNull(registry, "Registry must not be null");
Assert.notEmpty(sources, "Sources must not be empty");
this.sources = sources;
//注解形式的Bean阅读器
this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
//xml形式的Bean阅读器
this.xmlReader = new XmlBeanDefinitionReader(registry);
if (this.isGroovyPresent()) {
this.groovyReader = new GroovyBeanDefinitionReader(registry);
}
//类路径扫描器
this.scanner = new ClassPathBeanDefinitionScanner(registry);
this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
}
一直跟进load()。
//BeanDefinitionLoader.class
private int load(Class<?> source) {
if (this.isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
GroovyBeanDefinitionSource loader = (GroovyBeanDefinitionSource)BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
this.load(loader);
}
//启动类会走进这里
if (this.isEligible(source)) {
//将启动类注册进beanDefinitionMap
this.annotatedReader.register(new Class[]{source});
return 1;
} else {
return 0;
}
}
进入register()方法。
//AnnotatedBeanDefinitionReader.class
public void register(Class<?>... componentClasses) {
Class[] var2 = componentClasses;
int var3 = componentClasses.length;
for(int var4 = 0; var4 < var3; ++var4) {
Class<?> componentClass = var2[var4];
this.registerBean(componentClass);
}
}
public void registerBean(Class<?> beanClass) {
this.doRegisterBean(beanClass, (String)null, (Class[])null, (Supplier)null, (BeanDefinitionCustomizer[])null);
}
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
//将beanClass(这里是启动类DemoApplication)封装成AnnotatedGenericBeanDefinition
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
if (!this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
abd.setInstanceSupplier(supplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry);
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
int var10;
int var11;
if (qualifiers != null) {
Class[] var9 = qualifiers;
var10 = qualifiers.length;
for(var11 = 0; var11 < var10; ++var11) {
Class<? extends Annotation> qualifier = var9[var11];
if (Primary.class == qualifier) {
abd.setPrimary(true);
} else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
} else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
if (customizers != null) {
BeanDefinitionCustomizer[] var13 = customizers;
var10 = customizers.length;
for(var11 = 0; var11 < var10; ++var11) {
BeanDefinitionCustomizer customizer = var13[var11];
customizer.customize(abd);
}
}
//创建BeanDefinitionHolder，就是把BeanDefinition包装了一下，添加了一些属性和方法。
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//将启动类BeanDefinition注册到IOC容器的map中。
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
}
registerBeanDefinition()方法实际会调用BeanDefinitionRegistry的registerBeanDefinition()方法，它在DefaultListableBeanFactory实现类里实现的，之前说过这个就是IOC容器。
//DefaultListableBeanFactory.class
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition)beanDefinition).validate();
} catch (BeanDefinitionValidationException var8) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var8);
}
}
//IOC容器beanFactory的beanDefinitionMap
BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
if (existingDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(existingDefinition)) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
if (this.hasBeanCreationStarted()) {
synchronized(this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
this.removeManualSingletonName(beanName);
}
} else {
//启动阶段会走到这里，以beanName为key，beanDefinition为value存入beanDefinitionMap中
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition == null && !this.containsSingleton(beanName)) {
if (this.isConfigurationFrozen()) {
this.clearByTypeCache();
}
} else {
this.resetBeanDefinition(beanName);
}
}
注册完之后可以看到demoApplication已经被添加到beanFactory的beanDefinitionMap中了。
2.4、刷新上下文refreshContext()
Springboot最终在这里调用Spring的refresh()方法，从refreshContext()一直跟进去会到AbstractApplicationContext的refresh()方法。
//AbstractApplicationContext.class
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();
//2.4.1 获取容器
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
//准备beanFactory，这个方法就是为beanFactory添加一些组件和配置，比如后置处理器、类加载器、依赖处理器等等
this.prepareBeanFactory(beanFactory);
try {
//在上下文添加一些BeanFactory后置处理器，处理器在beanDefinition加载完后，bean实例化之前执行
this.postProcessBeanFactory(beanFactory);
//2.4.2 调用BeanFactory后置处理器，这一步会进行IOC容器的初始化
this.invokeBeanFactoryPostProcessors(beanFactory);
//注册bean的后置处理器，上面是BeanFactory后置处理器
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
//上面这些不看了，直接从这开始
//2.4.3 完成所有单例bean的初始化
this.finishBeanFactoryInitialization(beanFactory);
//广播刷新完成事件
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
2.4.1 obtainFreshBeanFactory()获取容器
之前说过Springboot在创建应用上下文时，触发了GenericApplicationContext的构造函数，创建了beanFactory，这个方法就是获取之前创建的beanFactory。
//AbstractApplicationContext.class
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
this.refreshBeanFactory();
return this.getBeanFactory();
}
这两个方法都是模板方法，由子类GenericApplicationContext实现
//GenericApplicationContext.class
protected final void refreshBeanFactory() throws IllegalStateException {
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException("GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
} else {
this.beanFactory.setSerializationId(this.getId());
}
}
public final ConfigurableListableBeanFactory getBeanFactory() {
return this.beanFactory;
}
2.4.2 invokeBeanFactoryPostProcessors()
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...
//默认的beanFactoryPostProcessors有三个，SharedMetadataReaferFactoryContextInitializer、ConfigurationWArningsApplicationContextInitializer、ConfigFileApplicationListener
Iterator var6 = beanFactoryPostProcessors.iterator();
//循环将它们注册到beanDefinitionMap中
while(var6.hasNext()) {
BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
} else {
regularPostProcessors.add(postProcessor);
}
}
currentRegistryProcessors = new ArrayList();
//这里postProcessorNames是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，internalConfigurationAnnotationProcessor是专门用来处理Configuration注解的类。
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
String[] var16 = postProcessorNames;
var9 = postProcessorNames.length;
int var10;
String ppName;
for(var10 = 0; var10 < var9; ++var10) {
ppName = var16[var10];
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//通过getBean,从实例化了ConfigurationClassPostProcessor到容器中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//对于使用基于@Configuration注解和@bean注入的对象, 此时的processor类型为ConfigurationClassPostprocessor, 且在此处执行
//如果是@Autowired和@Value注解注入的对象，processor类型应该是AutowiredAnnotationBeanPostProcessor，这些东西是在AnnotationConfigUtils类下定义的
//2.4.2.1 进去重点看看此时的processor类型为ConfigurationClassPostprocessor的postProcessBeanDefinitionRegistry()做了什么
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
...
}
2.4.2.1 invokeBeanDefinitionRegistryPostProcessors()
一直跟进这个方法，知道ConfigurationClassPostProcessor.class中的parser.parse(candidates)方法，看下面这张图，这时候的只有这个启动类，接下来继续跟进这个方法。
//ConfigurationClassParser.class
public void parse(Set<BeanDefinitionHolder> configCandidates) {
Iterator var2 = configCandidates.iterator();
while(var2.hasNext()) {
BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
BeanDefinition bd = holder.getBeanDefinition();
try {
//会走这里，之前看到过启动类是被封装成AnnotatedBeanDefinition的
if (bd instanceof AnnotatedBeanDefinition) {
this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
} else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
} else {
this.parse(bd.getBeanClassName(), holder.getBeanName());
}
} catch (BeanDefinitionStoreException var6) {
throw var6;
} catch (Throwable var7) {
throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
}
}
//springboot自动装配的入口
this.deferredImportSelectorHandler.process();
}
继续跟进parse()方法直到ConfigurationClassParser.class的doProcessConfigurationClass()方法。
//ConfigurationClassParser.class
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
...
do {
//主要就是这个方法进行处理
sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
} while(sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
}
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
//递归处理内部类，启动类是没有内部类的，如果是启动类这里进去什么都不做
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
this.processMemberClasses(configClass, sourceClass, filter);
}
//处理@PropertySource注解配置的属性，对于启动类来说，这里也没有
Iterator var4 = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, PropertySource.class).iterator();
AnnotationAttributes importResource;
while(var4.hasNext()) {
importResource = (AnnotationAttributes)var4.next();
if (this.environment instanceof ConfigurableEnvironment) {
this.processPropertySource(importResource);
} else {
this.logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment");
}
}
//处理@ComponentScan注解，扫描项目中的bean，启动类上包含这个注解
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
Iterator var14 = componentScans.iterator();
while(var14.hasNext()) {
AnnotationAttributes componentScan = (AnnotationAttributes)var14.next();
//2.4.2.2 扫描项目中的bean
Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
Iterator var8 = scannedBeanDefinitions.iterator();
while(var8.hasNext()) {
BeanDefinitionHolder holder = (BeanDefinitionHolder)var8.next();
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
//todo：解析扫描到的bean，这里又循环会去了，可能是再从它们所在的包继续向下扫描？
this.parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
//2.4.2.3 递归处理@Import注解，SpringBoot中经常用的各种@Enable***注解基本都是封装的@Import
this.processImports(configClass, sourceClass, this.getImports(sourceClass), filter, true);
...
return null;
}
2.4.2.2 扫描bean
主要看看怎么从扫描bean的，这里会调用doScan()方法扫描bean，然后将beanDefinition注册到beanDefinitionMap中。
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
...
for(int var5 = 0; var5 < var4; ++var5) {
String basePackage = var3[var5];
//从basePackage下找bean
Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
Iterator var8 = candidates.iterator();
while(var8.hasNext()) {
BeanDefinition candidate = (BeanDefinition)var8.next();
...
if (this.checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//注册beanDefinition
this.registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
执行完上面代码，看看扫描到了那些bean，这两个bean是我们提前写好的。
@Configuration
public class Config {
@Bean
public MyService getMyService(MyService myService){
return myService;
}
}
回到2.4.2.1的doProcessConfigurationClass()，此时代码执行到processImports()方法了，这个方法是处理@Import注解的。
2.4.2.3 processImports()
这个方法会处理@Import注解，这里主要从SpringBoot自动配置的角度看看这个方法，因为springboot开启自动配置的注解@EnableAutoConfiguration封装了@Import注解。进入processImports()代码。
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
//先看下面那段话
if (!importCandidates.isEmpty()) {
if (checkForCircularImports && this.isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
Iterator var6 = importCandidates.iterator();
while(var6.hasNext()) {
SourceClass candidate = (SourceClass)var6.next();
Class candidateClass;
if (candidate.isAssignable(ImportSelector.class)) {
candidateClass = candidate.loadClass();
ImportSelector selector = (ImportSelector)ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
//AutoConfigurationImportSelector会走这里
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector)selector);
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = this.asSourceClasses(importClassNames, exclusionFilter);
this.processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
} else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
//ImportBeanDefinitionRegistrar会
candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar = (ImportBeanDefinitionRegistrar)ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
} else {
//当真正需要注册需要自动配置的类时会走这里，不过要走到这里的入口是在2.4.2.1中提到的 this.deferredImportSelectorHandler.process()这个方法
this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
//又回到了这个方法，在2.4.2.1介绍启动类注册的时候说过了，就是注册到把beanDefinition注册到Map中，那这里就是去注册那些自动配置类了。
this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
} catch (BeanDefinitionStoreException var17) {
throw var17;
} catch (Throwable var18) {
throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", var18);
} finally {
this.importStack.pop();
}
}
}
}
看这张图，传入的两个importCandidates一个是ImportBeanDefinitionRegistrar类，一个是ImportSelector类，对于AutoConfigurationImportSelector，更准确的说他是一个DeferredImportSelector。从名字也能看出他是延迟执行的，所以这时并不会将自动配置的类注入近来，在2.4.2.1中说过，springboot自动配置的入口是在 this.deferredImportSelectorHandler.process()这个方法下。在看上面的代码，两个不同的类会走不同的if或else。
一直跟进代码，直到走到this.deferredImportSelectorHandler.process()。这个方法在ConfigurationClassParser.class的parse()方法下。
//ConfigurationClassParser.class
public void process() {
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
DeferredImportSelectorGroupingHandler handler = ConfigurationClassParser.this.new DeferredImportSelectorGroupingHandler();
deferredImports.sort(ConfigurationClassParser.DEFERRED_IMPORT_COMPARATOR);
deferredImports.forEach(handler::register);
//重点是这个
handler.processGroupImports();
}
} finally {
this.deferredImportSelectors = new ArrayList();
}
}
在跟进processGroupImports()方法。
//ConfigurationClassParser.class
public void processGroupImports() {
Iterator var1 = this.groupings.values().iterator();
while(var1.hasNext()) {
...
//调用getImport()方法去找spring.factories文件中的自动配置类
grouping.getImports().forEach((entry) -> {
ConfigurationClass configurationClass = (ConfigurationClass)this.configurationClasses.get(entry.getMetadata());
try {
//又到了这个方法了，之前也提过，会走processImports()的最后一个else
ConfigurationClassParser.this.processImports(configurationClass, ConfigurationClassParser.this.asSourceClass(configurationClass, exclusionFilter), Collections.singleton(ConfigurationClassParser.this.asSourceClass(entry.getImportClassName(), exclusionFilter)), exclusionFilter, false);
}
...
});
}
}
进入getImport()方法：
////ConfigurationClassParser.class
public Iterable<DeferredImportSelector.Group.Entry> getImports() {
Iterator var1 = this.deferredImports.iterator();
while(var1.hasNext()) {
DeferredImportSelectorHolder deferredImport = (DeferredImportSelectorHolder)var1.next();
//这里会调用Group接口的实现类AutoConfigurationImportSelector，执行process()方法将需要自动配置的类放到一个map中
this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector());
}
//调用AutoConfigurationImportSelector的selectImports()封装map然后返回需要自动配置的类
return this.group.selectImports();
}
DeferredImportSelector下定义了一个Group接口，AutoConfigurationImportSelector实现了这个接口，当程序运行到this.group.process()，会去调用AutoConfigurationImportSelector实现的process()。
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector, () -> {
return String.format("Only %s implementations are supported, got %s", AutoConfigurationImportSelector.class.getSimpleName(), deferredImportSelector.getClass().getName());
});
//getAutoConfigurationEntry()最终会调用SpringFactoriesLoader.loadFactoryNames()方法去加载spring.factories文件中的类
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector)deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
Iterator var4 = autoConfigurationEntry.getConfigurations().iterator();
while(var4.hasNext()) {
String importClassName = (String)var4.next();
//将这些需要自动配置的类放到一个名为entries的map中
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}
然后调用AutoConfigurationImportSelector的selectImports()封装map然后返回需要自动配置的类
之后再回到ConfigurationClassParser的processGroupImports()方法执行后面的processImports()方法，这时才真正开始注册自动配置类的beanDefinition，这时的processImports()会进入processImports()的最后一个else，processConfigurationClass()这个方法前面说过了，将beanDefinition注册到Map中。
//ConfigurationClassParser.class
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
...
try {
Iterator var6 = importCandidates.iterator();
while(var6.hasNext()) {
...
} else {
this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
}
...
}
这部分就到这里了，回到2.4。
2.4.3 finishBeanFactoryInitialization()初始化bean
之前只是将bean的beanDefinition注册到IOC容器中，但是还没有初始化，bean的完整生命周期是在这个方法中完成的。我们以自定义的bean为例来看看bean的初始化。跟进代码，到AbstractBeanFactory.class的doGetBean时在断点上添加条件，这个条件就是beanName=myController时才会进去。
//AbstractBeanFactory.class
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
//...
} else {
//...
try {
//获取bean的beanDefinition
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//...
//如果是单例bean
if (mbd.isSingleton()) {
//获取bean，这里是从缓冲池里拿，在初始化bean的过程中会把他们放到缓冲池
sharedInstance = this.getSingleton(beanName, () -> {
try {
//bean的初始化过程是在这里完成的
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
//...
} else {
//...
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
//...
}
然后一直跟进代码createBean()方法，直到AbstractAutowireCapableBeanFactory.class的doCreateBean()方法，这里完成了bean的初始化，主要包括三个步骤：1、创建bean实例。2、为bean实例进行属性注入。3、调用bean的初始化方法。
//AbstractAutowireCapableBeanFactory.class
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//2.4.3.1 创建bean实例
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
//...
//如果bean是单例且允许循环引用且正在创建，暴露一个bean的早期对象工厂，放到三级缓存
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
//...
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
//2.4.3.2 属性注入
this.populateBean(beanName, mbd, instanceWrapper);
//2.4.3.3 调用初始化方法
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
//...
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
2.4.3.1 createBeanInstance()创建bean实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) &&
//...
} else {
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
} else if (mbd.getFactoryMethodName() != null) {
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
//...
if (resolved) {
//...
} else {
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
ctors = mbd.getPreferredConstructors();
//对于myController这个我们自定义的bean，会进入instantiateBean()方法，通过BeanUtils创建bean实例
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
}
2.4.3.2 populateBean()属性注入
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
//...
} else {
//...
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
//...
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
Iterator var9 = this.getBeanPostProcessors().iterator();
//使用后置处理器进行属性注入，对于通过@Autowired注入的属性，使用ImportAwareBeanPostProcessor这个处理器，用它完成属性注入，它是InstantiationAwareBeanPostProcessor的一个实现类。
while(var9.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
//假如MyController中注入了MyService,在这里会先去初始化MyService,流程和MyController一样，之后再回到MyController的生命周期进行属性注入。
PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
//...
}
}
}
//...
}
}
进入postProcessProperties()看看注入逻辑。
//AutowriedAnnotationBeanPostProcessor.class
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//寻找要注入的属性
InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//注入
metadata.inject(bean, beanName, pvs);
return pvs;
} catch (BeanCreationException var6) {
throw var6;
} catch (Throwable var7) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
}
}
findAutowiringMetadata()可以找到要注入的属性，看下面的图，找到了要注入到MyController中的MyService。
然后执行inject()方法进行注入，注入MyService时会先去初始化MyService，流程是一样的。
2.4.3.3 initializeBean()调用初始化方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
//调用Aware接口的实现，设置相关的beanName、beanClassLoader、BeanFactory等，自己定义的bean好像不会走这。
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//在初始化之前调用BeanPostProcessor，为了方便扩展吧
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//调用初始化方法
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
//初始化之后调用BeanPostProcessor
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
接下来看一下invokeInitMethods()方法，有两个初始化方法，第一个是实现InitializingBean接口并重写afterPropertiesSet()方法，第二种方法是设置init-method方法。springboot会判断我们有没有定义这些方法，如果有就按顺序执行就好了。
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
//判断bean有没有实现InitializingBean接口并重写afterPropertiesSet()方法，如果判断为ture，那就调用afterPropertiesSet()方法进行初始化。
boolean isInitializingBean = bean instanceof InitializingBean;
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(() -> {
((InitializingBean)bean).afterPropertiesSet();
return null;
}, this.getAccessControlContext());
} catch (PrivilegedActionException var6) {
throw var6.getException();
}
} else {
//调用afterPropertiesSet()进行初始化
((InitializingBean)bean).afterPropertiesSet();
}
}
//判断bean是否配置了init-method方法，如果判断为true，通过反射得到method对象，然后调用init-method，完成最后的初始化。
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
this.invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
自定义这两种方法也很简单，如下：
//实现InitializingBean接口并重写afterPropertiesSet()方法
@Controller
public class MyController implements InitializingBean {
@Autowired
private MyService myService;
public void testController(){
return;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("method 1");
}
}
//配置了init-method方法
@Configuration
public class Config {
@Bean(initMethod = "test")
public MyService getMyService(MyService myService){
return myService;
}
}
@Service
public class MyService {
public void test(){
System.out.println("haha");
}
}
到这里单例bean就初始化完了，结束。
3、补充：循环依赖
Spring解决循环依赖的流程如下图所示。
没有AOP的情况下：
Spring通过三级缓存解决循环依赖问题，假设A和B发生了循环依赖，在A的生命周期中，在A创建了实例之后，会生成一个A的对象工厂并将其放入三级缓存，在A进行属性注入时，发生A依赖了B，这时Spring会先去创建B，和A的流程一样，当B进行属性注入时发现依赖了A，这时Spring又会调用doGetBean()想去创建A，但是在创建A之前，会先调用getSingleton()方法从缓存中取，这时Spring从三级缓存中调用A的对象工厂来生成一个A的早期对象，然后把它放到二级缓存。将A注入B之后，B会走完剩下的生命周期，然后通过getSingleton()方法将B放入一级缓存。接下来，A会走完剩下的生命周期，并且会把A放入一级缓存。就这样，A和B就都初始化完了。
有AOP的情况下：
AOP动态代理的处理一般是发生在bean初始化之后的，也就是initializeBean()方法中的最后执行applyBeanPostProcessorsAfterInitialization()时生成代理对象，但是当出现循环依赖时，可以发现bean的AOP代理提前发生了。我觉得将AOP代理提前才是为什么需要第三级缓存的原因把。
还是看上面这个例子，当A经过实例化createInstance之后，会生成一个早期bean工厂放入三级缓存，代码是这样的，可以看到它传入了一个lambda表达时，当三级缓存中的早期bean工厂执行getObject()时会触发这个lambda表达式调用getEarlyBeanReference()，也就是当B需要注入A时，需要走到这一步。如果A被AOP代理了，这个这个方法会去调wrapIfNecessary()方法生成A的代理对象。如果没有三级缓存，那么就无法提前生成bean的代理对象，那么B中就会注入A的原始对象，但是当A经过初始化之后再去生成AOP代理对象，就会出现多个A，这不符合单例模式。
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
