IOC容器加载
IOC容器加载
一、基本组件结构介绍xxxPostProcessor：后置处理器（各种组件可以bean实例化前后、初始化前后自定义执行操作）xxxAware：可以将spring容器中对应的对象注入进来xxxRegistry：对bean或beanDefinition的注册（添加、删除、是否存在等）二、注解方式IOC容器加载1、注解方法启动类配置类代码语言：javascript代码运行次数：0运行复制
IOC容器加载
- xxxPostProcessor：后置处理器（各种组件可以bean实例化前后、初始化前后自定义执行操作）
- xxxAware：可以将spring容器中对应的对象注入进来
- xxxRegistry：对bean或beanDefinition的注册（添加、删除、是否存在等）
1、注解方法启动类
配置类
代码语言：javascript代码运行次数：0运行复制@ComponentScan("com.xc.")
@Configuration
public class Config {
@Bean()
public Book book(){
return new Book();
}
}启动类
代码语言：javascript代码运行次数：0运行复制public class Client {
public static void main(String[] args) {
//创建注解容器，入参为配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//获取某个bean
Book book = context.getBean("book", );
println(book);
//关闭容器
();
}
}2、AnnotationConfigApplicationContext 的构造方法
2.1、创建bean工厂-beanFactory
this()；调用AnnotationConfigApplicationContext 的无参构造方法
调用当前类的无参构造，还会调用父类的无参构造，先看下父类无参构造做的事情。
接下来继续查看AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner的创建
2.1.1、注册默认后置处理器
调用AnnotatedBeanDefinitionReader的有参构造方法
注册默认后置处理器
代码语言：javascript代码运行次数：0运行复制public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @ullable Object source) {
//获取之前创建好的DefaultListableBeanFactory对象，beanFactory实例
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
//为beanFactory添加两属性
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.ISTACE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
//创建8长度集合
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//查询beanDefinitionMap是否有
//internalConfigurationAnnotationProcessor =ConfigurationClassPostProcessor
//（内部注解配置后置处理器）
if (!(COFIGURATIO_AOTATIO_PROCESSOR_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setSource(source);
//注册到beanDefinitionMap中，并添加到beanDefs集合中
beanDefs.add(registerPostProcessor(registry, def, COFIGURATIO_AOTATIO_PROCESSOR_BEA_AME));
}
//注册internalAutowiredAnnotationProcessor = AutowiredAnnotationBeanPostProcessor
//与上面一样
if (!(AUTOWIRED_AOTATIO_PROCESSOR_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_AOTATIO_PROCESSOR_BEA_AME));
}
// JSR-250，是java定义的一些注解，spring支持这注解。大致有：@PostCtruct@PreDestroy@Resource
//注册internalCommonAnnotationProcessor = CommonAnnotationBeanPostProcessor
if (jsr250Present && !(COMMO_AOTATIO_PROCESSOR_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMO_AOTATIO_PROCESSOR_BEA_AME));
}
// spring注册支持jpa注解的beanFactory后置处理器
if (jpaPresent && !(PERSISTECE_AOTATIO_PROCESSOR_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forame(PERSISTECE_AOTATIO_PROCESSOR_CLASS_AME,
getClassLoader()));
}
catch (ClassotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTECE_AOTATIO_PROCESSOR_CLASS_AME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTECE_AOTATIO_PROCESSOR_BEA_AME));
}
//注册事件监听后置处理器
//internalEventListenerProcessor = EventListenerMethodProcessor
if (!(EVET_LISTEER_PROCESSOR_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVET_LISTEER_PROCESSOR_BEA_AME));
}
//注册事件监听工厂
//internalEventListenerFactory = DefaultEventListenerFactory
if (!(EVET_LISTEER_FACTORY_BEA_AME)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVET_LISTEER_FACTORY_BEA_AME));
}
return beanDefs;
}查看一共注册的beanDefinition
1. internalConfigurationAnnotationProcessor = ConfigurationClassPostProcessor 注解配置后置处理器 2. internalAutowiredAnnotationProcessor = AutowiredAnnotationBeanPostProcessor @Autowired注解后置处理器 . internalCommonAnnotationProcessor = CommonAnnotationBeanPostProcessor java注解@Resource等注解后置处理器 4. internalEventListenerProcessor = EventListenerMethodProcessor 事件监听后置处理器 5. internalEventListenerFactory = DefaultEventListenerFactory 事件监听工厂
2.1.2、自定义扫描包功能
查看ClassPathBeanDefinitionScanner的构造函数 没太大用，主要为了扩展AnnotationConfigApplicationContext添加一个自助扫描的包的功能；一般用不到
代码语言：javascript代码运行次数：0运行复制AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("com.xc.lifecycle.pojo");2.2、注册配置类（）
register(componentClasses);
bean的注册：AnnotationConfigApplicationContext registry.registerBeanDefinition(…) 将bean添加到beanDefinitionMap中，若有别名，再用别名添加一个相同的对象
至此，配置类注册到beanDefinitionMap中了。
2.、容器刷新
代码语言：javascript代码运行次数：0运行复制@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1、刷新前预处理
prepareRefresh();
// 2、获取最新的bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 、注册bean工厂的类加载器和部分后置处理器
prepareBeanFactory(beanFactory);
try {
// 4、bean工厂的后置处理器（子类实现）
postProcessBeanFactory(beanFactory);
// 5、执行bean工厂的后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 6、实例化并注册所有的后置处理器
registerBeanPostProcessors(beanFactory);
// 7、初始化国际化组件
initMessageSource();
// 8、初始化事件多播器（用来广播事件）
initApplicationEventMulticaster();
// 9、子类实现，扩展其他bean
onRefresh();
// 10、注册
registerListeners();
// 11、实例化，初始化所有的非懒加载的单例bean
finishBeanFactoryInitialization(beanFactory);
// 12、最后刷新，发布相应事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 销毁已创建的单例bean
destroyBeans();
// 重置容器激活标签
cancelRefresh(ex);
// 抛异常
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}2..1、prepareRefresh();刷新前预处理
准备此上下文以进行刷新，设置其启动日期和活动标志，以及执行属性源的任何初始化。
代码语言：javascript代码运行次数：0运行复制protected void prepareRefresh() {
//设置启动时间
this.startupDate = ();
//容器是否关闭
set(false);
//容器是否激活
this.active.set(true);
//根据日志开启级别打印日志
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayame());
}
}
// 空实现，子类实现。AnnotationConfigApplicationContext容器的子容器初始化工作。
initPropertySources();
//校验必须的一些属性
getEnvironment().validateRequiredProperties();
// 保存容器预处理的事件
if ( == null) {
= new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.();
this.applicationListeners.addAll();
}
// 设置早期事件（以前的事件）
// 将在Multicast可用后发布
= new LinkedHashSet<>();
}2..2、obtainFreshBeanFactory();获取最新的bean工厂（beanFactory）
2..、prepareBeanFactory(beanFactory);注册bean工厂的类加载器和部分后置处理器
代码语言：javascript代码运行次数：0运行复制protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器：存在则直接设置/不存在则新建一个默认类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 设置属性注册解析器PropertyEditor
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，
// 从而在Aware接口实现类中的注入context
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略自动装配的接口
//因为在ApplicationContextAwareProcessor中已经完成了手动注入
beanFactory.ignoreDependencyInterface();
beanFactory.ignoreDependencyInterface();
beanFactory.ignoreDependencyInterface();
beanFactory.ignoreDependencyInterface();
beanFactory.ignoreDependencyInterface();
beanFactory.ignoreDependencyInterface();
/**
* 注册几个自动装配相关的类和实例
* 在应用代码就可以通过类型自动装配把工厂实例和ApplicationContext实例设置到自定义bean的属性中
*
* 例如：这几个属性都会被自动设置，虽然没有在显示的在bean定义xml中注入它们
* @Autowired
* private BeanFactory beanFactory;
* @Autowired
* private ApplicationContext appContext;
*/
beanFactory.registerResolvableDependency(, beanFactory);
beanFactory.registerResolvableDependency(, this);
beanFactory.registerResolvableDependency(, this);
beanFactory.registerResolvableDependency(, this);
// 注册监听后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 添加编译时AspectJ的支持
// 当容器检查到定义了名称为loadTimeWeaver的bean时
// 会注册一个LoadTimeWeaverAwareProcessor到容器中
// 这个后置处理器用来处理LoadTimeWeaverAware接口的
if ((LOAD_TIME_WEAVER_BEA_AME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//将以下三个bean放入singletonObjects单例bean容器中
// 注册当前容器环境environment组件Bean
if (!(EVIROMET_BEA_AME)) {
beanFactory.registerSingleton(EVIROMET_BEA_AME, getEnvironment());
}
// 注册系统配置systemProperties组件Bean
if (!(SYSTEM_PROPERTIES_BEA_AME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEA_AME, getEnvironment().getSystemProperties());
}
// 注册系统环境systemEnvironment组件Bean
if (!(SYSTEM_EVIROMET_BEA_AME)) {
beanFactory.registerSingleton(SYSTEM_EVIROMET_BEA_AME, getEnvironment().getSystemEnvironment());
}
}2..4、postProcessBeanFactory(beanFactory);bean工厂的后置处理器（子类实现）
空实现
AbstractApplicationContext抽象类子类去实现。 查看子类：
2..5、invokeBeanFactoryPostProcessors(beanFactory);执行bean工厂的后置处理器
getBeanFactoryPostProcessors()：返回bean工厂后置处理器列表，这里是个空集合
- BeanFactoryPostProcessor（bean工厂后置处理器）通过postProcessBeanFactory()对bean工厂做一些操作
- BeanFactoryPostProcessor子类BeanDefinitionRegistryPostProcessor（bean定义后置处理器），多定义了一个方法postProcessBeanDefinitionRegistry()对BeanDefinaition做一些增删改操作（故此子类优先执行）
- 这些操作都在实例化前，实例化后就没有意义了
接下来回归正题，进入invokeBeanFactoryPostProcessors()方法，执行所有bean公共后置处理器
代码语言：javascript代码运行次数：0运行复制public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 执行beans集合
Set<String> processedBeans = new HashSet<>();
//如果有BeanDefinitionRegistryPostProcessors-bean定义后置处理器，先执行。
//（后执行BeanFactoryPostProcessor-bean工厂后置处理器）
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 用于存放入参bean定义后置处理器集合
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 用于存放bean定义后置处理器集合
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//这里处理入参的bean定义后置处理器，入参的数据是自定义传入的，不怎么用，这里不说了
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// 用于保存本次要执行的bean定义后置处理器（当前bean定义后置处理器）
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 首先，先执行实现了PriorityOrdered的bean定义后置处理器
// 出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beaname
String[] postProcessorames =
beanFactory.getBeanamesForType(, true, false);
for (String ppame : postProcessorames) {
// 校验是否实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppame, )) {
// 获取ppame对应的bean实例, 添加到currentRegistryProcessors中
// beanFactory.getBean();获取bean，获取不到创建。后续单独将
currentRegistryProcessors.add(beanFactory.getBean(ppame, ));
//将要被执行的加入processedBeans，避免后续重复执行
processedBeans.add(ppame);
}
}
//进行排序(之前注册默认处理器时候，添加过排序策略属性 )
// beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.ISTACE);
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到bean定义后置处理器
registryProcessors.addAll(currentRegistryProcessors);
// 将所有bean定义后置处理器遍历执行它的方法 postProcessBeanDefinitionRegistry()
// --对beanBefinition的增删改
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 执行完毕后, 清空currentRegistryProcessors
();
// 接下来，先执行实现了Ordered的bean定义后置处理器
postProcessorames = beanFactory.getBeanamesForType(, true, false);
for (String ppame : postProcessorames) {
// 校验是否实现了Ordered接口，并且还未执行过
if (!(ppame) && beanFactory.isTypeMatch(ppame, )) {
currentRegistryProcessors.add(beanFactory.getBean(ppame, ));
processedBeans.add(ppame);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
();
// 最后，执行剩下的bean定义后置处理器，什么排序接口都没有实现
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorames = beanFactory.getBeanamesForType(, true, false);
for (String ppame : postProcessorames) {
// 跳过已经执行过的
if (!(ppame)) {
currentRegistryProcessors.add(beanFactory.getBean(ppame, ));
processedBeans.add(ppame);
// 如果有bean定义后置处理器被执行, 则有可能会产生新的bean定义后置处理器
// 因此这边将reiterate赋值为true, 代表需要再循环查一次
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
();
}
// 现在统一执行bean定义后置处理器的postProcessBeanFactory方法
//(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 现在统一执行入参bean定义后置处理器的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 如果没有bean定义后置处理器，直接执行参数传入的bean定义后置处理器
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕,
// 下面开始处理容器中的所有BeanFactoryPostProcessor
String[] postProcessorames =
beanFactory.getBeanamesForType(, true, false);
...与上面代码一模一样，下面总集说
}总结：
- 先遍历执行所有bean定义后置处理器，再执行bean工厂后置处理器
- 后置处理器根据是否实现PriorityOrdered、Ordered接口和order值来排序决定先后执行
- 每次执行，检查跳过之前执行过的后置处理器
2..6、registerBeanPostProcessors(beanFactory);实例化并注册所有后置处理器
处理流程方面和bean工厂后置处理器大致一样
// 实例化所有的BeanPostProcessor并将其注册到BeanFactory中
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取beanFactory中所有的BeanPostProcessor类型的bean的名字
String[] postProcessorames = beanFactory.getBeanamesForType(, true, false);
// 注册一个 BeanPostProcessorChecker，用来记录 bean 在 BeanPostProcessor 实例化时的信息。
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 对所有的BeanPostProcessor根据实现不同的接口(PriorityOrdered,Ordered等)进行分离
// 用于存放实现了的后处理器集合
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 用于存放实现了并且是MergedBeanDefinitionPostProcessor类型的后处理器集合
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 用于存放实现了的后处理器集合
List<String> orderedPostProcessorames = new ArrayList<>();
// 用于存放其它情况的后处理器集合
List<String> nonOrderedPostProcessorames = new ArrayList<>();
for (String ppame : postProcessorames) {
if (beanFactory.isTypeMatch(ppame, )) {
BeanPostProcessor pp = beanFactory.getBean(ppame, );
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppame, )) {
orderedPostProcessorames.add(ppame);
}
else {
nonOrderedPostProcessorames.add(ppame);
}
}
// 首先,注册实现了Proority接口的BeanPostProcessor
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册(将BeanPostProcessor加入到BeanFactory中beanFactory.addBeanPostProcessor(postProcessor))
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 其次注册实现了接口的BeanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorames.size());
for (String ppame : orderedPostProcessorames) {
BeanPostProcessor pp = beanFactory.getBean(ppame, );
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 然后,注册剩余的所有普通的BeanPostProcessor
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorames.size());
for (String ppame : nonOrderedPostProcessorames) {
BeanPostProcessor pp = beanFactory.getBean(ppame, );
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后,重新注册所有内部的BeanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
//先删除再注册ApplicationListenerDetector（主要是为了移动到处理器链的末尾）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}2..7、initMessageSource();初始化MessageSource组件
可以做国际化功能，已经注入bean工厂。MESSAGE_SOURCE_BEA_AME = messageSource；
2..8、initApplicationEventMulticaster();初始化事件多播器（用来广播事件）
2..9、onRefresh();扩展方法，空实现
留给子容器或者AbstractApplicationContext子类重写这个方法，在容器刷新的时候可以自定义逻辑；
2..10、registerListeners();注册
代码语言：javascript代码运行次数：0运行复制protected void registerListeners() {
// 添加实现ApplicationListener作为侦听器的bean。
// 不会影响其他侦听器，可以将它们添加为非bean。
// 先注册静态指定的
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 在事件多播器上添加监听 并没有执行
String[] listenerBeanames = getBeanamesForType(, true, false);
for (String listenerBeaname : listenerBeanames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeaname);
}
// 发布早期的时间,并且将 earlyApplicationEvents 设置为空
Set<ApplicationEvent> earlyEventsToProcess = ;
= null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}2..11、finishBeanFactoryInitialization(beanFactory);实例化所有剩余的（非惰性）单例bean
拆分到第三、四、五章单讲
2..12、finishRefresh();最后一步：发布相应的事件
代码语言：javascript代码运行次数：0运行复制protected void finishRefresh() {
// 清理缓存信息
clearResourceCaches();
// 初始化生命周期处理器
initLifecycleProcessor();
// 将刷新事件传播到生命周期处理器
getLifecycleProcessor().onRefresh();
// 发布容器刷新完毕事件到相应的
publishEvent(new ContextRefreshedEvent(this));
// 略
LiveBeansView.registerApplicationContext(this);
}2..12.1、初始化生命周期处理器
Bean对象可以实现Lifecycle接口，以便这些Bean可以在容器自身的生命周期驱动下进行start和stop过程。
使用
1、注册事件
代码语言：javascript代码运行次数：0运行复制public class MyApplicationEvent extends ApplicationEvent {
private static final long serialVersionUID = 566526212198848L;
private String message;
public MyApplicationEvent(Object source, String message) {
super(source);
= message;
}
public String getMessage() {
return message;
}
}2、注册
代码语言：javascript代码运行次数：0运行复制@Component
public class MyApplicationListener implements ApplicationListener<MyApplicationEvent> {
@Override
public void onApplicationEvent(MyApplicationEvent event) {
println("MyApplicationListener 收到消息: " + event.getMessage());
}
}、发布事件
代码语言：javascript代码运行次数：0运行复制@Component
public class MyAnnotationApplicationListener {
@EventListener(classes = )
public void myApplicationEventListener(MyApplicationEvent event) {
println("使用注解的方式, 收到事件: " + event.getMessage());
}
}4、使用
因为 AnnotationConfigApplicationContext 实现了 ApplicationContext ， 而 ApplicationContext 实现了 ApplicationEventPublisher，所以这块可以传入当前 context。
代码语言：javascript代码运行次数：0运行复制public class Client {
public static void main(String[] args) {
//创建注解容器，入参为配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
MyApplicationEvent event = new MyApplicationEvent(context,"呼叫。。。");
context.publishEvent(event);
//关闭容器
();
}
}输出：
2..1、异常情况
2..1.1、destroyBeans();销毁单例bean
2..1.2、cancelRefresh(ex);设置容器激活状态为否
finishBeanFactoryInitialization(beanFactory);
1、完成bean工厂的初始化
代码语言：javascript代码运行次数：0运行复制protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 初始化此上下文的转换服务
if ((COVERSIO_SERVICE_BEA_AME) &&
beanFactory.isTypeMatch(COVERSIO_SERVICE_BEA_AME, )) {
beanFactory.setConversionService(
beanFactory.getBean(COVERSIO_SERVICE_BEA_AME, ));
}
// 如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 初始化所有LoadTimeWeaverAware Bean实例对象
String[] weaverAwareames = beanFactory.getBeanamesForType(, false, false);
for (String weaverAwareame : weaverAwareames) {
getBean(weaverAwareame);
}
beanFactory.setTempClassLoader(null);
// 冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
beanFactory.freezeConfiguration();
// 实例化所有剩余（非懒加载）单例对象
beanFactory.preInstantiateSinglet();
}实例化前工作
代码语言：javascript代码运行次数：0运行复制@Override
public void preInstantiateSinglet() throws BeansException {
if (logger.isTraceEnabled()) {
("Pre-instantiating singlet in " + this);
}
// 创建beanDefinitionames的副本beanames用于后续的遍历，以允许init等方法注册新的bean定义
List<String> beanames = new ArrayList<>(this.beanDefinitionames);
// 所有非懒加载单例bean的初始化
for (String beaname : beanames) {
// 获取合并后的bean定义信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beaname);
// bean定义对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断beaname对应的bean是否为FactoryBean
if (isFactoryBean(beaname)) {
// 通过getBean(&beaname)拿到的是FactoryBean本身；
// 通过getBean(beaname)拿到的是FactoryBean创建的Bean实例
Object bean = getBean(FACTORY_BEA_PREFIX + beaname);
// 判断bean是否实现了FactoryBean
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
//判断是否需要立即创建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) {
// 如果希望马上初始化，则通过beaname获取bean实例
getBean(beaname);
}
}
}
else {
// 如果beaname对应的bean不是FactoryBean，只是普通Bean，通过beaname获取bean实例
getBean(beaname);
}
}
}
// 在所有bean实例化后，遍历所有beaname
// 触发所有SmartInitializingSingleton实例化后后置处理器方法afterSingletInstantiated();
for (String beaname : beanames) {
Object singletonInstance = getSingleton(beaname);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletInstantiated();
}
}
}
}1.1、getMergedLocalBeanDefinition(beaname);获取合并bean定义信息
protected RootBeanDefinition getMergedBeanDefinition(
String beaname, BeanDefinition bd, @ullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized () {
RootBeanDefinition mbd = null;
// 这里containingBd=null，所有，先从合并bean定义信息中获取
if (containingBd == null) {
mbd = .get(beaname);
}
//获取不到
if (mbd == null) {
// 如果bd的parentame为空，代表bd没有父定义，无需与父定义进行合并操作，
// 如果是RootBeanDefinition，则克隆一个；如果不是则new一个
if (bd.getParentame() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
else {
// 存在父定义，需要与父定义合并
BeanDefinition pbd;
try {
// 获取父定义的beaname,可能是别名
String parentBeaname = transformedBeaname(bd.getParentame());
// 如果父定义的beaname与该bean的beaname不同
if (!(parentBeaname)) {
// 获取父定义的MergedBeanDefinition（因为父定义也可能有父定义，也就是bd的爷爷定义...）
// 递归调用获取合并bean定义信息
pbd = getMergedBeanDefinition(parentBeaname);
}
else {
// 如果父定义的beaname与bd的beaname相同
// 只有在存在父BeanFactory的情况下，才允许父定义beaname与自己相同，否则就是将自己设置为父定义
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
// 如果父BeanFactory是ConfigurableBeanFactory，
// 则通过父BeanFactory获取父定义的MergedBeanDefinition
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeaname);
}
else {
throw new oSuchBeanDefinitionException(parentBeaname,
"Parent name '" + parentBeaname + "' is equal to bean name '" + beaname +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}
catch (oSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beaname,
"Could not resolve parent bean definition '" + bd.getParentame() + "'", ex);
}
// 使用父定义pbd构建一个新的RootBeanDefinition对象
mbd = new RootBeanDefinition(pbd);
// 使用bd覆盖父定义
(bd);
}
// 如果没有配置scope，则设置成默认的singleton
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SIGLETO);
}
// 这里 containingBd 为空
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 将beaname与mbd放到mergedBeanDefiniti缓存，以便之后可以直接使用
if (containingBd == null && isCacheBeanMetadata()) {
.put(beaname, mbd);
}
}
return mbd;
}
}1.1.1、父BeanFactory
SpringMVC的beanFactory和Spring的beanFactory，通常情况下，Spring的beanFactory是父工厂，SpringMVC的beanFactory是子工厂，子工厂可以使用父工厂的BeanDefinition，因此，如果当前beanFactory中不到，而又存在父工厂，则会去父工厂查。
举个例子
两个bean，childBean和rootBean，childBean的父bean是rootBean。和继承有点像，子类如果没有赋值某个属性，会继承父类的，比如这里的name=张三。
1.2、isFactoryBean(beaname) 判断bean是否为FactoryBean
代码语言：javascript代码运行次数：0运行复制@Override
public boolean isFactoryBean(String name) throws oSuchBeanDefinitionException {
// 获取真正的beaname（去掉&前缀、解析别名）
String beaname = transformedBeaname(name);
// 尝试从缓存中获取bean
Object beanInstance = getSingleton(beaname, false);
if (beanInstance != null) {
//存在，则判断类型是否为FactoryBean;
return (beanInstance instanceof FactoryBean);
}
// o singleton instance found -> check bean definition.
if (!containsBeanDefinition(beaname) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// 如果缓存中不存在此beaname && 父beanFactory是ConfigurableBeanFactory，则调用父BeanFactory判断是否为FactoryBean
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
//通过MergedBeanDefinition来检查beaname对应的Bean是否为FactoryBean
return isFactoryBean(beaname, getMergedLocalBeanDefinition(beaname));
}protected <T> T doGetBean(final String name, @ullable final Class<T> requiredType,
@ullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//解析beaname，主要是解析别名、去掉FactoryBean的前缀“&”
final String beaname = transformedBeaname(name);
Object bean;
// 1、从缓存中获取beaname对应的实例
Object sharedInstance = getSingleton(beaname);
if (sharedInstance != null && args == null) {
// 如果beaname的实例存在于缓存中
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beaname)) {
("Returning eagerly cached instance of singleton bean '" + beaname +
"' that is not fully initialized yet - a cequence of a circular reference");
}
else {
("Returning cached instance of singleton bean '" + beaname + "'");
}
}
// 2、返回beaname对应的实例对象（主要用于FactoryBean的特殊处理，普通Bean会直接返回sharedInstance本身）
bean = getObjectForBeanInstance(sharedInstance, name, beaname, null);
}
else {
// scope为prototype的循环依赖校验：如果beaname已经正在创建Bean实例中，
// 而此时我们又要再一次创建beaname的实例，则代表出现了循环依赖，需要抛出异常。
// 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，
// 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖
if (isPrototypeCurrentlyInCreation(beaname)) {
throw new BeanCurrentlyInCreationException(beaname);
}
// 获取parentBeanFactory（父容器)
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果parentBeanFactory存在，并且beaname在当前BeanFactory不存在Bean定义，
//则尝试从parentBeanFactory中获取bean实例
if (parentBeanFactory != null && !containsBeanDefinition(beaname)) {
// 将别名解析成真正的beaname
String nameToLookup = originalBeaname(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
// 尝试在parentBeanFactory中获取bean对象实例
else if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
// 如果不是仅仅做类型检测，而是创建bean实例，
// 这里要将beaname放到alreadyCreated缓存,做记录
markBeanAsCreated(beaname);
}
try {
//将bean和父bean合并
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beaname);
//检查MergedBeanDefinition
checkMergedBeanDefinition(mbd, beaname, args);
// 拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//遍历当前bean依赖的bean名称集合
for (String dep : dependsOn) {
//、检查dep是否依赖于beaname，即检查是否存在循环依赖
if (isDependent(beaname, dep)) {
//如果是循环依赖则抛异常
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Circular depends-on relatihip between '" + beaname + "' and '" + dep + "'");
}
//4、将dep和beaname的依赖关系注册到缓存中
registerDependentBean(dep, beaname);
try {
//获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
getBean(dep);
}
catch (oSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"'" + beaname + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 针对不同的scope进行bean的创建
if (mbd.isSingleton()) {
//5、单例bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
sharedInstance = getSingleton(beaname, () -> {
try {
//.5、创建Bean实例
return createBean(beaname, 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(beaname);
throw ex;
}
});
// 返回beaname对应的实例对象
bean = getObjectForBeanInstance(sharedInstance, name, beaname, mbd);
}
else if (mbd.isPrototype()) {
// 多例的bean创建
Object prototypeInstance = null;
try {
// 6、创建实例前的操作（将beaname保存到prototypesCurrentlyInCreation缓存中）
beforePrototypeCreation(beaname);
// 创建Bean实例
prototypeInstance = createBean(beaname, mbd, args);
}
finally {
//创建实例后的操作（将创建完的beaname从prototypesCurrentlyInCreation缓存中移除）
afterPrototypeCreation(beaname);
}
//beaname对应的实例对象
bean = getObjectForBeanInstance(prototypeInstance, name, beaname, mbd);
}
else {
// 其他scope的bean创建，可能是request之类的
// 根据scopeame，从缓存拿到scope实例
String scopeame = mbd.getScope();
final Scope scope = this.scopes.get(scopeame);
if (scope == null) {
throw new IllegalStateException("o Scope registered for scope name '" + scopeame + "'");
}
try {
//其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
Object scopedInstance = scope.get(beaname, () -> {
beforePrototypeCreation(beaname);
try {
return createBean(beaname, mbd, args);
}
finally {
afterPrototypeCreation(beaname);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beaname, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beaname,
"Scope '" + scopeame + "' is not active for the current thread; cider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beaname);
throw ex;
}
}
// 检查所需类型是否与实际的bean对象的类型匹配
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 类型不对，则尝试转换bean类型
T convertedBean = getTypeConverter().convertIfecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedame(requiredType) + "'", ex);
}
throw new BeanotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}1、getSingleton()获取单例bean
提前引入4个重要缓存：
代码语言：javascript代码运行次数：0运行复制//一级缓存（beaname->单例bean对象）单例对象的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//二级缓存（beaname_>单例bean对象，对象还未进行属性填充、初始化）提前曝光的单例对象的缓存
//又称为早期单例对象，是因为earlySingletonObjects里的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//缓存（beaname->ObjectFactory 通过beaname获取单例bean工厂）单例对象工厂的缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//当前正在创建单例bean对象的beaname集合
private final Set<String> singletCurrentlyInCreation =
(new ConcurrentHashMap<>(16));@ullable
protected Object getSingleton(String beaname, boolean allowEarlyReference) {
//从一级缓存获取单例对象
Object singletonObject = this.singletonObjects.get(beaname);
//如果一级缓存没有，并且该beaname对应的单例bean正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beaname)) {
synchronized (this.singletonObjects) {
//尝试从二级缓存获取
singletonObject = get(beaname);
// 如果二级缓存也没有，并且允许bean对象提前曝光
if (singletonObject == null && allowEarlyReference) {
// 从缓存中获取beaname的单例工厂
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beaname);
if (singletonFactory != null) {
// 如果存在单例对象工厂，则通过工厂创建一个单例对象
singletonObject = singletonFactory.getObject();
// 将通过单例对象工厂创建的单例对象，放到二级缓存中
put(beaname, singletonObject);
// 移除该beaname对应的单例对象工厂
// 因为该单例工厂已经创建了一个实例对象，并且放到二级缓存中
// 所以，后续获取beaname的单例对象，
// 可以通过二级缓存拿到，不需要在用到该单例工厂
this.singletonFactories.remove(beaname);
}
}
}
}
return singletonObject; //返回对象
}该段代码是 Spring 解决循环引用的核心代码
解决循环引用逻辑：使用构造函数创建一个 “不完整” 的 bean 实例（之所以说不完整，是因为此时该 bean 实例还未初始化），并且提前曝光该 bean 实例的 ObjectFactory（提前曝光就是将 ObjectFactory 放到 singletonFactories 缓存），通过 ObjectFactory 我们可以拿到该 bean 实例的引用，如果出现循环引用，我们可以通过缓存中的 ObjectFactory 来拿到 bean 实例，从而避免出现循环引用导致的死循环。这边通过缓存中的 ObjectFactory 拿到的 bean 实例虽然拿到的是 “不完整” 的 bean 实例，但是由于是单例，所以后续初始化完成后，该 bean 实例的引用地址并不会变，所以最终我们看到的还是完整 bean 实例。
2、getObjectForBeanInstance();返回bean真正的实例对象
代码语言：javascript代码运行次数：0运行复制protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beaname, @ullable RootBeanDefinition mbd) {
// 如果name以“&”为前缀，但是beanInstance不是FactoryBean，则抛异常
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof ullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsotAFactoryException(beaname, beanInstance.getClass());
}
}
// 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
// 或者
// 如果beanInstance是FactoryBean，并且name以“&”为前缀，
// 则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身）
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//走到这边，代表beanInstance是FactoryBean，但name不带有“&”前缀，
//表示想要获取的是FactoryBean创建的对象实例
Object object = null;
if (mbd == null) {
//这里mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
object = getCachedObjectForFactoryBean(beaname);
}
if (object == null) {
// 只有beanInstance是FactoryBean才能走到这边，因此直接强转
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition
if (mbd == null && containsBeanDefinition(beaname)) {
mbd = getMergedLocalBeanDefinition(beaname);
}
//mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false
boolean synthetic = (mbd != null && mbd.isSynthetic());
//2.1、从FactoryBean获取对象实例
object = getObjectFromFactoryBean(factory, beaname, !synthetic);
}
return object;
}、isDependent(beaname, dep);检查dep是否依赖于beaname
dep是bean依赖bean集合的一部分，如果dep也依赖bean，则是循环依赖，报错
代码语言：javascript代码运行次数：0运行复制private boolean isDependent(String beaname, String dependentBeaname, @ullable Set<String> alreadySeen) {
// alreadySeen这里是空，跳过
if (alreadySeen != null && (beaname)) {
return false;
}
// 将别名解析为真正的名称
String canonicalame = canonicalame(beaname);
//获取依赖beaname的set集合
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalame);
// 如果dependentBeans为空，则证明依赖beaname的为空，则dep不依赖bean，返回false
if (dependentBeans == null) {
return false;
}
// 如果依赖beaname的集合报告dep，则证明dep依赖beaname；则是循环依赖，返回true
if ((dependentBeaname)) {
return true;
}
//循环检查，即检查依赖canonicalame的所有beaname是否存在被dependentBeaname依赖的（即隔层依赖）
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
//已经检查过的添加到alreadySeen，避免重复检查
alreadySeen.add(beaname);
if (isDependent(transitiveDependency, dependentBeaname, alreadySeen)) {
return true;
}
}
return false;
}这里引入一个缓存：dependentBeanMap：beaname -> 所有依赖 beaname 对应的 bean 的 beaname 集合。 如：A依赖B，则key=B，value=A；
代码语言：javascript代码运行次数：0运行复制private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);4、registerDependentBean();注册依赖关系到缓存中
代码语言：javascript代码运行次数：0运行复制/**
注意：beaname:依赖bean;dependentBeaname:注册bean
*/
public void registerDependentBean(String beaname, String dependentBeaname) {
// 解析别名
String canonicalame = canonicalame(beaname);
synchronized (this.dependentBeanMap) {
//创建一个dependentBeanMap缓存，key为这里的依赖bean：beaname
Set<String> dependentBeans =
this.dependentBeanMapputeIfAbsent(canonicalame, k -> new LinkedHashSet<>(8));
//set value如果失败，证明依赖关系已存在
if (!dependentBeans.add(dependentBeaname)) {
return;
}
}
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMapputeIfAbsent(dependentBeaname, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalame);
}
}这里引入一个缓存：dependenciesForBeanMap：beaname -> 所有beaname依赖对应的 bean 的 beaname 集合。 如：A依赖B，则key=A，value=B；和 dependentBeanMap 相反。
5、getSingleton(String beaname, ObjectFactory<?> singletonFactory);单例bean创建
代码语言：javascript代码运行次数：0运行复制public Object getSingleton(String beaname, ObjectFactory<?> singletonFactory) {
(beaname, "Bean name must not be null");
// 加锁，避免重复创建单例对象
synchronized (this.singletonObjects) {
// 首先检查beaname对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
Object singletonObject = this.singletonObjects.get(beaname);
if (singletonObject == null) {
if (this.singletCurrentlyInDestruction) {
// 缓存中不存在，且bean工厂的单例处于destruction状态时，不允许进行单例bean创建，报错
throw new BeanCreationotAllowedException(beaname,
"Singleton bean creation not allowed while singlet 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 '" + beaname + "'");
}
// 5.1 创建单例前的操作
beforeSingletonCreation(beaname);
boolean newSingleton = false;
// 用于记录异常相关信息
boolean recordSuppressedExcepti = (this.suppressedExcepti == null);
if (recordSuppressedExcepti) {
this.suppressedExcepti = new LinkedHashSet<>();
}
try {
// 执行singletonFactory的getObject方法获取bean实例
singletonObject = singletonFactory.getObject();
// 标记为新的单例对象
newSingleton = true;
}
catch (IllegalStateException ex) {
//如果报错了，尝试从一级缓存中获取对象（已经不是新的单例对象了）
singletonObject = this.singletonObjects.get(beaname);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExcepti) {
for (Exception suppressedException : this.suppressedExcepti) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExcepti) {
this.suppressedExcepti = null;
}
// 5.2、创建单例后的操作
afterSingletonCreation(beaname);
}
if (newSingleton) {
// 5.、如果是新的单例对象，将beaname和对应的bean实例添加到缓存中
addSingleton(beaname, singletonObject);
}
}
return singletonObject;
}
}5.1、5.2、beforeSingletonCreation、afterSingletonCreation 创建单例前后操作
代码语言：javascript代码运行次数：0运行复制protected void beforeSingletonCreation(String beaname) {
// 先校验beaname是否为要在创建检查排除掉的（inCreationCheckExclusi缓存），如果不是，
// 则将beaname加入到正在创建bean的缓存中（Set），如果beaname已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
if (!this.(beaname) && !this.singletCurrentlyInCreation.add(beaname)) {
throw new BeanCurrentlyInCreationException(beaname);
}
}protected void afterSingletonCreation(String beaname) {
// 先校验beaname是否为要在创建检查排除掉的（inCreationCheckExclusi缓存），如果不是，
// 则将beaname从正在创建bean的缓存中（Set）移除，如果beaname不存在于该缓存，会返回false抛出异常
if (!this.(beaname) && !this.singletCurrentlyInCreation.remove(beaname)) {
throw new IllegalStateException("Singleton '" + beaname + "' isn't currently in creation");
}
}5.、addSingleton 新创建对象，添加到缓存
代码语言：javascript代码运行次数：0运行复制protected void addSingleton(String beaname, Object singletonObject) {
synchronized (this.singletonObjects) {
// 添加一级缓存（单例缓存对象）
this.singletonObjects.put(beaname, singletonObject);
// 删除缓存/单例工厂缓存（已经不需要）
this.singletonFactories.remove(beaname);
// 删除二级缓存/早期单例缓存，没有属性填充（已经不需要）
remove(beaname);
// 添加到已经注册的单例对象缓存
this.registeredSinglet.add(beaname);
}
}6、beforePrototypeCreation、afterPrototypeCreation 多例对象创建前后操作
代码语言：javascript代码运行次数：0运行复制protected void beforePrototypeCreation(String beaname) {
// 获取当前线程中正在创建的prototype的bean的beaname集合
Object curVal = this.prototypesCurrentlyInCreation.get();
// 如果为空，则将ThreadLocal设置成当前的beaname
if (curVal == null) {
this.prototypesCurrentlyInCreation.set(beaname);
}
// 如果不为空，并且是String类型，则代表目前只有一个beaname，
// 将之前和当前的一起封装成Set<String>，设置到ThreadLocal中
else if (curVal instanceof String) {
Set<String> beanameSet = new HashSet<>(2);
beanameSet.add((String) curVal);
beanameSet.add(beaname);
this.prototypesCurrentlyInCreation.set(beanameSet);
}
else {
// 如果不为空，并且不是String，则必然是Set<String>类型，将当前的beaname加到Set中去
Set<String> beanameSet = (Set<String>) curVal;
beanameSet.add(beaname);
}
}protected void afterPrototypeCreation(String beaname) {
// 拿到当前线程中正在创建的prototype的bean的beaname集合
Object curVal = this.prototypesCurrentlyInCreation.get();
//如果是String类型，则代表目前只有一个beaname，则直接移除
if (curVal instanceof String) {
this.prototypesCurrentlyInCreation.remove();
}
else if (curVal instanceof Set) {
// 如果是Set类型，则从Set从移除beaname
Set<String> beanameSet = (Set<String>) curVal;
beanameSet.remove(beaname);
if (beanameSet.isEmpty()) {
this.prototypesCurrentlyInCreation.remove();
}
}
}主要是在进行 多例 bean 实例的创建前，将 beaname 添加到 prototypesCurrentlyInCreation 缓存；bean 实例创建后，将 beaname 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object，在只有一个 beaname 的时候，直接存该 beaname，也就是 String 类型；当有多个 beaname 时，转成 Set 来存放。
@Override
protected Object createBean(String beaname, RootBeanDefinition mbd, @ullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
("Creating instance of bean '" + beaname + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 解析beaname对应的Bean的类型
Class<?> resolvedClass = resolveBeanClass(mbd, beaname);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassame() != null) {
// 如果resolvedClass存在，并且mdb的beanClass类型不是Class，并且mdb的beanClass不为空（则代表beanClass存的是Class的name）,
// 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性，
// 该拷贝副本取代mdb用于后续的操作
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 验证及准备覆盖的方法（对override属性进行标记及验证）
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beaname, "Validation of method overrides failed", ex);
}
try {
// 1、实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，动态代理
Object bean = resolveBeforeInstantiation(beaname, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beaname,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 创建Bean实例（真正创建Bean的方法）
Object beanInstance = doCreateBean(beaname, mbdToUse, args);
if (logger.isTraceEnabled()) {
("Finished creating instance of bean '" + beaname + "'");
}
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(), beaname, "Unexpected exception during bean creation", ex);
}
}1、resolveBeforeInstantiation 实例化前操作
代码语言：javascript代码运行次数：0运行复制@ullable
protected Object resolveBeforeInstantiation(String beaname, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.(mbd.beforeInstantiationResolved)) {
// mbd不是合成的，并且BeanFactory中存在InstantiationAwareBeanPostProcessor（实例化前后后置处理器）
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 解析beaname对应的Bean实例的类型
Class<?> targetType = determineTargetType(beaname, mbd);
if (targetType != null) {
// 1.1、实例化前的后置处理器应用（处理InstantiationAwareBeanPostProcessor）
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beaname);
if (bean != null) {
// 如果返回的bean不为空，会跳过Spring默认的实例化过程，
// 所以只能在这里调用BeanPostProcessor实现类的postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beaname);
}
}
}
// 如果bean不为空，则将beforeInstantiationResolved赋值为true，代表在实例化之前已经解析
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}1.1、实例化前的后置处理器
代码语言：javascript代码运行次数：0运行复制@ullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beaname) {
// 遍历当前BeanFactory中所有的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 如果InstantiationAwareBeanPostProcessor或其子类
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 执行postProcessBeforeInstantiation方法，在Bean实例化前操作，
Object result = ibp.postProcessBeforeInstantiation(beanClass, beaname);
if (result != null) {
return result;
}
}
}
return null;
}- 如果返回null，则依次遍历所有的后置处理器，遍历完以后创建对象。。。
- 如果返回不为空，则为实例bean，此时不会再执行后续的后置处理器和创建bean操作
2、doCreateBean 创建bean实例
代码语言：javascript代码运行次数：0运行复制protected Object doCreateBean(final String beaname, final RootBeanDefinition mbd, final @ullable Object[] args)
throws BeanCreationException {
// 新建Bean包装类
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存
instanceWrapper = this.factoryBeanInstanceCache.remove(beaname);
}
if (instanceWrapper == null) {
// 2.1、根据beaname、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper
instanceWrapper = createBeanInstance(beaname, mbd, args);
}
// 拿到创建好的Bean实例
final Object bean = instanceWrapper.getWrappedInstance();
// 拿到Bean实例的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != ) {
mbd.resolvedTargetType = beanType;
}
// 允许后置处理器修改合并bean的定义信息
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 2.2、应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition，
// Autowired注解正是通过此方法实现注入类型的预解析
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beaname);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beaname));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
("Eagerly caching bean '" + beaname +
"' to allow for resolving potential circular references");
}
// 2.、提前曝光beaname的ObjectFactory，用于解决循环引用
// 应用后置处理器SmartInstantiationAwareBeanPostProcessor，
// 允许返回指定bean的早期引用，若没有则直接返回bean
// 2.4、getEarlyBeanReference();获取对指定bean的早期访问的引用
addSingletonFactory(beaname, () -> getEarlyBeanReference(beaname, mbd, bean));
}
// 初始化bean实例
Object exposedObject = bean;
try {
// 2.5、对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
populateBean(beaname, mbd, instanceWrapper);
// 2.6、初始化beaname
exposedObject = initializeBean(beaname, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && (((BeanCreationException) ex).getBeaname())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
// 如果允许提前曝光实例，则进行循环依赖检查
Object earlySingletonReference = getSingleton(beaname, false);
// earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环引用
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beaname)) {
// 如果exposedObject在initializeBean方法中被增强
// && 不允许在循环引用的情况下使用注入原始bean实例
// && 当前bean有被其他bean依赖
// 拿到依赖当前bean的所有bean的beaname数组
String[] dependentBeans = getDependentBeans(beaname);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
//移除失败的添加到 actualDependentBeans
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
// 如果存在移除失败的，则抛出异常，因为存在bean依赖了“脏数据”
throw new BeanCurrentlyInCreationException(beaname,
"Bean with name '" + beaname + "' has been injected into other beans [" +
(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 - cider using " +
"'getBeanamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//注册用于销毁的bean，执行销毁操作的有三种：
//自定义destroy方法、
//DisposableBean接口、
//DestructionAwareBeanPostProcessor
registerDisposableBeanIfecessary(beaname, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Invalid destruction signature", ex);
}
// 完成创建并返回
return exposedObject;
}2.1、createBeanInstance 根据策略实例化bean
代码语言：javascript代码运行次数：0运行复制protected BeanWrapper createBeanInstance(String beaname, RootBeanDefinition mbd, @ullable Object[] args) {
// 解析bean的Class类型信息
Class<?> beanClass = resolveBeanClass(mbd, beaname);
// 确保class不为空，并且访问权限是public
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getame());
}
// 2.1.1、通过Supplier实例化
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beaname);
}
// 2.1.2、通过工厂方法实例化
if (mbd.getFactoryMethodame() != null) {
return instantiateUsingFactoryMethod(beaname, mbd, args);
}
// 构造函数或工厂方法是否已经解析过标记
boolean resolved = false;
// 是否需要自动注入（即是否需要解析构造函数参数）
boolean autowireecessary = false;
if (args == null) {
synchronized () {
if (mbd.resolvedCtructorOrFactoryMethod != null) {
// 如果resolvedCtructorOrFactoryMethod缓存不为空，则将resolved标记为已解析
resolved = true;
// 根据ctructorArgumentsResolved判断是否需要自动注入
autowireecessary = ;
}
}
}
// 如果已经解析过，则使用resolvedCtructorOrFactoryMethod缓存里解析好的构造函数方法
if (resolved) {
if (autowireecessary) {
// 2.1.、需要自动注入，则执行构造函数自动注入
return autowireCtructor(beaname, mbd, null, null);
}
else {
// 2.1.4、否则使用默认的构造函数进行bean的实例化
return instantiateBean(beaname, mbd);
}
}
// 2.1.5、应用后置处理器SmartInstantiationAwareBeanPostProcessor，拿到bean的候选构造函数
Ctructor<?>[] ctors = determineCtructorsFromBeanPostProcessors(beanClass, beaname);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_COSTRUCTOR ||
mbd.hasCtructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//如果ctors不为空 || mbd的注入方式为AUTOWIRE_COSTRUCTOR
// || mdb定义了构造函数的参数值 || args不为空，则执行构造函数自动注入
return autowireCtructor(beaname, mbd, ctors, args);
}
// 出最合适的默认构造方法
ctors = mbd.getPreferredCtructors();
if (ctors != null) {
构造函数自动注入
return autowireCtructor(beaname, mbd, ctors, null);
}
// 没有特殊处理，则使用默认的构造函数进行bean的实例化
return instantiateBean(beaname, mbd);
}实例化 bean的主要逻辑：
- 如果存在 Supplier 回调，则调用 obtainFromSupplier() 进行初始化
- 如果存在工厂方法，则使用工厂方法进行初始化
- 首先判断缓存，如果缓存中存在，即已经解析过了，则直接使用已经解析了的，根据 ctructorArgumentsResolved 参数来判断是使用构造函数自动注入还是默认构造函数
- 如果缓存中没有，则需要先确定到底使用哪个构造函数来完成解析工作，因为一个类有多个构造函数，每个构造函数都有不同的构造参数，所以需要根据参数来锁定构造函数并完成初始化，如果存在参数则使用相应的带有参数的构造函数，否则使用默认构造函数。
2.1.1、obtainFromSupplier()；通过Supplier实例化
如果RootBeanDefinition中存在Supplier接口实例，则使用Supplier接口回调来实例化。
代码语言：javascript代码运行次数：0运行复制@FunctionalInterface
public interface Supplier<T> {
T get();
}// 从supplier获取bean
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beaname) {
Object instance;
String outerBean = get();
set(beaname);
try {
// 调用 Supplier 的 get()，返回一个对象
instance = instanceSupplier.get();
}
finally {
if (outerBean != null) {
set(outerBean);
}
else {
remove();
}
}
if (instance == null) {
instance = new ullBean();
}
// 根据对象构造 BeanWrapper 对象
BeanWrapper bw = new BeanWrapperImpl(instance);
// 初始化 BeanWrapper
initBeanWrapper(bw);
return bw;
}2.1.2、instantiateUsingFactoryMethod()；通过工厂方法实例化
如果RootBeanDefinition 中存在 factoryMethodame 属性，或者在配置文件中配置了factory-method，Spring会尝试使用 instantiateUsingFactoryMethod 方法，根据RootBeanDefinition 中的配置生成bean实例。不常用。
2.1.、autowireCtructor()；自动注入，构造函数
简单来说，就是根据传入的参数列表，来匹配到合适的构造函数进行bean 的创建。
public BeanWrapper autowireCtructor(String beaname, RootBeanDefinition mbd,
@ullable Ctructor<?>[] chosenCtors, @ullable Object[] explicitArgs) {
// 实例化BeanWrapper。是包ean的容器
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Ctructor<?> ctructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// explicitArgs通过getBean方法传入
// 如果getBean方法调用的时候指定方法参数那么直接使用
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
else {
// 如果在调用getBean方法的时候没有指定，则尝试从配置文件中解析
Object[] argsToResolve = null;
synchronized () {
// 尝试从缓存中获取
ctructorToUse = (Ctructor<?>) mbd.resolvedCtructorOrFactoryMethod;
if (ctructorToUse != null && ) {
// Found a cached ctructor...
// 从缓存中到了构造器，那么继续从缓存中寻缓存的构造器参数
argsToUse = mbd.resolvedCtructorArguments;
if (argsToUse == null) {
// 没有缓存的参数，就需要获取配置i文件中配置的参数
argsToResolve = mbd.preparedCtructorArguments;
}
}
}
// 如果缓存中没有缓存的参数的话，即argsToResolve不为空，就需要解析配置的参数
if (argsToResolve != null) {
// 解析参数类型，比如将配置的String类型转换为list、boolean等类型
argsToUse = resolvePreparedArguments(beaname, mbd, bw, ctructorToUse, argsToResolve, true);
}
}
// 如果没有缓存，就需要从构造函数开始解析
if (ctructorToUse == null || argsToUse == null) {
// Take specified ctructors, if any.
// 如果传入的构造器数组不为空，就使用传入的过后早期参数，否则通过反射获取class中定义的构造器
Ctructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
// 使用public的构造器或者所有构造器
candidates = (mbd.isonPublicAccessAllowed() ?
beanClass.getDeclaredCtructors() : beanClass.getCtructors());
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Resolution of declared ctructors on bean Class [" + beanClass.getame() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
}
if (candidates.length == 1 && explicitArgs == null && !mbd.hasCtructorArgumentValues()) {
Ctructor<?> uniqueCandidate = candidates[0];
if (uniqueCandidate.getParameterCount() == 0) {
synchronized () {
mbd.resolvedCtructorOrFactoryMethod = uniqueCandidate;
= true;
mbd.resolvedCtructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beaname, mbd, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// eed to resolve the ctructor.
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_COSTRUCTOR);
CtructorArgumentValues resolvedValues = null;
int minrOfArgs;
if (explicitArgs != null) {
minrOfArgs = explicitArgs.length;
}
else {
// 提取配置文件中的配置的构造函数参数
CtructorArgumentValues cargs = mbd.getCtructorArgumentValues();
// 用于承载解析后的构造函数参数的值
resolvedValues = new CtructorArgumentValues();
// 能解析到的参数个数
minrOfArgs = resolveCtructorArguments(beaname, mbd, bw, cargs, resolvedValues);
}
// 排序给定的构造函数，public的构造函数优先，参数数量降序
AutowireUtils.sortCtructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Ctructor<?>> ambiguousCtructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
for (Ctructor<?> candidate : candidates) {
int parameterCount = candidate.getParameterCount();
// 如果已经到选用的构造函数或者需要的参数个数小于当前的构造函数参数个数则终止，前面已经经过了排序操作
if (ctructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
// Already found greedy ctructor that can be satisfied ->
// do not look any further, there are only less greedy ctructors left.
break;
}
if (parameterCount < minrOfArgs) {
// 参数个数不相等
continue;
}
ArgumentsHolder argsHolder;
Class<?>[] paramTypes = candidate.getParameterTypes();
if (resolvedValues != null) {
// 有参数则根据值构造对应参数类型的参数
try {
String[] paramames = (candidate, parameterCount);
if (paramames == null) {
// 获取参数名称探索器
ParameterameDiscoverer pnd = this.beanFactory.getParameterameDiscoverer();
if (pnd != null) {
// 获取指定构造函数的参数名称
paramames = pnd.getParameterames(candidate);
}
}
// 根据名称和数据类型创建参数持有者
argsHolder = createArgumentArray(beaname, mbd, resolvedValues, bw, paramTypes, paramames,
getUserDeclaredCtructor(candidate), autowiring, candidates.length == 1);
}
catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
("Ignoring ctructor [" + candidate + "] of bean '" + beaname + "': " + ex);
}
// Swallow and try next ctructor.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
else {
// Explicit arguments given -> arguments length must match exactly.
if (parameterCount != explicitArgs.length) {
continue;
}
// 构造函数没有参数的情况
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 探测是否有不确定性的构造函数存在，例如不同构造函数的参数为父子关系
int typeDiffWeight = (mbd.isLenientCtructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this ctructor if it represents the closest match.
// 如果它代表着当前最接近的匹配则选择作为构造函数
if (typeDiffWeight < minTypeDiffWeight) {
ctructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousCtructors = null;
}
else if (ctructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousCtructors == null) {
ambiguousCtructors = new LinkedHashSet<>();
ambiguousCtructors.add(ctructorToUse);
}
ambiguousCtructors.add(candidate);
}
}
if (ctructorToUse == null) {
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Could not resolve matching ctructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
else if (ambiguousCtructors != null && !mbd.isLenientCtructorResolution()) {
throw new BeanCreationException(mbd.getResourceDescription(), beaname,
"Ambiguous ctructor matches found in bean '" + beaname + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousCtructors);
}
if (explicitArgs == null && argsHolderToUse != null) {
// 将解析的构造函数加入缓存
argsHolderToUse.storeCache(mbd, ctructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved ctructor arguments");
// 将构造的实例加入BeanWrapper中
bw.setBeanInstance(instantiate(beaname, mbd, ctructorToUse, argsToUse));
return bw;
}2.1.4、instantiateBean()；默认构造函数
代码语言：javascript代码运行次数：0运行复制protected BeanWrapper instantiateBean(final String beaname, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beaname, parent),
getAccessControlContext());
}
else {
// 获取实例化策略并且进行实例化操作
beanInstance = getInstantiationStrategy().instantiate(mbd, beaname, parent);
}
// 包装成BeanWrapper
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Instantiation of bean failed", ex);
}
}@Override
public Object instantiate(RootBeanDefinition bd, @ullable String beaname, BeanFactory owner) {
// bd对象定义中，是否包含MethodOverride列表，
// spring中有两个标签参数会产生MethodOverrides,分别是lookup-method,replaced-method
// 没有MethodOverrides对象，可以直接实例化
if (!bd.hasMethodOverrides()) {
// 实例化对象的构造方法
Ctructor<?> ctructorToUse;
// 锁定对象，使获得实例化构造方法线程安全
synchronized () {
// 查看bd对象里使用否含有构造方法
ctructorToUse = (Ctructor<?>) bd.resolvedCtructorOrFactoryMethod;
if (ctructorToUse == null) {
// 从bd中获取beanClass
final Class<?> clazz = bd.getBeanClass();
// 如果要实例化的beanDefinition是一个接口，则直接抛出异常
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
// 获取系统安全管理器
if (System.getSecurityManager() != null) {
ctructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Ctructor<?>>) clazz::getDeclaredCtructor);
}
else {
// 获取默认的无参构造器
ctructorToUse = clazz.getDeclaredCtructor();
}
// 获取到构造器之后将构造器赋值给bd中的属性
bd.resolvedCtructorOrFactoryMethod = ctructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "o default ctructor found", ex);
}
}
}
// 通过反射生成具体的实例化对象
return BeanUtils.instantiateClass(ctructorToUse);
}
else {
// 生成cglib子类
return instantiateWithMethodInjection(bd, beaname, owner);
}
}2.2、applyMergedBeanDefinitionPostProcessors();应用后置处理器
代码语言：javascript代码运行次数：0运行复制protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beaname) {
//获取BeanFactory中已注册的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
// 调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法，
// 对指定bean的给定MergedBeanDefinition进行后置处理，@Autowire注解在这边对元数据进行预解析
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beaname);
}
}
}2.、addSingletonFactory()；提前曝光beaname的ObjectFactory，用于解决循环引用
代码语言：javascript代码运行次数：0运行复制protected void addSingletonFactory(String beaname, ObjectFactory<?> singletonFactory) {
(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 如果beaname不存在于一级缓存（完整对象bean）
if (!this.(beaname)) {
// 将beaname和singletonFactory
// 注册到缓存（工厂bean缓存）
this.singletonFactories.put(beaname, singletonFactory);
// 移除二级缓存（没有属性填充bean）
remove(beaname);
// 将beaname注册到registeredSinglet缓存（已经注册的单例集合）
this.registeredSinglet.add(beaname);
}
}
}2.4、getEarlyBeanReference()；获取对指定bean的早期访问的引用
代码语言：javascript代码运行次数：0运行复制protected Object getEarlyBeanReference(String beaname, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
// 如果bean不为空 && mbd不是合成 && 存在InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 应用所有SmartInstantiationAwareBeanPostProcessor，调用getEarlyBeanReference方法
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
// // .允许SmartInstantiationAwareBeanPostProcessor返回指定bean的早期引用
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beaname);
}
}
}
//返回要作为bean引用公开的对象，如果没有SmartInstantiationAwareBeanPostProcessor修改，
//则返回的是入参的bean对象本身
return exposedObject;
}2.5、populateBean()；属性填充
代码语言：javascript代码运行次数：0运行复制protected void populateBean(String beaname, RootBeanDefinition mbd, @ullable BeanWrapper bw) {
// bw为空时的处理
if (bw == null) {
if (mbd.hasPropertyValues()) {
// 如果bw为空，属性不为空，抛异常，无法将属性值应用于null实例
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Cannot apply property values to null instance");
}
else {
// 如果bw为空，属性也为空，则跳过
return;
}
}
// 用于标识是否继续之后的属性填充
boolean continueWithPropertyPopulation = true;
// 如果mbd不是合成的 && 存在InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 遍历处理InstantiationAwareBeanPostProcessor
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 在bean实例化后，属性填充之前被调用，允许修改bean的属性，如果返回false，则跳过之后的属性填充
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beaname)) {
//如果返回false，将continueWithPropertyPopulation赋值为false，代表要跳过之后的属性填充
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 如果continueWithPropertyPopulation为false，则跳过之后的属性填充
if (!continueWithPropertyPopulation) {
return;
}
// 返回此bean的属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 解析自动装配模式为AUTOWIRE_BY_AME和AUTOWIRE_BY_TYPE
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_AME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 2.5.1、解析autowireByame的注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_AME) {
autowireByame(beaname, mbd, bw, newPvs);
}
// 2.5.2、解析autowireByType的注入
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beaname, mbd, bw, newPvs);
}
pvs = newPvs;
}
// BeanFactory是否注册过InstantiationAwareBeanPostProcessors
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 是否需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPEDECY_CHECK_OE);
PropertyDescriptor[] filteredPds = null;
// 注册过InstantiationAwareBeanPostProcessors
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 应用后置处理器InstantiationAwareBeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beaname);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 应用后置处理器InstantiationAwareBeanPostProcessor的方法postProcessPropertyValues，
// 进行属性填充前的再次处理。例子：现在最常用的@Autowire属性注入就是这边注入依赖的bean实例对象
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beaname);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 依赖检查，对应depends-on属性
checkDependencies(beaname, mbd, filteredPds, pvs);
}
if (pvs != null) {
// 5.2.、 将所有PropertyValues中的属性填充到bean中
applyPropertyValues(beaname, mbd, bw, pvs);
}
}2.5.1、autowireByame()；根据名称注入
代码语言：javascript代码运行次数：0运行复制protected void autowireByame(
String beaname, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 寻bw中需要依赖注入的属性
String[] propertyames = unsatisfiedonSimpleProperties(mbd, bw);
for (String propertyame : propertyames) {
// 校验是否存在beaname=propertyame的bean实例或者BeanDefinition
if (containsBean(propertyame)) {
// 获取propertyame的bean实例对象
Object bean = getBean(propertyame);
// 将属性名和属性值添加到pvs
pvs.add(propertyame, bean);
// 注册依赖关系到缓存（beaname依赖propertyame）
registerDependentBean(propertyame, beaname);
if (logger.isTraceEnabled()) {
("Added autowiring by name from bean name '" + beaname +
"' via property '" + propertyame + "' to bean named '" + propertyame + "'");
}
}
else {
if (logger.isTraceEnabled()) {
("ot autowiring property '" + propertyame + "' of bean '" + beaname +
"' by name: no matching bean found");
}
}
}
}2.5.2、autowireByType()；根据类型注入
代码语言：javascript代码运行次数：0运行复制protected void autowireByType(
String beaname, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanames = new LinkedHashSet<>(4);
// 寻bw中需要依赖注入的属性
String[] propertyames = unsatisfiedonSimpleProperties(mbd, bw);
// 遍历所有需要依赖注入的属性
for (String propertyame : propertyames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyame);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if ( != pd.getPropertyType()) {
// 获取指定属性的set方法，封装成MethodParameter（必须有set方法才能通过属性来注入）
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !.isInstance(bw.getWrappedInstance());
// 将MethodParameter的方法参数索引信息封装成DependencyDescriptor
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 解析当前属性所匹配的bean实例，并把解析到的bean实例的beaname存储在autowiredBeanames中
Object autowiredArgument = resolveDependency(desc, beaname, autowiredBeanames, converter);
if (autowiredArgument != null) {
// 如果到了依赖的bean实例，将属性名和bean实例放到pvs中
pvs.add(propertyame, autowiredArgument);
}
for (String autowiredBeaname : autowiredBeanames) {
// 注册依赖关系，beaname依赖autowiredBeaname
registerDependentBean(autowiredBeaname, beaname);
if (logger.isTraceEnabled()) {
("Autowiring by type from bean name '" + beaname + "' via property '" +
propertyame + "' to bean named '" + autowiredBeaname + "'");
}
}
();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beaname, propertyame, ex);
}
}
}2.5.、applyPropertyValues()；将属性填充到bean中
代码语言：javascript代码运行次数：0运行复制protected void applyPropertyValues(String beaname, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
// 获取属性值列表
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
// 如果mpvs中的值已经被转换为对应的类型，那么可以直接设置到BeanWrapper中
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Error setting property values", ex);
}
}
// 如果pvs并不是使用MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法
original = mpvs.getPropertyValueList();
}
else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
// 获取对应的解析器
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beaname, mbd, converter);
// 创建深层拷贝副本，用于存放解析后的属性值
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveecessary = false;
// 遍历属性，将属性转换为对应类的对应属性的类型
for (PropertyValue pv : original) {
if (pv.isConverted()) {
// 如果pv已经包含转换的值，则直接添加到deepCopy
deepCopy.add(pv);
}
else {
// 否则，进行转换
// 拿到pv的原始属性名和属性值
String propertyame = pv.getame();
Object originalValue = pv.getValue();
// 使用解析器解析原始属性值
Object resolvedValue = valueResolver.resolveValueIfecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// 判断该属性是否可转换
boolean convertible = bw.isWritableProperty(propertyame) &&
!PropertyAccessorUtils.isestedOrIndexedProperty(propertyame);
if (convertible) {
// 如果可转换，则转换指定目标属性的给定值
convertedValue = convertForProperty(resolvedValue, propertyame, bw, converter);
}
// Possibly store converted value in merged bean definition,
// 在合并的BeanDefinition中存储转换后的值，以避免为每个创建的bean实例重新转换
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
// 设置bean的属性值为deepCopy
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beaname, "Error setting property values", ex);
}
}2.6、initializeBean()；初始化bean
代码语言：javascript代码运行次数：0运行复制protected Object initializeBean(final String beaname, final Object bean, @ullable RootBeanDefinition mbd) {
// 激活Aware方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// 2.6.1、执行Aware方法
invokeAwareMethods(beaname, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beaname, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 2.6.2、在初始化前应用BeanPostProcessor的postProcessBeforeInitialization方法，允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beaname);
}
try {
// 2.6.、调用初始化方法
invokeInitMethods(beaname, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beaname, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 2.6.4、在初始化后应用BeanPostProcessor的postProcessAfterInitialization方法，允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beaname);
}
return wrappedBean;
}2.6.1、invokeAwareMethods()；执行Aware方法
代码语言：javascript代码运行次数：0运行复制private void invokeAwareMethods(final String beaname, final Object bean) {
if (bean instanceof Aware) {
// BeanameAware: 实现此接口的类想要拿到beaname，因此我们在这边赋值给它
if (bean instanceof BeanameAware) {
((BeanameAware) bean).setBeaname(beaname);
}
// BeanClassLoaderAware：实现此接口的类想要拿到beanClassLoader，因此我们在这边赋值给它
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
// BeanFactoryAware: 实现此接口的类想要拿到 BeanFactory，因此我们在这边赋值给它
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory();
}
}
}2.6.2、applyBeanPostProcessorsBeforeInitialization()；初始化前后置处理器
代码语言：javascript代码运行次数：0运行复制@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beaname)
throws BeansException {
Object result = existingBean;
// 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessBeforeInitialization方法
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
// 2.在bean初始化方法执行前，调用postProcessBeforeInitialization方法
result = beanProcessor.postProcessBeforeInitialization(result, beaname);
if (result == null) {
return result;
}
}
return result;
}2.6.、invokeInitMethods()；初始化方法
代码语言：javascript代码运行次数：0运行复制protected void invokeInitMethods(String beaname, final Object bean, RootBeanDefinition mbd)
throws Throwable {
// 1.首先检查bean是否实现了InitializingBean接口，如果是的话调用afterPropertiesSet方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beaname + "'");
}
// 2.调用afterPropertiesSet方法
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
((InitializingBean) bean).afterPropertiesSet();
return null;
}
}, getAccessControlContext());
} catch (PrivilegedActionException pae) {
throw pae.getException();
}
} else {
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null) {
String initMethodame = mbd.getInitMethodame();
if (initMethodame != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodame)) &&
!mbd.isExternallyManagedInitMethod(initMethodame)) {
// .调用自定义初始化方法
invokeCustomInitMethod(beaname, bean, mbd);
}
}
}2.6.4、applyBeanPostProcessorsAfterInitialization()；初始化后方法
代码语言：javascript代码运行次数：0运行复制@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beaname)
throws BeansException {
Object result = existingBean;
// 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
// 2.在bean初始化方法执行后，调用postProcessAfterInitialization方法
result = beanProcessor.postProcessAfterInitialization(result, beaname);
if (result == null) {
return result;
}
}
return result;
}#感谢您对电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格的认可，转载请说明来源于"电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格
上传时间： 2025-07-20 20:28:48
上一篇：制作纯净版的U盘启动盘
推荐阅读
| 留言与评论（共有 6 条评论） |
| 本站网友 滴胶 | 5分钟前 发表 |
| beaname); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw | |
| 本站网友 wingdings字体 | 2分钟前 发表 |
| 初始化事件多播器（用来广播事件） initApplicationEventMulticaster(); // 9 | |
| 本站网友 贴现利率 | 2分钟前 发表 |
| 本站网友 四川泸县 | 25分钟前 发表 |
| 那么继续从缓存中寻缓存的构造器参数 argsToUse = mbd.resolvedCtructorArguments; if (argsToUse == null) { // 没有缓存的参数 | |
| 本站网友 北京楼盘地图 | 27分钟前 发表 |
| RootBeanDefinition mbd | |