spring源码解析思维导图模板_ProcessOn思维导图、流程图

Sping getBean加载源码解析

BeanFactory和FactoryBean的区别

AbstractBeanFactory.getBean

doGetBean

1、transformedBeanName

2、DefaultSingletonBeanRegistry.getSingleton（循环依赖）

1、this.singletonObjects.get(beanName)

2、singletonObject == null && isSingletonCurrentlyInCreation(beanName)

3、this.earlySingletonObjects.get(beanName)

4、singletonObject == null && allowEarlyReference

5、this.singletonFactories.get(beanName);

6、后续操作

3、getObjectForBeanInstance，FactoryBean创建bean实例

1、getCachedObjectForFactoryBean(beanName)

2、getObjectFromFactoryBean(factory, beanName, !synthetic);

1、factory.isSingleton() && containsSingleton(beanName)

2、doGetObjectFromFactoryBean(factory, beanName);

3、beforeSingletonCreation(beanName);

4、postProcessObjectFromFactoryBean(object, beanName);

5、afterSingletonCreation(beanName);

4、getParentBeanFactory

5、markBeanAsCreated

6、getMergedLocalBeanDefinition

7、checkMergedBeanDefinition

8、mbd.getDependsOn()

9、isDependent(beanName, dep)

10、DefaultSingletonBeanRegistry.registerDependentBean(dep, beanName);

12、getBean(dep)

13、DefaultSingletonBeanRegistry.getSingleton 放入一级缓存

14、AbstractAutowireCapableBeanFactory.createBean 创建Bean源码解析

15、adaptBeanInstance

1、TypeConverterSupport.convertIfNecessary

Spring createBean源码解析

AbstractAutowireCapableBeanFactory.createBean

1、resolveBeanClass(mbd, beanName);

2、mbdToUse.prepareMethodOverrides();

3、resolveBeforeInstantiation(beanName, mbdToUse);

1、applyBeanPostProcessorsBeforeInstantiation()

2、applyBeanPostProcessorsAfterInitialization()

4、doCreateBean(beanName, mbdToUse, args)

1、BeanWrapper instanceWrapper = null;

2、this.factoryBeanInstanceCache.remove(beanName)

3、createBeanInstance(beanName, mbd, args);

1、resolveBeanClass

2、AbstractBeanDefinition.getInstanceSupplier

3、instantiateUsingFactoryMethod

4、autowireConstructor

4、instantiateBean

1、getInstantiationStrategy().instantiate(mbd, beanName, parent);

2、new BeanWrapperImpl(beanInstance);

3、initBeanWrapper(bw);

4、instanceWrapper.getWrappedInstance()

5、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

1、AutowiredAnnotationBeanPostProcessor

1、postProcessMergedBeanDefinition

2、findAutowiringMetadata

3、buildAutowiringMetadata

4、findAutowiredAnnotation

2、CommonAnnotationBeanPostProcessor

6、addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 添加三级缓存

7、populateBean(beanName, mbd, instanceWrapper); bean属性填充

1、InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation

2、autowireByName

1、unsatisfiedNonSimpleProperties

2、containsBean

3、getBean(propertyName)

4、pvs.add(propertyName, bean);

5、registerDependentBean(propertyName, beanName);

3、autowireByType

1、getCustomTypeConverter()

2、unsatisfiedNonSimpleProperties

3、BeanUtils.getWriteMethodParameter

PropertyDescriptor.getWriteMethod

4、resolveDependency(desc, beanName, autowiredBeanNames, converter);

5、registerDependentBean(autowiredBeanName, beanName);

4、applyPropertyValues

8、initializeBean(beanName, exposedObject, mbd);

1、invokeAwareMethods

2、applyBeanPostProcessorsBeforeInitialization

BeanPostProcessor.postProcessBeforeInitialization bean初始化前扩展点

3、invokeInitMethods

4、applyBeanPostProcessorsAfterInitialization aop创建代理类

BeanPostProcessor.postProcessAfterInitialization bean初始化后扩展点

9、registerDisposableBeanIfNecessary

Spring 循环依赖解决

1、AbstractBeanFactory.doGetBean

1、getSingleton(beanName)

2、AbstractAutowireCapableBeanFactory.doCreateBean

1、mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName)

3、DefaultSingletonBeanRegistry.addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))，放入三级缓存（singletonFactories）

3、populateBean(beanName, mbd, instanceWrapper);

AbstractAutowireCapableBeanFactory.applyPropertyValues

BeanDefinitionValueResolver.resolveValueIfNecessary

AbstractBeanFactory.getBean(resolvedName); 回调，获取暴露的三级缓存

3、DefaultSingletonBeanRegistry.getSingleton(beanName, false)

3、DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory<?> singletonFactory)

addSingleton(String beanName, Object singletonObject)，放入一级缓存（singletonObjects）

Spring MVC源码解析

ContextLoaderListener web application启动时创建一个Spring的ROOT上下文。

initWebApplicationContext

1、判断ServletContext是否已存在SpringMVC根上下文，存在则报错

2、createWebApplicationContext 创建上下文根容器

利用反射加载类

3、loadParentContext(servletContext); 如果存在着父容器，则加载父容器

4、configureAndRefreshWebApplicationContext 加载并刷新上下文环境，也就是初始化Spring容器

1、sc.getInitParameter(CONFIG_LOCATION_PARAM)

2、wac.refresh(); 刷新父容器

5、将创建完的根上下文绑定到ServletContext

Servlet初始化

HttpServletBean.init

1、从ServletConfig中解析出Servlet配置中的init-param参数，并封装到PropertyValues中

2、将当前的servlet包装为一个BeanWrapper，从而能够以Spring的方式对init-param的值进行注入

3、initServletBean 调用子类FrameworkServlet来实例化servletBean

FrameworkServlet.initServletBean

1、initWebApplicationContext 初始化Web应用上下文对象

1、WebApplicationContextUtils.getWebApplicationContext(getServletContext()) 从ServletContext对象中获取到Spring Root上下文对象

2、cwac.setParent(rootContext) 设置子容器和父容器关系的关键代码.

3、configureAndRefreshWebApplicationContext 配置并刷新SpringWeb上下文对象

1、wac.setServletContext 设置子容器的属性

2、wac.addApplicationListener 传入ContextRefreshListener事件

3、wac.refresh() 刷新完成之后，Controller，ViewResolver以及HandlerMapper将会加入到IOC容器中

4、onRefresh(wac) 通过子类去初始化SpringMVC的九大组件

2、initFrameworkServlet 扩展点

DispatcherServlet.onRefresh

initStrategies

1、initMultipartResolver 文件上传解析器

2、initLocaleResolver 初始化国际化解析器组件

3、initThemeResolver 初始化主题解析器

4、initHandlerMappings 处理器映射器(url和Controller方法的映射)

BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false) 查找映射Mapping

this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values()); 查找出的mapping放在handlerMappings属性上

context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class)

5、initHandlerAdapters 处理器适配器(实际执行Controller方法)

6、initHandlerExceptionResolvers 处理器异常解析器

7、initRequestToViewNameTranslator 初始化视图名称转换器组件

8、initViewResolvers 视图解析器

9、initFlashMapManager 初始化FlashMap管理器组件，用来在重定向过程中携带数据

<mvc:annotation-driven /> 解析映射关系

RequestMappingHandlerMapping

afterPropertiesSet

processCandidateBean 解析@Controller、@RequestMapping注解

1、isHandler(beanType) 判断是否有@Controller注解

2、getMappingForMethod 获取@RequestMapping注解的方法，设置prefix

3、registerHandlerMethod 封装方法为可执行的Method，注册到URL-Controller方法映射表

pathLookup.add(path, mapping) 添加url->mapping的映射

RequestMappingHandlerAdapter 参数处理解析

afterPropertiesSet

1、getDefaultArgumentResolvers 默认的参数解析器，包括@RequestParam @RequestBody

2、getDefaultInitBinderArgumentResolvers InitBinder解析器

3、getDefaultReturnValueHandlers 初始化返回值处理器 @RespsonBody

spring mvc前端控制器请求流程

DispatcherServlet.doService

doDispatch(request, response); 调用doDispatch方法来处理请求，SpringMVC用来处理请求的核心方法.

1、checkMultipart 用来判断请求是否为文件上传请求.

2、getHandler 根据请求查找请求处理器

3、noHandlerFound 没有找到返回404

4、getHandlerAdapter(mappedHandler.getHandler()) 查找当前请求处理器对应的适配器

5、applyPreHandle 处理请求之前，执行拦截器中配置的方法，获取到配置的所有拦截器，循环遍历，依次执行

6、ha.handle 执行SpringMVC中真实对应的业务方法

7、applyDefaultViewName 查找视图路径

8、applyPostHandle 处理请求之后执行拦截器方法

9、processDispatchResult 将处理完成之后的结果进行页面视图渲染。比如：跳转到Jsp页面. 处理全局异常

processHandlerException 处理异常

resolver.resolveException 异常处理器

@RequestBody和@ResponseBody 理解spring参数解析

HttpMessageConverter

HandlerMethodArgumentResolver 参数解析器接口

HandlerMethodReturnValueHandler 返回值处理器接口

ServletInvocableHandlerMethod.invokeAndHandle

InvocableHandlerMethod.invokeForRequest 执行请求，解析入参

getMethodArgumentValues 解析方法的入参，已

循环所有参数

resolvers.supportsParameter 获取支持解析的参数类型，不支持抛异常

this.resolvers.resolveArgument 解析参数

getArgumentResolver 获取参数解析器

resolver.resolveArgument 获取到具体的参数解析器，解析参数

readWithMessageConverters 通过HttpMessageConverter读取HTTP报文

converter.canRead 判断转换器是否支持参数类型

((HttpMessageConverter<T>) converter).read read方法执行HTTP报文到参数的转换

doInvoke 执行反射调用

handleReturnValue 返回值处理

selectHandler 查找参数解析器

handleReturnValue 执行返回值处理

converter.canWrite 判断是否支持返回值类型

((HttpMessageConverter) messageConverter).write 执行返回值转换

spring mvc统一异常处理

ExceptionHandlerExceptionResolver

afterPropertiesSet

initExceptionHandlerAdviceCache

1、ControllerAdviceBean.findAnnotatedBeans(getApplicationContext()) 找到所有@ControllerAdvice注解

2、ExceptionHandlerMethodResolver(beanType) 找到所有@ExceptionHandler注解的方法，放到map缓存中

3、exceptionHandlerAdviceCache.put(adviceBean, resolver)

getExceptionHandlerMethod 根据exceptionHandlerAdviceCache这个找到具体需要处理异常的方法

doResolveHandlerMethodException处理异常

1、getExceptionHandlerMethod 根据HandlerMethod和exception获取异常处理的Method

2、exceptionHandlerMethod.invokeAndHandle 执行异常处理方法

spring boot源码解析

spring-boot-dependencies parent实现依赖管理

spring boot主启动类注解

@SpringBootApplication 说明这个类是SpringBoot的主配置类

@SpringBootConfiguration 标注在某个类上，表示这是一个Spring Boot的配置类

@EnableAutoConfiguration 通知SpringBoot开启自动配置功能

@AutoConfigurationPackage

@Import(AutoConfigurationPackages.Registrar.class) 默认将主配置类(@SpringBootApplication)所在的包及其子包里面的所有组件扫描到Spring容器中

register(registry, new PackageImport(metadata).getPackageName())

AutoConfigurationImportSelector 导入组件的选择器

getCandidateConfigurations

spring boot 启动流程源码解析

1、SpringApplication 构造方法

1、设置主启动类，属性存储起来

2、deduceFromClasspath 设置应用类型是Standard还是Web

3、getSpringFactoriesInstances 获取spring工厂BootstrapRegistryInitializer

SpringFactoriesLoader.forDefaultResourceLocation

4、setInitializers 设置初始化器ApplicationContextInitializer

5、setListeners 设置监听器ApplicationListener

6、deduceMainApplicationClass 获取main方法所在类

2、run 方法

1、createBootstrapContext 创建一个DefaultBootstrapContext对象

2、configureHeadlessProperty 设置headless模式

3、getRunListeners 获取所有监听器 spring观察者模式重要案例

EventPublishingRunListener 事件推送监听器

SimpleApplicationEventMulticaster 广播器

multicastInitialEvent

refreshApplicationListeners 刷新监听器，并清除缓存，发布事件前调用

this.initialMulticaster.multicastEvent 发布事件

getApplicationListeners 通过事件类型ApplicationStartingEvent获取对应的监听器

invokeListener 发布事件给所有监听器（存在异步或同步）

doInvokeListener

onApplicationEvent

4、prepareEnvironment 根据SpringApplicationRunListeners以及参数来准备环境

listeners.environmentPrepared(environment) 发布环境已准备事件

EnvironmentPostProcessorApplicationListener 加载配置的监听器，properties 和yml文件都是其内部类所加载

5、printBanner 启动打印Banner.txt

6、createApplicationContext 创建Spring容器

7、prepareContext spring容器前置处理

1、context.setEnvironment 设置容器环境

2、postProcessApplicationContext 执行容器后置处理

3、applyInitializers 执行容器中的ApplicationContextInitializer

4、listeners.contextPrepared 发送容器已经准备好的事件，通知各监听器

5、registerSingleton("springApplicationArguments",
applicationArguments) 注册启动参数

6、getBeanFactory().registerSingleton("springBootBanner", printedBanner) 设置banner

7、load 加载启动类

8、listeners.contextLoaded 发布容器已加载事件

8、refreshContext 刷新容器

spring refresh 刷新容器

9、afterRefresh spring容器后置处理

10、listeners.started 发出结束执行的事件

11、this.callRunners 执行Runners 启动时初始化数据

ApplicationRunner

CommandLineRunner

spring 中使用观察者设计模式

ApplicationEvent 继承自JDK的 EventObject ，所有事件都要继承它,也就是被观察者

ApplicationEventPublisher、ApplicationEventMulticaster 发布事件

ApplicationListener 承JDK的 EventListener ，所有监听者都继承它，也就是我们所说的观察者，也可以使用注解 @EventListener

spring boot 自动配置

load

spring boot自定义starter

1、新建Module {模块名}-spring-boot-starter

2.编写自动配置类AutoConfig

3、编写spring.factories文件加载自动配置类

4、自定义starter，pom配置

5、打包安装 install

6、将打包文件上传至私服，或配置本地仓库

7、其它项目pom引用

spring boot内置servlet容器

1、默认tomcat

2、切换容器

3、onRefresh 启动servlet

ServletWebServerApplicationContext.createWebServer

spring boot 如何实现spring mvc

1、自定义Servlet、Filter、Listener

ServletRegistrationBean

FilterRegistrationBean

ServletListenerRegistrationBean

DispatcherServletAutoConfiguration DispatcherServlet注解配置类

spring boot事务源码解析

DataSourceTransactionManagerAutoConfiguration 事务注解自动配置类创建DataSourceTransactionManager并注入Spring容器中

@EnableTransactionManagement 开启事务

spring boot集成aop

AopAutoConfiguration aop AOP自动配置类

spring boot 集成 mybatis

MybatisAutoConfiguration mybatis自动配置类

Spring refresh 全过程源码解析

refresh全流程解析

ClassPathXmlApplicationContext

super（）

AbstractRefreshableConfigApplicationContext.setConfigLocations 解析xml文件名称

1、resolvePath，解析路径

2、AbstractPropertyResolver.resolveRequiredPlaceholders

3、AbstractPropertyResolver.doResolvePlaceholders

4、PropertyPlaceholderHelper.parseStringValue

AbstractApplicationContext.refresh 刷新bean容器

startupShutdownMonitor 锁对象

1、prepareRefresh() 刷新容器准备

1、记录容器的状态和启动时间

2、initPropertySources() 扩展点

3、getEnvironment().validateRequiredProperties()

4、初始化监听器

2、obtainFreshBeanFactory() 获取Bean工厂，解析xml文件

1、AbstractRefreshableApplicationContext.refreshBeanFactory()

1、destroyBeans

2、AbstractXmlApplicationContext.loadBeanDefinitions

1、new XmlBeanDefinitionReader(beanFactory)

2、initBeanDefinitionReader 扩展点

3、customizeBeanFactory(beanFactory);

4、loadBeanDefinitions(beanDefinitionReader)

1、AbstractBeanDefinitionReader.loadBeanDefinitions(String location)

2、AbstractBeanDefinitionReader.loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources)

3、XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource)

4、XmlBeanDefinitionReader.doLoadBeanDefinitions

1、doLoadDocument

1、getValidationModeForResource

2、DefaultDocumentLoader.parse

2、registerBeanDefinitions

1、DefaultBeanDefinitionDocumentReader.registerBeanDefinitions

2、doRegisterBeanDefinitions

3、createDelegate(getReaderContext(), root, parent)

4、profile配置读取，切换环境

5、preProcessXml(root) 扩展点

6、parseBeanDefinitions

1、parseDefaultElement(ele, delegate) spring定义标签解析

1、importBeanDefinitionResource(ele);

2、processAliasRegistration(ele);

3、processBeanDefinition(ele, delegate);

1、parseBeanDefinitionElement

2、decorateBeanDefinitionIfRequired

3、BeanDefinitionReaderUtils.registerBeanDefinition

2、delegate.parseCustomElement 自定义标签解析

1、getNamespaceURI

2、this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)

1、getHandlerMappings

2、namespaceHandler.init() 重要示例AOP、MVC标签解析

3、handler.parse(ele, new ParserContext(this.readerContext, this, containingBd))

7、postProcessXml(root); 扩展点

3、prepareBeanFactory bean工厂初始化，设置相关属性

1、setBeanExpressionResolver SPEL解析器

2、addPropertyEditorRegistrar 添加属性编辑注册器

3、addBeanPostProcessor 添加Bean后置处理器

4、ignoreDependencyInterface(EnvironmentAware.class)

5、ignoreDependencyInterface(EmbeddedValueResolverAware.class);

6、ignoreDependencyInterface(ResourceLoaderAware.class) 资源加载器

7、ignoreDependencyInterface(ApplicationEventPublisherAware.class) 事件发布器

8、ignoreDependencyInterface(MessageSourceAware.class) 消息资源

9、ignoreDependencyInterface(ApplicationContextAware.class) 应用上下文

10、addBeanPostProcessor(new ApplicationListenerDetector(this)) 增加bean后置处理器

4、postProcessBeanFactory 空实现，扩展点

5、invokeBeanFactoryPostProcessors 执行beanFactory的后置处理器，扩展点

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors

1、invokeBeanDefinitionRegistryPostProcessors

BeanDefinitionRegistryPostProcessor 实现了bean的动态注入，新增额外的注册解析。最先执行

ConfigurationClassPostProcessor

2、invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor 通过获取beanFactory可以修改beanFactory中的bean信息，如修改bean的属性值、实现bean的动态代理

PlaceholderConfigurerSupport ，解析$符号，${person.age}

PropertyOverrideConfigurer

CustomEditorConfigurer 自定义属性解析器

6、registerBeanPostProcessors 注册所有BeanPostProcessors，getBean时会调用

PostProcessorRegistrationDelegate.registerBeanPostProcessors

7、initMessageSource 初始化消息源

8、initApplicationEventMulticaster 初始化事件派发器，用来发布事件

ApplicationEventMulticaster

SimpleApplicationEventMulticaster.multicastEvent

9、onRefresh SpringBoot也是在该步骤中启动内嵌Tomcat容器的

10、registerListeners 注册监听器

1、AbstractApplicationEventMulticaster.addApplicationListener

2、getBeanNamesForType(ApplicationListener.class, true, false);

3、AbstractApplicationEventMulticaster.addApplicationListenerBean

4、getApplicationEventMulticaster().multicastEvent 将事件传递给所有匹配的监听器。

ApplicationEvent 是所有Spring事件的基类

ApplicationListener 是一个泛型接口，用于处理特定类型的事件

ApplicationEventPublisher 是事件发布的核心接口

11、finishBeanFactoryInitialization 初始化所有剩余的单实例Bean(没有使用懒加载的Bean).整个Spring IOC的核心

12、finishRefresh 发布事件

Spring aop源码解析

aop调用流程

AbstractAutowireCapableBeanFactory.initializeBean 初始化Bean时创建aop增强

AbstractAutoProxyCreator.postProcessAfterInitialization AOP代理生成类

1、wrapIfNecessary

2、getAdvicesAndAdvisorsForBean 如果存在增强方法则创建代理

3、createProxy 创建代理

配置文件，aop解析流程

AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary

AnnotationAwareAspectJAutoProxyCreator

aop获取增强器,注解式和配置式

getAdvicesAndAdvisorsForBean 如果存在增强方法则创建代理

findCandidateAdvisors 获取所有增强器

1、BeanFactoryAspectJAdvisorsBuilder.buildAspectJAdvisors

2、BeanFactoryUtils.beanNamesForTypeIncludingAncestors 获取所有bean name

3、AbstractAspectJAdvisorFactory.isAspect for循环判断，所有bean是否有Aspect注解

AnnotationUtils.findAnnotation(clazz, Aspect.class) 查找类里是否有指定注解

4、ReflectiveAspectJAdvisorFactory.getAdvisors 解析标记Aspect注解中的增强方法

getAdvisorMethods

getAdvisor

1、getPointcut 获取切点信息

1、AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod

2、aspectJAnnotation.getPointcutExpression() 获取execution

2、InstantiationModelAwarePointcutAdvisorImpl 根据切点信息生成增强类

instantiateAdvice 初始化

ReflectiveAspectJAdvisorFactory.getAdvice 根据不同的类型获取不同的增强器

findAdvisorsThatCanApply 寻找增强器中适用于当前class的增强器

aop 创建代理类

createProxy

proxyFactory.addAdvisors 加入增强器

ProxyCreatorSupport.createAopProxy 获取AOP代理，默认为JDK动态代理

createAopProxy().getProxy(classLoader) 真正创建代理的方法

aop 目标方法和增强方法的执行

ReflectiveMethodInvocation.proceed

1、invokeJoinpoint() 如果所有interceptor执行完了，执行被代理方法

2、dm.interceptor.invoke(this) 如果interceptor没有执行完，执行AOP增强方法

3、((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); 如果Interceptor不是PointCut类型（不是AOP），就直接执行Interceptor里面的增强

Spring @Transactional注解的声明式事物介绍

1、AnnotationDrivenBeanDefinitionParser.parse() 事务注解解析

1、registerTransactionAspect mode="aspectj"

2、AopAutoProxyConfigurer.configureAutoProxyCreator mode="proxy"

1、AopNamespaceUtils.registerAutoProxyCreatorIfNecessary

2、创建AnnotationTransactionAttributeSource类型的Bean

3、创建TransactionInterceptor类型的Bean

4、创建BeanFactoryTransactionAttributeSourceAdvisor类型的Bean

5、将上面AnnotationTransactionAttributeSource类型Bean注入进上面的Advisor

6、将上面TransactionInterceptor类型Bean注入进上面的Advisor

7、将上面三个Bean注册进IOC中

3、TransactionAttributeSourcePointcut

AbstractFallbackTransactionAttributeSource.

1、getTransactionAttribute

2、computeTransactionAttribute

3、findTransactionAttribute

4、TransactionAttribute.parseTransactionAnnotation 解析Transactional注解

SpringTransactionAnnotationParser

Spring @Configuration、@Bean等常用注解源码解析

ConfigurationClassPostProcessor

1、ConfigurationClassUtils.checkConfigurationClassCandidate 判断是否有@Configuration注解

1、metadata.getAnnotationAttributes(Configuration.class.getName())

isConfigurationCandidate

2、configCandidates.sort 多个Java配置类，按@Ordered注解排序

3、ConfigurationClassParser.parse 解析@Congiguration配置类

doProcessConfigurationClass

1、processMemberClasses 递归处理任何成员（嵌套）类

2、processPropertySource 解析@PropertySource注解

3、this.conditionEvaluator.shouldSkip 解析@Conditional注解

4、componentScanParser.parse 解析@CmponentScan注解

1、添加filter

2、scanner.doScan

1、findCandidateComponents(basePackage) //根据basePackage加载包下所有java文件，并扫描出所有bean组件

scanCandidateComponents

isCandidateComponent 按照scanner过滤器过滤，比如配置类本身将被过滤掉，没有@Component等组件注解的类将过滤掉

2、this.scopeMetadataResolver.resolveScopeMetadata 解析@Scope作用域

3、AnnotationConfigUtils.processCommonDefinitionAnnotations 主要是处理Lazy, primary DependsOn, Role ,Description这五个注解

5、processImports 解析@Import注解

6、configClass.addImportedResource 解析@ImportResource注解

7、retrieveBeanMethodMetadata 处理@Bean注解

8、processInterfaces 处理接口中所有添加@Bean注解的方法

4、this.reader.loadBeanDefinitions 加载bean定义信息

NamespaceHandler spring注册解析器，例如AOP、MVC等