Spring Boot Starters启动器

Spring Boot Starters启动器

图片

 

Starters是什么？

Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成Spring及其他技术，而不需要到处找示例代码和依赖包。如你想使用Spring JPA访问数据库，只要加入spring-boot-starter-data-jpa启动器依赖就能使用了。

Starters包含了许多项目中需要用到的依赖，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖。

Starters命名

Spring Boot官方的启动器都是以spring-boot-starter-命名的，代表了一个特定的应用类型。

第三方的启动器不能以spring-boot开头命名，它们都被Spring Boot官方保留。一般一个第三方的应该这样命名，像mybatis的mybatis-spring-boot-starter。

图片

Starters分类

1. Spring Boot应用类启动器

启动器名称 功能描述
spring-boot-starter 包含自动配置、日志、YAML的支持。
spring-boot-starter-web 使用Spring MVC构建web 工程，包含restful，默认使用Tomcat容器。
... ...

2. Spring Boot生产启动器

启动器名称 功能描述
spring-boot-starter-actuator 提供生产环境特性，能监控管理应用。

3. Spring Boot技术类启动器

启动器名称 功能描述
spring-boot-starter-json 提供对JSON的读写支持。
spring-boot-starter-logging 默认的日志启动器，默认使用Logback。
... ...

4. 其他第三方启动器

更多可以参考下面链接。

https://github.com/spring-projects/spring-boot/blob/master/spring-boot-starters/README.adoc

用过 Spring Boot 的都知道在 Spring Boot 中有以下两种配置文件

  • bootstrap (.yml 或者 .properties)

  • application (.yml 或者 .properties)

为什么会有这两种配置文件呢？大家都清楚它们的区别和具体使用场景吗？

bootstrap/ application 的区别

特意去翻了下 Spring Boot 的官方文档，没有找到关于这两种文件的具体定义，然后再翻了下 Spring Cloud 的官方文档找到了它们的区别。

http://cloud.spring.io/spring-cloud-static/Edgware.SR3/single/spring-cloud.html#thebootstrapapplicationcontext

认真阅读了下文档，原文大概意思是这样。

Spring Cloud 构建于 Spring Boot 之上，在 Spring Boot 中有两种上下文，一种是 bootstrap, 另外一种是 application, bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于 applicaton。bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，它们默认也不能被本地相同配置覆盖。

因此，对比 application 配置文件，bootstrap 配置文件具有以下几个特性。

  • boostrap 由父 ApplicationContext 加载，比 applicaton 优先加载

  • boostrap 里面的属性不能被覆盖

bootstrap/ application 的应用场景

application 配置文件这个容易理解，主要用于 Spring Boot 项目的自动化配置。

bootstrap 配置文件有以下几个应用场景。

  • 使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；

  • 一些固定的不能被覆盖的属性

  • 一些加密/解密的场景；

以下这个截图是一个国外网友问了一个 Spring Cloud 工程师得到的回答。

图片

做过 Spring Cloud 微服务的朋友应该对 bootstrap 的应用十分清楚，我们也有 Spring Cloud 的实战教程，在 Spring 专题中都能看到。

使用 Spring Boot 会涉及到各种各样的配置，如开发、测试、线上就至少 3 套配置信息了。Spring Boot 可以轻松的帮助我们使用相同的代码就能使开发、测试、线上环境使用不同的配置。

在 Spring Boot 里面，可以使用以下几种方式来加载配置。本章内容基于 Spring Boot 2.0 进行详解。

1、properties文件；

2、YAML文件；

3、系统环境变量；

4、命令行参数；

等等……

配置属性加载的顺序如下：

1、开发者工具 `Devtools` 全局配置参数；

2、单元测试上的 `@TestPropertySource` 注解指定的参数；

3、单元测试上的 `@SpringBootTest` 注解指定的参数；

4、命令行指定的参数，如 `java -jar springboot.jar --name="Java技术栈"`；

5、命令行中的 `SPRING_APPLICATION_JSONJSON` 指定参数, 如 `java -Dspring.application.json='{"name":"Java技术栈"}' -jar springboot.jar`

6、`ServletConfig` 初始化参数；

7、`ServletContext` 初始化参数；

8、JNDI参数（如 `java:comp/env/spring.application.json`）；

9、Java系统参数（来源：`System.getProperties()`）；

10、操作系统环境变量参数；

11、`RandomValuePropertySource` 随机数，仅匹配：`ramdom.*`；

12、JAR包外面的配置文件参数（`application-{profile}.properties（YAML）`）

13、JAR包里面的配置文件参数（`application-{profile}.properties（YAML）`）

14、JAR包外面的配置文件参数（`application.properties（YAML）`）

15、JAR包里面的配置文件参数（`application.properties（YAML）`）

16、`@Configuration`配置文件上 `@PropertySource` 注解加载的参数；

17、默认参数（通过 `SpringApplication.setDefaultProperties` 指定）；

数字小的优先级越高，即数字小的会覆盖数字大的参数值，我们来实践下，验证以上配置参数的加载顺序。

1、在主应用程序中添加 Java 系统参数。

@Bean
public CommandLineRunner commandLineRunner() {
    return (args) -> {
        System.setProperty("name", "javastack-system-properties");
    };
}

2、在 application.properties 文件中添加属性。

name = javastack-application

3、在 application-dev.properties 文件中添加属性。

name = javastack-application-dev

4、添加测试类

@RunWith(SpringRunner.class)
@SpringBootTest(value = { "name=javastack-test", "sex=1" })
@ActiveProfiles("dev")
public class SpringBootBestPracticeApplicationTests {

    @Value("${name}")
    private String name;

    @Test
    public void test() {
        System.out.println("name is " + name);
    }

}

运行 test 单元测试，程序输出：

name is javastack-test

根据以上参数动态调整，发现参数会被正确被覆盖。了解了 Spring Boot 各种配置的加载顺序，如果配置被覆盖了我们就知道是什么问题了。

在Spring Boot实现代码热部署是一件很简单的事情，代码的修改可以自动部署并重新热启动项目。

引用devtools依赖

  1. <dependency>

  2.    <groupId>org.springframework.boot</groupId>

  3.    <artifactId>spring-boot-devtools</artifactId>

  4.    <optional>true</optional>

  5. </dependency>

这样，当修改一个java类时就会热更新。

自定义配置热部署

以下配置用于自定义配置热部署，可以不设置。

  1. # 热部署开关，false即不启用热部署

  2. spring.devtools.restart.enabled: true

  3.  

  4. # 指定热部署的目录

  5. #spring.devtools.restart.additional-paths: src/main/java

  6.  

  7. # 指定目录不更新

  8. spring.devtools.restart.exclude: test/**

Intellij Idea修改

如果是idea，需要改以下两个地方：

1、勾上自动编译或者手动重新编译

File > Settings > Compiler-Build Project automatically

2、注册

ctrl + shift + alt + / > Registry > 勾选Compiler autoMake allow when app running

注意事项

1、生产环境devtools将被禁用，如java -jar方式或者自定义的类加载器等都会识别为生产环境。

2、打包应用默认不会包含devtools，除非你禁用SpringBoot Maven插件的 excludeDevtools属性。

3、Thymeleaf无需配置 spring.thymeleaf.cache:false，devtools默认会自动设置，参考完整属性。

https://github.com/spring-projects/spring-boot/blob/v1.5.7.RELEASE/spring-boot-devtools/src/main/java/org/springframework/boot/devtools/env/DevToolsPropertyDefaultsPostProcessor.java

下面是devtools自动配置的部分源码：

  1. @Order(Ordered.LOWEST_PRECEDENCE)

  2. public class DevToolsPropertyDefaultsPostProcessor implements EnvironmentPostProcessor {

  3.  

  4.    private static final Map<String, Object> PROPERTIES;

  5.  

  6.    static {

  7.        Map<String, Object> properties = new HashMap<String, Object>();

  8.        properties.put("spring.thymeleaf.cache", "false");

  9.        properties.put("spring.freemarker.cache", "false");

  10.        properties.put("spring.groovy.template.cache", "false");

  11.        properties.put("spring.mustache.cache", "false");

  12.        properties.put("server.session.persistent", "true");

  13.        properties.put("spring.h2.console.enabled", "true");

  14.        properties.put("spring.resources.cache-period", "0");

  15.        properties.put("spring.resources.chain.cache", "false");

  16.        properties.put("spring.template.provider.cache", "false");

  17.        properties.put("spring.mvc.log-resolved-exception", "true");

  18.        properties.put("server.jsp-servlet.init-parameters.development", "true");

  19.        PROPERTIES = Collections.unmodifiableMap(properties);

  20.    }

4、devtools会在windows资源管理器占用java进程，在开发工具里面杀不掉，只能手动kill掉，不然重启会选成端口重复绑定报错。

关于boot-devtools更多详细用法，参考官方文档。

https://docs.spring.io/spring-boot/docs/current/reference/html/using-boot-devtools.html

 

Spring Boot依赖

使用Spring Boot很简单，先添加基础依赖包，有以下两种方式

1. 继承spring-boot-starter-parent项目

  1. <parent>

  2.    <groupId>org.springframework.boot</groupId>

  3.    <artifactId>spring-boot-starter-parent</artifactId>

  4.    <version>1.5.6.RELEASE</version>

  5. </parent>

2. 导入spring-boot-dependencies项目依赖

  1. <dependencyManagement>

  2.    <dependencies>

  3.        <dependency>

  4.            <groupId>org.springframework.boot</groupId>

  5.            <artifactId>spring-boot-dependencies</artifactId>

  6.            <version>1.5.6.RELEASE</version>

  7.            <type>pom</type>

  8.            <scope>import</scope>

  9.        </dependency>

  10. </dependencyManagement>

 

图片

Spring Boot依赖注意点

1. 属性覆盖只对继承有效

This only works if your Maven project inherits (directly or indirectly) from spring-boot-dependencies. If you have added spring-boot-dependencies in your own dependencyManagement section withimportyou have to redefine the artifact yourself instead of overriding the property.

Spring Boot依赖包里面的组件的版本都是和当前Spring Boot绑定的，如果要修改里面组件的版本，只需要添加如下属性覆盖即可，但这种方式只对继承有效，导入的方式无效。

  1. <properties>

  2.    <slf4j.version>1.7.25<slf4j.version>

  3. </properties>

如果导入的方式要实现版本的升级，达到上面的效果，这样也可以做到，把要升级的组件依赖放到Spring Boot之前。

  1. <dependencyManagement>

  2.    <dependencies>

  3.        <!-- Override Spring Data release train provided by Spring Boot -->

  4.        <dependency>

  5.            <groupId>org.springframework.data</groupId>

  6.            <artifactId>spring-data-releasetrain</artifactId>

  7.            <version>Fowler-SR2</version>

  8.            <scope>import</scope>

  9.            <type>pom</type>

  10.        </dependency>

  11.        <dependency>

  12.            <groupId>org.springframework.boot</groupId>

  13.            <artifactId>spring-boot-dependencies</artifactId>

  14.            <version>1.5.6.RELEASE</version>

  15.            <type>pom</type>

  16.            <scope>import</scope>

  17.        </dependency>

  18.    </dependencies>

  19. </dependencyManagement>

Each Spring Boot release is designed and tested against a specific set of third-party dependencies. Overriding versions may cause compatibility issues.

需要注意，要修改Spring Boot的依赖组件版本可能会造成不兼容的问题。

图片

2. 资源文件过滤问题

使用继承Spring Boot时，如果要使用Maven resource filter过滤资源文件时，资源文件里面的占位符为了使${}和Spring Boot区别开来，此时要用@...@包起来，不然无效。另外，@...@占位符在yaml文件编辑器中编译报错，所以使用继承方式有诸多问题，坑要慢慢趟。

Spring Boot日志框架

Spring Boot支持Java Util Logging,Log4j2,Lockback作为日志框架，如果你使用starters启动器，Spring Boot将使用Logback作为默认日志框架。无论使用哪种日志框架，Spring Boot都支持配置将日志输出到控制台或者文件中。

spring-boot-starter启动器包含spring-boot-starter-logging启动器并集成了slf4j日志抽象及Logback日志框架。

属性配置日志

Spring Boot支持属性配置日志参数，这个不是很灵活，不细讲。

参考配置：

  1. # LOGGING

  2. logging.config= # Location of the logging configuration file. For instance `classpath:logback.xml` for Logback

  3. logging.exception-conversion-word=%wEx # Conversion word used when logging exceptions.

  4. logging.file= # Log file name. For instance `myapp.log`

  5. logging.level.*= # Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`

  6. logging.path= # Location of the log file. For instance `/var/log`

  7. logging.pattern.console= # Appender pattern for output to the console. Only supported with the default logback setup.

  8. logging.pattern.file= # Appender pattern for output to the file. Only supported with the default logback setup.

  9. logging.pattern.level= # Appender pattern for log level (default %5p). Only supported with the default logback setup.

  10. logging.register-shutdown-hook=false # Register a shutdown hook for the logging system when it is initialized.

如：

  1. logging.level.root=DEBUG

  2. logging.level.org.springframework.web=DEBUG

  3. logging.level.org.hibernate=ERROR

自定义日志文件

根据不同的日志框架，默认加载的日志配置文件的文件名，放在资源根目录下，其他的目录及文件名不能被加载。

Logging System Customization
Logback logback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2 log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging) logging.properties

既然默认自带了Logback框架，Logback也是最优秀的日志框架，往资源目录下创建一个logback-spring.xml即可，下面是一个参考配置文件。

  1. <?xml version="1.0" encoding="UTF-8"?>

  2. <configuration debug="false">

  3.  

  4.    <springProperty scope="context" name="APP_NAME" source="spring.application.name"/>

  5.    <springProperty scope="context" name="APP_PORT" source="server.port"/>

  6.    <springProperty scope="context" name="DEFAULT_APP_PORT" source="spring.application.port"/>

  7.  

  8.    <property name="OS_NAME" value="${os.name}"/>

  9.    <if condition='property("OS_NAME").contains("Windows")'>

  10.        <then>

  11.            <property name="LOG_PATH" value="${LOG_PATH:-E:/logs}" />

  12.        </then>

  13.        <else>

  14.            <property name="LOG_PATH" value="${LOG_PATH:-/log}" />

  15.        </else>

  16.    </if>      

  17.  

  18.    <property name="LOG_DIR" value="${APP_NAME:-system}" />

  19.    <property name="APP_PORT" value="${APP_PORT:-${DEFAULT_APP_PORT:-0}}" />

  20.    <if condition='!property("APP_PORT").equals("0")'>

  21.        <then>

  22.            <property name="LOG_DIR" value="${LOG_DIR}-${APP_PORT}" />

  23.        </then>

  24.    </if>

  25.  

  26.  

  27.    <!-- 控制台输出 -->

  28.    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">

  29.        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">

  30.            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度，%msg：日志消息，%n是换行符 -->

  31.            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

  32.        </encoder>

  33.    </appender>

  34.  

  35.    <!-- 按照每天生成日志文件 -->

  36.    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

  37.        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">

  38.            <level>INFO</level>

  39.        </filter>

  40.        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

  41.            <!--日志文件输出的文件名 -->

  42.            <FileNamePattern>${LOG_PATH}/${LOG_DIR}/info.log.%d{yyyy-MM-dd}.log</FileNamePattern>

  43.  

  44.            <!--日志文件保留天数 -->

  45.            <MaxHistory>30</MaxHistory>

  46.        </rollingPolicy>

  47.  

  48.        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">

  49.            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->

  50.            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

  51.        </encoder>

  52.  

  53.        <!--日志文件最大的大小 -->

  54.        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">

  55.            <MaxFileSize>10MB</MaxFileSize>

  56.        </triggeringPolicy>

  57.  

  58.    </appender>

  59.  

  60.    <!-- 按照每天生成日志文件 error级别 -->

  61.    <appender name="FILE-ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">

  62.        <filter class="ch.qos.logback.classic.filter.LevelFilter">

  63.            <level>ERROR</level>

  64.            <onMatch>ACCEPT</onMatch>

  65.            <onMismatch>DENY</onMismatch>

  66.        </filter>  

  67.        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

  68.            <!--日志文件输出的文件名 -->

  69.            <FileNamePattern>${LOG_PATH}/${LOG_DIR}/error.log.%d{yyyy-MM-dd}.log</FileNamePattern>

  70.  

  71.            <!--日志文件保留天数 -->

  72.            <MaxHistory>30</MaxHistory>

  73.        </rollingPolicy>

  74.  

  75.        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">

  76.            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->

  77.            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>

  78.        </encoder>

  79.  

  80.        <!--日志文件最大的大小 -->

  81.        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">

  82.            <MaxFileSize>10MB</MaxFileSize>

  83.        </triggeringPolicy>

  84.  

  85.    </appender>

  86.  

  87.    <!--myibatis log configure -->

  88.    <logger name="com.apache.ibatis" level="TRACE" />

  89.    <logger name="java.sql.Connection" level="DEBUG" />

  90.    <logger name="java.sql.Statement" level="DEBUG" />

  91.    <logger name="java.sql.PreparedStatement" level="DEBUG" />

  92.  

  93.    <!-- 日志输出级别 -->

  94.    <root level="INFO">

  95.        <appender-ref ref="STDOUT" />

  96.        <appender-ref ref="FILE" />

  97.        <appender-ref ref="FILE-ERROR" />

  98.    </root>

  99.  

  100. </configuration>

强烈推荐使用logback-spring.xml作为文件名，因为logback.xml加载太早。

日志初始化在ApplicationContext创建之前，所以@PropertySources加载的配置是读取不到的，系统环境变量、Spring Environment及application,bootstrap配置文件中的信息可以读取到。

读取系统环境属性：

  1. <property name="LOG_PATH" value="${LOG_PATH:-E:/logs}" />

读取当前应用Environment中的属性：

  1. <springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"

  2.        defaultValue="localhost"/>

Spring Boot也支持通过springProfile来加载不同profiles下的配置。

  1. <springProfile name="staging">

  2.    <!-- configuration to be enabled when the "staging" profile is active -->

  3. </springProfile>

  4.  

  5. <springProfile name="dev, staging">

  6.    <!-- configuration to be enabled when the "dev" or "staging" profiles are active -->

  7. </springProfile>

  8.  

  9. <springProfile name="!production">

  10.    <!-- configuration to be enabled when the "production" profile is not active -->

  11. </springProfile>

  12.  

Spring Boot自动配置原理、实战

Spring Boot读取配置的几种方式

 

posted @ 2023-08-11 17:03  CharyGao  阅读(129)  评论(0)  编辑  收藏  举报