Spring 源码解析

文章15 |   阅读 8463 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析十二：SpringBoot 的加载机制

x33g5p2x  于2022-02-11 发布在 Spring  
字(14.2k)|赞(0)|评价(0)|浏览(496)

1. spring-boot 包含的模块

在解析 SpringBoot 的加载机制之前，先来看看官方 spring-boot 包含有哪些模块，各有什么用。

spring-boot 官方仓库

  • spring-boot：SpringBoot 的核心包，包括对 spring-framework 的封装与扩展、application.yaml 加载机制、注解启动机制等
  • spring-boot-autoconfigure：application.yaml 的配置项定义
  • spring-boot-actuator：对 Spring 的健康检查、审计、统计和监控
  • spring-boot-actuator-autoconfigure：对 Spring 健康检查、审计、统计和监控的 application.yaml 配置项支持
  • spring-boot-cli：命令行执行支持
  • spring-boot-devtools：开发时监听 class 文件变动自动刷新应用程序
  • spring-boot-starters/*：SpringBoot starter，下面的项目全部是依赖定义，没有代码
  • spring-boot-tools/*：SpringBoot 配套工具

2. 应用入口

一个打包好的应用有如下的基本目录结构

  1. - /
  2.   - BOOT-INF
  3.     - classes      # 存放应用的class文件与Resources资源文件
  4.     - lib           # 依赖的jar
  5.   - META-INF
  6.     - MANIFEST.MF  # 应用的启动配置
  7.   - org/springframework/boot/loader/   # spring-boot-loader 代码

我们一般可以使用 java -jar app.jar 来启动应用，MANIFEST.MF 就是来配置应用的启动

  1. # MANIFEST.MF
  3. Manifest-Version: 1.0
  4. Start-Class: com.example.demo.App
  5. Spring-Boot-Classes: BOOT-INF/classes/
  6. Spring-Boot-Lib: BOOT-INF/lib/
  7. Spring-Boot-Version: 2.1.4.RELEASE
  8. Main-Class: org.springframework.boot.loader.JarLauncher

对 Java 来说，这里面的配置，只有 Main-Class 是有效的，就是指定入口类

3. JarLauncher

JarLauncher
的主要功能是通过 jar 来启动应用

  1. public class JarLauncher extends ExecutableArchiveLauncher {
  2.     // 入口启动方法
  3.     public static void main(String[] args) throws Exception {
  4.         new JarLauncher().launch(args);
  5.     }
  6. }

现在来仔细分解这个类，先来看看继承关系

  1. - Launcher
  2.   - ExecutableArchiveLauncher
  3.     - JarLauncher

3.1. Launcher

Launcher
的主要功能是实现了基本的启动机制

  1. public abstract class Launcher {
  2.     // 启动应用
  3.     protected void launch(String[] args) throws Exception {
  4.         // 获取类加载器
  5.         ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
  6.         // 获取启动类
  7.         String launchClass = getMainClass();
  8.         // 启动
  9.         launch(args, launchClass, classLoader);
  10.     }
  12.     // 启动
  13.     protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {
  14.         Thread.currentThread().setContextClassLoader(classLoader);
  15.         // 创建runner，run
  16.         createMainMethodRunner(launchClass, args, classLoader).run();
  17.     }
  19.     // 创建runner
  20.     protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
  21.         return new MainMethodRunner(mainClass, args);
  22.     }
  24.     // 获取启动类，由子类实现
  25.     protected abstract String getMainClass() throws Exception;
  26. }

来看看 MainMethodRunner
是怎么运行的

  1. public class MainMethodRunner {
  2.     private final String mainClassName;
  3.     private final String[] args;
  5.     public MainMethodRunner(String mainClass, String[] args) {
  6.         this.mainClassName = mainClass;
  7.         this.args = (args != null) ? args.clone() : null;
  8.     }
  10.     public void run() throws Exception {
  11.         Class<?> mainClass = Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
  12.         // 获取mainClass的main方法
  13.         Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
  14.         mainMethod.setAccessible(true);
  15.         // 调用main方法
  16.         mainMethod.invoke(null, new Object[] { this.args });
  17.     }
  19. }

3.2. ExecutableArchiveLauncher

ExecutableArchiveLauncher
的主要功能是执行归档文件(jar, war)

  1. public abstract class ExecutableArchiveLauncher extends Launcher {
  2.     // 启动类
  3.     private static final String START_CLASS_ATTRIBUTE = "Start-Class";
  5.     // 获取启动类
  6.     @Override
  7.     protected String getMainClass() throws Exception {
  8.         // 获取归档文件(jar, war)中的`MANIFEST.MF`文件
  9.         Manifest manifest = this.archive.getManifest();
  10.         String mainClass = null;
  11.         if (manifest != null) {
  12.             // 获取Start-Class指定的类作为启动类
  13.             mainClass = manifest.getMainAttributes().getValue(START_CLASS_ATTRIBUTE);
  14.         }
  15.         if (mainClass == null) {
  16.             // 启动类不能为空
  17.             throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);
  18.         }
  19.         return mainClass;
  20.     }
  21. }

3.3. JarLauncher

JarLauncher
的主要功能是执行 jar 文件，并指定 classpath

  1. public class JarLauncher extends ExecutableArchiveLauncher {
  2.     // 是否可以加载这下面的文件
  3.     static final EntryFilter NESTED_ARCHIVE_ENTRY_FILTER = (entry) -> {
  4.         if (entry.isDirectory()) {
  5.             return entry.getName().equals("BOOT-INF/classes/");
  6.         }
  7.         return entry.getName().startsWith("BOOT-INF/lib/");
  8.     };
  10.     // "BOOT-INF/classes/"与"BOOT-INF/lib/*.jar"当做classpath加载
  11.     @Override
  12.     protected boolean isNestedArchive(Archive.Entry entry) {
  13.         return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
  14.     }
  15. }

4. 启动应用

我们来看一个最基本的启动

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class App {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(App.class, args);
  8.     }
  9. }

SpringApplication
的 run 方法由于启动一个 SpringBoot 应用

  1. public class SpringApplication {
  2.     public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
  3.         // 指定启动主源，运行参数
  4.         return new SpringApplication(primarySources).run(args);
  5.     }
  6. }

5. SpringApplication.run

  1. public class SpringApplication {
  2.     public SpringApplication(Class<?>... primarySources) {
  3.         this(null, primarySources);
  4.     }
  6.     public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  7.         // 资源加载器
  8.         this.resourceLoader = resourceLoader;
  9.         // 启动主源
  10.         this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  11.         // 获取 spring.factories 文件中定义的，实现Bootstrapper接口的组件
  12.         this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
  13.         // 获取 spring.factories 文件中定义的，实现ApplicationContextInitializer接口的组件
  14.         setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
  15.         // 获取 spring.factories 文件中定义的，实现ApplicationListener接口的组件
  16.         setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  17.         // 获取入口类文件，如com.example.demo.App.class
  18.         this.mainApplicationClass = deduceMainApplicationClass();
  19.     }
  21.     // 运行项目
  22.     public ConfigurableApplicationContext run(String... args) {
  23.         // 创建启动上下文
  24.         DefaultBootstrapContext bootstrapContext = createBootstrapContext();
  25.         // 应用上下文
  26.         ConfigurableApplicationContext context = null;
  28.         // ... 代码省略
  30.         // 获取 spring.factories 文件中定义的，实现SpringApplicationRunListener接口的组件
  31.         SpringApplicationRunListeners listeners = getRunListeners(args);
  32.         // 启动监听器
  33.         listeners.starting(bootstrapContext, this.mainApplicationClass);
  34.         try {
  35.             // 应用参数
  36.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  37.             // 准备环境对象
  38.             ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
  39.             // 初始化spring.beaninfo.ignore配置
  40.             configureIgnoreBeanInfo(environment);
  41.             // 创建应用上下文，默认使用 AnnotationConfigServletWebServerApplicationContext
  42.             context = createApplicationContext();
  44.             // 准备应用上下文
  45.             prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
  46.             // 调用context的refresh方法，刷新上下文数据
  47.             refreshContext(context);
  49.             // ... 代码省略
  51.             // 调用应用开始的监听函数
  52.             listeners.started(context);
  53.             // 运行应用
  54.             callRunners(context, applicationArguments);
  55.         }
  56.         catch (Throwable ex) {
  57.             // ... 代码省略
  58.         }
  60.         try {
  61.             // 调用应用运行的监听函数
  62.             listeners.running(context);
  63.         }
  64.         catch (Throwable ex) {
  65.             // ... 代码省略
  66.         }
  67.         return context;
  68.     }
  70.     // 创建启动上下文
  71.     private DefaultBootstrapContext createBootstrapContext() {
  72.         // 默认使用DefaultBootstrapContext，调用bootstrappers中每个组件的intitialize方法初始化
  73.         DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
  74.         this.bootstrappers.forEach((initializer) -> initializer.intitialize(bootstrapContext));
  75.         return bootstrapContext;
  76.     }
  77. }
  1. public class SpringApplication {
  2.     // 准备环境对象
  3.     private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
  4.             DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
  5.         // 创建一个spring-web的标准环境
  6.         ConfigurableEnvironment environment = getOrCreateEnvironment();
  7.         // 配置环境
  8.         configureEnvironment(environment, applicationArguments.getSourceArgs());
  10.         // ... 代码省略
  12.         // 配置 additionalProfiles
  13.         configureAdditionalProfiles(environment);
  14.         // 绑定环境与应用
  15.         bindToSpringApplication(environment);
  17.         // ... 代码省略
  19.         return environment;
  20.     }
  22.     // 配置环境
  23.     protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
  24.         // 添加数据转换与格式化服务
  25.         if (this.addConversionService) {
  26.             ConversionService conversionService = ApplicationConversionService.getSharedInstance();
  27.             environment.setConversionService((ConfigurableConversionService) conversionService);
  28.         }
  29.         // 配置命令行的属性来源 propertySources
  30.         configurePropertySources(environment, args);
  31.     }
  32. }
  1. public class SpringApplication {
  2.     // 准备应用上下文
  3.     private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
  4.             ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
  5.             ApplicationArguments applicationArguments, Banner printedBanner) {
  6.         // 设置环境
  7.         context.setEnvironment(environment);
  8.         // 添加bean名字生成器、资源加载器、数据转换服务
  9.         postProcessApplicationContext(context);
  10.         // 调用initializers中组件的initialize方法
  11.         applyInitializers(context);
  13.         // ... 代码省略
  15.         // 获取bean工厂
  16.         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
  17.         // 注册springApplicationArguments单例
  18.         beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
  20.         // ... 代码省略
  22.         // 获取所有的源
  23.         Set<Object> sources = getAllSources();
  24.         // 加载这些源下的资源
  25.         load(context, sources.toArray(new Object[0]));
  27.         // ... 代码省略
  28.     }
  30.     // 加载这些源下的资源
  31.     protected void load(ApplicationContext context, Object[] sources) {
  32.         // 创建BeanDefinitionLoader
  33.         BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
  35.         // ... 代码省略
  37.         // 加载资源
  38.         loader.load();
  39.     }
  40. }
  1. public class SpringApplication {
  2.     // 运行应用
  3.     private void callRunners(ApplicationContext context, ApplicationArguments args) {
  4.         List<Object> runners = new ArrayList<>();
  5.         // 应用运行器ApplicationRunner
  6.         runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
  7.         // 命令行运行器CommandLineRunner
  8.         runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
  10.         for (Object runner : new LinkedHashSet<>(runners)) {
  11.             if (runner instanceof ApplicationRunner) {
  12.                 // 调用ApplicationRunner.run方法
  13.                 callRunner((ApplicationRunner) runner, args);
  14.             }
  15.             if (runner instanceof CommandLineRunner) {
  16.                 // 调用CommandLineRunner.run方法
  17.                 callRunner((CommandLineRunner) runner, args);
  18.             }
  19.         }
  20.     }
  21. }

这一小节中，有几点需要接下来慢慢解析

  • AnnotationConfigServletWebServerApplicationContext 如何管理应用与数据
  • BeanDefinitionLoader.load 如何加载资源

6. AnnotationConfigServletWebServerApplicationContext

AnnotationConfigServletWebServerApplicationContext
是 SpringBoot 默认使用应用上下文

先看看继承关系

  1. - GenericWebApplicationContext
  2.   - ServletWebServerApplicationContext
  3.     - AnnotationConfigServletWebServerApplicationContext

GenericWebApplicationContext
在 Spring 源码解析二：上下文组件(WebApplicationContext) 中已经讲过了，先来看看 ServletWebServerApplicationContext

6.1. ServletWebServerApplicationContext

ServletWebServerApplicationContext
的主要功能是可以启动自身为一个应用服务

  1. public class ServletWebServerApplicationContext extends GenericWebApplicationContext
  2.         implements ConfigurableWebServerApplicationContext {
  3.     // 刷新应用
  4.     @Override
  5.     protected void onRefresh() {
  6.         super.onRefresh();
  8.         // 刷新的时候，重新创建一个应用服务
  9.         createWebServer();
  10.     }
  12.     // 创建一个应用服务
  13.     private void createWebServer() {
  14.         WebServer webServer = this.webServer;
  15.         ServletContext servletContext = getServletContext();
  17.         // 应用服务与上下文都为空
  18.         if (webServer == null && servletContext == null) {
  19.             // 获取 ServletWebServerFactory 的bean，内置实现有tomcat、jetty、undertow、netty
  20.             ServletWebServerFactory factory = getWebServerFactory();
  21.             // 当应用服务初始化完成后，调用自身的selfInitialize
  22.             this.webServer = factory.getWebServer(getSelfInitializer());
  24.             // ... 代码省略
  25.         }
  26.         // 如果有上下文对象，调用自身的selfInitialize来初始化
  27.         else if (servletContext != null) {
  28.             try {
  29.                 getSelfInitializer().onStartup(servletContext);
  30.             }
  31.             catch (ServletException ex) {
  32.                 // ... 代码省略
  33.             }
  34.         }
  36.         // ... 代码省略
  37.     }
  38. }
  1. public class ServletWebServerApplicationContext extends GenericWebApplicationContext
  2.         implements ConfigurableWebServerApplicationContext {
  3.     // 初始化应用
  4.     private void selfInitialize(ServletContext servletContext) throws ServletException {
  5.         // ... 代码省略
  7.         // 获取所有ServletContextInitializer的bean，调用这些组件的onStartup方法
  8.         for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
  9.             beans.onStartup(servletContext);
  10.         }
  11.     }
  12. }

6.2. AnnotationConfigServletWebServerApplicationContext

AnnotationConfigServletWebServerApplicationContext
的主要功能是自动扫描注解定义的 bean

  1. public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
  2.         implements AnnotationConfigRegistry {
  3.     // 注解bean定义读取器
  4.     private final AnnotatedBeanDefinitionReader reader;
  5.     // 类路径bean定义扫描器
  6.     private final ClassPathBeanDefinitionScanner scanner;
  7.     // 已注册的注解类组件
  8.     private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();
  9.     // 待扫描的包
  10.     private String[] basePackages;
  12.     public AnnotationConfigServletWebServerApplicationContext() {
  13.         // 初始化读取器与扫描器
  14.         this.reader = new AnnotatedBeanDefinitionReader(this);
  15.         this.scanner = new ClassPathBeanDefinitionScanner(this);
  16.     }
  18.     public AnnotationConfigServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
  19.         super(beanFactory);
  20.         // 初始化读取器与扫描器
  21.         this.reader = new AnnotatedBeanDefinitionReader(this);
  22.         this.scanner = new ClassPathBeanDefinitionScanner(this);
  23.     }
  25.     public AnnotationConfigServletWebServerApplicationContext(Class<?>... annotatedClasses) {
  26.         this();
  27.         // 注册bean，并刷新应用上下文数据
  28.         register(annotatedClasses);
  29.         refresh();
  30.     }
  32.     public AnnotationConfigServletWebServerApplicationContext(String... basePackages) {
  33.         this();
  34.         // 扫描包，并刷新应用上下文数据
  35.         scan(basePackages);
  36.         refresh();
  37.     }
  38. }
  1. public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
  2.         implements AnnotationConfigRegistry {
  3.     // 注册bean
  4.     @Override
  5.     public final void register(Class<?>... annotatedClasses) {
  6.         this.annotatedClasses.addAll(Arrays.asList(annotatedClasses));
  7.     }
  9.     // 扫描包
  10.     @Override
  11.     public final void scan(String... basePackages) {
  12.         this.basePackages = basePackages;
  13.     }
  15.     // 应用上下文刷新完之后，自动加载bean与扫描包
  16.     @Override
  17.     protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  18.         super.postProcessBeanFactory(beanFactory);
  19.         if (this.basePackages != null && this.basePackages.length > 0) {
  20.             this.scanner.scan(this.basePackages);
  21.         }
  22.         if (!this.annotatedClasses.isEmpty()) {
  23.             this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
  24.         }
  25.     }
  26. }

7. BeanDefinitionLoader.load

在上面的代码中，资源加载是类 BeanDefinitionLoader
完成的

  1. class BeanDefinitionLoader {
  2.     // 加载资源
  3.     void load() {
  4.         // 遍历加载
  5.         for (Object source : this.sources) {
  6.             load(source);
  7.         }
  8.     }
  10.     // 加载单个资源
  11.     private void load(Object source) {
  12.         // 加载类下的资源
  13.         if (source instanceof Class<?>) {
  14.             loadClass((Class<?>) source);
  15.             return;
  16.         }
  17.         // 加载Resource的资源
  18.         if (source instanceof Resource) {
  19.             loadResource((Resource) source);
  20.             return;
  21.         }
  22.         // 加载包下的资源
  23.         if (source instanceof Package) {
  24.             loadPackage((Package) source);
  25.             return;
  26.         }
  27.         // 加载字符代表的资源
  28.         if (source instanceof CharSequence) {
  29.             loadCharSequence((CharSequence) source);
  30.             return;
  31.         }
  32.         // 其他不能加载
  33.         throw new IllegalArgumentException("Invalid source type " + source.getClass());
  34.     }
  35. }
  1. class BeanDefinitionLoader {
  2.     // 加载类下的资源
  3.     private void loadClass(Class<?> source) {
  4.         // 加载类下的注解
  5.         this.annotatedReader.register(source);
  6.     }
  8.     // 加载Resource的资源
  9.     private void loadResource(Resource source) {
  10.         // 加载Resource的xml
  11.         this.xmlReader.loadBeanDefinitions(source);
  12.     }
  14.     // 加载包下的资源
  15.     private void loadPackage(Package source) {
  16.         // 扫描包下的注解
  17.         this.scanner.scan(source.getName());
  18.     }
  20.     // 加载字符代表的资源
  21.     private void loadCharSequence(CharSequence source) {
  22.         // 替换占位符${}
  23.         String resolvedSource = this.scanner.getEnvironment().resolvePlaceholders(source.toString());
  24.         // 当做类加载，如果成功，返回
  25.         try {
  26.             load(ClassUtils.forName(resolvedSource, null));
  27.             return;
  28.         }
  29.         catch (IllegalArgumentException | ClassNotFoundException ex) {}
  30.         // 当做Resource加载，如果成功，返回
  31.         if (loadAsResources(resolvedSource)) {
  32.             return;
  33.         }
  34.         // 当做包加载，如果成功，返回
  35.         Package packageResource = findPackage(resolvedSource);
  36.         if (packageResource != null) {
  37.             load(packageResource);
  38.             return;
  39.         }
  40.         // 其他不能加载
  41.         throw new IllegalArgumentException("Invalid source '" + resolvedSource + "'");
  42.     }
  43. }

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com