首页  思维导图  详情

spring源码脑图

2021-07-04 16:47:56   39  举报





AI智能生成

源码脑图

源码

作者其他创作

大纲/内容

refresh()

//1、初始化前的预处理 prepareRefresh();

//2、获取BeanFactory，加载所有xml配置文件中的bean定义信息（未实例化） ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

//刷新BeanFactory（包含配置文件的加载和解析） refreshBeanFactory(); ConfigurableListableBeanFactory beanFactory = getBeanFactory();

//加载配置文件 loadBeanDefinitions(beanFactory);

//XML配置文件由XmlBeanDefinitionReader解析 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

//使用xml解析器，解析xml配置文件 loadBeanDefinitions(beanDefinitionReader);

//加载配置文件资源路径的xml配置文件 reader.loadBeanDefinitions(configLocations);

//真正干活的 return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

//重点：registerBeanDefinitions return registerBeanDefinitions(doc, resource);

BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

//解析 documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

doRegisterBeanDefinitions(root);

//取<bean>上的profile属性，并根据Environment中配置好的profile决定是否继续解析（profile过滤） String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

//解析xml parseBeanDefinitions(root, this.delegate);

////解析<bean>标签 processBeanDefinition(ele, delegate);

//解析xml元素为BeanDefinition //bdHolder内部组合了BeanDefinition BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

//BeanDefinition注册到BeanDefinitionRegistry BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

//3、BeanFactory的预处理配置 prepareBeanFactory(beanFactory);

//4、准备BeanFactory完成后进行的后置处理 postProcessBeanFactory(beanFactory);

//5、执行BeanFactory创建后的后置处理器 invokeBeanFactoryPostProcessors(beanFactory);

//交给代理执行 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

1、将BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor分离开

registryProcessor.postProcessBeanDefinitionRegistry(registry);

//解析配置类（解析配置类中的定义的bean，并封装为BeanDefinition） processConfigBeanDefinitions(registry);

//筛选出所有的配置类

//配置类的排序

//构造默认的BeanNameGenerator bean的名称生成器

//真正解析配置类的组件：ConfigurationClassParser ConfigurationClassParser parser

//解析配置类 parser.parse(candidates);

子主题

//编程式注入配置类

//其他情况

//回调特殊的ImportSelectors，DeferredImportSelectors它的执行时机比ImportSelectors更晚， // 它会在注解配置类的所有解析工作完成后才执行 processDeferredImportSelectors();

//加载配置类的内容 this.reader.loadBeanDefinitions(configClasses);

loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);

//与条件配置有关

//如果当前配置类是被@Import的，要把自己注册进BeanFactory<div>registerBeanDefinitionForImportedConfigurationClass(configClass); </div>

//构造AnnotatedGenericBeanDefinition

//包装BeanDefinitionHolder

//注册进BeanDefinitionRegistry

//注册@Bean注解方法（在解析阶段，只是对@Bean加入的处理）<div>loadBeanDefinitionsForBeanMethod(beanMethod); </div>

//如果条件装配将其跳过，则该@Bean标注的方法，对应的BeanDefinition不会注册进BeanDefinitionRegistry

//检查方法上真的有@Bean注解吗

//如果bean指定了多个name，则第一个作为为唯一标识，其余都是alias别名

//注解中配置了@Bean，与xml中的bean撞车了，会抛出异常

//构造ConfigurationClassBeanDefinition

//【复杂】解析@Bean所在方法的修饰符

//处理@Bean的属性（name，initMethod等），额外的注解（@Lazy，@DependsOn等）

//注册进BeanDefinitionRegistry

//注册来自xml配置文件的bean（使用XmlBeanDefinitionReader搞的） loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

//注册来自ImportBeanDefinitionRegistrars的bean loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

//一些额外处理动作

1、执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法     （1）执行实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor     （2）执行实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessor     （3）执行普通的 BeanDefinitionRegistryPostProcessor 2、执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法      同上 3、执行BeanFactoryPostProcessor 的 postProcessBeanFactory 方法      同上

//6、注册bean的后置处理器 registerBeanPostProcessors(beanFactory);

PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

//获取ioc容器中已经有的BeanPostProcessor的name

//1.1此处会先注册一个BeanPostProcessorChecker

//根据排序规则，给所有的后置处理器分类

//1.2注意此处，PriorityOrdered类型的后置处理器被提前初始化了(防止优先级低的后置处理器干预了优先级高的后置处理器，从而引发程序的运行情况异常)

//MergedBeanDefinitionPostProcessor要额外筛选出来

//首先，注册所有实现了PriorityOrdered接口的后置处理器

//其次，注册所有实现了Ordered接口的后置处理器

//最后注册所有普通的后置处理器

//1.3注意此处，所有的MergedBeanDefinitionPostProcessor又被注册了一次

//最后又注册了一个ApplicationListenerDetector

//7、初始化MessageSource initMessageSource();

//8、初始化事件派发器 initApplicationEventMulticaster();

//9、子类的多态onRefresh onRefresh();

//10、注册监听器 registerListeners();

//到此为止BeanFactory已创建完成 // Instantiate all remaining (non-lazy-init) singletons. //11、初始化所有剩下的单例bean finishBeanFactoryInitialization(beanFactory);

//处理单实例bean的初始化 beanFactory.preInstantiateSingletons();

//此处循环初始化剩余的非延迟加载的单实例bean

//先合并BeanDefinition RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

//不是抽象的、不是延迟加载的单实例bean要初始化

//普通的初始化，就是getBean方法 getBean(beanName);

return doGetBean(name, requiredType, null, false);

//处理bean的alias

//循环依赖的探测

//如果原型bean之间互相依赖，则一定会引发无限循环，此处会抛出循环依赖的异常

//如果本地不存在当前bean的定义信息，则尝试让父容器实例化bean //此举可以保证每个BeanFactory持有它应该有的bean，而不是所有的bean都集中在某一个BeanFactory中

//标记当前bean已经开始创建了

//此处会合并BeanDefinition，并检查是否为抽象类（abstract则会抛出无法实例化的异常） final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

<div>//核心逻辑：它会自上而下递归寻找父BeanDefinition，再从上而下合并获得最终的BeanDefinition </div><div>return getMergedBeanDefinition(beanName, bd, null); </div>

//此处会处理当前bean依赖的bean的初始化

//单实例bean的初始化，如果缓存中没有，最终调用createBean

getSingleton

//加锁后，再查一次单实例bean的缓存

/【createBean】如果单实例bean的缓存中真的没有，那就创建对象（即外面的lamda表达式中的createBean方法）

//新创建的单实例bean要存入单实例bean的缓存中 addSingleton(beanName, singletonObject);

return createBean(beanName, mbd, args);

//给后置处理器一个机会来创建代理bean而不是目标bean实例 //【后置处理器拦截创建bean】 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

//执行所有InstantiationAwareBeanPostProcessor bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { //如果成功创建出了bean，则执行BeanPostProcessors的后置初始化 //我们说postProcessorsAfterInitialization方法的一个关键作用是生成代理对象，如果一个bean被 //InstantiationAwareBeanPostProcessor提前创建出了bean，但又需要创建代理对象，这个时候 //就必须要回调postProcessorsAfterInitialization bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); }

//真正的创建bean Object beanInstance = doCreateBean(beanName, mbdToUse, args);

进入到这个方法，那就相当于要真实的中规中矩的创建 bean 对象了！这个方法中共有三个大步骤： 1、实例化 bean 对象（此时 bean 中所有属性均为空） 2、属性赋值 & 依赖注入 3、bean 对象的初始化（执行完该步骤后 bean 已经完整）

//处理FactoryBean的小细节问题

//factoryBeanInstanceCache的作用：获取到FactoryBean中生成的bean的类型。

//【真正的bean对象创建】 instanceWrapper = createBeanInstance(beanName, mbd, args);

//解析出bean的类型 Class<?> beanClass = resolveBeanClass(mbd, beanName);

//bean无法被访问，则抛出异常

//【工厂方法创建】

//这一步是为原型bean的一个小优化（由于原型bean的创建过程中，每次的执行流程都是一样的，所以执行一次后，把这个过程中 // 一些需要的东西缓存起来，以备后续再创建该bean是可以直接拿这些信息，去创建bean对象）

//当满足任一条件，就会执行基于构造器的实例化 //1、通过SmartInstantiationAwareBeanPostProcessor找到了构造器 //2、配置了注入方式是AUTOWIRE_CONSTRUCTOR //3、定义bean的时候指定了constructor-arg //4、构造bean时传入了args参数 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); }

//使用默认的无参构造器反射创建bean对象 return instantiateBean(beanName, mbd);

//得到真实的bean对象引用

//回调MergedBeanDefinitionPostProcessor（处理相关注解）<div>applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); </div>

InitDestroyAnnotationBeanPostProcessor实现类

//处理初始化和销毁注解的后置处理器 @Override public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) { //查找bean的生命周期元信息 LifecycleMetadata metadata = findLifecycleMetadata(beanType); metadata.checkConfigMembers(beanDefinition); }

<div>//用到缓存机制，把bean的初始化和销毁注解信息都保存到lifecycleMetadataCache里 </div>return buildLifecycleMetadata(clazz);

//反射所有的public方法

//寻找所有被初始化注解（@PostConstruct）标注的方法

//寻找所有被销毁注解（@PreDestroy）标注的方法

CommonAnnotationBeanPostProcessor实现类

//调用InitDestroyAnnotationBeanPostProcessor super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);

//收集注入相关的信息 InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);

<div>//额外收集了@Resource注解的信息 </div>metadata = buildResourceMetadata(clazz);

AutowiredAnnotationBeanPostProcessor实现类

//已经指定好默认支持@Autowire注解、@Value注解、如果 classpath 下有来自 JSR 330 的 @Inject 注解，也会一并支持

//早期bean对象引用的获取与缓存（bean被实例化出来以后还没有进行属性赋值和组件的依赖注入，但此时的bean对象已经实实在在的存在了 // 。如果在此期间，有另外的bean又需要创建它时，就不应该再创建同样的一个bean对象，而是直接拿到该引用）

//属性赋值+依赖注入 populateBean(beanName, mbd, instanceWrapper);

//检查BeanWrapper是否存在

//回调InstantiationAwareBeanPostProcessors（postProcessAfterInstantiation方法也是干预bean的属性等东西。 // 而且postProcessAfterInstantiation方法返回的boolean类型，当postProcessAfterInstantiation返回false时， // 会直接return出去，不再执行下面的属性赋值+组件依赖注入的逻辑。 // 这个回调的位置，就是让咱在bean已经初始化好，但还没有开始属性赋值和依赖注入时切入自定义逻辑）

//解析出当前bean支持的自动注入模式

//它将这个过程中需要组件依赖注入的信息也封装进了PropertyValues中了，所以此时pvs就应该有一开始封装的信息， //以及通过自动注入封装好的依赖信息 pvs = newPvs;

//又回调InstantiationAwareBeanPostProcessor<div>//【核心】回调postProcessProperties（传入pvs返回pvs，这个过程相当于反复给pvs封装数据） pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); </div>

AutowiredAnnotationBeanPostProcessor实现类

//收集注解信息 InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);

//真正的给bean对象属性赋值（注意点：在BeanFactoryPostProcessor或者BeanDefinitionRegistryPostProcessor // 中无法使用@Autowire直接注入spring中的内部组件（如Environment），因为当BeanDefinitionRegistryPostProcessor // 在初始化阶段，还不存在BeanPostProcessor呢，所以那些用于支持依赖注入的后置处理器（AutowiredAnnotationBeanPostProcessor） // 还没有被初始化，自然也就没办法支持注入了。正确的做法是借助Aware接口的回调注入） metadata.inject(bean, beanName, pvs);

//收集所有需要注入的信息 Collection<InjectedElement> elementsToIterate = (checkedElements != null ? checkedElements : this.injectedElements);

//迭代，依次注入<div>element.inject(target, beanName, pvs); </div>

//反射注入字段 Field field = (Field) this.member; ReflectionUtils.makeAccessible(field); field.set(target, getResourceToInject(target, requestingBeanName));

//反射调用setter方法 Method method = (Method) this.member; ReflectionUtils.makeAccessible(method); method.invoke(target, getResourceToInject(target, requestingBeanName));

//将PropertyValues应用给bean applyPropertyValues(beanName, mbd, bw, pvs);

//预检查和准备

//重复解析的提前返回

//BeanDefinitionValueResolver的初始化需要传入一个TypeConverter，而这个TypeConverter是spring中内部用于 //类型转换的核心api。简单来说，使用TypeConverter可以将一个`String类型的数据，转换为特定的所需要的类型的数据。 //而BeanDefinitionValueResolver就利用TypeConverter，完成对bean实例中需要注入的属性值进行解析，并适配 //为bean所需要的类型（如String->int，依赖的bean的名称转为实际bean的引用） BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

//类型转换（不是重点）

//把pvs中的属性值全部应用到bean对象中。 bw.setPropertyValues(new MutablePropertyValues(deepCopy));

//此时bean中的属性都是齐全的了 exposedObject = initializeBean(beanName, exposedObject, mbd);

//执行aware回调 invokeAwareMethods(beanName, bean);

//如果bean实现了BeanNameAware，则强转后调用setBeanName方法注入bean的名称

//如果bean实现了BeanClassLoaderAware，则强转后调用setBeanClassLoader方法注入当前的classLoader

//如果bean实现了BeanFactoryAware，则强转后调用setBeanFactory方法注入BeanFactory

//执行BeanPostProcessor的前置回调 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

InitDestroyAnnotationBeanPostProcessor实现类

//findLifecycleMetadata方法把标注了@PostConstruct 和 @PreDestroy的方法都提取出来，所以这里就相当于回调@PostConstruct //标注的方法 LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass()); try { metadata.invokeInitMethods(bean, beanName); }

ApplicationContextAwareProcessor实现类

由此我们可以先得出一个结论：BeanFactory 的注入时机比 ApplicationContext 早。

//执行生命周期回调 invokeInitMethods(beanName, wrappedBean, mbd);

//回调InitializingBean的afterPropertiesSet方法 ((InitializingBean) bean).afterPropertiesSet();

//回调init-method方法（同样是反射调用） invokeCustomInitMethod(beanName, bean, mbd);

//执行BeanPostProcessor的后置回调 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

AbstractAutoProxyCreator实现类

//创建代理对象 return wrapIfNecessary(bean, beanName, cacheKey);

ApplicationListenerDetector实现类

这个 ApplicationListenerDetector它用来关联所有的监听器引用。同样的，监听器在创建的时候，也需要 ApplicationListenerDetector 把这些监听器挂进 ApplicationContext 中，这样这些监听器才可以被事件广播器使用。

//注册销毁时的回调（如果一个bean定义的class有实现DisposableBean接口，或者声明了@@PreDestroy注解，或者声明了 // destroy-method方法，则会在doCreateBean的方法最后一步，注册一个销毁bean的回调钩子） try { registerDisposableBeanIfNecessary(beanName, bean, mbd); }

//不是原型bean，且有定义销毁类型的方法

//处理特殊的scope

//原型bean的初始化，直接调用createBean

//处理自定义的scope

//类型强转前的检查

//初始化的最后阶段

//12、完成容器的创建工作 finishRefresh();

//清楚上下文级别的资源缓存 clearResourceCaches();

//为当前ApplicationContext初始化一个生命周期处理器 initLifecycleProcessor();

无论 BeanFactory 中有没有 LifecycleProcessor ，它都会保证最终容器中会有，注意它的实现类是 DefaultLifecycleProcessor

//将refresh的动作传播到生命周期处理器 getLifecycleProcessor().onRefresh();

startBeans(true); this.running = true;

//广播事件 publishEvent(new ContextRefreshedEvent(this));

start()

close()

doClose();

//广播 ContextClosedEvent 事件 publishEvent(new ContextClosedEvent(this));

//销毁bean destroyBeans();

//获取到 ApplicationContext 内部的 BeanFactory ，让它去销毁所有的单实例 bean 。 getBeanFactory().destroySingletons();

DefaultListableBeanFactory实现类

super.destroySingletons(); //清空单实例bean的名称 this.manualSingletonNames.clear(); // 清空“类型到 name ” 的映射。（ // allBeanNamesByType 中保存了 bean 的类型包含的所有 bean ，如 Person 类型的 bean 在 IOC 容器中包含 master 和 admin ） clearByTypeCache();

DefaultSingletonBeanRegistry实现类

//销毁所有单实例bean for (int i = disposableBeanNames.length - 1; i >= 0; i--) { //重载的 destroySingleton(beanName) destroySingleton(disposableBeanNames[i]); }

//此处会处理掉BeanFactory中设计的用于处理bean循环依赖的三级缓存 removeSingleton(beanName);

//回调 bean 的销毁动作<div>destroyBean(beanName, disposableBean); </div>

//在销毁一个 bean 时，如果它有依赖其它的 bean ，则首要目标不是销毁自己，而是先销毁那些依赖的 bean ，递归销毁

//自定义bean销毁方法的回调<div>bean.destroy(); </div>

//回调DestructionAwareBeanPostProcessor //此处会有执行@PreDestoty注解标注的方法

//回调DisposableBean接口的destroy方法 ((DisposableBean) bean).destroy();

//回调自定义的destroy-method方法

//处理bean中的bean

//销毁依赖的bean

/清空一切缓存

//关闭 BeanFactory ，实际上更接近于 “销毁” ，因为原来的 BeanFactory 无论如何都无法继续用了。 closeBeanFactory();

AbstractRefreshableApplicationContext实现类