正文

【SpringBoot1.x】SpringBoot1.x 启动配置原理 和 自定义starter

IP云
IP云V管理员/2 阅读
08/01
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

SpringBoot1.x 启动配置原理 和 自定义starter

启动配置原理

本节源码

启动过程主要为：

  • new SpringApplication(sources) 创建 SpringApplication 对象
  • springApplication.run() 运行Spring应用程序，创建并刷新一个新的应用环境
  • 整个过程使用了事件监听机制

创建 SpringApplication 对象

SpringApplication.run(StartStarterApplication.class, args);public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
return new SpringApplication(sources).run(args);
}public SpringApplication(Object... sources) {
initialize(sources);
}private void initialize(Object[] sources) {
// 保存主配置类信息
if (sources != null && sources.length > 0) {
this.sources.addAll(Arrays.asList(sources));
} // 判断当前是否是一个 Web App
this.webEnvironment = deduceWebEnvironment(); // 从类路径下找到 META_INF/spring.factories 配置文件的 ApplicationContextInitializer，然后保存起来
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); // 从类路径下找到 META_INF/spring.factories 配置文件的 ApplicationListener，然后保存起来
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); // 从多个配置类中找到有 main() 的主配置类
this.mainApplicationClass = deduceMainApplicationClass();
}

运行Spring应用程序，创建并刷新一个新的应用环境

public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty(); // 从类路径下的 META_INF/spring.factories 中获取 SpringApplicationRunListeners
SpringApplicationRunListeners listeners = getRunListeners(args); // 回调所有的 SpringApplicationRunListener.starting()
listeners.starting();
try {
// 封装命令行参数
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // 准备环境
// 准备环境完成后，回调 SpringApplicationRunListener.environmentPrepared() 表示环境准备完成
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); // 打印 Spring 标志
Banner printedBanner = printBanner(environment); // 创建 ApplicationContext，决定创建 web 的ioc，还是普通的 ioc
context = createApplicationContext(); analyzers = new FailureAnalyzers(context); // 准备上下文环境，将 environment 保存到 ioc 中，而且调用 applyInitializers()
// 这个方法将 回调之前保存的所有的 ApplicationContextInitializer 的 initialize()
// 和 回调之前保存的所有的 SpringApplicationRunListener 的 contextPrepared()
// 准备上下文环境完成后，回调之前保存的所有的 SpringApplicationRunListener 的 contextLoaded（）
// 控制台打印：使用 PID 6894 在 192.168.0.103 上启动 主配置类
prepareContext(context, environment, listeners, applicationArguments, printedBanner); // 刷新容器，即 ioc 容器初始化，如果是 web app 还会创建嵌入式的 Tomcat
refreshContext(context); // 从 ioc 容器中获取所有的 ApplicationRunner 和 CommandLineRunner 进行回调
afterRefresh(context, applicationArguments); // 所有的 SpringApplicationRunListener 回调 finished()
listeners.finished(context, null); stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
} // 整个 SpringBoot 应用启动完成以后返回启动的 ioc 容器
return context;
}
catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}

事件监听机制

ApplicationContextInitializer、SpringApplicationRunListener 配置在 META-INF/spring.factories 中。

ApplicationRunner、CommandLineRunner 放在 ioc 容器中。

HelloApplicationContextInitializer：

public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
}
}

HelloSpringApplicationRunListener：

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {
// 必须有一个构造器
public HelloSpringApplicationRunListener(SpringApplication application, String[] arg) {
} @Override
public void starting() {
System.out.println("SpringApplicationRunListener...starting...");
} @Override
public void environmentPrepared(ConfigurableEnvironment environment) {
System.out.println("SpringApplicationRunListener...environmentPrepared.." + environment); Object o = environment.getSystemProperties().get("os.name");
System.out.println("SpringApplicationRunListener...environmentPrepared.. os.name "+o);
} @Override
public void contextPrepared(ConfigurableApplicationContext context) {
System.out.println("SpringApplicationRunListener...contextPrepared...");
} @Override
public void contextLoaded(ConfigurableApplicationContext context) {
System.out.println("SpringApplicationRunListener...contextLoaded...");
} @Override
public void finished(ConfigurableApplicationContext context, Throwable exception) {
System.out.println("SpringApplicationRunListener...finished...");
}
}

将它们配置在 META-INF/spring.factories 中：

src/main/resources/META-INF/spring.factories

org.springframework.context.ApplicationContextInitializer=\
cn.parzulpan.listener.HelloApplicationContextInitializerorg.springframework.boot.SpringApplicationRunListener=\
cn.parzulpan.listener.HelloSpringApplicationRunListener

HelloApplicationRunner：

@Component
public class HelloApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run...." + args);
}
}

HelloCommandLineRunner：

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
}
}

将它们放置在 ioc 容器中。

运行主配置类，观察打印输出，可以得到上面的结论。

自定义 starter

SpringBoot 最大的特点就是引入非常多的场景启动器，想使用那个场景就可以直接整合。

它也支持自定义场景启动器，比如 mybatis-spring-boot-starter。

编写自动配置需要的必有项：

@Configuration // 指定这个类是一个配置类
@ConditionalOnXXX // 在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter // 指定自动配置类的顺序@Bean // 给容器中添加组件
@ConfigurationPropertie // 结合相关 xxxProperties 类来绑定相关的配置
@EnableConfigurationProperties // 让 xxxProperties 生效并加入到容器中

自动配置类要能加载将需要启动就加载的自动配置类，配置在 META‐INF/spring.factories 中

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

模式总结：

  • 启动器只用来做依赖导入 xx-spring-boot-starter
  • 编写一个自动配置模块 xx-spring-boot-starter-autoconfigurer
  • 启动器依赖自动配置模块，别人使用只需要引入启动器
  • 官方命名空间: spring-boot-starter-模块名， 自定义命名空间：模块名-spring-boot-starter

自定义步骤

本节源码

前期准备：创建一个空项目 custom-starter ，向其加入一个 Maven 工厂

parzulpan-spring-boot-starter 模块，在加入一个 springboot 类型的 parzulpan-spring-boot-starte 模块。

启动器模块：

<?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>cn.parzulpan</groupId>
<artifactId>parzulpan-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version> <!-- 启动器 -->
<dependencies> <!-- 依赖自动配置模块 -->
<dependency>
<groupId>cn.parzulpan</groupId>
<artifactId>parzulpan-spring-boot-starter-configurer</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies></project>

自动配置模块：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.22.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.parzulpan</groupId>
<artifactId>parzulpan-spring-boot-starter-configurer</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>parzulpan-spring-boot-starter-configurer</name>
<description>parzulpan starter configurer</description> <properties>
<project.build.sourceEncoding>UTF‐8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF‐8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties> <dependencies>
<!-- 引入spring‐boot‐starter，它是所有 starter 的基本配置 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies></project>

编写业务类 HelloService：

package cn.parzulpan;/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : HelloService
*/public class HelloService { HelloServiceProperties helloServiceProperties; public HelloServiceProperties getHelloServiceProperties() {
return helloServiceProperties;
} public void setHelloServiceProperties(HelloServiceProperties helloServiceProperties) {
this.helloServiceProperties = helloServiceProperties;
} public String sayHelloName(String name) {
return helloServiceProperties.getPrefix() + " - " + name + " - " + helloServiceProperties.getSuffix();
}
}

编写属性类 HelloServiceProperties：

/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : HelloService 属性类
*/@ConfigurationProperties(prefix = "parzulpan.hello")
public class HelloServiceProperties {
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;
}
}

编写配置文件 src/main/resources/META-INF/spring.factories：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.parzulpan.HelloServiceAutoConfiguration

编写自动配置类 HelloServiceAutoConfiguration：

/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : HelloService 自动配置类
*/@Configuration
@ConditionalOnWebApplication // web app 才有效
@EnableConfigurationProperties(HelloServiceProperties.class) // 让 HelloServiceProperties 生效并加入到容器中
public class HelloServiceAutoConfiguration { @Autowired
HelloServiceProperties helloServiceProperties; @Bean
public HelloService helloService() {
HelloService helloService = new HelloService();
helloService.setHelloServiceProperties(helloServiceProperties);
return helloService;
}
}

将这两个模块分别 install 到本地，然后测试使用，创建一个 SpringBoot Web 项目 custom-starter-test ，引入自定义 starter。测试源码

<!-- 引入自定义 starter -->
<dependency>
<groupId>cn.parzulpan</groupId>
<artifactId>parzulpan-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>

编写配置文件 application.properties：

parzulpan.hello.prefix=PARZULPAN
parzulpan.hello.suffix=HELLO WORLD

编写控制类：

/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc :
*/@RestController
public class HelloController { @Autowired
HelloService helloService; // http://localhost:8080/hello
@GetMapping("/hello")
public String hello() {
return helloService.sayHelloName("curry");
}
}

练习和总结