IOC初始化源码分析
前言
分析Spring源码我们不需要太过于纠结细节，不然，这个源码最起码得分析几个月才能分析完；我们最主要的目的是分析整个容器初始化过程，怎么初始化bean，怎么设置动态代理；我们主要学习的是他们的思想，以及代码中运用到的设计模式；
源码中重要的角色
BeanFactory：用于访问容器中bean的接口，使用的是工厂模式，我们这次学习中，重点注意DefaultListableBeanFactory
BeanDefinition：BeanDefinition是bean在Spring中的描述，先读取到bean的各种元素，然后利用BeanDefinition去初始化bean
BeanDefinitionRegistry接口：注册bean定义到Spring容器中
BeanFactoryPostProcessor接口：bean工厂的后置处理器，该接口的作用主要是提供扩展点，用于各种bean定义的注册，我们主要关注ConfigurationClassPostProcessor该类；
BeanPostProcessor接口：bean的后置处理器，该接口提供的扩展点，用于初始化bean，以及初始化完成后的各种扩展；
IOC容器初始化的大致流程
其实IOC主要流程就是先读取BeanDefinition放到容器中，然后根据BeanDefinition去初始化bean，然后提供后置处理器作为扩展，来实现各种不同的功能；我们来看看，Spring IOC容器初始化大致的一个流程，主要是看AnnotationConfigApplicationContext和refresh，其他的细节，我们留到下个章节细讲
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
//初始化容器，创建bean工厂，加载各种内部重要类的bean定义，用于初始化我们或者其他引入类
this();
//注册我们配置类的bean定义，初始化容器，从这个类开始
register(componentClasses);
//准备工作做好后，开始初始化容器
refresh();
}
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//设置容器状态，准备刷新容器
prepareRefresh();
//获取到容器的bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//填充bean工厂的各种属性
prepareBeanFactory(beanFactory);
try {
//留给子类实现，我们看的AnnotationConfigApplicationContext继承了GenericApplicationContext，该类主要是注册了ServletContextAwareProcessor
postProcessBeanFactory(beanFactory);
//主要是调用bean工厂的后置处理器，把我们的类，注册成bean定义
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean的后置处理器
registerBeanPostProcessors(beanFactory);
//初始化国际化资源（这个方法不重要）
initMessageSource();
//Spring事件相关，主要是创建一个事件多播器
initApplicationEventMulticaster();
//留给子类实现
onRefresh();
//把我们的事件注册到容器中
registerListeners();
//实例化我们需要的bean，放入IOC容器
finishBeanFactoryInitialization(beanFactory);
//完成容器IOC容器初始化，并且发布初始化完成事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
destroyBeans();
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
}
}
}
我们先对这个过程有个了解，然后清楚里面的一些重要角色
AnnotationConfigApplicationContext构造器分析
上面讲到，传入配置类的构造函数
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}
接下来所有，我们主要是来看下代码注释；我们先看下this()这一行代码
public AnnotationConfigApplicationContext() {
//初始化读取bean定义的读取器，完成Spring内部bean定义的注册
this.reader = new AnnotatedBeanDefinitionReader(this);
//初始化一个类扫描器，其实这个方法进来，是没有用到这个扫描器的
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
//值得注意的是，AnnotationConfigApplicationContext继承了GenericApplicationContext，调用构造方法时，肯定会先调用父类的构造器
public GenericApplicationContext() {
/**
*初始化了Bean工厂
*DefaultListableBeanFactory该类是功能最全的bean工厂
*bean定义还有bean都是注册到bean工厂中
*/
this.beanFactory = new DefaultListableBeanFactory();
}
//从上面创建bean定义读取器，看下构造方法
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
//把ApplicationContext对象赋值给bean定义读取器
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//主要是看这个方法，注册Spring内部重要的bean定义
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
//获取bean工厂，方便bean定义的注册
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
//注册了一个排序器
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
//注册了@Autowired的候选解析器
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
//其实并没有用到这个返回
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//注册了解析配置的后置处理器ConfigurationClassPostProcessor，我们主要来看这个registerPostProcessor注册bean定义的过程
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
/**
*使用类名创建该类的bean定义
*BeanDefinition中可以获取以下的信息
*该bean的Class，可以根据该类来获取该类依赖的其他bean的属性
*可以获取是否是单例的bean等等。。。
**/
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//注册了处理@Autowired注解的后置处理器AutowiredAnnotationBeanPostProcessor
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//后面注册的可以自己了解下，看下源码，我们主要看下registerPostProcessor的注册流程
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
//注册bean定义
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
//这个角色属性，代表是spring内部的bean
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
//主要是看这个方法，这个就是注册bean定义的
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
//把bean定义，注册到beanFactory中去
this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
}
//registerBeanDefinition方法主要是看这句，就是把bean定义放入缓存beanDefinitionMap中
this.beanDefinitionMap.put(beanName, beanDefinition);
到这里this()；这个方法流程就过完了，主要就是注册spring内部重要的bean定义，下面我们来看下register(componentClasses);方法
public void register(Class<?>... annotatedClasses) {
Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
//使用上面初始化的bean定义读取器，去注册我们配置类的bean定义
this.reader.register(annotatedClasses);
}
//遍历去注册
public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}
public void registerBean(Class<?> annotatedClass) {
doRegisterBean(annotatedClass, null, null, null);
}
//注册bean定义
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
//根据配置类创建一个bean定义
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
//解析bean的作用域，如果没有设置，则默认是单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//解析该bean是否有Lazy，Primary，DependsOn，Description等注解，有则填充进去
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
if (customizers != null) {
for (BeanDefinitionCustomizer customizer : customizers) {
customizer.customize(abd);
}
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//最后把该bean定义注册到Bean工厂中去
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
register(componentClasses);方法到此结束，然后我们分析refresh();方法，该方法初始化了IOC容器
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//设置容器状态，准备刷新容器
prepareRefresh();
//获取到容器的bean工厂
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//填充bean工厂的各种属性
prepareBeanFactory(beanFactory);
try {
//留给子类实现，我们看的AnnotationConfigApplicationContext继承了GenericApplicationContext，该类主要是注册了ServletContextAwareProcessor
postProcessBeanFactory(beanFactory);
//主要是调用bean工厂的后置处理器，把我们的类，注册成bean定义
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean的后置处理器
registerBeanPostProcessors(beanFactory);
//初始化国际化资源（这个方法不重要）
initMessageSource();
//Spring事件相关，主要是创建一个事件多播器
initApplicationEventMulticaster();
//留给子类实现
onRefresh();
//把我们的事件注册到容器中
registerListeners();
//实例化我们需要的bean，放入IOC容器
finishBeanFactoryInitialization(beanFactory);
//完成容器IOC容器初始化，并且发布初始化完成事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
destroyBeans();
cancelRefresh(ex);
throw ex;
}
finally {
resetCommonCaches();
}
}
}
我们接下来分析主要的步骤，如果不重要的，会略过；首先 prepareRefresh(); 方法主要是为容器设置一个状态，然后第二行代码，是去获取相应的工厂类，我们AnnotationConfigApplicationContext主要是获取到DefaultListableBeanFactory，但是如果是XML方式，会在该方法去加载bean定义，我们不分析这种方式；
我们来看下prepareBeanFactory(beanFactory);这个方法
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//设置类加载器，为当前应用的application的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
//为bean工厂设置一个标准的SPEL表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
//为bean工厂设置一个资源编辑器，为了后面bean初始化时，给bean对象赋值
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
//忽略以下接口的bean，这些bean都有set方法，不会对这些bean进行属性赋值
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//注册了工厂实例，如果我们在程序中注入BeanFactory，就是从这里注册的获取到的
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//注册事件监听器的bean后置处理接口
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//处理AOP的后置处理器
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//注册bean工厂的环境属性
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
接下来分析postProcessBeanFactory(beanFactory);
//该方法其实没有做实际的事情，主要是把ServletContextAwareProcessor后置处理器，给注册进去
//当我们实现ServletContextAware接口获取上下文容器，就是从这里注入的
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
if (this.servletContext != null) {
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
}
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}
接下来分析invokeBeanFactoryPostProcessors(beanFactory);
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//获取FactoryPostProcessors，Spring内置的和我们自己设置的，然后供接下来的调用
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//放入已经被处理过的bean
Set<String> processedBeans = new HashSet<>();
//当前bean工厂是否实现了BeanDefinitionRegistry，如果有的话，则可以注册bean定义
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
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);
}
}
//保存当前实例化的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//从bean工厂中获取到继承了BeanDefinitionRegistryPostProcessor的bean
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//实例化优先级最高的BeanDefinitionRegistryPostProcessor
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//实例化出BeanDefinitionRegistryPostProcessor的类，我们正常初始化这里只有ConfigurationClassPostProcessor
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//对实例化出来的BeanDefinitionRegistryPostProcessor进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把实例化出来的BeanDefinitionRegistryPostProcessor添加进总的集合中供后面调用
registryProcessors.addAll(currentRegistryProcessors);
//调用刚实例化出来的bean，注册bean定义
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空调用后的BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.clear();
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//实例化实现了Ordered接口的BeanDefinitionRegistryPostProcessor
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
//调用 BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//调用自己实现的BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
//没有实现BeanDefinitionRegistry接口的bean工厂，直接调用invokeBeanFactoryPostProcessors
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//调用所有的BeanDefinitionRegistryPostProcessor完毕
//获取容器中所有的 BeanFactoryPostProcessor
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
//执行所有BeanFactoryPostProcessor.postProcessBeanFactory方法，按照order接口排序
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
//执行完成所有BeanFactoryPostProcessor.postProcessBeanFactory方法，清除所有缓存信息
beanFactory.clearMetadataCache();
}
//我们接下来主要是看ConfigurationClassPostProcessor调用postProcessBeanDefinitionRegistry方法
private static void invokeBeanDefinitionRegistryPostProcessors(
Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
//循环最开始初始化的所有bean定义
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//对配置类（带有@Configuration标签）进行标记，后续实例化时有用
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnable()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
//进行标记，添加到配置类，候选集合中
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
if (configCandidates.isEmpty()) {
return;
}
//对所有配置类进行排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// 创建我们通过@CompentScan导入进来的bean name的生成器
// 创建我们通过@Import导入进来的bean的名称
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
//创建一个类解析器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
/**解析配置类，包括@Component、@ComponentScans等需要扫描的类，都会被解析出来放入bean定义容器
*@Configuration配置类为full配置类，其他的为lite配置类
**/
parser.parse(candidates);
parser.validate();
//获取到解析出来的配置类
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//把所有@Import、@Bean解析出来的bean定义放入容器
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
//我们再来看看ConfigurationClassPostProcessor.invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
//这里会修改@Configuration配置类的bean定义，到时候实例化bean时，会使用CGLIB创建动态代理，@Bean中调用获取的bean都是容器中的bean，其他配置类的bean，获取的都是new出来的
enhanceConfigurationClasses(beanFactory);
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
到此bean定义就全部加载完成，太细节的代码就不贴出来了，其实也是想分析的细一点，但是确实不够写，感觉分析下去，一章一个方法都分析不完，我们下面来讲bean的实例化；
bean的实例化过程源码分析
上面讲了bean定义的加载过程，现在我们来讲一下bean的实例化过程，bean的实例化，主要是finishBeanFactoryInitialization(beanFactory);这个方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//bean工厂创建转化器
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(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
//实例化AOP相关的组件
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
//调用工厂实例化方法，这个方法我们后面来分析
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
//冻结所有bean定义，在实例化时，不允许再修改bean定义
beanFactory.freezeConfiguration();
//实例化所有bean
beanFactory.preInstantiateSingletons();
}
//实例化所有bean
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//获取到容器中所有bean定义
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//循环去实例化
for (String beanName : beanNames) {
//把各种不同类型的bean定义转换成RootBeanDefinition类型
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//只有不是抽象类，必须是单例类，并且不是懒加载才会去实例化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是不是工厂类
if (isFactoryBean(beanName)) {
//工厂类会先生存实际的bean，用 &+bean名称
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
//实际去实例化bean
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//调用实例化bean
getBean(beanName);
}
}
}
//遍历所有的bean，如果实现了SmartInitializingSingleton接口，调用afterSingletonsInstantiated方法
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
public Object getBean(String name) throws BeansException {
//真实去实例化bean
return doGetBean(name, null, null, false);
}
//这个方法就是最重要的实例化过程，最主要是关注spring是怎么解决循环依赖的
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
//先从一级缓存中去获取bean，可以看下getSingleton方法
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 + "'");
}
}
//如果是普通单例bean则会直接返回，如果是工厂bean。则会调用getObject获取真正的bean实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//Spring只解决单例bean的循环依赖，如果非单例，循环依赖则会直接报错
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
//获取到父工厂，如果当前工厂中没有当前bean，则委托给父工厂实例化
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
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);
}
}
//如果不仅仅做类型检查，而是创建bean，则标记这个bean
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//把不同类型的bean定义转换成RootBeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//如果是抽象类，则会报错
checkMergedBeanDefinition(mbd, beanName, args);
//处理dependsOn依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
//如果依赖的bean是正在创建的bean，就是循环依赖问题，这个直接抛异常，这种是@Bean依赖，不给解决循环依赖
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//如果是单例bean放进三级缓存，并且获取依赖注入的bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//这段逻辑可以看下面createBean的详解
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
//创建bean的逻辑报异常，则销毁当前bean相关的所有信息
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//第一步先从缓存中获取bean
Object singletonObject = this.singletonObjects.get(beanName);
//如果没有获取到bean，并且这个bean正在实例化过程中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//从二级缓存中获取bean
singletonObject = this.earlySingletonObjects.get(beanName);
//如果未获取到
if (singletonObject == null && allowEarlyReference) {
//先对一级缓存加锁，保证获取到的是一个实例化完成的bean
synchronized (this.singletonObjects) {
//因为获取到锁，可能这个bean已经放入到一级缓存，如果不去获取一次，可能出现多个bean
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//然后再去从二级缓存中获取
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
//然后从三级缓存中获取生成bean的方法，这是解决循环依赖的关键，生成代理类，也是这个方法调用后才生成的
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用这个钩子方法，我们在上一个方法doGetBean中可以找到这个钩子方法
singletonObject = singletonFactory.getObject();
//然后把这个类放到二级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
//再从三级缓存中移除这个bean
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
}
//获取单例bean
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//加锁，如果同时有多线程在获取bean，保证不会获取到不完成的bean
synchronized (this.singletonObjects) {
//获取到锁后先从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//标记当前bean正在被创建，用于判断是否是循环依赖，就是加入到set集合中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//调用外面传入进来的createBean钩子方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
//返回实例化后的bean
return singletonObject;
}
}
//实例化bean
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//调用第一个bean的后置处理器，生成代理对象，我们一般的AOP是不会在这里生成代理的，因为还没实例化出对象
//这里这里是AOP和事务的关键，会生成切面信息进行缓存
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//真正去创建bean，进行实例化
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取早期对象
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
/**
* 这一段就是循环依赖最关键的点，会先放一个早期对象到钩子方法（getEarlyBeanReference）中
* 这个钩子方法如果这个对象不用创建动态代理，则会直接返回当前对象
* 把这个钩子方法放入三级缓存，等真正来获取bean时，执行
* 过了这段逻辑，才开始去注入各种属性，如果有需要循环获取的属性，则会从三级缓存中获取
**/
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
//去注入属性，比如有依赖的属性，则是从这里去注入，会循环调用getBean
populateBean(beanName, mbd, instanceWrapper);
/**
* 到这一步，对象已经实例化完成
* 如果有经过循环依赖的话，需要进行动态代理的类，已经生成了动态代理
* 但是，未经过循环依赖的类，需要我们实例化完成后，进行动态代理
* 动态代理时，还需判断是否是接口，需要用JDK的动态代理，还是CGLIB的动态代理
**/
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//如果是正常bean，一般只会从一级或者二级缓存中获取，不会把bean存入三级缓存
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//注册销毁的bean的销毁接口
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
Spring IOC容器bean的实例化，到这基本就完成了，这次所有源代码的分析把重要的地方，大致流程都讲了一遍，但是有很多细节没有讲到，比如说怎么创建动态代理，怎么具体怎么实例化，这些代码根据我的注释找到相应的地方，可以去自己看看源码，我基本上都标注了每一步的步骤，只是如果要深挖的话，层级太深，绕也会绕晕，最好是自己脑子里有个框架，然后再根据框架去找细节，这样就会事半功倍。
最后总结
这次Spring只分析了源代码，这次就分析到这里，其实我们分析源代码不仅仅只是知道它内部逻辑是怎么运行的，关键是需要学习这个框架的思想，以及各种设计模式的运用，这样才算学到了东西；其实Spring的代码，你过了一段时间，基本上就只会记得大概，主要是确实层级太深，所以我们需要了解到精髓，例如里面生成bean用到的工厂模式，去解析@ComponentScan，里面的这个type用到的策略模式，还有AOP切面调用advisor使用的责任链模式，等等，都是我们学习的点；