AnnotationConfigApplicationContext
启动类
public class ConfigStart {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Student student = applicationContext.getBean(Student.class);
}
}
主配置类
@Configuration
public class MainConfig {
@Bean
public Student student() {
return new Student();
}
}
bean
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
/**
* id
*/
private Long id;
/**
* name
*/
private String name;
}
结构图
AnnotationConfigApplicationContext构造器
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}
AnnotationConfigApplicationContext#this()方法解析
public AnnotationConfigApplicationContext() {
// 初始化
// 1.传入的 this==AnnotationConfigApplicationContext 对象
// 2.AnnotatedBeanDefinitionReader对象有属性BeanDefinitionRegistry【BeanDefinition注册器】, 指向AnnotationConfigApplicationContext对象
// 3.同时创建Environment对象, 实现是StandardEnvironment对象, 赋给AbstractApplicationContext对象
// 4.调用AnnotationConfigApplicationContext直接父类GenericApplicationContext的构造器方法，初始化beanFactory对象DefaultListableBeanFactory
// 5.调用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)方法
// 6.【重要: AnnotatedBeanDefinitionReader的作用】
this.reader = new AnnotatedBeanDefinitionReader(this);
// ClassPathBeanDefinitionScanner 这个类比较重要, 我们在spring整合mybatis中, 自定义扫描器就继承了这个扫描器!!!
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
AnnotationConfigUtils#registerAnnotationConfigProcessors(this.registry) 方法解析
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
// 调用registerAnnotationConfigProcessors(registry, null)
registerAnnotationConfigProcessors(registry, null);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
// 1.从AnnotationConfigApplicationContext中获取beanFactory，内部是通过AnnotationConfigApplicationContext的直接父类GenericApplicationContext中获取beanFacory，这个在之前调用public AnnotationConfigApplicationContext(){...}构造器时，调用其父类GenericApplicationContext的构造器的时候，已经初始化了
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
// 赋值beanFactory的dependencyComparator为AnnotationAwareOrderComparator【单例】
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
// 赋值beanFactory的autowireCandidateResolver为ContextAnnotationAutowireCandidateResolver
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
// beanFactory中的成员变量beanDefinitionMap, key为类的全限定名, value为BeanDefinition对象
// 总结: 是对ConfigurationClassPostProcessor的处理
// 【ConfigurationClassPostProcessor】非常重要: 实现了BeanDefinitionRegistryPostProcessor接口, BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口
// 1.向beanDefinitionMap中注册(internalConfigurationAnnotationProcessor, ConfigurationClassPostProcessor对应的BeanDefinition)
// 2.beanDefinitionNames中添加internalConfigurationAnnotationProcessor
// 3.beanDefs中添加BeanDefinitionHolder
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
// 没有internalConfigurationAnnotationProcessor的BeanDefinition对象
// 创建RootBeanDefinition对象, 是对ConfigurationClassPostProcessor Class对象的封装
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
/**
* registy: AnnotationConfigApplicationContext对象
* def: BeanDefinition对象
* CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME：internalConfigurationAnnotationProcessor
*/
// registerPostProcessor(...)方法解析:
// 1.内部调用registry.registerBeanDefinition(beanName, definition)
// 2.判断 beanDefinitionMap 中没有key==internalConfigurationAnnotationProcessor
// 3.将(internalConfigurationAnnotationProcessor, RootBeanDefinition def) 放入 beanDefinitionMap!
// 4.将beanDefinitionNames添加internalConfigurationAnnotationProcessor
// 创建BeanDefinitionHolder对象添加到 beanDefs
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 跟上面的方法类似
// 总结： 是对AutowiredAnnotationBeanPostProcessor的处理
// 1.向beanDefinitionMap中注册(internalAutowiredAnnotationProcessor, AutowiredAnnotationBeanPostProcessor对应的BeanDefinition)
// 2.beanDefinitionNames中添加internalAutowiredAnnotationProcessor
// 3.beanDefs中添加BeanDefinitionHolder
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 跟上面的方法类似
// 总结： 是对CommonAnnotationBeanPostProcessor的处理
// 1.向beanDefinitionMap中注册(internalCommonAnnotationProcessor, CommonAnnotationBeanPostProcessor对应的BeanDefinition)
// 2.beanDefinitionNames中添加internalCommonAnnotationProcessor
// 3.beanDefs中添加BeanDefinitionHolder
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// jpaPresent:false 不会执行
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 跟上面的方法类似
// 总结： 是对EventListenerMethodProcessor的处理
// 1.向beanDefinitionMap中注册(internalEventListenerProcessor, EventListenerMethodProcessor对应的BeanDefinition)
// 2.beanDefinitionNames中添加internalEventListenerProcessor
// 3.beanDefs中添加BeanDefinitionHolder
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 跟上面的方法类似
// 总结： 是对DefaultEventListenerFactory的处理
// 1.向beanDefinitionMap中注册(internalEventListenerFactory, DefaultEventListenerFactory对应的BeanDefinition)
// 2.beanDefinitionNames中添加internalEventListenerFactory
// 3.beanDefs中添加BeanDefinitionHolder
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
DefaultListableBeanFactory结构图
总结
1.创建AnnotatedBeanDefinitionReader对象，用于解析注解类BeanDefinition，同时AnnotatedBeanDefinitionReader对象有一个成员：
BeanDefinitionRegistry，赋值为AnnotationConfigApplicationContext对象(AnnotationConfigApplicationContext和AnnotatedBeanDefinitionReader相互引用)
2.AbstractApplicationContext对象有Environment成员，会初始化为StandardEnvironment对象。
AbstractApplicationContext是AnnotationConfigApplicationContext父类的父类
3.GenericApplicationContext对象有DefaultListableBeanFactory成员，会初始化为DefaultListableBeanFactory, 该对象是真正的beanFactory。【非常重要】
GenericApplicationContext是AnnotationConfigApplicationContext的父类
4.beanFactory, 类型为DefaultListableBeanFactory, 有几个重要的成员变量:
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);//key-类的全限定名 value-BeanDefinition
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);// 存储类的全限定名
初始化的时候，会先后在beanDefinitionMap中添加:
(internalConfigurationAnnotationProcessor, ConfigurationClassPostProcessor对应的BeanDefinition)
(internalAutowiredAnnotationProcessor, AutowiredAnnotationBeanPostProcessor对应的BeanDefinition)
(internalCommonAnnotationProcessor, CommonAnnotationBeanPostProcessor对应的BeanDefinition)
(internalEventListenerProcessor, EventListenerMethodProcessor对应的BeanDefinition)
(internalEventListenerFactory, DefaultEventListenerFactory对应的BeanDefinition)
在beanDefinitionNames中添加:
internalConfigurationAnnotationProcessor, internalAutowiredAnnotationProcessor, internalCommonAnnotationProcessor,
internalEventListenerProcessor, internalEventListenerFactory
以上注册的5个BeanDefinition非常非常重要！！！！！！
5.创建ClassPathBeanDefinitionScanner对象
AnnotationConfigApplicationContext#register(componentClasses)方法解析
public void register(Class<?>... componentClasses) {
Assert.notEmpty(componentClasses, "At least one component class must be specified");
// 调用reader的register方法, reader为AnnotatedBeanDefinitionReader, 内部是调用doRegisterBean(beanClass, null, null, null)
this.reader.register(componentClasses);
}
public void registerBean(Class<?> beanClass) {
doRegisterBean(beanClass, null, null, null);
}
AnnotatedBeanDefinitionReader#doRegisterBean(...) 方法解析
<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// 1.根据配置类创建AnnotatedGenericBeanDefinition注解通用BeanDefinition对象
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
// 2.判断需不需要跳过注册，Spring中有一个@Condition注解，如果不满足条件，就会跳过这个类的注册
// 此处为false, 不能跳过注册
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
// 3.解析scope注解, 默认是singleton, 单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());// singleton
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // mainConfig
// 4.解析通用注解 @Lazy @Primary @DependsOn @Role @Description 这些注解都会解析为AnnotatedGenericBeanDefinition中的属性
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
// 5.创建BeanDefinitionHolder对象
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
// 6.applyScopedProxyMode是否采用代理模式, 默认不采用
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 7.注册BeanDefinition【常用方法】
// 向beanDefinitionMap中注册(mainConfig, MainConfig对应的BeanDefinition)
// 向beanDefinitionNames中添加mainConfig
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
此时，一共注册了6个BeanDefinition，其中5个内置的RootBeanDefinition，一个注解式的AnnotatedGenericBeanDefinition
总结
1.解析主配置类MainConfig
2.创建MainConfig对应的BeanDefinition对象AnnotatedGenericBeanDefinition
3.解析@Scope注解
4.解析通用注解 @Lazy @Primary @DependsOn @Role @Description, 如果有加对应的注解, 会配置AnnotatedGenericBeanDefinition的对应属性
5.向beanDefinitionMap中注册(mainConfig, MainConfig对应的BeanDefinition), 向beanDefinitionNames中添加mainConfig
AbstractApplicationContext#refresh()
refresh()方法调用的是AnnotationConfigApplicationContext父类的父类AbstractApplicationContext的refresh()方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
1. AbstractApplicationContext#prepareRefresh()
protected void prepareRefresh() {
// 设置启动时间, closed, active标识
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
// 日志
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// 空实现, 初始化placeholder property sources
initPropertySources();
// 校验Environment中必须的属性, 目前为空, Environment在构造器方法中已经初始化完毕, StandardEnvironment, 被AbstractApplicationContext所持有
getEnvironment().validateRequiredProperties();
// 初始化earlyApplicationListeners
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// 初始化earlyApplicationEvents
this.earlyApplicationEvents = new LinkedHashSet<>();
}
总结
设置了 启动时间, closed, active标识, 初始化了AbstractApplicationContext的两个成员变量：
private Set<ApplicationListener<?>> earlyApplicationListeners = new LinkedHashSet<>();
private Set<ApplicationEvent> earlyApplicationEvents = new LinkedHashSet<>();
2. AbstractApplicationContext#obtainFreshBeanFactory()
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 1.调用GenericApplicationContext的refreshBeanFactory()方法
// 2.修改GenericApplicationContext对象里的 refreshed 标识改为true
// 3.设置beanFactory(实际类型为类型为DefaultListableBeanFactory)对象的serializationId
refreshBeanFactory();
// 4.返回beanFactory
return getBeanFactory();
}
总结
修改GenericApplicationContext对象里的 refreshed 标识改为true, 设置id, 返回beanFactory对象【DefaultListableBeanFactory】
3. AbstractApplicationContext#prepareBeanFactory(beanFactory)
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 1.设置类加载器 - 系统类加载器AppClassLoader
beanFactory.setBeanClassLoader(getClassLoader());
// 2.设置spring el表达式解析器 - StandardBeanExpressionResolver
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 3.添加属性编辑器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 4.添加了一个后置处理器 ApplicationContextAwareProcessor, 实现了BeanPostProcessor接口, 将其添加到了AbstractBeanFactory对象的beanPostProcessors列表中
// beanFactory的一个父类 AbstractBeanFactory，有一个属性:
// private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>() // 用于存放所有的后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 5. beanFactory的一个父类 AbstractAutowireCapableBeanFactory, 有一个属性:
// private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>() // 用于存放【忽略自动装配】的接口
// 当前对象初始化完成后, ignoredDependencyInterfaces会存放三个接口: BeanFactoryAware、BeanClassLoaderAware、BeanNameAware
// 此时又添加了6个接口: EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、
// MessageSourceAware、ApplicationContextAware, 一共有9个忽略自动装配的接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 6. beanFactory有一个属性:
// private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16); // 用于存放允许自动装配的bean
// key - 类的Class对象, value - 具体的实例对象, this - AnnotationConfigApplicationContext
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 7.添加了一个后置处理器 ApplicationListenerDetector, 实现了BeanPostProcessor接口, 将其添加到了AbstractBeanFactory对象的beanPostProcessors列表中, 现在beanPostProcessors里有两个成员: ApplicationContextAwareProcessor, ApplicationListenerDetector
// 同时 ApplicationListenerDetector 实现了 DestructionAwareBeanPostProcessor接口, AbstractBeanFactory的hasDestructionAwareBeanPostProcessors属性置为 true
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 8.判断beanFactory是否有 loadTimeWeaver 对象, 如果没有, 会判断beanFactory的父容器中有没有包含当前对象, 如果没有, 返回false
// 当前beanFactory没有loadTimeWeaver, 且beanFactory的父容器为空, 此处返回false
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
/*
* 解析重点方法:
* beanFactory.containsLocalBean(beanName) {
* String beanName = transformedBeanName(name);
* return ((containsSingleton(beanName) || containsBeanDefinition(beanName)) &&
* (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(beanName)));
* }
* spring的三级缓存, 存储在beanFactory的父类对象 DefaultSingletonBeanRegistry, 分别是:
* private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); // 一级缓存
* private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二级缓存
* private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三级缓存
* private final Set<String> registeredSingletons = new LinkedHashSet<>(256); // 已经注册了的bean列表
* containsSingleton(beanName): 判断一级缓存中有没有
* containsBeanDefinition(beanName): 判断beanFactory的beanDefinitionMap有没有
*/
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
// 注册单例
// 放入一级缓存中: (environment, StandardEnvironment)
// 从二级缓存和三级缓存中移除
// 放入已注册的bean列表
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
// 注册单例
// 放入一级缓存中: (systemProperties, Map<String, Object>)
// 放入已注册bean列表
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
// 注册单例
// 放入一级缓存中: (systemEnvironment, Map<String, Object>)
// 放入已注册bean列表
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
总结
1.设置类加载器为AppClassLoader
2.设置spring el表达式解析器 - StandardBeanExpressionResolver
3.添加属性编辑器 - ResourceEditorRegistrar
4.添加两个后置处理器: ApplicationContextAwareProcessor, ApplicationListenerDetector
5.ignoredDependencyInterfaces中注册 6个忽略自动装配的接口, 一共9个
6.resolvableDependencies中注册 4个允许自动装配的bean
7.beanFactory中注册三个实例对象: environment, systemProperties, systemEnvironment, 放入一级缓存map和已注册bean列表中
此时的beanFactory
4. AbstractApplicationContext#postProcessBeanFactory(beanFactory)
空实现,子类扩展
5.AbstractApplicationContext#invokeBeanFactoryPostProcessors(beanFactory)
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// getBeanFactoryPostProcessors拿到的beanFactoryPostProcessors一直是空的
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// 这里为false, 跳过
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
5. 1 PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()) 解析 【重点方法】
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 用来存储已经执行完了的BeanFactoryPostProcessor
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 1.regularPostProcessors 用来存放普通BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 2.registryProcessors 用来存放BeanDefinitionRegistryPostProcessor, BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 3.beanFactoryPostProcessors是空的, 所以此处不会执行
// 【注意：】我们如果在主配置里向容器注册了自定义的BeanFactoryPostProcessors, 这里的beanFactoryPostProcessors也是空的！！！因为, 还没有开始解析主配置类
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 翻译: 在这里不会初始化普通的bean对象, 让它们处于未初始化的状态, 我们需要先让bean factory post processors来处理它们, 其次, 需要分离出来 PriorityOrdered(实现优先级顺序的), Ordered(普通顺序的)和一般的BeanDefinitionRegistryPostProcessors
// 临时列表
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 翻译: 先处理实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
// 4.获取BeanDefinitionRegistryPostProcessor的实现类的名称, 从beanDefinitionNames中获取的, 结果为:internalConfigurationAnnotationProcessor, 对应的BeanDefinition为:ConfigurationClassPostProcessor对应的BeanDefinition
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 5.internalConfigurationAnnotationProcessor, 对应的BeanDefinition:ConfigurationClassPostProcessor实现了PriorityOrdered接口
// 这里为: true
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 6. 获得ConfigurationClassPostProcessor类，并且放到currentRegistryProcessors
// ConfigurationClassPostProcessor是很重要的一个类，它实现了BeanDefinitionRegistryPostProcessor接口, BeanFactoryPostProcessor接口
// ConfigurationClassPostProcessor是极其重要的类, 里面执行了扫描Bean，Import，ImportResouce等各种操作
// 用来处理配置类（有两种情况 一种是传统意义上的配置类，一种是普通的bean）的各种逻辑
// beanFactory.getBean()方法也极其重要, 这里创建了ConfigurationClassPostProcessor对象
// 此时, currentRegistryProcessors中包含了ConfigurationClassPostProcessor
// 【重要：这里会创建并初始化ConfigurationClassPostProcessor对象, 并放入到一级缓存中！！！】beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)这个方法会在后面解析, 这个是创建bean的核心方法
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 把name放到processedBeans，后续会根据这个集合来判断处理器是否已经被执行过了
processedBeans.add(ppName);
}
}
// 7.处理排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 8.合并Processors，为什么要合并，因为registryProcessors是装载BeanDefinitionRegistryPostProcessor的
// 一开始的时候，spring只会执行BeanDefinitionRegistryPostProcessor独有的方法
// 而不会执行BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryProcessor的方法
// 所以这里需要把处理器放入一个集合中，后续统一执行父类的方法
// 这里目前还只有一个 ConfigurationClassPostProcessor
registryProcessors.addAll(currentRegistryProcessors);
// 9.这里调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry()方法
// 目前只有一个内置的实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor：【ConfigurationClassPostProcessor】
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 10.跟上述过程一样, 这里处理实现Ordered的接口
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();
// 11.跟上述过程一样, 处理未实现PriorityOrdered和Ordered接口的普通的 BeanDefinitionRegistryPostProcessor
// 这里没有, 直接跳过
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// registryProcessors集合装载BeanDefinitionRegistryPostProcessor
// 上面的代码是执行子类独有的方法【invokeBeanDefinitionRegistryPostProcessors】
// 这里需要再把父接口【BeanFactoryPostProcessor】的方法【invokeBeanFactoryPostProcessors】也执行一次!!!
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// regularPostProcessors是空的, 跳过
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 12.获取BeanFactoryPostProcessor对应的实现类的名称, 从beanDefinitionNames中获取的, 结果为:internalConfigurationAnnotationProcessor, internalEventListenerProcessor两个name, 对应的BeanDefinition为:ConfigurationClassPostProcessor对应的BeanDefinition, 以及EventListenerMethodProcessor对应的BeanDefinition
// 【注意：】如果此时我们有自定义的BeanFactoryPostProcessor, 且注册到容器中, 执行到这里的时候我们自定义的BeanFactoryPostProcessor,已经被前面的内置的实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor--【ConfigurationClassPostProcessor】封装成BeanDefinition并注册到beanDefinitionMap中了
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 13.将 获取的BeanFactoryPostProcessor进行分类, 按照PriorityOrdered、Ordered以及未排序三个维度
// 【注意：】我们自定义的BeanFactoryPostProcessor将在这里被初始化完成, 并调用其postProcessBeanFactory
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// ConfigurationClassPostProcessor已经处理过了
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
// EventListenerMethodProcessor被添加到未排序的列表当中
nonOrderedPostProcessorNames.add(ppName);
}
}
// 14. 这里priorityOrderedPostProcessors为空, 跳过
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 15. 这里orderedPostProcessorNames也为空, 跳过
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 16. 执行未排序的BeanFactoryPostProcessor, 这里是 EventListenerMethodProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
【5.1 方法总结】
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors的思路很清晰：
1.首先需要知道两个接口, 这个方法就是在围绕两个接口:
BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor, 且后者是前者的子接口
BeanFactoryPostProcessor的核心方法:postProcessBeanFactory
BeanDefinitionRegistryPostProcessor的核心方法:postProcessBeanDefinitionRegistry
2.这个方法的执行过程就是:
先找到实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor, 排序后依次执行他们的postProcessBeanDefinitionRegistry方法;
再找到实现Ordered接口的BeanDefinitionRegistryPostProcessor, 排序后依次执行postProcessBeanDefinitionRegistry
再找到普通的BeanDefinitionRegistryPostProcessor, 依次执行postProcessBeanDefinitionRegistry
最后依次执行上面BeanDefinitionRegistryPostProcessor的postProcessBeanFactory
以上把BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry和postProcessBeanFactory都执行完了
继续执行:
把普通的BeanFactoryPostProcessor都找到, 然后依次执行它们的postProcessBeanFactory方法
3.在当前例子中, 实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor只有一个【内置的】:
ConfigurationClassPostProcessor,所以要研究它的postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法
实现了普通的BeanFactoryPostProcessor也只有一个【内置的】:EventListenerMethodProcessor, 需要研究它的postProcessBeanFactory方法
5.2 ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry()解析【重点方法】
postProcessBeanDefinitionRegistry内部调用的是processConfigBeanDefinitions, 所以当前我们研究processConfigBeanDefinitions方法,
这个方法会解析 @Configuration 标签
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 1.这里获取的candidateNames一共有6个, 一个自定义的mainConfig, 5个内置的
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 2.上述6个都不满足以下条件
// 内部有两个标记位来标记是否已经处理过了: isFullConfigurationClass, isLiteConfigurationClass
// 当我们注册配置类的时候，可以不加@Configuration注解，直接使用@Component @ComponentScan @Import @ImportResource注解，称之为Lite配置类
// 如果加了@Configuration注解，就称之为Full配置类
// 如果我们注册了Lite配置类，我们getBean这个配置类，会发现它就是原本的那个配置类
// 如果我们注册了Full配置类，我们getBean这个配置类，会发现它已经不是原本那个配置类了，而是已经被cgilb代理的类了
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 3.自定义的mainConfig满足下面条件: 同时修改MainConfig为Full配置类
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 4.校验, 此时不为空, 跳过
if (configCandidates.isEmpty()) {
return;
}
// 5.根据@Order标签排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
SingletonBeanRegistry sbr = null;
// 6.DefaultListableBeanFactory会实现SingletonBeanRegistry接口, 进入
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
// 7.为空, 直接跳过
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
// 8.跳过
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// 9.解析所有@Configuration的类!!!!!!
// 9.1 创建@Configuration配置类解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 9.2 需要被ConfigurationClassParser解析的类
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
// 9.3 已经被ConfigurationClassParser解析的类
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 9.4 这个方法极其重要！！！在@5.3中单独解析
parser.parse(candidates);
// 9.5 校验
parser.validate();
// 9.6 获取解析完成后的MainConfig对应的ConfigurationClass
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
// 9.7 创建 ConfigurationClassBeanDefinitionReader 对象
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 9.8 【重点方法】
// 内部调用 ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass(..)方法, 见@5.5解析
// 这个方法在内部是解析ConfigurationClass的内部的@Bean方法对应的BeanMethod注册到beanDefinitionMap中
this.reader.loadBeanDefinitions(configClasses);
// 9.9 解析MainConfig完成, 添加到已解析列表中
alreadyParsed.addAll(configClasses);
candidates.clear();
// 9.10 这里beanDefiniton新添加了一个, student对应的BeanDefinition, 大于candidateNames.length
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// 暂略
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
// 暂略
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
5.3 ConfigurationClassParser#parse(Set configCandidates)解析
内部调用的是【doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)】, 最后将解析结果放入到ConfigurationClassParser的configurationClasses中，
下面解析【doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)】方法
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// 1.@Configuration上加了@Component注解, 进入
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// 递归处理内部类, 这里没有, 跳过
processMemberClasses(configClass, sourceClass);
}
// 2.解析@PropertySources标签, 这里没有, 跳过
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 3.解析@ComponentScan标签, 这里没有, 跳过
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// 4.解析@Import标签, 这里没有, 跳过
processImports(configClass, sourceClass, getImports(sourceClass), true);
// 5.解析@ImportResource标签, 这里没有, 跳过
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 6.处理内部@Bean标签
// 提取 带有注解的所有方法, 封装成BeanMethod, 添加到对应的ConfigClass中
// 本例中, 将student()方法, 放入到mainConfig中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 7.处理MainConfig父接口的基本方法, 这里没有, 跳过
processInterfaces(configClass, sourceClass);
// 8.处理MainConfig父类的基本方法, 这里没有, 跳过
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
【5.3 方法总结】
当前方法主要使用ConfigurationClassParser来处理我们主配置类对应的ConfigurationClass, 这里我们的主配置类是:MainConfig
递归处理 内部类、@PropertySources、@ComponentScan、@Import、@ImportResource、内部@Bean标签
5.4 ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForConfigurationClass()解析
这里的configClass是MainConfig对应的Configuration
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
// 不会跳过
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// 不是@Import
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 处理@Bean标签的方法, 这里是student()方法
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
// 见@5.5解析
// 核心：将student和对应的BeanDefinition放入beanDefinitionMap 和 beanDefinitionNames中
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// importedResources 为空, 跳过
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// importBeanDefinitionRegistrars 为空, 跳过
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
5.5 ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod)方法解析
这里的BeanMethod是@Bean student()方法对应的 BeanMethod
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
// 获取student()方法所在的配置类 即MainConfig对应的ConfigurationClass
ConfigurationClass configClass = beanMethod.getConfigurationClass();
// 获取student()方法的所有标签元数据
MethodMetadata metadata = beanMethod.getMetadata();
// 获取方法名, 即student
String methodName = metadata.getMethodName();
// student()方法不会被跳过
if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
// 获取Bean标签里的所有属性
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// bean的name优先使用@Bean的name属性, 如果为空, 则用方法名, 这里用方法名-student
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
// 这里names为空, 跳过
for (String alias : names) {
this.registry.registerAlias(beanName, alias);
}
// Has this effectively been overridden before (e.g. via XML)?
// 是否需要被覆盖, 这里不需要， 跳过
if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
"' clashes with bean name for containing configuration class; please make those names unique!");
}
return;
}
// 创建MainConfig对应的BeanDefinition对象【ConfigurationClassBeanDefinition】!!!
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
beanDef.setResource(configClass.getResource());
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
if (metadata.isStatic()) {
// static @Bean method
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
beanDef.setFactoryMethodName(methodName);
}
else {
// instance @Bean method
// student方法是实例方法
// factoryBeanName为mainConfig
beanDef.setFactoryBeanName(configClass.getBeanName());
// uniqueFactoryMethodName为student
beanDef.setUniqueFactoryMethodName(methodName);
}
// 设置autowire模式
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
// 处理student方法上的其他标签, 如@Lazy, @Primary, @DependOn, @Role, @Description等
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
// 修改autowireMode
beanDef.setAutowireMode(autowire.value());
}
// 跳过
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
// 跳过initMethodName属性
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
// 处理destroyMethod属性, 跳过
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// 处理scope标签, 这里跳过
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
// 是否采用代理方式替换原生的bean
BeanDefinition beanDefToRegister = beanDef;
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName), this.registry,
proxyMode == ScopedProxyMode.TARGET_CLASS);
beanDefToRegister = new ConfigurationClassBeanDefinition(
(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
}
if (logger.isTraceEnabled()) {
logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
configClass.getMetadata().getClassName(), beanName));
}
// 注册BeanDefinition, 核心方法
// beanName: student registy: DefaultListableBeanFactory
// 将student和对应的BeanDefinition对象放入 beanDefinitionMap, beanDefinitionNames中
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
此时的beanFactory, beanDefinitionMap中已经有了7个, 其中5个内置的, 还有一个mainConfig，一个student
5.6 ConfigurationClassPostProcessor#postProcessBeanFactory()方法解析
我们在@5.1 中的总结里提到过, 本质就是先后执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法，这里只有一个内置的BeanDefinitionRegistryPostProcessor，即ConfigurationClassPostProcessor，上面我们介绍了ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法，接下来就需要解析它的postProcessBeanFactory方法了
/**
* Prepare the Configuration classes for servicing bean requests at runtime
* by replacing them with CGLIB-enhanced subclasses.
* 翻译: 通过用CGLIB增强的子类替换Configuration类，在运行时为bean提供服务。
*/
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
// 这里跳过
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
// 跳过
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
// 1.增强beanFactory里的@Configuration主配置类, 采用cglib的方式, 我们在@5.7中解析当前方法
// 这里我们会用增强的MainConfig替换原生MainConfig
enhanceConfigurationClasses(beanFactory);
// 2. 再增加一个BeanPostProcessors 【ImportAwareBeanPostProcessor】
// 这里一共有3个BeanPostProcessor:
// ApplicationContextAwareProcessor, ApplicationListenerDetector, ImportAwareBeanPostProcessor
// 前面两个是在@ 3.prepareBeanFactory(beanFactory)方法中添加的
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
5.7 ConfigurationClassPostProcessor#enhanceConfigurationClasses(beanFactory)方法解析
/**
* Post-processes a BeanFactory in search of Configuration class BeanDefinitions;
* any candidates are then enhanced by a {@link ConfigurationClassEnhancer}.
* Candidate status is determined by BeanDefinition attribute metadata.
* @see ConfigurationClassEnhancer
* 翻译: 后置处理BeanFactory, 查找@Configuration对应的BeanDefinition;
* 所有 @Configuration 的类都会被增强
*/
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
// 这里存放的是@Configuration类对应的BeanDefinition
Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
// 1.遍历beanDefinitionNames, 里面有7个元素, 有5个内置的, 还有两个： mainConfig 和 student
for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
// 2.这里我们只需要 @Configuration的
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
if (!(beanDef instanceof AbstractBeanDefinition)) {
throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
}
else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
logger.info("Cannot enhance @Configuration bean definition '" + beanName +
"' since its singleton instance has been created too early. The typical cause " +
"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
"return type: Consider declaring such methods as 'static'.");
}
configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
}
}
// 3.这里拿到了mainConfig, 不为空, 跳过
if (configBeanDefs.isEmpty()) {
// nothing to enhance -> return immediately
return;
}
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
AbstractBeanDefinition beanDef = entry.getValue();
// If a @Configuration class gets proxied, always proxy the target class
beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
try {
// Set enhanced subclass of the user-specified bean class
// 4.获取Class<MainConfig>
Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
if (configClass != null) {
// 5.生成Class<MainConfig>增强类 Class< com.tca.spring.framework.learning.ioc.config.MainConfig$$EnhancerBySpringCGLIB$$8da450e4>
Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
if (configClass != enhancedClass) {
if (logger.isTraceEnabled()) {
logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
}
// 修改MainConfig对应的BeanDefinition中的beanClass, 之前指向MainConfig, 现在替换成MainConfig的增强类 MainConfig$$EnhancerBySpringCGLIB$$8da450e4
beanDef.setBeanClass(enhancedClass);
}
}
}
catch (Throwable ex) {
throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
}
}
}
【5.2 - 5.7方法总结】
1.在上述方法中, 我们已经处理了唯一的内置 BeanDefinitionRegistryPostProcessor【ConfigurationClassPostProcessor】, 先后执行了 它的postProcessBeanDefinitionRegistry方法和 postProcessBeanFactory方法
2.它的postProcessBeanDefinitionRegistry方法主要是：
解析@Configuration对应的配置类, 将@Configuration配置类里的@Bean标签对应的方法取出, 封装成BeanDefinition, 注册到
BeanDefinitionMap和BeanDefinitionNames中
3.它的postProcessBeanFactory方法主要是:
找到@Configuration配置类对应的BeanDefinition, 替换BeanDefinition中beanClass为cglib增强后的配置类
4.接下来, 就需要处理普通的BeanFacotryPostProcessor, 这里也只剩一个了：EventListenerMethodProcessor, 解析它的postProcessBeanFactory()方法
5.8 EventListenerMethodProcessor.postProcessBeanFactory()方法解析
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
// 找到EventListenerFactory对象, 这里只有一个:
// org.springframework.context.event.internalEventListenerFactory - DefaultEventListenerFactory
Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
List<EventListenerFactory> factories = new ArrayList<>(beans.values());
AnnotationAwareOrderComparator.sort(factories);
this.eventListenerFactories = factories;
}
至此, @5.1 的方法已经全部执行完毕, 回到@5, @5中接下来的条件不满足, 也直接跳过, 所以此时@5全部执行完毕！！！
总结
1.首先需要知道两个接口, 整个方法就是在围绕两个接口:
BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor, 且后者是前者的子接口
BeanFactoryPostProcessor的核心方法:postProcessBeanFactory
BeanDefinitionRegistryPostProcessor的核心方法:postProcessBeanDefinitionRegistry
2.这个方法的执行过程就是:
先找到实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor, 排序后依次执行他们的postProcessBeanDefinitionRegistry方法;
再找到实现Ordered接口的BeanDefinitionRegistryPostProcessor, 排序后依次执行postProcessBeanDefinitionRegistry
再找到普通的BeanDefinitionRegistryPostProcessor, 依次执行postProcessBeanDefinitionRegistry
最后依次执行上面BeanDefinitionRegistryPostProcessor的postProcessBeanFactory
以上把BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry和postProcessBeanFactory都执行完了
继续执行:
把普通的BeanFactoryPostProcessor都找到, 然后依次执行它们的postProcessBeanFactory方法
3.在当前例子中, 实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor只有一个【内置的】:
ConfigurationClassPostProcessor,所以要研究它的postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法
实现了普通的BeanFactoryPostProcessor也只有一个【内置的】:EventListenerMethodProcessor, 需要研究它的postProcessBeanFactory方法
4.在上述方法中, 我们已经处理了唯一的内置 BeanDefinitionRegistryPostProcessor【ConfigurationClassPostProcessor】, 先后执行了 它的postProcessBeanDefinitionRegistry方法和 postProcessBeanFactory方法
它的postProcessBeanDefinitionRegistry方法主要是：
解析@Configuration对应的配置类, 将@Configuration配置类里的@Bean标签对应的方法取出, 封装成BeanDefinition, 注册到
BeanDefinitionMap和BeanDefinitionNames中
它的postProcessBeanFactory方法主要是:
找到@Configuration配置类对应的BeanDefinition, 替换BeanDefinition中beanClass为cglib增强后的配置类
接下来, 就需要处理普通的BeanFacotryPostProcessor, 这里也只剩一个了：EventListenerMethodProcessor, 解析它的postProcessBeanFactory()方法
问题解答：
1.我们自定义的BeanFactoryPostProcessor，并注册到容器中，构造器方法在什么时候执行，postProcessBeanFactory在什么时候执行
@Slf4j
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public CustomBeanFactoryPostProcessor() {
log.info("CustomBeanFactoryPostProcessor构造器被执行");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
log.info("自定义CustomBeanFactoryPostProcessor.postProcess()");
}
}
根据invokeBeanFactoryPostProcessors方法分析我们知道：
1.这个方法会优先执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法，这个方法会解析我们的@Configuration配置类, 把配置类中通过@ComponentScan、@Import、@Bean等方式注册到spring容器中的类, 全部解析封装成BeanDefinition对象, 放入beanFactory【DefaultListableBeanFactory】的beanDefinitionMap中, 所以这个时候, 我们自定义的
CustomBeanFactoryPostProcessor已经被解析封装成BeanDefinition对象了
2.等ConfigurationClassPostProcessor执行完postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法后, 就开始解析普通的BeanFactoryPostProcessor了
3.此时, 会从beanDefinitionMap中找到所有BeanFacotyPostProcessor对应的BeanDefinition, 见方法@5.1的第12步, 然后使用getBean()方法获取实例对象, 此时会初始化BeanFacotyPostProcessor对象, 调用构造器方法, 这里, 我们自定义的CustomBeanFactoryPostProcessor构造器方法被调用了
4.初始化完成后会添加到list中, 遍历执行postProcessBeanFactory方法, 此时自定义的postProcessBeanFactory方法也被执行了
6. AbstractApplicationContext#registerBeanPostProcessors(beanFactory)
注册拦截bean创建的BeanPostProcessor
/**
* Instantiate and register all BeanPostProcessor beans,
* respecting explicit order if given.
* <p>Must be called before any instantiation of application beans.
* 翻译: 按照顺序, 实例化并注册所有BeanPostProcessor
* BeanPostProcessor是在普通Bean实例化之前创建并实例化完成的
*/
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
6.1 PostProcessorRegistrationDelegate#registerBeanPostProcessors(beanFactory, applicationContext)
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 1.从beanDefinitionNames中找到两个内置的BeanPostProcessor：
// internalAutowiredAnnotationProcessor
// internalCommonAnnotationProcessor
// 【注意:】我们自定义的BeanPostProcessor会在@5执行中被封装成BeanDefintion, 注册到beanDefinitionMap中
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 翻译: 注册BeanPostProcessorChecker，当一个bean是在BeanPostProcessor实例化期间创建的，即它不能被所有beanPostProcessor处理时, 打印日志
// 2.此时已经包含的BeanPostProcessors有:
// AbstractBeanFactory中已经包含的beanPostProcessors, 有3个：ApplicationContextAwareProcessor, ApplicationListenerDetector, ImportAwareBeanPostProcessor
// 新加入的一个 BeanPostProcessorChecker,
// 以及: beanDefinitionNames在this()方法中就添加的两个:internalAutowiredAnnotationProcessor, internalCommonAnnotationProcessor
// 所以这里一共有6个
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 3.根据PriorityOrdered, Ordered, 未实现排序的分开处理
// 实现PriorityOrdered的BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 内置的 , 实现MergedBeanDefinitionPostProcessor的 BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 实现Ordered的BeanPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
// 未实现排序的BeanPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 4.遍历postProcessorNames, 有两个内置的, 且都实现了PriorityOrdered, 分别是:
// (internalAutowiredAnnotationProcessor, AutowiredAnnotationBeanPostProcessor对应的BeanDefinition)
// (internalCommonAnnotationProcessor, CommonAnnotationBeanPostProcessor对应的BeanDefinition)
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 5.排序实现了PriorityOrdered的
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 6.把实现了PriorityOrdered的BeanPostProcessor添加到 AbstractBeanFactory中的 beanPostProcessors中,
// 现在6个BeanPostProcessor都在 beanPostProcessors中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 7.排序并注册实现Ordered接口的BeanPostProcessors, 这里为空, 跳过
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
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);
// 8.排序并注册普通的BeanPostProcessors, 这里为空, 跳过
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 9.排序并注册内部BeanPostProcessors, 这里有两个, 且都为PriorityOrdered, 所在在这里重新删除又添加了一次
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 10.再添加注册一个BeanPostProcessor 【ApplicationListenerDetector】
// 这里ApplicationListenerDetector在@3方法中已经添加过, 所以这里把之前添加的删除了, 把新创建的放到列表最后一个, 所以这里一共还是6个
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
总结
1.这个方法比较简单, 根据PriorityOrdered, Ordered接口排序, 并注册排序好的BeanPostProcessor, 把BeanPostProcessor实例化后添加到 AbstractBeanFactory的beanPostProcessors中, 此时一共有6个;
2.如果我们自定义了 BeanPostProcessors 也会被实例化并添加进去
3.此时BeanPostProcessor的核心方法还没有执行, 他们会在普通bean的实例化前后执行
问题解答：
1.我们自定义的BeanPostProcessor，并注册到容器中，构造器方法在什么时候执行
根据registerBeanPostProcessors方法分析我们知道:
1.我们在@5方法中已经将我们自定义的普通bean封装成BeanDefinition对象, 放到beanFactory的beanDefinitionMap中, 我们在@6.1方法一开始就从beanDefinitionMap中获取所有BeanPostProcessor对应的BeanDefinition对象
2.@6.1的第8步中, 我们调用getBean()方法获取实例对象, 此时会初始化BeanPostProcessor对象, 调用构造器方法, 这里, 我们自定义的CustomBeanPostProcessor构造器方法被调用了
7. AbstractApplicationContext#initMessageSource()
/**
* Initialize the MessageSource.
* Use parent's if none defined in this context.
* 翻译: 初始化MessageSource, 如果当前类中没有, 使用父类的
*/
protected void initMessageSource() {
// 1.获取beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 2.判断容器中是否已经有messageSource, 下面解析beanFactory.containsLocalBean(name)方法
/* public boolean containsLocalBean(String name) {
* String beanName = transformedBeanName(name);
* return ((containsSingleton(beanName) // containsSingleton, 判断DefaultListableBeanFactory的父类 DefaultSingtonBeanRegistry 的一级缓存 singtonObjects中有没有
* || containsBeanDefinition(beanName)) // containsBeanDefinition, 判断beanDefinitionMap中有没有
* && (!BeanFactoryUtils.isFactoryDereference(name) // 判断name是否以&开头
* || isFactoryBean(beanName))); //判断是不是FactoryBean
* }
*/
// 这里没有, 需要跳过
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
// 3.创建MessageSource实例【DelegatingMessageSource】
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
// 4.将beanFactory的messageSource指向当前DelegatingMessageSource
this.messageSource = dms;
// 5.registrySington将当前MessageSource放入到一级缓存singtonObjects中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
总结
初始化MessageSource对象, 赋给beanFactory对象的messageSource属性, 同时放入到一级缓存singtonObjects中
8. AbstractApplicationContext#initApplicationEventMulticaster()
/**
* Initialize the ApplicationEventMulticaster.
* Uses SimpleApplicationEventMulticaster if none defined in the context.
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
* 翻译: 初始化ApplicationEventMulticaster, 如果没有, 则使用 SimpleApplicationEventMulticaster
*/
protected void initApplicationEventMulticaster() {
// 1.获取beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 2.跟@7 一样, 容器中没有, 这里跳过
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 3.创建默认的 SimpleApplicationEventMulticaster, 赋值给beanFactory
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 4.registrySington将当前applicationEventMulticaster放入到一级缓存singtonObjects中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
总结
跟@7的处理类似, 初始化ApplicationEventMulticaster, 赋给beanFactory对象的applicationEventMulticaster属性, 同时放入到一级缓存singtonObjects中
9. AbstractApplicationContext#onRefresh()
跟@4一样, 空实现, 等子类扩展
10. AbstractApplicationContext#registerListeners()
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
* 翻译: 添加实现 ApplicationListener 的 listener
*/
protected void registerListeners() {
// Register statically specified listeners first.
// 1.获取 AbstractApplicationContext 中的applicationListeners, 目前是空的, 跳过
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 翻译: 这里不用初始化beans, 我们会在后面先使用BeanPostProcess后置处理器来处理它们
// 2.获取所有的 ApplicationListener实现类, 这里也是空的
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 派发earlyApplicationEvents事件, 这里是空的, 跳过
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
总结
这里默认是空的, 后面会补充 自定义ApplicationListenerBean
11.AbstractApplicationContext#finishBeanFactoryInitialization(beanFactory)【核心方法】
前提
在前面的方法中, 已经：
1.BeanFactoryPostProcessor(包括其子接口BeanDefinitionRegistryPostProcessor)、BeanPostProcessor的实体bean已经创建并初始化完成
2.BeanFactoryPostProcessor(包括其子接口BeanDefinitionRegistryPostProcessor)的接口方法已经完成
3.自定义的bean已经扫描完成, 创建了对应的BeanDefinition对象
/**
* Finish the initialization of this context's bean factory,
* initializing all remaining singleton beans.
* 翻译: 完成beanFactory的初始化, 初始化所有剩余的单例bean, 比如我们注册的student。
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 翻译: 初始化conversion service
// 1.这里会跳过
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
// 2.这里暂略
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
// 3.跳过
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
// 4.跳过
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 5.跳过
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 6.初始化剩余的所有的非lazy的bean, 具体解析见@11.1
beanFactory.preInstantiateSingletons();
}
11.1 DefaultListableBeanFactory#preInstantiateSingletons()
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 触发所有非lazy的单例bean的初始化
// 这里我们的BeanDefinition一共有7个: 5个内置的, 还有一个mainConfig增强的, 一个student
for (String beanName : beanNames) {
// 1.获取beanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 2.当BeanDefinition对应的Bean满足：非抽象的、单例的、非lazy三个条件时, 执行下面
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 3.判断Bean是不是FactoryBean, 即是否实现FactoryBean接口
if (isFactoryBean(beanName)) {
// 4.实现了BeanFactory
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 5.未实现BeanFactory的普通Bean 见@11.2,内部调用的就是doGetBean()方法
// 完成bean的创建和初始化, 并将创建好的bean放入到一级缓存中
getBean(beanName);
}
}
}
// 6.判断bean有没有实现SmartInitializingSingleton接口, 如果实现了, 调用它们的afterSingletonsInstantiated()方法
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();
}
}
}
}
总结【注意：这里只讨论一般情况：非Lazy的，singleton的，非FactoryBean的，以下总结也是一样】
1.遍历BeanDefinition
2.调用getBean(beanName)方法, 根据name获取bean --> 这个方法尤其重要, 内部调用doGetBean(beanName, null, null, null)方法
对于已经初始化完成的bean, 从beanFactory的一级缓存中直接取出; 对于未实例化的bean, 会完成bean的整个生命周期(实例化、初始化等), 并放入到一级缓存中
3.判断bean有没有实现SmartInitializingSingleton接口, 如果实现了, 调用它们的afterSingletonsInstantiated()方法
11.2 AbstractBeanFactory#deGetBean【重点方法】
这个方法是创建实体Bean的方法
/**
* Return an instance, which may be shared or independent, of the specified bean.
* @param name the name of the bean to retrieve //实例name
* @param requiredType the required type of the bean to retrieve //要校验bean的类型
* @param args arguments to use when creating a bean instance using explicit arguments
* (only applied when creating a new instance as opposed to retrieving an existing one)
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 1.getSington(beanName)方法, 实际调用重载方法getSingleton(beanName, true)
// 见@11.4 getSingleton(String beanName, boolean allowEarlyReference)方法解析
// 【注意】: 内置的5个BeanDefinition已经实例化完成, 在一级缓存了, 但是MainConfig和Student都没有实例化
Object sharedInstance = getSingleton(beanName);
// 2.如果从一级、二级或者三级缓存中拿到数据了, 且args为null, 第一次获取肯定拿不到, 因为还没有开始实例化
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 3.对于从一级缓存中取出来的bean, 且不是FactoryBean, 则直接返回
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 4.如果一级二级三级缓存中都没有
else {
// 5.是否在原型模式的创建中, 如果是, 抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 6.父beanFactory为空, 这里跳过
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 7.当前bean是否只是做类型校验, 一般都不是， 进入
if (!typeCheckOnly) {
// 8.标记当前bean为已经创建的bean
markBeanAsCreated(beanName);
}
try {
// 9.mainConfig之前对应的是AnnotationGenericBeanDefinition, 现在把它封装成RootDefinition, 存放到mergedBeanDefinitions中
//【注意:】上面的markBeanAsCreated(beanName)方法会将RootDefinition从mergedBeanDefinitions中移除,然后这里又添加回来了, why
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 10.校验RootBeanDefinition对应的Class不是抽象的
checkMergedBeanDefinition(mbd, beanName, args);
// 11. 获取当前Bean @DependsOn的Bean, mainConfig没有, 这里跳过
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 12.创建实体Bean
// 创建scope==singleton的bean, 默认是singleton
if (mbd.isSingleton()) {
// 13.调用getSingleton方法, 将创建的bean放入到一级缓存中, 并且从二级和三级缓存中移除, 见@11.3
sharedInstance = getSingleton(beanName, () -> {
try {
// 14.创建Bean, 见@11.5 方法
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 创建scope==protoType的bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 创建非singleton和protoType的bean
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
// 如果参数中传了Bean的类型, 则进行校验和强制转换
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
总结
1.先从beanFactory的一级缓存获取一次, 从一级缓存中取出来的bean, 一开始一般取不出来
2.判断是否在原型模式创建中, 如果是, 则抛出循环依赖异常 -- 原型模式不支持循环依赖
3.获取当前beanFactory的父类beanFactory, 一般为空
4.把当前beanName存储到alreadyCreated已创建集合中
5.将当前beanName对应的bd存放到 mergedBeanDefinitions中
6.解析@DependOn标签
7.调用 getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法, 完成bean的生命周期, 并放入到一级缓存中
8.如果传了ClassType, 则需要校验
11.3 DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)
/**
* Return the (raw) singleton object registered under the given name,
* creating and registering a new one if none registered yet.
* @param beanName the name of the bean
* @param singletonFactory the ObjectFactory to lazily create the singleton
* with, if necessary
* @return the registered singleton object
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 1.先从一级缓存中拿
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 2.如果当前bean在销毁过程中, 则抛出异常
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 3.创建前准备工作
// 添加到 singletonsCurrentlyInCreation 【在创建过程中的单例集合】
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 4.这里调用的是createBean()方法, 见@11.5, 这个方法中完成bean的生命周期
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 5.bean的生命周期完成后, 从singletonsCurrentlyInCreation移除 【在创建过程中的单例集合】, 根创建前的准备工作对应
afterSingletonCreation(beanName);
}
// 6.如果是新创建的bean, 放入到一级缓存中, 从二级缓存和三级缓存中移除
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
总结
1.一开始还是会先从一级缓存中取, 如果取出来不为空则直接返回
2.一级缓存中没有, 则先把当前beanName添加到 singletonsCurrentlyInCreation 【在创建过程中的单例集合】, 然后调用createBean()完成bean的生命周期, 完成后, 从singletonsCurrentlyInCreation中移除
3.把完成生命周期的bean放入到一级缓存中, 同时从二级缓存和三级缓存中移除
11.4 getSingleton(String beanName, boolean allowEarlyReference)
/**
* Return the (raw) singleton object registered under the given name.
* <p>Checks already instantiated singletons and also allows for an early
* reference to a currently created singleton (resolving a circular reference).
* @param beanName the name of the bean to look for
* @param allowEarlyReference whether early references should be created or not
* @return the registered singleton object, or {@code null} if none found
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1.先从一级缓存中拿, 一级缓存中存放的是实例化完成的bean
Object singletonObject = this.singletonObjects.get(beanName);
// 2.如果一级缓存中没有拿到, 且也不在创建过程中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 3.从二级缓存中拿
singletonObject = this.earlySingletonObjects.get(beanName);
// 4.二级缓存中如果为空, 且允许早期引用, 则从三级缓存中拿
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 5.三级缓存中如果有, 则从三级缓存中删除, 把自己放入到二级缓存中
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
总结
getSington(beanName)方法, 就是从缓存中拿实体bean
先从一级缓存中拿, 拿到直接返回; 拿不到就从二级缓存中拿, 拿到直接返回; 拿不到就从三级缓存中拿, 拿到就使用三级缓存中存放的工厂对象创建对象, 然后把自己从三级缓存中移除, 把创建的对象放入到二级缓存, 并返回; 如果都没拿到, 返回null
11.5 AbstractAutowireCapableBeanFactory#createBean()
/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
* 翻译: 核心方法: 创建bean, 初始化bean, 应用BeanPostProcessors后置处理器
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 1.获取当前BeanDefinition对应的Class对象
// 我们的mainConfig对应的Class是增强后的MainClass, 即com.tca.spring.framework.learning.ioc.config.MainConfig$$EnhancerBySpringCGLIB$$e2c0a82
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 2.对于mainConfig, 这里跳过
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 3.准备override的方法, 这里没有, 跳过
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 4.重点: 这里让【实现了InstantiationAwareBeanPostProcessor】的BeanPostProcessor来生成bean的代理对象
// 【这里是第一处使用到特殊BeanPostProcessor的地方】
// resolveBeforeInstantiation方法解析:
// 判断当前bean不是spring内置bean且容器中有InstantiationAwareBeanPostProcessor的实现类:
// 依次执行postProcessBeforeInstantiation方法, 返回的结果【代理对象】不为空时, 直接跳出循环, 这里我们就知道为什么前面的BeanPostProcessor需要分PriorityOrdered/Ordered/普通的 并排序了, 优先级高的, 如果执行完了, 生成代理对象了, 优先级低的就无法执行了
// 当生成了代理对象之后, 就要依次执行所有BeanPostProcessor的postProcessAfterInitialization方法【注意: 当其中某一个方法执行的结果为null时, 此时后面的BeanPostProcessors也无法执行了, 此时返回上一个BeanPostProcessor的处理结果】
// 这里我们内置的InstantiationAwareBeanPostProcessor一共有3个, 这3个的postProcessBeforeInstantiation()方法都是空实现: ImportAwareBeanPostProcessor、CommonAnnotationBeanPostProcessor、AutowireAnnotationBeanPostProcessor
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 5.如果上面没有InstantiationAwareBeanPostProcessor生成的代理对象, 则进入到doCreateBean方法, 创建普通的bean对象
// 具体见@11.6, 完成bean的创建和初始化【bean的生命周期】
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
总结
1.这里让【实现了InstantiationAwareBeanPostProcessor】的BeanPostProcessor来生成bean的代理对象, 如果有生成, 则直接返回【这是第一次使用BeanPostProcessor】
2.如果上面没有生成, 则调用 doCreateBean(beanName, mbdToUse, args) 方法完成bean的生命周期
11.6 AbstractAutowireCapableBeanFactory#doCreateBean()【完成bean的生命周期】
/**
* Actually create the specified bean. Pre-creation processing has already happened
* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
* <p>Differentiates between default bean instantiation, use of a
* factory method, and autowiring a constructor.
* 翻译:
* @param beanName the name of the bean
* @param mbd the merged bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a new instance of the bean
* @throws BeanCreationException if the bean could not be created
* @see #instantiateBean
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// 1.判断是否是单例 mainConfig是
if (mbd.isSingleton()) {
// 2.这里 factoryBeanInstanceCache 是空的, 所以instanceWrapper==null
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 3.进入
if (instanceWrapper == null) {
// 4.【重点方法:】真正的创建对象的方法, 见@11.7
// 【注意:】这里仅仅是实例化完成, 即使用反射创建出对象本身, 但是并没有初始化完成
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 5.创建的对象和对象的Class类型
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 6.【注意:】这里会第三次使用到BeanPostProcessor, 这里用的是MergedBeanDefinitionPostProcessor
// applyMergedBeanDefinitionPostProcessors() 执行过程:
// 拿到所有的MergedBeanDefinitionPostProcessor【已经排序过】, 依次调用它们的postProcessMergedBeanDefinition()方法
// 这里的MergedBeanDefinitionPostProcessor【排序后】依次是:
// CommonAnnotationBeanPostProcessor
// AutowiredAnnotationBeanPostProcessor
// ApplicationListenerDetector
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 7.是否支持循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// 8.如果支持循环依赖, 创建对象对应的ObjectFactory对象, 放入到三级缓存中:
// private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16)
// 当调用 () -> getEarlyBeanReference(beanName, mbd, bean) 时, 会第四次使用到BeanPostProcessor【SmartInstantiationAwareBeanPostProcessor】
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
// 9.给对象属性赋值【上面仅仅是创建了对象, 但是没有初始化, 即属性字段都没有赋值】, 见@11.8
// 这里会第五次第六次使用BeanPostProcessor 【InstantiationAwareBeanPostProcessor】,判断是否需要属性注入, 并完成注入
populateBean(beanName, mbd, instanceWrapper);
// 10.初始化对象, 依次调用BeanPostProcessor的postProcessBeforeInitialization方法, bean配置初始化方法, BeanPostProcessor的postProcessAfterInitialization方法
// 这里会第七次第八次使用BeanPostProcessor
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 11.是否支持循环依赖, 默认是
if (earlySingletonExposure) {
// 12.这时候bean只在三级缓存中, 第二个参数为false时, 取出来的earlySingletonReference == null
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
// 13.这里会跳过
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
总结
doCreateBean()这个方法是狭义上的完成bean的生命周期的方法:
1.创建对象: 使用反射的方式, 通过合适的构造器创建对象【对应的方法--createBeanInstance(beanName, mbd, args)】
-- 这里会第二次使用BeanPostProcessor【SmartInstantiationAwareBeanPostProcessor】用于推断使用特殊的构造器来反射创建bean实例
2.第三次调用BeanPostProcessor【MergedBeanDefinitionPostProcessor】, 具体作用以后再谈
3.如果支持循环依赖, 创建对应bean对应的ObjectFactory, 并将其放入到三级缓存中！！！用以解决循环依赖问题
-- 创建的ObjectFactory重新了getEarlyBeanReference()方法, 这个方法第四次使用BeanPostProcessor【SmartInstantiationAwareBeanPostProcessor】
4.属性注入: 注入bean的相关属性【对应的方法--populateBean(beanName, mbd, instanceWrapper)】
-- 这里会第五次和第六次使用BeanPostProcessor【InstantiationAwareBeanPostProcessor】, 判断是否需要属性注入, 并完成注入
5.对象的初始化操作: 先后调用@PostConstruct配置的方法, 如果实现InitailizingBean接口, 重写afterPropertiesSet()方法, 调用@Bean(initMethod)配置的init-method方法【对应的方法--initializeBean(beanName, exposedObject, mbd)中调用的invokeAwareMethods(beanName, bean)方法】
-- 这里会第七次使用BeanPostProcessor
6.aop的实现: 【对应的方法--initializeBean(beanName, exposedObject, mbd)中调用的applyBeanPostProcessorsAfterInitialization方法】
-- 这里会第八次使用BeanPostProcessor【这里是狭义上AOP的实现】
7.放入beanFactory: 将完整的bean放入到一级缓存singletonObjects
11.7 AbstractAutowireCapableBeanFactory#createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
/**
* Create a new instance for the specified bean, using an appropriate instantiation strategy:
* factory method, constructor autowiring, or simple instantiation.
* 翻译: 使用适当的实例化策略为指定bean创建新实例：工厂方法、构造函数自动连接或简单实例化。
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a BeanWrapper for the new instance
* @see #obtainFromSupplier
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
* @see #instantiateBean
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1.获取bean对应的Class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 2.跳过
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
// 3.获取instanceSupplier, mainConfig为空, 下面跳过
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 4.对于mainConfig, 这里跳过
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 5.mainConfig, 这里跳过
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 6.mainConfig, 这里跳过
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// 7.决定使用哪个构造器来反射创建对象
// 【注意:】这里会第二次使用到BeanPostProcessor, 这里用的是SmartInstantiationAwareBeanPostProcessor
// 【复习:】第一次使用BeanPostProcessor, 是在创建对象之前, 使用的是InstantiationAwareBeanPostProcessor, 这里使用的SmartInstantiationAwareBeanPostProcessor是 InstantiationAwareBeanPostProcessor 的子接口
// determineConstructorsFromBeanPostProcessors() 执行过程:
// 拿到所有的SmartInstantiationAwareBeanPostProcessor【已经排序过】, 依次调用它们的determineCandidateConstructors()方法, 执行结果如果不为空, 则直接返回, 剩下的SmartInstantiationAwareBeanPostProcessor就没有机会执行了
// 这里的SmartInstantiationAwareBeanPostProcessor【排序后】依次是:
// ImportAwareBeanPostProcessor: 它的determineCandidateConstructors方法返回bull;
// AutowiredAnnotationBeanPostProcessor: 它的determineCandidateConstructors方法有具体实现, 但是对于mainConfig, 这里返回null
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 8.继续查找合适的构造器
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 9.没有特殊的构造器的时候, 使用特殊的无参构造器方法
// 【注意】这里使用反射创建出对象, 但是仅仅是创建出对象, 但是对象还没有初始化完成
return instantiateBean(beanName, mbd);
}
总结
这个方法的主要作用：选择合适的构造器方法, 通过反射创建对应的对象
1.优先使用BeanPostProcessor获取最合适的构造器：获取所有的已排序的SmartInstantiationAwareBeanPostProcessor, 依次调用它们的determineCandidateConstructors, 获取构造器对象
2.其次选择BeanDefinition的preferedConstructor
3.以上都为空时, 使用默认的无参构造器生成对象
11.8 AbstractAutowireCapableBeanFactory#populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
/**
* Populate the bean instance in the given BeanWrapper with the property values
* from the bean definition.
* 翻译: 注入bean的属性
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param bw the BeanWrapper with bean instance
*/
@SuppressWarnings("deprecation") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 1.这里跳过
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
// 翻译: 在注入属性之前, 可以使用BeanPostProcessor修改bean的状态, 用来支持字段注入的不同方式
boolean continueWithPropertyPopulation = true;
// 2.这里是第五次使用BeanPostProcessor, 这里使用的是InstantiationAwareBeanPostProcessor
// 依次拿到所有的InstantiationAwareBeanPostProcessor, 并执行它们的postProcessAfterInstantiation()方法, 这个方法的作用是：判断当前bean对象是否需要在创建完成之后进行属性注入, 如果需要, 返回true, 不需要, 则返回false;
// spring内置的三个InstantiationAwareBeanPostProcessor都是返回true
// ImportAwareBeanPostProcessor:
// CommonAnnotationBeanPostProcessor:
// AutowireAnnotationBeanPostProcessor:
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 3.根据上面InstantiationAwareBeanPostProcessor的执行结果, 只要有一个返回的结果为不需要注入属性, 那么这里会直接终止方法执行
if (!continueWithPropertyPopulation) {
return;
}
// 4.对于mainConfig, 这里会跳过
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 5.对于mainConfig, 这里也会跳过mbd.getResolvedAutowireMode() == AUTOWIRE_NO
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 6.这里为true, 即第五次使用的BeanPostProcessor
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 7.这里为false
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 8.第六次使用BeanPostProcessor, 这次跟第五次使用的BeanPostProcessor一样,InstantiationAwareBeanPostProcessor,但是调用的方法不一样, 这一次调用的是postProcessProperties()方法
// 【注意:】这里会完成属性注入
// ImportAwareBeanPostProcessor:
// CommonAnnotationBeanPostProcessor:
// AutowireAnnotationBeanPostProcessor:
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
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);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
// 9.对于MainConfig, 下面跳过
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
总结
这个方法的主要作用: 完成属性注入
1.在属性注入之前, 先使用BeanPostProcessor, 判断是否需要属性注入
2.判断是否是自动注入还是非自动注入, 如果是非自动注入, 则使用BeanPostProcessor完成属性注入
11.9 AbstractAutowireCapableBeanFactory#initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
/**
* Initialize the given bean instance, applying factory callbacks
* as well as init methods and bean post processors.
* <p>Called from {@link #createBean} for traditionally defined beans,
* and from {@link #initializeBean} for existing bean instances.
* 翻译: 调用工厂回调、init方法、以及BeanPostProcessor, 进一步初始化对象
* @param beanName the bean name in the factory (for debugging purposes)
* @param bean the new bean instance we may need to initialize
* @param mbd the bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* @return the initialized bean instance (potentially wrapped)
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 1.调用Aware接口回调方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 2.【注意:】这里是第七次调用BeanPostProcessor
// 获取所有的BeanPostProcessor, 调用它们的postProcessBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 3.【注意:】这里spring的bean的初始化方法有多种实现方式:
// 第一种: 实现InitailizingBean接口, 重写afterPropertiesSet()方法
// 第二种: 使用@Bean(initMethod)配置的方法
// 第三种: 使用@PostConstruct配置的方法
// 以上三种方式可以同时存在, 调用顺序依次是:第三种、第一种、第二种
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 4.【注意:】这里是第八次调用BeanPostProcessor
// 获取所有的BeanPostProcessor, 调用它们的postProcessAfterInitialization
// 【注意:】这里是真正实现aop原理的地方
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
总结
这个方法的主要作用: 在属性注入完成后, 完成生命周期的其他初始化
1.调用部分Aware接口
2.调用@PostConstruct配置的方法
3.如果实现InitailizingBean接口, 调用重写的afterPropertiesSet()方法
4.调用@Bean(initMethod)配置的方法
5.使用BeanPostProcessor完成AOP
问题解答：
1.我们自定义的BeanPostProcessor, postProcessBeforeInitialization()方法、postProcessAfterInitialization()方法什么时候执行?
1.由前面我们知道, 自定义的BeanPostProcessor的bean对象是在@6 步骤创建并初始化完成的;
2.它们的postProcessBeforeInitialization()方法、postProcessAfterInitialization()方法会在创建普通bean对象时, 在普通bean对象实例化完成后, 生命周期初始化方法调用完成之后, 调用, 进行AOP, 针对于每一个普通bean
BeanPostProcessor总结【非常重要】
1.第一次: 在创建bean之前, 使用【实现了InstantiationAwareBeanPostProcessor】的BeanPostProcessor来生成bean的代理对象, 如果有生成, 则直接返回
2.第二次: 如果第一次使用的过程中没有生成代理对象, 在实例化bean对象时, 使用BeanPostProcessor【SmartInstantiationAwareBeanPostProcessor】用于推断使用特殊的构造器来反射创建bean实例
3.第三次: 在实例化bean对象之后, 调用BeanPostProcessor【MergedBeanDefinitionPostProcessor】, 具体作用以后再谈
4.第四次: 如果支持循环依赖, 创建对应bean对应的ObjectFactory, 并将其放入到三级缓存中！！！用以解决循环依赖问题, 创建的ObjectFactory第四次使用BeanPostProcessor【SmartInstantiationAwareBeanPostProcessor】
5.第五、六次: 实例化完成后, 注入bean的相关属性时, 这里会第五次和第六次使用BeanPostProcessor【InstantiationAwareBeanPostProcessor】, 判断是否需要属性注入, 并完成注入
6.第七、八次: 在属性注入之后, 执行初始化方法前后, 会先后调用BeanPostProcessor, 完成AOP
以上, 在实例化bean之前, 第一次使用bdp, 生成代理对象; 如果代理对象没有生成, 在普通bean实例化时, 第二次使用bdp进行构造器推断, 实例化后第三次、第四次使用dbp, 属性注入时第五次、第六次使用bdp, 在初始化方法前后完成第七次、第八次使用bdp
12.finishRefresh()
/**
* Finish the refresh of this context, invoking the LifecycleProcessor's
* onRefresh() method and publishing the
* {@link org.springframework.context.event.ContextRefreshedEvent}.
*/
// 翻译: 调用LifecycleProcessor的 onRefresh() 方法并发布ContextRefreshedEvent事件
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 翻译: 清除上下文级别的资源缓存(例如来自扫描的ASM元数据)。
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
评论