Spring IOC （三）
refresh()
后八个方法
refresh()
定义：
这个方法中，内置了13个方法，做了很多事情
方法：
| 方法 | 作用 |
|---|---|
| prepareRefresh() | 保存了容器的启动时间，启动标志等 |
| obtainFreshBeanFactory(); | 获得了DefaultListableBeanFactory |
| prepareBeanFactory(beanFactory); | 添加了两个后置处理器 忽略自动装配 和 允许自动装配 bean表达式解析器 |
| postProcessBeanFactory(beanFactory); | 空方法 |
| invokeBeanFactoryPostProcessors(beanFactory); | 执行自定义的BeanFactoryProcessor 和内置的BeanFactoryProcessor |
| registerBeanPostProcessors(beanFactory); | 注册BeanPostProcessor |
| initMessageSource(); | 初始化信息源 |
| initApplicationEventMulticaster(); | 初始化应用事件多播器 |
| onRefresh(); | 空方法 |
| registerListeners(); | 注册监听器，用于监听bean并注册他们 |
| finishBeanFactoryInitialization(beanFactory); | 初始化所有剩余的单例 bean |
| finishRefresh(); | 调用 生命周期处理器的onRefresh() 发布事件 |
| destroyBeans(); | 销毁所有单例池所有实例bean |
registerBeanPostProcessors()
定义：
重要方法，这个方法用来**实例化Bean的很多后置处理器**，在Bean的创建过程中，我们可以实现Spring给定的Bean后置处理器接口，来对Bean的创建过程进行一些修改
原理是：Spring会在这个过程中进行多次回调
源码：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 又调用了这个类的方法，跟进
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
调用了 PostProcessorRegistrationDelegate 类的静态方法
源码：
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 1. 内部通过遍历所有Bean定义，来找到所有的Bean后置处理器
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 2. 注册一个BeanPostProcessorChecker，来记录过程
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 又是分为最优先的、优先的、不优先的三种
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 3. 遍历所有的Bean后置处理器名字
for (String ppName : postProcessorNames) {
// 最高优先级
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 在这里实例化bean后置处理器
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);
}
}
// 4. 注册最高优先级的BeanPostProcessor
// （其实就是add到一个List中beanPostProcessors的list）
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 5. 循环去找次优先级的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
// 在这里实例化bean后置处理器
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 6. 注册次优先级的BeanPostProcessor
// （其实就是add到一个List中beanPostProcessors的list）
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 7. 循环去找无优先级的BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
// 实例化bean后置处理器
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 8. 注册无优先级的BeanPostProcessor
// （其实就是add到一个List中beanPostProcessors的list）
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 9. 最后执行Spring内部的BeanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 10. 再次注册Spring的内置的监听器探测器，用来探测 **内部的应用监听器bean**
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
小结：
这个方法比较简单，通过Bean定义找到所有BeanPostProcessor，然后主要做了三件事：
- 匹配BeanPostProcessor
- 排序BeanPostProcessor
- 实例化BeanPosrProcessor
注意：不会执行BeanPostProcessor，这个适用于增强Bean的，到创建Bean的时候才会执行。
initMessageSource()
定义：
这个方法主要是用于国际化
源码：
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 1. 实现国际化的话，就必须配置一个Bean，且他的名称必须要是 messageSource
// 用户自定义一个信息源
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// 2. 当父类没有注册信息源时，去设置父类的信息源
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// 3. 用户没有自定义，Spring默认配置
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 4. 将这个Bean注册到Bean工厂
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
initApplicationEventMulticaster()
定义：
这个方法用于初始化应用事件多播器
源码：
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 1. 检查 applicationEventMulticaster 的Bean或Bean定义是否存在
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 2. 实例化bean并赋值
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 3. 如果不存在，那么new一个SimpleApplicationEventMulticaster
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 4. 将该对象注入bean工厂
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() + "]");
}
}
}
小结
总的流程很简单，检查容器中有没有默认的事件多播器
- 有就赋值给applicationEventMulticaster
- 没有就实例化一个SimpleApplicationEventMulticaster 给applicationEventMulticaster
OnRefresh()
定义：
空方法，给子类继承，就是SpringMVC那些用的
registerListeners()
定义：
注册监听器
源码：
protected void registerListeners() {
// 1. 首先注册静态的、指定的监听器,注册的是特殊的事件监听器,而不是配置中的bean
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 2. 实例化应用监听器Bean，排除==FactoryBean==，目的是为了让后置处理器能处理他们
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 3. 现在有了事件广播组,发布之前的应用事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
// 4. 多播器发布早期事件，通知监听器
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
小结：
一个订阅、发布的模式，主要是四个角色：
- ApplicationEvent：事件，每个实现类表示一类事件，可携带数据。抽象类。
- ApplicationListener：事件监听器，用于接收事件处理时间。接口。
- ApplicationEventMulticaster：事件管理者，可以注册（添加）/移除/发布事件。用于事件监听器的注册和事件的广播。接口。
- ApplicationEventPublisher：事件发布者，委托事件管理者ApplicationEventMulticaster完成事件发布。
finishBeanFactoryInitialization(beanFactory)
定义：
实例化所有剩下的Bean，重要方法，这里有实例化bean的一个整体逻辑
源码：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
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));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 1. 初始化LoadTimeWeaverAware Bean实例对象
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
// 2.冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
// 3. 实例化所有剩余（非懒加载）单例对象 【重要】
beanFactory.preInstantiateSingletons();
}
源码：
preInstantiateSingletons()方法，主要是去执行实例化剩余的单例对象
@Override
public void preInstantiateSingletons() throws BeansException {
// 1. 创建bean定义副本
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// 2. 循环遍历
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 3. 不是抽象类 && 是单例 && 不是懒加载 才有资格被实例化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 4. 是否为FactoryBean
if (isFactoryBean(beanName)) {
// 4.1 通过beanName获取FactoryBean实例
/**
* 工厂bean的特性： **& 前缀符**
* - 通过getBean(&beanName)拿到的是FactoryBean本身；
* - 通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
*/
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
// 4.2 判断这个FactoryBean是否希望急切的实例化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 4.3 如果希望急切的实例化，getbean()实例化
getBean(beanName);
}
} else {
// 5. 普通bean，直接实例化
getBean(beanName);
}
}
}
// 6. 上面已经实例化完所有的bean了
// 7. 遍历beanNames，触发所有SmartInitializingSingleton的后实例化回调
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
// 7.1 这个接口，可以让bean在**所有的bean实例化**完成后，执行一个**特定的方法**
// 区别于，BeanPostProcessor，在bean**自己实例化**完成后，执行一个**特定的方法**
// 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
// 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
if (System.getSecurityManager() != null) {
// 7.4 Spring的安全控制
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
// 7.5 执行回调方法，无论如何都会执行
smartSingleton.afterSingletonsInstantiated();
return null;
}
}, getAccessControlContext());
} else {
// 7.5 执行回调方法,无论如何都会执行
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
小结：
该方法主要是区分FactoryBean和普通bean
并且调用回调函数==SmartInitializingSingleton接口==定义的函数
- 该函数的意义：
- 当所有bean实例化都完成后，实现了这个接口的bean可以执行一个特定的方法
源码：
调用getBean()方法，可以实例化bean【假如说bean还没实例化】
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
在Spring中，所有doXxxx()的方法都是真正执行具体操作的代码
源码：
doGetBean()方法，真正的去获取bean
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) {
// 1. 拿到beanName
String beanName = transformedBeanName(name);
Object beanInstance;
// 2. 直接去单例池找之前有没有实例化过，如果找到直接返回
Object sharedInstance = getSingleton(beanName);
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 + "'");
}
}
// 2.1 获取bean实例，准备返回
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
// 3. 单例池找不到，走去创建的逻辑
else {
// 3.1 如果是多例bean的循环依赖，直接报错！Spring无法解决多例bean的循环依赖
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
// 3.2 找不到这个beanName对应的beanDefinition，委托父工厂来doGetBean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
// 3.3 委托父工厂，父 工厂是AbstractBeanFactory
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// 3.4 委托父工厂，有参数
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// 3.5 委托父工厂，有Type
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 4. 获取bean的依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
}
}
// 5. 真正去创建bean，**单例创建**
if (mbd.isSingleton()) {
// 6. 从单例池中获取，传入 lambda函数方法 提供给 getSingleton()方法内回调
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
});
// 7. 包装，并获取bean实例
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 8. 多例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);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 9. 其他的Scope的Bean创建
else {
String scopeName = mbd.getScope();
Scope scope = this.scopes.get(scopeName);
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
}
}
finally {
beanCreation.end();
}
}
// 根据requiredType，将beanInstance强转为目标类型，然后返回
return adaptBeanInstance(name, beanInstance, requiredType);
}
小结：
通过doGetBean()主要做了
- 从单例池中获取，如果没有，委托父工厂getBean，如果还没有，那就走创建的流程，有三种bean选择
- 如果是单例bean
- 如果是多例bean
- 如果是特定的Scope的bean
源码：
getSingleton()方法有多个重载机制！！！！！很重要
-
getSingleton(String beanName) —— 单例池寻找🔎，本质上会调用第二种
-
getSingleton(String beanName, boolean allowEarlyReference) —— 单例池寻找，找不到会调用 函数方法，根据allowEarlyReference，决定是否获取早期引用对象
-
getSingleton(String beanName, ObjectFactory<?> singletonFactory) —— 单例池寻找，找不到则调用 函数方法，执行createBean()执行创建bean流程
⚠注意！很重要！
2和3的都会调用一个函数方法，他们各自调用的函数接口和时机都是不一样的
- 第二种
- 它的调用时机是，一开始进入getBean()时，马上调用的，它是用来避免循环依赖！一进来，发现自己正在处于循环依赖，就去调用函数方法执行getEarlyBeanReference()获取早期对象，暴露出来就给了一个出口给循环依赖
- 第三种
- 它的调用时机是，当前bean真的需要创建的时候【第二种调用无果】，后面真正创建时候调用的，它是用来**再次确认从单例池中获取bean，**如果拿不到，那就调用函数方法执行createBean()，真正地执行创建一个bean流程
第二种getSingleton()
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1. 利用了双重检测锁DCL，来获取单例
Object singletonObject = this.singletonObjects.get(beanName);
// 2. 如果单例池拿不到，并且正在创建，尝试从二级缓存找早期对象 【循环依赖】
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 3. 早期对象获取
singletonObject = this.earlySingletonObjects.get(beanName);
// 4. 如果获取不到早期对象，并且允许获得早期引用
if (singletonObject == null && allowEarlyReference) {
// 加锁
synchronized (this.singletonObjects) {
// 5. 再拿一次，尝试
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 6. 获取函数方法，调用该方法获取早期的bean
// 【调用getEarlyBeanReference()】，与下面不同，👇是createBean()
singletonObject = singletonFactory.getObject();
// 7. 早期的bean，存入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 8. 马上删除函数方法，因为函数方法只用一次！
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
函数方法调用getEarlyBeanReference()被放入的时机： —— 被依赖的bean已经完成实例化，但未开始填充属性的时机
第三种getSingleton()
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 1. 调用之前传进来的回调，创建bean
// 2. 【createBean()】，与上面不同，👆是getEarlyBeanReference()
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
// 3. 如果是一个新创建的bean，那么让他加入缓存
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);
this.registeredSingletons.add(beanName);
}
}
函数方法调用createBean()被放入的时机： —— 第二次，也就是本次getSingleton()拿不到结果，就调用回调createBean()
源码：
createBean() 创建bean方法，—— 执行创建bean之前的一些准备动作
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
try {
// 1. ！这里是给第一次实例化普通bean的时候，封装Advisors的地方
// 通过这里调用BeanPostProcessor的方法，
// 实现扫描切面类，并封装【切点和通知 一一对应】
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
try {
// 2. 真正去创建一个bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 3. 返回
return beanInstance;
}
}
源码：
doCreateBean() 创建bean方法 —— 执行创建bean的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1. 包装Bean
BeanWrapper instanceWrapper = null;
// 2. 单例
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 3. 走创建bean的流程
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 4. 获取包装的原型bean
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 5. 调用合并beanDefinition的一个后置处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
mbd.postProcessed = true;
}
}
// 6. 关键，打破循环依赖
// 是单例 && 允许循环依赖 && 当前bean正在创建 ，早期暴露
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 7. 满足条件，在填充属性前！！！早期暴露bean，将早期暴露的函数方法存入三级缓存
// 7.1 这个getEarlyBeanReference()函数，在获取早期对象的时候，会去判断是否需要AOP，如果要，就会给这个早期对象创建动态代理
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 8. 已经实例化的bean
Object exposedObject = bean;
try {
// 9. 填充属性
populateBean(beanName, mbd, instanceWrapper);
// 10. 初始化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
/**
* 11. 再去取一次早期单例引用呢？？？
* ===> 为什么要这么做？
* 因为如果出现了循环依赖的话，如果当前beanA需要AOP，那么它是提前AOP的，
* 即当前beanA仍然是普通对象，
* 而B.a,已经是提前AOP了
* 所以现在要拿出那个代理对象（B.a）给当前beanA
*/
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);
}
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
return exposedObject;
}
源码：
最后看一个==initializeBean()==方法，它做了很多事请，能保证
- 生命周期回调
- BeanPostProcessor后置处理器增强
- init初始化方法
这三种增强的操作都是依赖这个方法实现的
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// 1. 执行生命周期回调方法 Aware接口的
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 1. 执行生命周期回调方法 Aware接口的
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 2. 执行BeanProcessor的初始化前的增强方法的
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 3. 如果当前bean实现了初始化接口，那么执行init()方法的
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. 执行BeanProcessor的初始化后的增强方法的
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
小结：
这个方法保证了三种增强的执行：
- Aware回调
- BeanPostProcessor后置处理器增强回调
- 初始化方法init()的回调
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
