Sping Boot启动原理精讲第二讲

编程语言 2022-02-21 10:38:26 阅读次数: 0

前言

上一篇文章 《深度解析Spring Boot以及手写一个 starter》火了之后，由于篇幅的原因讲的不够深，我决定再加更一篇，两篇看下来相信对SpringBoot肯定能够理解了。

image.png

自动装配就是像事务、配置文件加载和解析、aop、缓存、数据源、springmvc等等，我们以前在项目中要加载这些需要配置xml或者写个@Configuration和很多个@Bean，这些都是需要手写的，现在不需要，只需要引入spring-boot-autoconfigure这个jar包即可，这个就是自动装配的魅力。以前要手动搞定的事，现在自动搞定。

本文的议题是run方法启动，SPI机制以及@EnableAutoConfiguration。

run方法启动

我们从SpringApplication.run(SpringBootApp.class,args);方法点进去看下，具体的步骤写在下面源码上。

public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   DefaultBootstrapContext bootstrapContext = createBootstrapContext();
   ConfigurableApplicationContext context = null;
   configureHeadlessProperty();
   //SPI的方式获取SpringApplicationRunListener实例
   SpringApplicationRunListeners listeners = getRunListeners(args);
   //调用SpringApplicationRunListener的starting()方法
   listeners.starting(bootstrapContext, this.mainApplicationClass);
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      //生成Environment对象
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      configureIgnoreBeanInfo(environment);
      //打印banner图
      Banner printedBanner = printBanner(environment);
      //创建springboot的上下文对象AnnotationConfigServletWebServerApplicationContext
      context = createApplicationContext();
      context.setApplicationStartup(this.applicationStartup);
      //初始化上下文对象
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
      //spring容器启动的核心代码
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      listeners.started(context);
      callRunners(context, applicationArguments);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
   }

   try {
     //调用SpringApplicationRunListener的running()方法
      listeners.running(context);
   }
   catch (Throwable ex) {
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
   }
   return context;
}
复制代码

上面的源码主要干了两件事

  • 完成Spring容器的启动，把需要扫描的类实例化
  • 启动Servlet容器，完成Servlet容器的启动

上面的核心代码就是refreshContext(context)，这个context对象就是AnnotationConfigServletWebServerApplicationContext，打个断点启动一下

image.png 最终进到了AbstractApplicationContext类的refresh方法，这个就是spring容器启动的核心方法，所以springboot的底层调的还是spring的源码。

Servlet容器启动，refresh方法往下走，就有一个onRefresh方法 image.png 点到具体的实现类ServletWebServerApplicationContext，这里有个createWebServer方法

image.png

private void createWebServer() {
   WebServer webServer = this.webServer;
   ServletContext servletContext = getServletContext();
   if (webServer == null && servletContext == null) {
      StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
      //这里获取TomcatServletWebServerFactory对象
      ServletWebServerFactory factory = getWebServerFactory();
      createWebServer.tag("factory", factory.getClass().toString());
      //这里new了Tomcat对象，启动了tomcat容器
      this.webServer = factory.getWebServer(getSelfInitializer());
      createWebServer.end();
      getBeanFactory().registerSingleton("webServerGracefulShutdown",
            new WebServerGracefulShutdownLifecycle(this.webServer));
      getBeanFactory().registerSingleton("webServerStartStop",
            new WebServerStartStopLifecycle(this, this.webServer));
   }
   else if (servletContext != null) {
      try {
         getSelfInitializer().onStartup(servletContext);
      }
      catch (ServletException ex) {
         throw new ApplicationContextException("Cannot initialize servlet context", ex);
      }
   }
   initPropertySources();
}
复制代码

点击factory.getWebServer(getSelfInitializer());进入到tomcat的实现类

image.png 这一段就是在启动tomcat容器并且把项目部署到tomcat中。至此run方法就介绍完了，结合着源码看就是启动Spring容器和Servlet容器。

SPI机制

SPI简介

SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文 件夹查找文件，自动加载文件里所定义的类。 这一机制为很多框架扩展提供了可能，比如在Dubbo、JDBC中都使用 到了SPI机制。我们先通过一个很简单的例子来看下它是怎么用的。 简单来说，SPI是一种扩展机制，核心就是将服务配置化，在核心代码不用改动的前提下，通过加载配置文件中的服 务，然后根据传递的参数来决定到底走什么逻辑，走哪个服务的逻辑。这样就对扩展是开放的，对修改是关闭的。

SpringBoot中的SPI

先在包里建了几个类

image.png

分别看下它们的代码，定义接口

public interface Log {
    void debug();
}
复制代码

定义Log4j实现类

public class Log4j implements Log {
    @Override
    public void debug() {
        System.out.println("-----Log4j");
    }
}
复制代码

定义Logback实现类

public class Logback implements Log {
    @Override
    public void debug() {
        System.out.println("-----Logback");
    }
}
复制代码

定义Slf4j实现类

public class Slf4j implements Log {
    @Override
    public void debug() {
        System.out.println("-----Slf4j");
    }
}
复制代码

在resources文件下META-INF文件下新建一个spring.factories

image.png

里面写的内容，这里的key是类型(可以是接口、注解、抽象类等等)，value是实例类

image.png

再写一个测试类

public class SpiTest {

    @Test
    public void test() {
        List<String> strings = SpringFactoriesLoader.loadFactoryNames(Log.class, ClassUtils.getDefaultClassLoader());
        for (String string : strings) {
            System.out.println(string);
        }
    }

    @Test
    public void test1() {
        List<Log> logs = SpringFactoriesLoader.loadFactories(Log.class, ClassUtils.getDefaultClassLoader());
        for (Log log : logs) {
            System.out.println(log);
        }
    }

}
复制代码

执行一下，没问题，全都获取出来了

image.png

image.png

下面我们来分析下SpringFactoriesLoader.loadFactoryNames源码，点进去看到factoryType.getName()是获取类型的名字，这个就是key。

image.png

再点进去看下

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
   //先根据classLoader从缓存中拿，如果能拿到就返回
   Map<String, List<String>> result = cache.get(classLoader);
   if (result != null) {
      return result;
   }

   result = new HashMap<>();
   try {
      //FACTORIES_RESOURCE_LOCATION的值就是 META-INF/spring.factories
      //获取的文件是所有jar包和自己工程里面的所有spring.factories文件
      Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
      //循环所有文件
      while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         //包装成UrlResource对象
         UrlResource resource = new UrlResource(url);
         //核心代码，把文件包装成properties对象
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
         //循环properties对象
         for (Map.Entry<?, ?> entry : properties.entrySet()) {
            //拿到key
            String factoryTypeName = ((String) entry.getKey()).trim();
            String[] factoryImplementationNames =
                  StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
            for (String factoryImplementationName : factoryImplementationNames) {
               //把key对应的所有实例加入到list容器中
               result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                     .add(factoryImplementationName.trim());
            }
         }
      }

      // Replace all lists with unmodifiable lists containing unique elements
      result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
      //建立缓存
      cache.put(classLoader, result);
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
   return result;
}
复制代码

我们看到 Enumeration urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);这里FACTORIES_RESOURCE_LOCATION的值就是META-INF/spring.factories，所以我们上面做演示的时候，配置是写在这个文件里面的，因为代码里就是从这里读的。

image.png 然后我们看到这里Enumeration是urls，为什么是urls，因为这里获取的是自己项目里的META-INF/spring.factories文件以及引用jar包里的META-INF/spring.factories文件。

我们在result上打个断点，发现加载了46个key value，可是我们在项目里只写了com.jackxu.zhengcheng.spi.Log这三个，剩下的就是在别的jar包里加载的key value。比如我们熟悉的EnableAutoConfiguration，一共有131个，这个就是在spring-boot-autoconfigure包里读取出来的。

image.png 最后SpringFactoriesLoader.loadFactoryNames返回的就是上面截图中com.jackxu.zhengcheng.spi.Log作为key返回的3个list，SpringFactoriesLoader.loadFactories就不分析了，只是调用了loadFactoryNames拿到了接口类型对应的所有类的名称，多了一步反射实例化而已。

@EnableAutoConfiguration

在第一篇文章中介绍了@SpringBootApplication是一个组合注解，它包含了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan这三个注解。这里来介绍@EnableAutoConfiguration注解。

image.png @EnableAutoConfiguration注解上面又有一个核心注解@Import，在第一篇文章中介绍过它的功能，可以引入三种类型的对象：

  1. 普通 Bean 或者带有 @Configuration 的配置文件
  2. 实现 ImportSelector 接口进行动态注入
  3. 实现 ImportBeanDefinitionRegistrar 接口进行动态注入

我们这里用的就是第二种，动态注入，下面来介绍一下它的写法。新建三个类。

image.png

这个就是实现DeferredImportSelector接口的固定写法，这么写了spring才能获取到需要实例化的类。

/**
 * @author jack xu
 */
public class DeferredImportSelectorDemo implements DeferredImportSelector {

    //返回需要实例化的类，这个方法spirng是不会直接调的，这里是给下面process方法调的
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        System.out.println("==============DeferredImportSelectorDemo.selectImports===========");
        //如果需要把类实例化，就需要把该类的完整限定名返回
        return new String[]{DeferredBean.class.getName()};
    }

    //需要返回一个实现了Group接口的类
    @Override
    public Class<? extends Group> getImportGroup() {
        return DeferredImportSelectorGroupDemo.class;
    }

    //内部类，实现Group
    private static class DeferredImportSelectorGroupDemo implements Group {

        List<Entry> list = new ArrayList<>();


        //spring会调这个方法，收集需要实例化的类
        @Override
        public void process(AnnotationMetadata metadata, DeferredImportSelector selector) {
            System.out.println("==============DeferredImportSelectorGroupDemo.process===========");
            String[] strings = selector.selectImports(metadata);
            for (String string : strings) {
                list.add(new Entry(metadata, string));
            }
        }

        //spring会调这个方法，返回给spring容器进行实例化
        @Override
        public Iterable<Entry> selectImports() {
            System.out.println("==============DeferredImportSelectorGroupDemo.selectImports===========");
            return list;
        }
    }
}
复制代码

需要实例的bean

public class DeferredBean {

    @PostConstruct
    public void init() {
        System.out.println("DeferredBean，我是通过Import注解加载进来的");
    }
    
}
复制代码

通过Import导进来，spring会扫描收集Import注解里面需要实例化的类。

@Component
@Import(DeferredImportSelectorDemo.class)
public class ImportBean {
}
复制代码

启动执行一下，代码里打印的日志全显示出来了，证明spring确实是走的这一套逻辑。

image.png

下面看下AutoConfigurationImportSelector，确实也是这个套路，实现了DeferredImportSelector接口

image.png

返回了实现Group接口的类 image.png

实现了process方法，selectImports方法 image.png

那process方法里我们猜也能够猜到，它的功能是收集需要交给spring容器需要实例化的类，点进去 getAutoConfigurationEntry方法看下。

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
   if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
   }
   //获取@SpringBootApplication的配置属性
   AnnotationAttributes attributes = getAttributes(annotationMetadata);
   //获取候选的所有类的名称
   List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
   configurations = removeDuplicates(configurations);
   //从注解配置属性中获取需要排除的类
   Set<String> exclusions = getExclusions(annotationMetadata, attributes);
   checkExcludedClasses(configurations, exclusions);
   //从候选的类中删除需要排除的类
   configurations.removeAll(exclusions);
   //SPI的扩展，获取过滤器实例对候选的类过滤
   configurations = getConfigurationClassFilter().filter(configurations);
   fireAutoConfigurationImportEvents(configurations, exclusions);
   //把候选的所有类包装成AutoConfigurationEntry对象
   return new AutoConfigurationEntry(configurations, exclusions);
}
复制代码

那么怎么收集就是通过上面说的SPI的方式，点进getCandidateConfigurations方法看下，SpringFactoriesLoader.loadFactoryNames，获取了131个类型，和上面演示SPI的时候数量一样。

image.png

其实就是收集spring.factories文件中以@EnableAutoConfiguration类型为key的所有的类，然后把这些类交给spring去实例化，而这些类就是我们说的aop、事务、缓存、mvc等功能的支持类，从而达到自动装配。

后记

最后在演示一下自动装配，写一个需要注入的类Person类

image.png

在META-INF/spring.factories下加上org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.jackxu.zhengcheng.spi.Person这句话 image.png 启动一下，Person类就被注进来了

image.png 而DeferredBean是通过@Import注解加载进来的，所以我们想把一个类加载到Spring容器的时候，又多了两种方式，看完这篇文章原理相信大家也都明白了，最后感谢收看，如果你喜欢请点一个赞！

猜你喜欢

转载自juejin.im/post/7056338149655445512
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022