springmvc源码范分析说明

最新推荐文章于 2025-03-14 19:49:49 发布

原创最新推荐文章于 2025-03-14 19:49:49 发布 · 200 阅读

0 ·

CC 4.0 BY-SA版权

sprigmvc源码专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了 Spring Boot 应用程序启动过程中容器的创建流程，包括 Bean 的初始化、后置处理器的作用、事件监听器的注册及 Spring 容器刷新的各个阶段。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

spring boot

结构：

类：org.springframework.context.support.AbstractApplicationContext#refresh

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      //创建一个factory
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      //准备bea 上下文的使用，比如
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         //子类重新beanFactory创建预准备工作
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         //执行beanFactoryPostProcessor,beanFactory标准初始化后处理
         //（优先级执行子类BeanFactoryDefinitionRegistyPostPressor）
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         //注册beanPostProcessors，获取BeanPostProcessor类型bean,拦截和创建过程，其中ApplicationListeners
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         //做消息绑定和国际化
         initMessageSource();

         // Initialize event multicaster for this context.
         //初始化事件派发器4
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         //子类重新子类刷新的时候自定义
         onRefresh();

         // Check for listener beans and register them.
         //注册所以监听器 4
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         //初始化剩下的bean
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

分析：

1、spring -context

@enableAspectJAutoProxy 开启AOP功能

@enableAspectJAutoProxy 会给组件注册一个组件

annotationAwareAspectJAutoProxyCreator是一个后置处理器

容器的创建流程

1）、registerBeanPostProcessors() 注册后置处理器，创建annotationAware

2)、finishBeanFactoryInitalization（）初始化剩下的单例bean

1) 创建业务逻辑组件和切面组件

2）annotationAwareAspectJAutoProxyCreator拦截组件创建过程

3）组件创建完之后，判断组件是否需要增强

是：切面通知方法，包装成增强器（advisor）;给业务逻辑组件创建一个代理对象

执行目标方法

1）代理对象执行方法

2）CgilibAopProxy.intercept()

1) 得到目标方法的拦截器（增强器包装成拦截器MethodInterceptor）

2)利用拦截器的链式机制，依次进入每一个拦截器进行执行；

3）效果：

正常执行：前置通知-》目标方法-》后置通知-》返回通知

	  出现异常：前置通知-》目标方法-》后置通知-》异常通知

2、事务

transactional 开启@enableTransationManagement

利用transactionManagementConfigurationSelector給容器导入两个组件：AutoProxyRegistrar,ProxyTransactionManagementConfiguratio

AutoProxyRegistrar

给容器注册一个InfrastructureAdvisorAutoProxyCreator组件

InfrastructureAdvisorAutoProxyCreate利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用代理链

proxyTransactionManagementConfiguration

1)给容器注册事务增强器

1）事务增强注解的信息：annotationTransactionAttributesource解析注解配置

2）事务拦截器：

transationInterceptor:保存事务的属性，事务管理器

他是一个MethodInterceptor;

在目标方法执行时候：

执行拦截器链，

事务拦截器：

1）获取事务属性

2）在获取platformTransactionManager,如果事先没有注册transationManagement,会从容器获取platformTransationManage

3)执行目标方法

如果异常获取事务管理器，利用事务进行管理回滚

如果正常利用事务管理器提交事务

3、扩展

BeanPostProcessor

beean后置处理器，bean前后换进行拦截，实现BeanFactoryProcessor,然后使用注解@component

BeanPostProcessor原理

1）ioc容器创建对象

2）invokeBeanFactoryPostProcessors(beanFactory);

BeanFactoryPostProcessor执行方法：
1)直接冲beanFactory获取类型是BeanFactoryPostProcessor的组件，并执行的方法

2）在初始化创建其他组件前面执行

BeanDefinitionRegistryPostProcessor extend BeanFactoryPostProcessor

在初始化信息之后，在初始化先执行BeanDefinitionRegistryPostProcessor 然后是BeanFactoryPostProcessor

原理：

1)ioc

2)refresh()–>invokeBeanFactoryPostProcessors(beanFactory)

3)从容器中获取invokeBeanDefinitionRegistryPostProcessor组件

1、postBeanDefinitionRegistry()

2、postProessBeanFatory

4、ApplicationListener

applicationListener

public interface ApplicationListener

监听applicationEvent事件

自定义

1）写一个监听器监听事件ApplicationEvent及其子类或者@eventListen

@eventListener

EvnetlistenerMothedProcessor extend smartInitalizingSingleton

2）把监听加入到容器

3）只要容器中有相关事件发布，我们就能监听这个事件

contextRefreshedEvent:容器刷新完，全部加载完bean

contextCloseEvent:关闭容器后发布事件

发布一个事件：

1\创建容器对象：refresh();

2\finishRefresh()容器刷新完

3）publishEvent(new ContextRefreshedEvent)

事件多播器（派发起）

如果没有进行注册initApplictionEventMulticaster（）方法，自动注入到applictioneventMulticaster

容器中那些监听器

1）容器创建对象：refresh()

2)registerListeners();

获取所有监听器，把注册到applicationEvnentMulticaster中

smartInitalizingSingleton原理：

1)ioc容器的创建对象,refresh()

2）finishBeanFactoryInitalization(beanFactory);初始化剩下的单例bean

1\getbean()

2\判断是否是smartInitalizingSingleton类型，调用afterSingletionsInstantiated()

5、spring容器创建过程

容器的创建和刷新refresh()
prepareRefresh():刷新的预处理

1)initPropertySources() ：可以定义一个子类annotationConfigApplicationContext子类

2）getEnvinronment().validateRequiredProperties

3)earlyApplictionEventes
obtainFreshBeanFactotry(),获取beanfactory

1）refreshBeanFactory

prepareBeanFactory(beanFactory)

设置beanFactory的类加载器，解析表达式

添加beanPostProcessor（aplicationContextAwareProcessor）

设置忽略自动装配接口：EnvironmentAware,EmbeddadValueResolverAware,

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);

注解可以解析的自动装载addBeanPostProcessor

添Aspectj

beanfactory注册一些组件environment,systemproperties,SystemEnvironment

postProessBeanFactory （beanFactory）完成bean处理后工作

1)子类重写BeanFactory
invokeBeanFactoryPostProcessor

1）先执行BeanDefinitionRegistryPostProcessor

1\获取beanFinitionRegistryPostProcessor

2\优先级排序PriorityOrdered优先级，postProcessor.postProcessBeanDefinitionRegistry(registry)

3\ordered顺序，放到currentRegistry里面

4、最后执行没有顺序BeanDefinitionRegistry方法

2）在BeanFactoryPostProcessor,
registerBeanPostProcessors

1)beanPostProcessor

2)DestructionAwareBeanPostProcessor

3)InstantiationAwareBeanPostProcessor

4)SmartInstantiationAwareBeanPostProcessor

5)mergedBeanDefinitionPostProcessor(记录到internalPostProcessors)

1\获取beanPostProcess

2|先注册priorityOdered

3\在注册ordered

4\nonOrder

5\mergedDefinitionBeanPostProcessor

6\注册一个applicationListenerDetectory,来拿检查,AplicationListens
initMessageSource

1\或者bean

2\获取看容器中是否有id为messageSource，类型为MessageSource的组件

3\如有赋值给messageSource,如果没有就自己创建一个DelegationMessageSource

messagesource 获取这国际配置文件key值，local区域或者

4）factory,registerSingleton
1. MessageSoruce.getMessage(String code ,Object[] args,String defaultMessage,Local Local)
initApplicationEventMulticaster 事件派发器

1）获取beanfactory ，获取pplicationEventMulticaster
1. 如果获取不到，simpleApplicationEventMulticaster
3）创建applicationEventMulticaster添加到BeanFactory
onRefresh();留给子容器(子类重写方法)
registerListeners();给容器里面将所有项目ApplicationListener进行注册进来1

1）从容器获取所有的applicationListener

2)将每个监听器添加到事件派发器中：

getApplicationEventMulticaster().addApplicationListenerBean();

3)派发之前步骤产生的事件
finishBeanFactoryInitialization初始化剩下的bean

1)beanFactory.preInstantiateSingletons()

是factory，使用factory.getobject

不是，getBean()方法–》doGetBean()->(

doGetBean：
singletonObjects.getSingletion(name)缓存取，取不到，

1、创建：标记防止多线程创建markBeanAsCreate,

2、获取bean的定义信息

3、获取bean依赖的信息获取dependsOn,如有有依赖bean,getBean方式把依赖的创建处理

4、启动单实例的bean,getSIngleton

1)createBean,

2） resolvBeforeInstantiation,让beanPostProcess拦截，提前执行

InstantiationAwareBeanPostProcessor提前执行；触发postprocessBeforeInstantiation()
```
						先出发：InstantiationAware
```
1. 如果前面的instantiationAWareBeanPostProcessor没有返回代理对象调用
4）doCreateBean

1)创建bean历史，createBeanInstance利用工程方法或者对象构造器创建出bean实例

2）applyMergeBeanDefinitionPostProcessor,调用postProcessorMergedBeanDefinition()

3）populateBean【bean属性赋值】

1)赋值前，

1\执行InstantiationAwareBeanPostProcessor类的postProcessAfterInstantiation

2\拿到InstantiationAwareBeanPostProcessor后置处理器， postProcessProPertyValue()

3）赋值后：applyPropertyValue为属性利用setter方法进行赋值

4)[bean初始化]initializeBean

1 執行Aware接口方法,invokeAwaremethod

beanNameAware\beanClassLoaderAware\BeanFactoryAware

2執行後置后置applyBeanPostProcessorsBeforInitalization

3\执行初始化方法invokeInitmethods

1是否initializingBean接口的实现

2、是否初始化

4）初始化applyBeanpostProcessorAfterInitalization
5）
jdk或cgblic创建

1）org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
对象，赋值，初始化
finishRefresh()，ioc创建bean完成

initlifecycleListableBean