Spring Boot 2.0从出来到现在已经很久了，也使用一阵子，每次构建一个内嵌tomcat的jar的web项目，都很自然的java -jar XXXX.jar就跑起来了。没有深入的去研究过这条命令后面的执行过程，今天就整了这篇博文，做个记录。来分析分析Spring Boot给我们带来了什么便捷配置。

1. Spring Boot Web Jar包结构拆解

1.1. 目标项目结构

为了便于调试，构建一个极简的基于Spring Boot 2.x的Web项目：

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
</dependencies>
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
 </build>

启动类

@SpringBootApplication
public class UnifiedPlatformApplication {

    public static void main(String[] args) {
        SpringApplication.run(UnifiedPlatformApplication.class, args);
    }
}

Maven 编译

mvn compiler:compile

在项目目录下将生成：unified-platform-0.0.1-SNAPSHOT.jar

1.2. Jar包展示

• 用解压软件，打开jar文件，目录结构如下：

jar.png

• 主要文件和目录

• 重点文件MANIFEST.MF

Manifest-Version: 1.0
Implementation-Title: unified-platform
Implementation-Version: 0.0.1-SNAPSHOT
Built-By: fuhao-pc
Implementation-Vendor-Id: com.supcon
Spring-Boot-Version: 2.1.2.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.supcon.UnifiedPlatformApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Created-By: Apache Maven 3.3.9
Build-Jdk: 1.8.0_144
Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo
 ot-starter-parent/unified-platform

2. Java -jar 执行过程解析

根据可运行Jar执行机制，存在MANIFEST.MF的情况下，JVM会解析该文件内部的Main-Class的值，作为整个jar程序运行的入口。

Main-Class: org.springframework.boot.loader.JarLauncher

看看解压出来的文件夹，都是class，二话不说那就反编译呗，其实直接丢IDEA就行了。

JarLauncher.class:

public class JarLauncher extends ExecutableArchiveLauncher {
    static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
    static final String BOOT_INF_LIB = "BOOT-INF/lib/";

    public JarLauncher() {
    }

    protected JarLauncher(Archive archive) {
        super(archive);
    }

    protected boolean isNestedArchive(Entry entry) {
        return entry.isDirectory() ? entry.getName().equals("BOOT-INF/classes/") : entry.getName().startsWith("BOOT-INF/lib/");
    }
    //入口方法，构建JarLauncher对象，执行父类的ExecutableArchiveLauncher的父类Launcher的Launch方法。
    public static void main(String[] args) throws Exception {
        (new JarLauncher()).launch(args);
    }
}

Launcher.class:

    
    protected void launch(String[] args) throws Exception {
        JarFile.registerUrlProtocolHandler();
        ClassLoader classLoader = this.createClassLoader(this.getClassPathArchives());
        this.launch(args, this.getMainClass(), classLoader);
    }

    protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader);
        this.createMainMethodRunner(mainClass, args, classLoader).run();
    }

    protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
        return new MainMethodRunner(mainClass, args);
    }

MainMethodRunner.class:

public class MainMethodRunner {
    private final String mainClassName;
    private final String[] args;

    public MainMethodRunner(String mainClass, String[] args) {
        this.mainClassName = mainClass;
        this.args = args != null ? (String[])args.clone() : null;
    }

    public void run() throws Exception {
        //反射执行对象mainClass类的main方法
        Class<?> mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);
        Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
        mainMethod.invoke((Object)null, this.args);
    }
}

所以关键点就在mainClass的获取了：

    protected String getMainClass() throws Exception {
        Manifest manifest = this.archive.getManifest();
        String mainClass = null;
        if (manifest != null) {
            mainClass = manifest.getMainAttributes().getValue("Start-Class");
        }

        if (mainClass == null) {
            throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);
        } else {
            return mainClass;
        }
    }

跟踪到这里，最后还是到了我们自己的代码 Start-Class: com.supcon.UnifiedPlatformApplication。绕了一大圈，才到SpringBoot启动类，整个过程貌似也就是获取了下当前线程的类加载器，不知道这么搞的初衷是啥，没有进一步深究。那么接下来，就得分析Spring Boot的启动过程了，别的不说，直接代码跟踪。

3. Spring Boot自动配置过程源码解析

3.1. 官方约定

Spring Boot 文档显示，在项目Jar下META-INFO下文件spring.factories内添加org.springframework.boot.autoconfigure.EnableAutoConfiguration=***，即可以按照约定的方式进行Bean的注册和初始化

cotent.png

3.2. 源码调试跟踪

• 项目启动类

  public static void main(String[] args) {
        SpringApplication.run(UnifiedPlatformApplication.class, args);
  }

• SpringApplication.java构建Spring Context，然后进行上下文刷新（构建Bean）

public ConfigurableApplicationContext run(String... args) {

        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        //...非核心代码...
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);

            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(
                    SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            
            //调试断点
            //Spring 容器上下文准备好后，进行相关工厂Bean等的注册
            refreshContext(context);
            //**************************
            
            afterRefresh(context, applicationArguments);
            
            //...非核心代码...
        }
        
        //...非核心代码...

        return context;
    }

• AbstractApplicationContext.java，执行各种处理器。

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

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

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);
                
                //调试断点
                //BeanFactory后置处理器
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
                //************************************

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

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

            //...非核心代码...
        }
    }

• PostProcessorRegistrationDelegate.java循环调用实现了BeanDefinitionRegistryPostProcessor类的处理器

    private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
        
        //调试断点
        //循环调用实现了BeanDefinitionRegistryPostProcessor类的处理器
        //当然也包括本文重点的ConfigurationClassPostProcessor
        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
        
    }

• ConfigurationClassPostProcessor.java

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        int registryId = System.identityHashCode(registry);
        
        //...非核心代码...
        this.registriesPostProcessed.add(registryId);
        //调试断点 
        //处理配置类Bean的注册信息
        processConfigBeanDefinitions(registry);
    }

@import注解处理

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        //...非核心代码...
        //调试断点  
        //处理注解导入类
        this.deferredImportSelectorHandler.process();
    }

public void process() {
            List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
            this.deferredImportSelectors = null;
            try {
                if (deferredImports != null) {
                    DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
                    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
                    deferredImports.forEach(handler::register);
                    //调试断点  
                    //处理注解导入类
                    handler.processGroupImports();
                }
            }
            finally {
                this.deferredImportSelectors = new ArrayList<>();
            }
        }

public Iterable<Group.Entry> getImports() {
            //调试断点
            //定位到 @EnableAutoConfiguration的注解
            //@Import(AutoConfigurationImportSelector.class)
            for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
                this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                        deferredImport.getImportSelector());
            }
            return this.group.selectImports();
        }

这个@EnableAutoConfiguration注解正好是启动类继承来的

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

• EnableAutoConfiguration.java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
        //...非核心代码...
}

• AutoConfigurationImportSelector.java

        public void process(AnnotationMetadata annotationMetadata,
                DeferredImportSelector deferredImportSelector) {
            //调试断点
            //获取自动配置实体
            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
                    .getAutoConfigurationEntry(getAutoConfigurationMetadata(),
                            annotationMetadata);
            this.autoConfigurationEntries.add(autoConfigurationEntry);
            
            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }
        }

• SpringFactoriesLoader.java，终于到了核心类，就是它去加载了需要自动加载的类

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
        //调试断点
        //通过SpringFactoriesLoader 去META-INF/spring.factories.
        //加载 org.springframework.boot.autoconfigure.EnableAutoConfiguration
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());

        //...非核心代码...
        return configurations;
    }

接下去就是通过Spring Bean的导入机制，遍历各种AutoConfiguration类，进行上下文Bean注册以及后续的处理过程。这里有必要列下常用注解的意思：

3. Spring MVC 在哪里初始化

心细如我的读者可能会发现，貌似对于Web项目还少了些什么，怎么没有看到MVC的重要类：DispatcherServlet。莫急，其实看看spring.factories文件会发现：

org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\

就是这些AutoConfiguration类，进行了对MVC各个组件的初始化。比如：

@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
        TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
    //.....
}

具体过程这里就不在研究了，话题太大了。