spring源码-导读与进阶

 

源码读了很多次，总有些地方记得不清楚，每次用到的时候总是要从根目录找下去，这篇文章主要使用层级结构记录spring中主要类以及使用的具体位置，方便查找与理解

一、Spring 源码流程的整体过程

obtainFreshBeanFactory->
            beanDefinitionReader,   documentLoader 读取配置文件
            parseBeanDefinitions->
                                    parseDefaultElement->alias、beans、
                                            import(resource , 重新加载配置文件的逻辑)
                                            bean(singleton,scope , abstract , lazy-init,autowire  , depends-on , autowire-candidate,primary  , init-method , destroy-method , factory-method , factory-bean )
                                                meta标签，lookup-method、replaced-method、constructor-arg、property、qualifier、
                                      parseCustomElement  ->   根据加载的SPI机制对应的信息进行信息加载
            最后生成：BeanDefinitionHolder(beanDefinition, beanName, aliasesArray)
  

 

当含有component-scan配置中含有(annotation-config)的时候就会注册：

ComponentScanBeanDefinitionParser 
        -> registerComponents
      ->  AnnotationConfigUtils->
                ConfigurationClassPostProcessor
                        ->registerAnnotationConfigProcessors
                            ->postProcessBeanDefinitionRegistry
                           ->processConfigBeanDefinitions
                           ->isFullConfigurationClass（）
                                    ->isFullConfigurationCandidate（判断类中是否存在Configuration注解）
                                    ->isLiteConfigurationCandidate(判断类中是否有：Component，ComponentScan ，Import ，ImportResource，Bean对应注解 )
                                    -> 只要存在上面对应配置注解则BeanDefinition设置对应的标识
                                           ->PropertySources（资源文件加载，并处理变量）
                                            ->ComponentScans （扫描注解）
                                            ->Import (循环不断加载Import对应的类) 
                                                                    ->如果类上有ImportSelector则 实例化ImportSelector->执行selector.selectImports-> 然后重复执行这个引入过程 processImports
                                                                     如果是:ImportBeanDefinitionRegistrar,则注册到ConfigrationClass的类的集合中 （最终都会放到这个集合里面）   
                                                                     否则，当做一般的Configuration来处理（正常解析内部的方法如带有Bean注解的方法），
                                                                     那parse方法过后通过this.reader.loadBeanDefinitions统一将所有的ImportBeanDefinitionRegistrar进行执行
 
                                            -> ImportResource  资源导入
                                            -> Bean 注解的方法
 
 
                    Component/PropertySources/PropertySource/ComponentScans/ImportResource
            AutowiredAnnotationBeanPostProcessor - >Autowired ->反射注入对象
            CommonAnnotationBeanPostProcessor  -> Resource/PostConstruct/PreDestroy注解处理
            EventListenerMethodProcessor-> EventListener注解处理
DefaultEventListenerFactory 

 

 

 

prepareBeanFactory->

 

            注册：ApplicationContextAwareProcessor

 

           EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware

 

            ApplicationListenerDetector->收集所有的ApplicationListener

 

            注册getEnvironment、systemProperties、systemEnvironment

 

 

 

执行所有的Processors
     两个扩展方法，自己可以实现接口进行扩展对已经注册完成的BeanDefine进行修改和新增(
invokeBeanDefinitionRegistryPostProcessors，
invokeBeanFactoryPostProcessors
)
 
 
invokeBeanFactoryPostProcessors-> 执行前面已经注册过的Processor
        currentRegistryProcessors(存放ConfigurationClassPostProcessor)
            ConfigurationClassPostProcessor（BeanDefinitionRegistryPostProcessor子类）
                invokeBeanDefinitionRegistryPostProcessors->processConfigBeanDefinitions-》
                    isFullConfigurationCandidate-> Configuration
                    isLiteConfigurationCandidate-> Component/ComponentScan/Import/ImportResource
                            configCandidates存放满足上面2个条件的对象（自己写的带有注解的类）
                ConfigurationClassParser——>Component ,PropertySources,ComponentScans , ComponentScan 
                                                  ->@Import(processImports) ,selector.selectImports代码不断深入循环处理 ,如果是      ImportBeanDefinitionRegistrar则(类会放到集合中)，如果是Configration则，直接注册内                                                             部的bean
                                                ->  @ImportResource
                     
 
                           -> retrieveBeanMethodMetadata 处理Bean注解
                                                -> 注册
        reader.loadBeanDefinitions->  执行上面扫描到的ImportBeanDefinitionRegistrar接口
 
 
  1.  判断beanFactory是否为BeanDefinitionRegistry  
  2. 循环ApplicationContext中的beanFactoryPostProcessors列表对象
  3. 查找类型为：BeanDefinitionRegistryPostProcessor的类放到registryProcessors
  4. 查找BeanFactory中的类，如果为BeanDefinitionRegistryPostProcessor则放到registryProcessors
  5. 排序执行registryProcessors集合中的对象（ 主要有ConfigurationAnnotationProcessor，会扫描和处理所有的注解）
  6. 重新执行4、5步骤（步骤5中可能有添加进来的对象，这个步骤会排除4中已经执行的Processors）
  7. 再次执行4、5步骤的代码（排除已经执行的）
  8. beanFactory中获取所有类型为BeanFactoryPostProcessor的数据（ EventListenerProcessor和ConfigurationAnnotationProcessor ）
  9. 排除上面的ConfigurationAnnotationProcessor ，然后放到容器中
 
registerBeanPostProcessors-所有与创建实例相关的Processor按照优先级排序，bean实例化的时候会执行
  1.  beanFactory中查到所有类型为BeanPostProcessor的数据
  2. 找到的Processor添加到beanFactory的beanPostProcessors容器中（ AutowiredAnnotationProcessor， CommonAnnotationProcessor）
  3. beanFactory分别找到PriorityOrdered、Ordered、其它种类的Processors
  4. beanPostProcessors中注册所有找到的Processor
initApplicationEventMulticaster() ->初始化applicationEventMulticaster
registerListeners()->注册监听器，主要是将一些Listener注册到applicationEventMulticaster中
  
finishBeanFactoryInitialization - 初始化所有非懒加载的 单例对象 ->preInstantiateSingletons
             ->   getBean -> doGetBean
  1.  查询 对象singletonObjects   中是否已经存在
  2. singletonsCurrentlyInCreation 中是否存在
  3. prototypesCurrentlyInCreation 对象中是否存在
  4. 判断当前类是否有父类，并且包含在BeanDefinition中
  5. 判断如果没有在alreadyCreated中，则mergedBeanDefinitions中删除，alreadyCreated中添加
  6. 判断是否为单例-一下是单例的创建步骤
  7. getSingleton中判断对象是否在singletonObjects中
  8. beforeSingletonCreation，判断不在inCreationCheckExclusions并且不在singletonsCurrentlyInCreation
  9. createBean -> 
  1. resolveBeforeInstantiation-> 对象创建前创建代理
  2. doCreateBean ->  populateBean initializeBean(aop的入口)
  • createBeanInstance -> obtainFromSupplier、instantiateUsingFactoryMethod(工厂方法)、autowireConstructor(autowire修饰的构造函数)、instantiateBean（无参构造函数）
  • 执行MergedBeanDefinitionPostProcessors-> applyMergedBeanDefinitionPostProcessors->postProcessMergedBeanDefinition主要包括 CommonAnnotationBeanPostProcessor(查找所有Resource注解修饰的方法和属性)、 AutowiredAnnotationBeanPostProcessor(查找类中Autowired字段和方法)、InitDestroyAnnotationBeanPostProcessor（ @PostConstruct、 @PreDestory）等,作用收集信息
  • populateBean参数注入->
  1. autowire现根据名称在根据类型注入
  2. 执行InstantiationAwareBeanPostProcessor主要是对属性Value的注入
  • initializeBean初始化Bean对象
  1. 初始对象执行applyBeanPostProcessorsBeforeInitialization            
  2. 如果实现了接口InitializingBean，则执行对应会方法（对象创建以后调用实现这个接口的方法）
  3. 执行初始化方法：invokeCustomInitMethod( 注解上配置的的init方法 )
  4. 执行所有初始化方法后需要执行的PostProcessor-> applyBeanPostProcessorsAfterInitialization（动态代理的Processor会执行），代理条件：引入AbstractAutoProxyCreator类的子类则会走到代理入口
  • 从三个缓存中获取数据对象：singletonObjects、earlySingletonObjects、singletonFactories
  • 注册类的销毁方法：registerDisposableBeanIfNecessary
 
  1. 判断对象是否为mbd.isPrototype
  2. doCreateBean创建一个bean
  3.  新创建的对象放到ThreadLocal中
  4. 如果不是单例，也不是prototype类型的则可能是自定义scope（可以自定义Scope，然后实现里面的创建类的工厂）
 
            
 
创建类的动态代理
@EnableAspectJAutoProxy-> 
            @Import(AspectJAutoProxyRegistrar.class)->执行类中的registerBeanDefinitions
            ->AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary
            ->AnnotationAwareAspectJAutoProxyCreator注册到BeanDefinitionRegistry
            ->proxyTargetClass/exposeProxy两个属性
 
Bean创建成功->initializeBean(初始化bean)-> applyBeanPostProcessorsAfterInitialization
                    
  1.  ->processor.postProcessAfterInitialization
  1. （如果启动了AspectJ则会执行AbstractAutoProxyCreator中的方法）
  2. 如果启用了事务则会执行：AbstractAutoProxyCreator.postProcessAfterInitialization（代理入口）
  3. 查找该bean对应的advice-> getAdvicesAndAdvisorsForBean->findEligibleAdvisors->findCandidateAdvisors(实现了Advisor接口的类，其中事务就有自己的这个类)->findAdvisorsThatCanApply(查找匹配当前对象的Advisor，根据配置的信息)
  4. 创建代理工厂ProxyFactory（ProxyConfig的子类）
  •    wrapIfNecessary  -> createProxy
  •  buildAdvisors 构建Advisor集合
  • proxyFactory 创建代理工厂对象，并将Advisor和代理对象添加到proxyFactory中
  • proxyFactory.getProxy 得到代理对象
  • proxyFactory-> createAopProxy->主要是创建InvocationHandler对象
  1.  拿到DefaultAopProxyFactory，
  2.  调用createAopProxy(this)，参数this为proxyFactory的父类AdvisedSupport 
  3. 创建JdkDynamicAopProxy对象（实现了InvocationHandler）
  • 创建代理对象JdkDynamicAopProxy.getProxy(classLoader)（）
  1. 获取对象的接口列表proxiedInterfaces
  2. 创建代理对象：Proxy.newProxyInstance(classLoader, proxiedInterfaces, this)
  1.  得到代理类
  2. 得到InvocationHandler为参数的构造函数
  3. cons.newInstance(new Object[]{h})，参数为实际的InvocationHandler对象
 
 
 
如果是JDK动态代理，则在真实调用的时候会调用到JdkDynamicAopProxy中的invoke方法：
  1.  根据方法和类查找拦截器链   advised.getInterceptorsAndDynamicInterceptionAdvice
  2. 封装拦截器类对象等信息  MethodInvocation invocation = new ReflectiveMethodInvocation
  3. 执行 拦截器链retVal = invocation.proceed();
  4. 执行ReflectiveMethodInvocation 里面  dm.interceptor.invoke(this);即执行对应的拦截器（如：TransactionInterceptor，Aop相关拦截器，缓存拦截器）
  5.  
 
 
 
二、源码中主要的接口使用
 
1）ApplicationContextAwareProcessor类中处理Aware接口进行处理
       ApplicationContextAware 会设置applicationContext对象
       EnvironmentAware 类会收到Environment对象
       EmbeddedValueResolverAware 类会收到StringValueResolver对象
       ResourceLoaderAware 会收到ResourceLoader对象
       ApplicationEventPublisherAware 会收到ApplicationEventPublisher对象
       MessageSourceAware会收到MessageSource对象
    2）ApplicationListenerDetectorApplicationListenerDetector类会收集所有的ApplicationListener对象
 
InitializingBean->对象创建以后会调用这个类的方法
 
 
 
三、主要的扩展接口认识
 
 
四、注解方式的加载流程
  1.  创建  AnnotatedBeanDefinitionReader
  2. 创建  ClassPathBeanDefinitionScanner -> doScan，注册所有的BeanDefinitio
  3. registerAnnotationConfigProcessors 注册Processors
  1. ConfigurationClassPostProcessor/AutowiredAnnotationBeanPostProcessor
  2. CommonAnnotationBeanPostProcessor
  3. DefaultEventListenerFactory
  •  refresh方法-同xml处理一样
 
五、事务注解
  1.  @EnableTransactionManagement （这个注解在执行ConfigBeanPosProcessor时候执行的）
  2. 导入 TransactionManagementConfigurationSelector -> 执行selectImports
  3. AutoProxyRegistrar ->registerBeanDefinitions->registerAutoProxyCreatorIfNecessary->注册InfrastructureAdvisorAutoProxyCreator（对象创建以后，使用这个进行创建对象的代理，父类为AbstractAutoProxyCreator）
  4. ProxyTransactionManagementConfiguration  -> 主要实例化：(TransactionInterceptor拦截后执行哪些代码、PointCutAdvisor主要拦截过滤)
 
 
    事务代理创建流程：
  1.      bean创建完成->initializeBean(初始化方法)->applyBeanPostProcessorsAfterInitialization（执行后置处理）->processor.postProcessAfterInitialization
  2. AbstractAutoProxyCreator.postProcessAfterInitialization（子类InfrastructureAdvisorAutoProxyCreator被注册）
  3. wrapIfNecessary(对象，bean名称，缓存的key)对象包装（创建代理）
  4. getAdvicesAndAdvisorsForBean（找到所有advisor然后进行过滤-这里包括事务注解注册的PointCutAdvisor，然后满足当前对象需要的advisor）
  5. createProxy->buildAdvisors(独有的Advisor+common的Advisor)
  6. createAopProxy()->JdkDynamicAopProxy(config)(实现了InvocationHandler，并且内部持有Advisor)
  7. AopProxyUtils.completeProxiedInterfaces 查找对应的接口
  8. Proxy.newProxyInstance
  1. 使用InvocationHandler构建构造函数
  2. 使用InvocationHandler对象为参数来创建对象
 
 
 
 
 
 
 
 
 

 

posted @ 2020-12-17 18:03  码来  阅读(242)  评论(0)  编辑  收藏  举报