要将类注入到IOC容器中成为一个Bean：
- 通过xml、注解、javaconfig等方式进行配置类
- 通过实例化不同的ApplicationContext实现来加载Spring上下文
- 通过BeanDefinitionReader读取配置类
- BeanDefinitionScanner扫描合格的Bean（比如加了@Component注解等）
- BeanDefinitionRegistry注册成BeanDefinition（BeanDefinition是 Spring Framework 中定义 Bean 的配置元信息接口。BeanDefinition 并非 Bean 终态，可以自定义修改。）
- 注册成BeanDefinition之后，ApplicationContext可以通过BeanFactoryPostProcessor扩展去修改BeanDefinition；
- 将BeanDefinition交给BeanFactory，通过其getBean方法可以生产和获取Bean，中间会经历一系列实例化，填充属性，初始化等操作，其中还包括一些BeanPostProcessor来扩展生产过程；
- 生产完成之后会将最终的Bean一级缓存singletonObjects中，再次获取时就从缓存中获取。
一、IOC容器加载过程
常见加载spring上下文两种方式：
-
xml配置:ClassPathXmlApplicationContext(“xxx.xml”);
-
注解方式:AnnotationConfigApplicationContext(config.class);
实例化容器，以AnnotationConfigApplicationContext为例
// 加载spring上下文，同时传入自己的配置类Config
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
AnnotationConfigApplicationContext继承关系：
从AnnotationConfigApplicationContext构造方法作为切入点：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//1.调用无参构造函数
this();
//2.注册传入的配置类
register(annotatedClasses);
//3.IOC容器刷新接口
refresh();
}
1.this()
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
调用无参构造函数
- 隐式调用父类GenericApplicationContext的构造函数，实例化一个Bean工厂DefaultListableBeanFactory(最底层的实现，功能最全)，并且赋值给beanFactory；
- 本类的构造函数实例化一个读取注解的Bean定义读取器AnnotatedBeanDefinitionReader和一个扫描器ClassPathBeanDefinitionScanner(此处的scanner用处不大)。
1.1BeanFactory
BeanFactory是Spring顶层核心接口。使用简单工厂模式，负责生产和获取Bean(通过getBean)。DefaultListableBeanFactory是其底层实现，继承关系如下：
1.2BeanDefinitionReader
BeanDefinitionReader是负责读取配置的接口。实例化AnnotatedBeanDefinitionReader主要注册一些内置Bean。可以从构造方法依次进入到registerAnnotationConfigProcessors方法中查看相关代码。
其中注册的ConfigurationClassPostProcessor就是解析配置类的后置处理器，其他Bean注册流程也类似。
//判断容器中是否已经存在
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//如果不存在就通过RootBeanDefinition的构造方法获得ConfigurationClassPostProcessor的BeanDefinition，
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
//注册Bean
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
2.register
注册传入的配置类，最终会调用到AnnotatedBeanDefinitionReader#doRegisterBean
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
...
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
2.1registerBeanDefinition
AnnotatedBeanDefinitionReader#doRegisterBean最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册，其中beanDefinitionNames用来保存beanName，beanDefinitionMap用来保存beanName和beanDefinition。
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
...
else {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
...
}
BeanDefinition结构图
3.refresh
刷新容器。前两个方法分别实例化Bean工厂、注册一些内置的Bean和自己的配置类，refresh是重点方法。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
prepareRefresh();
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
prepareBeanFactory(beanFactory);
try {
postProcessBeanFactory(beanFactory);
//调用bean工厂后置处理器(BeanFactoryPostProcessors)，注册BeanDefinition
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean后置处理器(BeanPostProcessors)
registerBeanPostProcessors(beanFactory);
initMessageSource();
initApplicationEventMulticaster();
onRefresh();
registerListeners();
//将BeanDefinition通过getBean方法创建和获取Bean
finishBeanFactoryInitialization(beanFactory);
finishRefresh();
}
...
3.1invokeBeanFactoryPostProcessors
在前面实例化BeanDefinitionReader时，注册了ConfigurationClassPostProcessor的BeanDefinition；调用register方法注册了我们自己配置类的BeanDefinition。
在本方法中，ConfigurationClassPostProcessor会对配置类进行解析，解析@Configuration、@ComponentScan、@Import、@Bean等注解。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//getBeanFactoryPostProcessors()默认是空的(size=0)，需要在外部调用context.addBeanFactoryPostProcessor添加我们自定义BeanFactoryPostProcessor
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
...
}
PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
- 按照优先级处理所有BeanDefinitionRegistryPostProcessor（PriorityOrdered>Ordered>没有实现优先级接口>postProcessBeanFactory方法）
- 按照优先级处理所有BeanFactoryPostProcessor（PriorityOrdered>Ordered>没有实现优先级接口）
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//-----------------------------------------调用BeanDefinitionRegistryPostProcessor
...
//判断beanFactory实现了BeanDefinitionRegistry(实现了该结构就有注册和获取Bean定义的能力）
if (beanFactory instanceof BeanDefinitionRegistry) {
...
//去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//判断是否实现了PriorityOrdered接口的，作为第一优先级
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//显示的调用getBean()的方式获取该对象然后加入到currentRegistryProcessors集合中去
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//调用。这里会调用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//处理后续优先级的BeanDefinitionRegistryPostProcessor（实现Order接口>没有实现优先级接口），逻辑类似
...
//调用postProcessBeanFactory方法，因为BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProcessor
//这里会调用ConfigurationClassPostProcessor的postProcessBeanFactory
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
...
}
//-----------------------------------------按照优先级处理BeanFactoryPostProcessor
...
ConfigurationClassPostProcessor
继承关系
ConfigurationClassPostProcessor实现了PriorityOrdered和BeanDefinitionRegistryPostProcessor，重写了postProcessBeanDefinitionRegistry和postProcessBeanFactory方法。
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
...
processConfigBeanDefinitions(registry);
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
...
// 使用cglib对配置类进行代理，因为@Bean方法到时候要进行创建Bean的实例
enhanceConfigurationClasses(beanFactory);
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
ConfigurationClassPostProcessor#processConfigBeanDefinitions
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
...
//创建一个配置类解析器对象
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
...
do {
//解析配置类
parser.parse(candidates);
...
ConfigurationClassParser
public void parse(Set<BeanDefinitionHolder> configCandidates) {
//用于来保存延时的ImportSelectors
//其中包括SpringBoot自动装配的类 AutoConfigurationImportSelector
this.deferredImportSelectors = new LinkedList<>();
// 循环配置类
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
...
}
//处理延时的DeferredImportSelectors
//springboot就是通过这步进行记载spring.factories文件中的自定装配的对象
processDeferredImportSelectors();
}
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
//把配置类源信息和beanName包装成一个ConfigurationClass对象
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
...
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
...
}
//doProcessConfigurationClass方法会解析@propertySource、@ComponentScan、@Import、@ImportResource、@Bean等注解
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
...
//处理 @propertySource
...
//处理 @ComponentScan
...
// 处理 @Import
...
// 处理 @ImportResource
...
// 处理 @Bean，获取配置类中所有标注了@Bean的方法
...
// 处理配置类接口，默认方法的@Bean
...
// 处理配置类的父类，循环再解析
...
}
3.2finishBeanFactoryInitialization
实例化剩余的单例Bean
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
...
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
...
//获取容器中所有bean定义的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//循环所有的bean定义名称
for (String beanName : beanNames) {
//合并bean定义，转换为统一的RootBeanDefinition类型
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
/**
* 要求bean定义不是抽象的&&是单例的&&不是懒加载的
*/
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//是不是工厂bean
if (isFactoryBean(beanName)) {
...
}
else {//非工厂Bean 就是普通的bean
getBean(beanName);
}
}
}
...
}
二、Bean生命周期
1.整体流程
通过getBean方法，将BeanDefinition创建为Bean并获取到Bean。大致流程：
getBean
-----doGetBean
-----------getMergedLocalBeanDefinition BeanDefinition 合并阶段
-----------getSingleton
----------------createBean
---------------------resolveBeanClass Bean加载
---------------------resolveBeforeInstantiation Bean 实例化前阶段
---------------------doCreateBean 实例化、属性赋值，初始化
--------------------------createBeanInstance Bean 实例化阶段
--------------------------populateBean 属性赋值
-------------------------------postProcessAfterInstantiation Bean 实例化后阶段
-------------------------------postProcessPropertyValues Bean 属性赋值前阶段
-------------------------------applyPropertyValues Bean 属性赋值阶段
--------------------------initializeBean Bean初始化
-------------------------------invokeAwareMethods Bean Aware 接口回调阶段（不包括ApplicationContext相关）
-------------------------------applyBeanPostProcessorsBeforeInitialization Bean 初始化前阶段
-------------------------------invokeInitMethods Bean 初始化阶段
-------------------------------applyBeanPostProcessorsAfterInitialization Bean 初始化完成阶段
2.doGetBean
AbstractBeanFactory#doGetBean
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
...
//尝试去缓存中获取对象:一级>二级>三级
Object sharedInstance = getSingleton(beanName);
...
//创建单例bean
if (mbd.isSingleton()) {
//此处getSingleton不同于上面的getSingleton方法：前面的getSingleton主要是从缓存中获取对象，如果有直接返回；后面的getSingleton是把Bean标记成正在创建，作为循环依赖的出口
sharedInstance = getSingleton(beanName, () -> {
try {
//进入创建bean的逻辑
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//创建bean的过程中发生异常,需要销毁关于当前bean的所有信息
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
...
return (T) bean;
}
3.createBean
AbstractAutowireCapableBeanFactory#createBean
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
...
// 把beanClass从String类型变成Class类型并返回该Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
...
try {
/**
* 第1个bean后置处理器
* 通过bean的后置处理器来进行后置处理生成代理对象,一般情况下在此处不会生成代理对象，因为真实的对象没有生 * 成。这一步是aop和事务的关键，因为在这里解析aop切面信息进行缓存
*/
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
...
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
...
}
4.Bean实例化-初始化
-实例化是 Class 到 Object 的过程；初始化是 Object 状态准备的过程
4.1resolveBeforeInstantiation
默认返回null，表示继续 Spring IoC 容器的实例化操作；如果不为null，直接return，不走后续实例化操作
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
...
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
...
}
applyBeanPostProcessorsBeforeInstantiation
-InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation（循环BeanPostProcessor，调用InstantiationAwareBeanPostProcessor类型的postProcessBeforeInstantiation）
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
/**
*获取容器中的所有后置处理器，
*循环BeanPostProcessor，
*调用InstantiationAwareBeanPostProcessor类型的postProcessBeforeInstantiation
*/
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
/**
* 【很重要】
* AOP @EnableAspectJAutoProxy为容器中导入了 AnnotationAwareAspectJAutoProxyCreator
* 事务注解@EnableTransactionManagement为容器导入了 InfrastructureAdvisorAutoProxyCreator
* 都是实现了BeanPostProcessor接口,InstantiationAwareBeanPostProcessor,进行后置处理解析切面
*/
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
4.2doCreateBean
AbstractAutowireCapableBeanFactory#doCreateBean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
...
//创建bean实例化，使用合适的实例化策略来创建新的实例（两种方式：反射、工厂）
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//从beanWrapper中获取我们的早期对象
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
...
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性赋值 给我们的属性进行赋值(调用set方法进行赋值)
populateBean(beanName, mbd, instanceWrapper);
//进行对象初始化操作(在这里可能生成代理对象)
exposedObject = initializeBean(beanName, exposedObject, mbd);
...
createBeanInstance
返回一个instanceWrapper，装饰器模式
-instantiateBean
-getInstantiationStrategy()#instantiate()
populateBean
默认返回true，则继续进行后续的属性赋值流程；如果返回false，则直接return，不走后续的属性赋值操作
...
//是否持有 InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//获取容器中的所有的BeanPostProcessor
//循环BeanPostProcessor，调用InstantiationAwareBeanPostProcessor类型的postProcessAfterInstantiation
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//调用InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
//若存在后置处理器给我们属性赋值了，那么返回false，就不会走下面的逻辑了
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
...
if (hasInstAwareBpps) {
//获取所有的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//对依赖对象进行后置处理
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
...
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
initializeBean
AbstractAutowireCapableBeanFactory#initializeBean
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
...
else {
//若bean实现了XXXAware接口进行方法的回调
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//调用我们的bean的后置处理器的postProcessorsBeforeInitialization方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
...
if (mbd == null || !mbd.isSynthetic()) {
//调用我们bean的后置处理器的PostProcessorsAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
invokeAwareMethods
调用顺序BeanNameAware > BeanClassLoaderAware > BeanFactoryAware（不包括ApplicationContext相关Aware 接口，DefaultListableBeanFactory无法使用非 public 类 ApplicationContextAwareProcessor）
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
applyBeanPostProcessorsBeforeInitialization
-AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization
-BeanPostProcessor#postProcessBeforeInitialization
-initPostConstruct 初始化（@PostConstruct注释）
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
...
//循环BeanPostProcessor调用，
//包含CommonAnnotationBeanPostProcessor接口和ApplicationContextAwareProcessor的postProcessBeforeInitialization中的Aware接口回调
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
...
}
invokeInitMethods
-AbstractAutowireCapableBeanFactory#invokeInitMethods
-afterPropertiesSet 初始化（重写）
-invokeCustomInitMethod 初始化（自定义）
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
...
((InitializingBean) bean).afterPropertiesSet();
...
invokeCustomInitMethod(beanName, bean, mbd);
...
applyBeanPostProcessorsAfterInitialization
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//获取我们容器中的所有的bean的后置处理器,循环BeanPostProcessor调用postProcessAfterInitialization
for (BeanPostProcessor processor : getBeanPostProcessors()) {
/**
* aop和事务都会在这里生存代理对象
*
*
* AOP @EnableAspectJAutoProxy 为容器中导入了 AnnotationAwareAspectJAutoProxyCreator
* 事务注解@EnableTransactionManagement 为容器导入了 InfrastructureAdvisorAutoProxyCreator
* 都是实现了BeanPostProcessor接口,InstantiationAwareBeanPostProcessor,
* 在这里实现的是BeanPostProcessor接口的postProcessAfterInitialization来生成代理对象
*/
Object current = processor.postProcessAfterInitialization(result, beanName);
...
}
5.加入缓存
Bean初始化完成之后，会加入到缓存中，下次getBean就直接从缓存中获取。DefaultSingletonBeanRegistry
/** 一级缓存 这个就是单例缓存池 用于保存我们所有的单实例bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** 三级缓存 该map用户缓存 key为 beanName value 为ObjectFactory(包装为早期对象) */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** 二级缓存 ，用户缓存我们的key为beanName value是我们的早期对象(对象属性还没有来得及进行赋值) */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
...
if (newSingleton) {
//加入缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
//加入到单例缓存池中
this.singletonObjects.put(beanName, singletonObject);
//从三级缓存中移除(针对的不是处理循环依赖的)
this.singletonFactories.remove(beanName);
//从二级缓存中移除(循环依赖的时候 早期对象存在于二级缓存)
this.earlySingletonObjects.remove(beanName);
//用来记录保存已经处理的bean
this.registeredSingletons.add(beanName);
}
}
三、Spring中扩展点
BeanFactoryPostProcessor：主要针对BeanDefinition进行扩展，生产Bean之前调用。
BeanDefinitionRegistryPostProcessor：主要用于注册BeanDefinition，生产Bean之前调用。
BeanPostProcessor：主要针对Bean进行扩展，生产Bean过程中调用。
扫一扫
1794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
