spring Boot重点岗要(一)pom文件-配置文件等

ゝ一世哀愁。 2022-05-26 21:17 382阅读 0赞

*  第一、从pom.xml文件开始
    
     *  1.导出jar/war
     *  2.spring-boot-starter-parent
     *  其它starter
 *  第二、springboot约定的代码结构
 *  第三、属性文件application.propertier或application.yml
    
     *  2者区别
     *  修改配置文件名
     *  通过@Value(“$\{属性名\}”)注解来加载对应的配置属性
     *  通过命令行设置属性值
     *  多环境配置
     *  @ConfigurationProperties根据前缀分类映射到不同对象
     *  Spring Boot 还支持嵌套属性注入，例如：
     *  属性间的引用（占位符）
     *  属性名匹配规则
     *  属性验证

Spring Boot的主要优点：

\-为所有Spring开发者更快的入门  
\- 开箱即用，提供各种默认配置来简化项目配置  
\- 内嵌式容器简化Web项目  
\- 没有冗余代码生成和XML配置的要求

从这几个特点我们不难发现，springBoot帮我们自动配置了很多功能，省去我们自己配置，在pom里引入功能模块开箱即用。同时，即然是开箱即用，则表示我们第一步需要了解springboot给我们配置的规则，学习的重点转移到`潜规则`学习上，当然这是一次性的，懂了即可，甚至记得大概也可。

在这里【[初始化一个springboot项目代码地址][springboot]】可以初始化一个springboot代码。

# 第一、从pom.xml文件开始 #

看一个全的pom.xml代码

<?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.example</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>demo</name>
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.1.RELEASE</version>
            <relativePath /> 
        </parent>
    
        <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>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
            <finalName>demo</finalName>
        </build>
    </project>

Spring Boot依赖使用的groupId所有都为`org.springframework.boot`，项目一般继承于父类`spring-boot-starter-parent`，同时可添加springBoot封装好的一些依赖`spring-boot-starter-XXXX`。  
Spring Boot提供了一个可选的Maven插件，用于创建可执行jars，一旦spring-boot-maven-plugin被包含到你的pom.xml中，它就会自动尝试使用spring-boot:repackage目标重写存档以使它们能够执行。

## 1.导出jar/war ##

指定`<packaging>jar</packaging>`或`<packaging>war</packaging>`导出格式。  
`以idea工具为便，导出jar/war`。  
idea界面最右边有个`Maven Project`选项卡，点开，选择`install`命令，它是maven命令，相当于`mvn clean install`.在项目target目录下会生成`XXX-0.0.1-SNAPSHOT.jar`和`XXX-0.0.1-SNAPSHOT.jar.original`,前一个是`胖jar`意思是它所有依赖的jar都被包括在内，后面是不包含依赖jar的文件。

## 2.spring-boot-starter-parent ##

它是一个特殊的starter，提供了有用的Maven默认设置，它有版本号，同时Springboot提供很多”Starters”简化添加jars到classpath的操作，它们只简单提供开发特定类型应用所需的依赖,`导入其他的starters放心的省略版本号好了`。  
`Spring Boot参考`指南罗列出它的一些默认设置：  
\- 默认编译级别为Java 1.6  
\- 源码编码为UTF-8  
\- 一个\[Dependency management\](./13.1. Dependency management.md)节点，允许你省略常见依赖的标签，继承自spring-boot-dependencies POM。  
\- 恰到好处的资源过滤  
\- 恰到好处的插件配置（exec插件，surefire，Git commit ID，shade）  
\- 恰到好处的对application.properties和application.yml进行筛选，包括特定profile（profile-specific）的文件，比如application-foo.properties和application-foo.yml

所以修改jdk用1.8的话，则

## 其它starter ##

[其它starter][starter]

--------------------

# 第二、springboot约定的代码结构 #

这里说约定而不是规定是因为Spring Boot不要求使用任何特殊的代码结构，不过，遵循以下的一些最佳实践还是挺有帮助的。  
1、类尽量在包下，禁止无包名的类。  
2、**通常建议将应用的main类放到其他类所在包的顶层(root package)**，并将@EnableAutoConfiguration注解到你的main类上，这样就隐式地定义了一个基础的包搜索路径（search package），以搜索某些特定的注解实体（比如@Service，@Component等） 。

--------------------

# 第三、属性文件application.propertier或application.yml #

在 spring boot 中，有两种配置文件，一种是application.properties,另一种是application.yml,两种都可以配置spring boot 项目中的一些变量的定义，参数的设置等。[yml配置官方介绍][yml]

## 2者区别 ##

**application.properties 配置文件在写的时候要写完整**，如：  
spring.profiles.active=dev  
spring.datasource.data-username=root  
spring.datasource.data-password=root  
在yml 文件中配置的话，写法如下：

**yml 文件在写的时候层次感强，当有前缀的情况下，使用.yml格式的配置文件更简单。**  
spring:  
profiles:  
active: prod  
datasource:  
driver-class-name: com.mysql.jdbc.Driver  
url: jdbc:mysql://127.0.0.1:3306/test  
username: root  
password: root

> 注意：使用`.yml`时，属性名的值和冒号中间必须有空格，如`name: cy`正确，`name:cy`就是错的。  
> YAML文件可以由一或多个文档组成（相对独立的组织结构组成），文档间使用“—”（三个横线）做为文档开始,使用“…”（三个点号）作为结束符（可选），如果只是单个文档，分隔符“—”可省略

除了格式不一样外，在代码里取值方式是一样的。后面以application.properties为便说明属性配置。  
application.properties文件是springboot提供的通用默认配置文件。springboot每个引入的模块都有自己的配置，所以application.properties一般用于配置全局属性。

SpringApplication将从以下位置加载application.properties文件，并把它们添加到Spring Environment中：

1.  列表内容
2.  当前目录下的/config子目录。
3.  当前目录。
4.  classpath下的/config包。
5.  classpath根路径（root）。  
    该列表是按优先级排序的（列表中位置高的路径下定义的属性将覆盖位置低的）。

## 修改配置文件名 ##

如果不喜欢将application.properties作为配置文件名，你可以通过指定spring.config.name环境属性来切换其他的名称，也可以使用spring.config.location环境属性引用一个明确的路径（目录位置或文件路径列表以逗号分割）。  
`java -jar myproject.jar --spring.config.name=myproject`  
或  
`java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties`

## 通过@Value(“$\{属性名\}”)注解来加载对应的配置属性 ##

定义属性与获取  
例如application.properties内容：

security.app.nm=app
    myName=cy

`通过@Value("${属性名}")注解来加载对应的配置属性`

@Component
    public class AppProperties { 
        @Value("${security.app.nm}")
        private String appNm;
    
        @Value("${myName}")
        private String myName;
    
        public String getAppNm() {
            return appNm;
        }
    
        public void setAppNm(String appNm) {
            this.appNm = appNm;
        }
    
        public String getMyName() {
            return myName;
        }
    
        public void setMyName(String myName) {
            this.myName = myName;
        }
    }

使用@Component标识组件被spring管理。然后使用@Autowired按byType取，即可拿到属性值。

@Controller
    @RequestMapping("/bss")
    public class TestController { 
        @Autowired
        private AppProperties appProperties;
        @GetMapping("/testProperties")
        @ResponseBody
        public String testProperties() {
            String  value = appProperties.getAppNm() + ":" + appProperties.getMyName();
            return value;
        }
    }

## 通过命令行设置属性值 ##

例如`java -jar xxx.jar --server.port=8888`通过使用`--server.port`属性来设置xxx.jar应用的端口为8888。在命令行运行时，连续的两个减号–就是对application.properties中的属性值进行赋值的标识。所以`java -jar xxx.jar --server.port=8888`命令，等价于我们在application.properties中添加属性–server.port=8888

> 屏蔽命令行访问属性的设置`SpringApplication.setAddCommandLineProperties(false)`

## 多环境配置 ##

对于多环境的配置，各种项目构建工具或是框架的基本思路是一致的，通过配置多份不同环境的配置文件，再通过打包命令指定需要打包的内容之后进行区分打包，Spring Boot也不例外，或者说更加简单。  
在Spring Boot中多环境配置文件名需要满足application-\{profile\}.properties的格式，其中\{profile\}对应你的环境标识，比如：

1.  `application-dev.properties`：开发环境
2.  `application-test.properties`：测试环境
3.  `application-prod.properties`：生产环境  
    dev,test,prod本身没有意义，意义产生于我们指定。在application.properties里指定spring.profiles.active值来使用当前是哪个环境，如果`spring.profiles.active=dev`当前是开发环境。  
    在线上启动项目时指定使用的环境。`java -jar xxx.jar --spring.profiles.active=prod`

总结：  
\- 在application.properties里指定开发环境文件，开发环境指定`spring.profiles.active=dev`。  
\- 代码提供到线上部署成功后，启动项目切换到生产环境`java -jar xxx.jar --spring.profiles.active=prod`。  
完整介绍请移步[Spring Boot属性配置文件详解][Spring Boot]

## @ConfigurationProperties根据前缀分类映射到不同对象 ##

使用`@Value("${property}")`注解注入配置属性有时会比较麻烦（cumbersome），特别是需要使用多个properties，或数据本身有层次结构。Spring Boot提供一种使用配置的替代方法，这种方法允许强类型的beans以管理和校验应用的配置。  
Spring Boot 可以方便的将属性注入到一个配置对象中。例如：

test.name=cy
    test.port=8090
    test.servers[0]=dev.bar.com
    test.servers[1]=foo.bar.com

对应对象：

@ConfigurationProperties(prefix="test")
    public class Config {
        private String name;
        private Integer port;
        private List<String> servers = new ArrayList<String>();
    
        public String geName(){
            return this.name;
        }
    
        public Integer gePort(){
            return this.port;
        }
        public List<String> getServers() {
            return this.servers;
        }
    }

Spring Boot 会自动将prefix=”my”前缀为my的属性注入进来。  
Spring Boot 会自动转换类型，当使用List的时候需要注意在配置中对List进行初始化！  
注意，新版的已经将`location`属性移除。可能它不想把一个配置文件绑定到一个类上。如果实现想指定资源路径，可如下替代：

@Component
    @ConfigurationProperties(prefix = "test")
    @PropertySource("classpath:test.properties")

## Spring Boot 还支持嵌套属性注入，例如： ##

name=cy
    redis.ip=127.0.0.1
    redis.password=root

对应配置类

@ConfigurationProperties
    public class Config {
        private String name;
        private Redis redis;
        class Redis  {
            private String ip;
            private String password;
            //getter...
        }
    
        public Integer gePort(){
            return this.port;
        }
        public Jdbc getRedis() {
            return this.redis;
        }
    }

jdbc开头的属性都会注入到Jdbc对象中。

## 属性间的引用（占位符） ##

属性间的引用（占位符）是对前面使用变量的引用.如

app.name=MyApp
    app.description=${app.name} is a Spring Boot application
    server.port=${port:8080}

通过如`${app.name:默认名称}`方法还可以设置默认值，当找不到引用的属性时，会使用默认的属性。

## 属性名匹配规则 ##

@Component
    @ConfigurationProperties(prefix="person")
    public class ConnectionSettings { 
    
        private String firstName;
    
    }

firstName可以使用的属性名如下：  
`person.firstName`，标准的驼峰式命名  
`person.first-name`，虚线（-）分割方式，推荐在.properties和.yml配置文件中使用  
`PERSON_FIRST_NAME`，大写下划线形式，建议在系统环境变量中使用

## 属性验证 ##

可以使用JSR-303注解进行验证，例如：

@Component
    @ConfigurationProperties(prefix="test")
    public class ConnectionSettings { 
        @NotNull
        private Redis redis;
        // ... getters and setters
    }

[官文提供的属性][Link 1]  
总结下来,配置方式有2种,application.yml格式比较多,因为现阶段IDEA比较流行.然后就是配置属性,在代码里使用`@Value("${属性名}")注解取值`或`@ConfigurationProperties映射`,尽量设置属性简单些,那么其它注点都不用考虑了.`所以关键是定义属性并取值和多环境配置`

[springboot]: http://start.spring.io/
[starter]: https://blog.csdn.net/u014430366/article/details/53648139
[yml]: https://docs.spring.io/spring-boot/docs/1.2.3.RELEASE/reference/html/boot-features-external-config.html#boot-features-external-config-yaml
[Spring Boot]: http://blog.didispace.com/springbootproperties/
[Link 1]: https://docs.spring.io/spring-boot/docs/1.2.3.RELEASE/reference/html/common-application-properties.html