SpringBoot源码解读

一、启动流程

0、构造

1
2
3
4
5
6
7
8
9
10
11
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 判断当前应用是JAVA应用，SERVLET应用或REACTIVE应用
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 加载spring.factories中配置的ApplicationContextInitializer实现类
    setInitializers((Collection)getSpringFactoriesInstances
                    (ApplicationContextInitializer.class));
    // 加载spring.factories中配置的ApplicationListener实现类
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 获取main方法所在Class
    this.mainApplicationClass = deduceMainApplicationClass();
}
  • META-INF/spring.factories
1
2
3
4
5
6
7
8
# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
1
SpringApplication#getSpringFactoriesInstances->SpringFactoriesLoader#loadSpringFactories

1、getRunListeners

  • 获取并启动监听器，用于监听SpringApplication运行过程
1
2
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);

2、createApplicationContext

  • 依据webApplicationType创建应用上下文
1
2
3
4
5
6
7
8
switch (webApplicationType) {
    case SERVLET:
        return new AnnotationConfigServletWebServerApplicationContext();
    case REACTIVE:
        return new AnnotationConfigReactiveWebServerApplicationContext();
    default:
        return new AnnotationConfigApplicationContext();
}
  • 注册必须PostProcessor
1
2
AnnotationConfigServletWebServerApplicationContext->AnnotatedBeanDefinitionReader->
registerAnnotationConfigProcessors
1
2
3
4
// 注册ConfigurationClassPostProcessor，处理@Configuration等注解
registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME);
// 注册AutowiredAnnotationBeanPostProcessor，处理@Value，@Autowired等注解
registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME);

3、prepareContext

  • 准备应用上下文，将启动类注册至BeanDefinition
1
prepareContext->load->register->registerBean->doRegisterBean

4、refreshContext

  • 刷新应用上下文
1
refreshContext->refresh
  • 调用工厂处理器处理启动类
1
2
3
invokeBeanFactoryPostProcessors->invokeBeanDefinitionRegistryPostProcessors->
postProcessBeanDefinitionRegistry->processConfigBeanDefinitions->parse->
processConfigurationClass->doProcessConfigurationClass
1
2
3
4
5
6
7
8
9
10
// 处理@ComponentScan，默认扫描启动类所在包下所有class
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 处理@Import，启动类注解上实现类AutoConfigurationImportSelector
// getAutoConfigurationEntry->getCandidateConfigurations->loadFactoryNames->spring.factories
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 处理@Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
    configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
  • 创建启动Web Server容器
1
onRefresh->createWebServer->getWebServer->getTomcatWebServer->initialize->start
  • 实例化单例对象
1
finishBeanFactoryInitialization->preInstantiateSingletons->getBean

5、callRunners

  • 调用Runner，执行自定义逻辑
1
2
3
4
5
6
7
8
for (Object runner : new LinkedHashSet<>(runners)) {
    if (runner instanceof ApplicationRunner) {
        callRunner((ApplicationRunner) runner, args);
    }
    if (runner instanceof CommandLineRunner) {
        callRunner((CommandLineRunner) runner, args);
    }
}

二、IOC

1、BeanDefinition

  • 满足不同类型资源（XML、Annotation、Interface）加载，解析生成统一的Bean定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
    implements BeanDefinition, Cloneable {
    // 字节码
    private volatile Object beanClass;
    // 作用域
    private String scope = SCOPE_DEFAULT;
    // 是否懒加载
    private Boolean lazyInit;
    // 依赖项
    private String[] dependsOn;
    // 构造参数
    private ConstructorArgumentValues constructorArgumentValues;
    // 属性信息
    private MutablePropertyValues propertyValues;
}

2、BeanFactory

  • 对容器中的Bean提供统一的管理和调用
1
2
3
4
5
6
public interface BeanFactory {
    // 获取对象
    Object getBean(String name) throws BeansException;
    // 获取类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
}

3、BeanRegistry

  • 依据Bean的定义加载生成Bean实例，放置在统一的容器中
1
2
3
4
5
6
public interface SingletonBeanRegistry {
    // 注册
    void registerSingleton(String beanName, Object singletonObject);
    // 获取
    Object getSingleton(String beanName);
}

4、扫描流程

1
2
doScan->findCandidateComponents->scanCandidateComponents->checkCandidate->
registerBeanDefinition

5、注册流程

1
2
getBean->doGetBean->createBean->doCreateBean->createBeanInstance->populateBean->
initializeBean

6、循环依赖

1
2
3
4
5
6
// 一级缓存：单例对象缓存池，完成实例化并且属性赋值的成熟对象
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存：单例对象缓存池，完成实例化但尚未属性赋值的半成品对象
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存：单例工厂的缓存池
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  • 实例化后，放入三级缓存
  • AbstractAutowireCapableBeanFactory#doCreateBean
1
2
3
4
5
6
7
8
9
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));
}
  • 三级缓存升级至二级缓存
  • DefaultSingletonBeanRegistry#getSingleton
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // Quick check for existing instance without full singleton lock
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}
  • 二级缓存升级至一级缓存
  • DefaultSingletonBeanRegistry#getSingleton
1
2
3
if (newSingleton) {
    addSingleton(beanName, singletonObject);
}

三、AOP

1、BeanPostProcessor

  • 基于BeanPostProcessor实现用户自定义增强
1
2
3
4
5
6
7
8
9
10
public interface BeanPostProcessor {
    // before
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    // after
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

2、调用过程

1
2
3
initializeBean->
applyBeanPostProcessorsBeforeInitialization/applyBeanPostProcessorsAfterInitialization->
postProcessAfterInitialization->wrapIfNecessary->createProxy->createAopProxy
1
2
3
4
5
6
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || AopProxyUtils.isLambda(targetClass)) {
    // 返回JDK动态代理
    return new JdkDynamicAopProxy(config);
}
// 返回Cglib动态代理
return new ObjenesisCglibAopProxy(config);

3、对比

  • JDK代理只能对实现接口的类生成代理，而CGLib通过继承类的实现方式对指定的类生成一个子类，并覆盖其中的方法，不能代理final修饰的类
  • JDK代理使用的是反射机制实现aop的动态代理，CGLib代理使用字节码处理框架ASM，通过修改字节码生成子类。所以JDK动态代理的方式创建代理对象效率较高，执行效率较低，CGLib创建效率较低，执行效率高

四、MVC

1、Servlet

  • DispatcherServlet本质上是一个Servlet，遵循相应规范
1
2
3
4
5
public interface Servlet {
    public void init(ServletConfig config);
    public void service(ServletRequest req, ServletResponse res);
    public void destroy();
}

2、声明注入

  • 在spring-boot-autoconfigure模块下spring.factories文件中声明
1
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
1
2
3
4
5
6
@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
    DispatcherServlet dispatcherServlet = new DispatcherServlet();
    // 省略部分代码
    return dispatcherServlet;
}
  • 在refreshContext阶段，createWebServer时进行依赖注入

3、初始化

  • 由标识位指定，在首次请求时，会进行初始化操作
1
2
3
if (!instanceInitialized) {
    initServlet(instance);
}
  • 初始化流程
1
init->initServletBean->initWebApplicationContext->onRefresh->initStrategies
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protected void initStrategies(ApplicationContext context) {
    initMultipartResolver(context);
    initLocaleResolver(context);
    initThemeResolver(context);
    // 初始化HandlerMapping
    initHandlerMappings(context);
    // 初始化HandlerAdapter
    initHandlerAdapters(context);
    // 初始化HandlerExceptionResolver
    initHandlerExceptionResolvers(context);
    initRequestToViewNameTranslator(context);
    // 初始化ViewResolver
    initViewResolvers(context);
    initFlashMapManager(context);
}

4、工作流程

1
2
doService->doDispatch->getHandler->getHandlerAdapter->applyPreHandle->handle->
applyPostHandle->processDispatchResult

5、HandlerMapping

  • 实现类为RequestMappingHandlerMapping，在WebMvcAutoConfiguration中注入，实现了InitializingBean接口
1
2
3
4
5
6
7
8
9
10
11
12
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            // 获取请求映射处理器
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}
  • 初始化流程
1
2
afterPropertiesSet->initHandlerMethods->processCandidateBean->detectHandlerMethods->
getMappingForMethod->createRequestMappingInfo->registerHandlerMethod
  • MappingRegistry
1
2
3
4
5
6
7
8
9
10
class MappingRegistry {
	// register映射
    private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
	// path映射
    private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();
	// name映射
    private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
	// cors映射
    private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
}
1
public void register(T mapping, Object handler, Method method) {}

6、HandlerMethodArgumentResolver

  • 请求参数解析器
1
2
3
4
5
6
public interface HandlerMethodArgumentResolver {
    // 是否支持此参数解析
    boolean supportsParameter(MethodParameter parameter);
    // 解析参数
    Object resolveArgument(MethodParameter parameter);
}
  • RequestParamMethodArgumentResolver、PathVariableMethodArgumentResolver、RequestResponseBodyMethodProcessor

7、HandlerMethodReturnValueHandler

  • 返回值处理器
1
2
3
4
5
6
public interface HandlerMethodReturnValueHandler {
    // 是否支持此返回类型
    boolean supportsReturnType(MethodParameter returnType);
    // 处理返回
    void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType);
}
  • RequestResponseBodyMethodProcessor

8、HandlerExceptionResolver

  • 异常解析器
1
2
3
4
public interface HandlerExceptionResolver {
    // 解析异常
    ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, 								Exception ex);
}
  • ExceptionHandlerExceptionResolver
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码