SpringBoot回顾3-运行原理、自定义启动器Starter（附源码）

上上签i
381 阅读7分钟

SpringBoot回顾3-运行原理、自定义启动器Starter

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

运行原理

启动器

在刚拿到SpringBoot初始化项目后，我们发现pom.xml里有一个

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

springboot-boot-starter-xxx：就是spring-boot的场景启动器

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

主启动类

我们跑SpringBoot程序的时候，直接运行这个主启动类就完成了所有操作

@SpringBootApplication
public class Helloworld1sbApplication {

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

}

这不就是一个我们熟悉的不能在熟悉的main方法吗，怎么跑了一下还能启动整个web服务？让我们一探究竟

首先看到这个类上有一个注解@SpringBootApplication

@SpringBootApplication

作用：标注在某个类上说明这个类是SpringBoot的主配置类 ， SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

点进源码发现里面还有很多其他注解

image-20201006112703319

比如

@ComponentScan

这个注解在Spring中很重要 ,它对应XML配置中的元素。

作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

@SpringBootConfiguration

作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；

我们继续进去这个注解查看

// 点进去得到下面的 
@Component@Configurationpublic 
@interface SpringBootConfiguration {}
@Componentpublic 
@interface Configuration {}

这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；

里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

我们回到 SpringBootApplication 注解中继续看。

@EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解接续查看：

@AutoConfigurationPackage ：自动配置包

@Import({Registrar.class})
public @interface AutoConfigurationPackage {}

@import ：Spring底层注解@import ， 给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

这个分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

1、这个类中有一个这样的方法

// 获得候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {    
    //这里的getSpringFactoriesLoaderFactoryClass（）方法    
    //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration    
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
            this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());    
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");    
    return configurations;}

2、这个方法又调用了 SpringFactoriesLoader 类的静态方法！我们进入SpringFactoriesLoader类loadFactoryNames() 方法

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		String factoryTypeName = factoryType.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}
//这里它又调用了 loadSpringFactories 方法

3、我们继续点击查看 loadSpringFactories 方法

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
		String factoryTypeName = factoryType.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}

	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}
		try {
            //去获取一个资源 "META-INF/spring.factories"
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
            //将读取到的资源遍历，封装成为一个Properties   
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

4、发现一个多次出现的文件：spring.factories，全局搜索它

spring.factories

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

image-20201006113316733

WebMvcAutoConfiguration

我们在上面的自动配置类随便找一个打开看看，比如 ：WebMvcAutoConfiguration

image-20201006113418155

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看着熟悉一下！

所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容器中。

结论：

  1. SpringBoot在启动的时候从类路径下的/META-INF/spring.factories中获取EnableAutoConfiguration指定的值
  2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
  3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
  4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
  5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

SpringApplication

不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

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

SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication

这个类主要做了以下四件事情：

1、推断应用的类型是普通的项目还是Web项目

2、查找并加载所有可用初始化器 ， 设置到initializers属性中

3、找出所有的应用程序监听器，设置到listeners属性中

4、推断并设置main方法的定义类，找到运行的主类

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {    // ......    
    this.webApplicationType = WebApplicationType.deduceFromClasspath();   
    this.setInitializers(this.getSpringFactoriesInstances();
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));    
this.mainApplicationClass = this.deduceMainApplicationClass();}

run方法流程分析

img

跟着源码和这幅图就可以一探究竟了！

自定义Starter

初步了解了SpringBoot启动器的原理后，我们可以自己手写一个简单的starter来加深理解

新建项目

新建一个Empty Project

image-20201006143048583

取一个你喜欢的名字，比如diySpringBootStarter，Finnish后在项目结构（ProjectStructure）里新建两个Modules，

先新建一个maven模块，取名feng-spring-boot-starter，whatever you like，都可以

image-20201006143503076

再新建一个SpringBoot模块，取名feng-spring-boot-starter-autoconfigure，当然了，你想怎么取都行。

image-20201006143649125

创建完成后项目结构如下所示

image-20201006143811868

首先在starter项目中的pom文件引入我们自己配置的启动类

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.feng</groupId>
    <artifactId>feng-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.feng</groupId>
            <artifactId>feng-spring-boot-starter-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

自定义启动类中多余的东西删除

image-20201006144328920

先编写自己的服务

HelloService.java

package com.feng;

/**
 * <h3>diySpringBootStarter</h3>
 * <p></p>
 *
 * @author : Nicer_feng
 * @date : 2020-10-06 14:44
 **/
public class HelloService {
    HelloProperties helloProperties;
    public HelloProperties getHelloProperties() {
        return helloProperties;
    }
    public void setHelloProperties(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }
    public String sayHello(String name){
        return helloProperties.getPrefix() + name + helloProperties.getSuffix();
    }
}

再编写一个配置类

HelloProperties.java

package com.feng;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * <h3>diySpringBootStarter</h3>
 * <p></p>
 *
 * @author : Nicer_feng
 * @date : 2020-10-06 14:45
 **/
@ConfigurationProperties(prefix = "feng.hello")
public class HelloProperties {
    private String prefix;
    private String suffix;
    public String getPrefix() {
        return prefix;
    }
    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }
    public String getSuffix() {
        return suffix;
    }
    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

再编写一个自动配置类，并且注入bean

HelloServiceAutoConfiguration.java

package com.feng;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * <h3>diySpringBootStarter</h3>
 * <p></p>
 *
 * @author : Nicer_feng
 * @date : 2020-10-06 14:47
 **/
@Configuration
@ConditionalOnWebApplication //web应用生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {
    @Autowired
    HelloProperties helloProperties;
    @Bean
    public HelloService helloService(){
        HelloService service = new HelloService();
        service.setHelloProperties(helloProperties);
        return service;
    }
}

在resources下创建META-INF文件夹，再新建一个spring.factories

spring.factories

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.feng.HelloServiceAutoConfiguration

项目结构一览

image-20201006150115867

测试

新建一个SpringBoot项目

在新SpringBoot项目的pom.xml里导入我们自己写的启动器

<dependency>
    <groupId>com.feng</groupId>
    <artifactId>feng-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

编写一个Controller

HelloController.java

package com.feng.teststarter.controller;

import com.feng.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <h3>diySpringBootStarter</h3>
 * <p></p>
 *
 * @author : Nicer_feng
 * @date : 2020-10-06 14:52
 **/
@RestController
public class HelloController {
    @Autowired
    HelloService helloService;

    @RequestMapping("/hello")
    public String hello(){
        return helloService.sayHello("666");
    }

}

编写配置文件

application.properties

feng.hello.prefix="555"
feng.hello.suffix="888"

直接启动项目，可以看到结果成功

image-20201006150344142

注：

本文核心配置文件源码分析处参考B站狂神说，Spring入门视频推荐可以看狂神说

avatar
文章
阅读
粉丝