Spring boot 官网学习笔记

  1. Spring Boot uses a very particular PropertySource order that is designed to allow sensible overriding of values. Properties are considered in the following order:
      1. Devtools global settings properties on your home directory (~/.spring-boot-devtools.properties when devtools is active).
      2. @TestPropertySource annotations on your tests.
      3. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
      4. Command line arguments.
      5. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
        1. The SPRING_APPLICATION_JSON properties can be supplied on the command line with an environment variable. For example, you could use the following line in a UN*X shell:

$ SPRING_APPLICATION_JSON='{"acme":{"name":"test"}}' java -jar myapp.jar

In the preceding example, you end up with acme.name=test in the Spring Environment. You can also supply the JSON as spring.application.json in a System property, as shown in the following example:

$ java -Dspring.application.json='{"name":"test"}' -jar myapp.jar

You can also supply the JSON by using a command line argument, as shown in the following example:

$ java -jar myapp.jar --spring.application.json='{"name":"test"}'

You can also supply the JSON as a JNDI variable, as follows: java:comp/env/spring.application.json.
      6. ServletConfig init parameters.
      7. ServletContext init parameters.
      8. JNDI attributes from java:comp/env.
      9. Java System properties (System.getProperties()).
      10. OS environment variables.
      11. A RandomValuePropertySource that has properties only in random.*.
      12. Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants).
      13. Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants).

        1. The spring.profiles.active property follows the same ordering rules as other properties: The highest PropertySource wins. This means that you can specify active profiles in application.properties and then replace them by using the command line switch.

          Sometimes, it is useful to have profile-specific properties that add to the active profiles rather than replace them. The spring.profiles.include property can be used to unconditionally add active profiles. The SpringApplication entry point also has a Java API for setting additional profiles (that is, on top of those activated by the spring.profiles.active property). See the setAdditionalProfiles() method in SpringApplication.

          For example, when an application with the following properties is run by using the switch, --spring.profiles.active=prod, the proddb and prodmq profiles are also activated:

        2. ---
my.property: fromyamlfile
---
spring.profiles: prod
spring.profiles.include:
  - proddb
  - prodmq
      14. Application properties outside of your packaged jar (application.properties and YAML variants).
      15. Application properties packaged inside your jar (application.properties and YAML variants).
        1. 　

          SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:

          1. A /config subdirectory of the current directory
          2. The current directory
          3. A classpath /config package
          4. The classpath root

          The list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations).

        2. If you do not like application.properties as the configuration file name, you can switch to another file name by specifying a spring.config.name environment property. You can also refer to an explicit location by using the spring.config.location environment property (which is a comma-separated list of directory locations or file paths). The following example shows how to specify a different file name:

          $ java -jar myproject.jar --spring.config.name=myproject

          The following example shows how to specify two locations:

          $ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
      16. @PropertySource annotations on your @Configuration classes.
      17. Default properties (specified by setting SpringApplication.setDefaultProperties).
  2. 转：https://blog.csdn.net/isea533/article/details/50281151
  3. Spring Boot 支持多种外部配置方式，这些方式优先级如下：
    1. 命令行参数
    2. 来自java:comp/env的JNDI属性
    3. Java系统属性（System.getProperties()）
    4. 操作系统环境变量
    5. RandomValuePropertySource配置的random.*属性值
    6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
    7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
    8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
    9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
    10. @Configuration注解类上的@PropertySource
    11. 通过SpringApplication.setDefaultProperties指定的默认属性　　
  4. 命令行参数
    1. 通过java -jar app.jar --name="Spring" --server.port=9090方式来传递参数。

      参数用--xxx=xxx的形式传递。

      可以使用的参数可以是我们自己定义的，也可以是Spring Boot中默认的参数。

      很多人可能会关心如web端口如何配置这样的问题，这些都是Spring Boot中提供的参数，部分可用参数如下：

    2. 注意：命令行参数在app.jar的后面！
    3. # LOGGING
logging.path=/var/logs
logging.file=myapp.log
logging.config= # location of config file (default classpath:logback.xml for logback)
logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)

# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080
server.address= # bind to a specific NIC
server.session-timeout= # session timeout in seconds
server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha
server.context-path= # the context path, defaults to '/'
server.servlet-path= # the servlet path, defaults to '/'12345678910111213
    4. 更多常见的应用属性请浏览这里
  5. Java系统属性

    1. 注意Java系统属性位置java -Dname="isea533" -jar app.jar，可以配置的属性都是一样的，优先级不同。

      例如java -Dname="isea533" -jar app.jar --name="Spring!"中name值为Spring!

  6. 操作系统环境变量

    1. 配置过JAVA_HOME的应该都了解这一个。

      这里需要注意的地方，有些OS可以不支持使用.这种名字，如server.port，这种情况可以使用SERVER_PORT来配置。

      具体名字如何匹配，看本文后面。

  7. RandomValuePropertySource

    1. 系统中用到随机数的地方，例如： my.secret=${random.value} my.number=${random.int} my.bignumber=${random.long} my.number.less.than.ten=${random.int(10)} my.number.in.range=${random.int[1024,65536]}12345

      random.int*支持value参数和,max参数，当提供max参数的时候，value就是最小值。

  8. 应用配置文件（.properties或.yml）

    1. 应用配置文件（.properties或.yml）

      在配置文件中直接写： name=Isea533 server.port=808012

      .yml格式的配置文件如： name: Isea533 server:     port: 8080123

      当有前缀的情况下，使用.yml格式的配置文件更简单。关于.yml配置文件用法请看这里 注意：使用.yml时，属性名的值和冒号中间必须有空格，如name: Isea533正确，name:Isea533就是错的。

      属性配置文件的位置 spring会从classpath下的/config目录或者classpath的根目录查找application.properties或application.yml。

      /config优先于classpath根目录

  9. @PropertySource
    1. 这个注解可以指定具体的属性配置文件，优先级比较低。
  10. SpringApplication.setDefaultProperties
    1. SpringApplication application = new SpringApplication(Application.class);
Map<String, Object> defaultMap = new HashMap<String, Object>();
defaultMap.put("name", "Isea-Blog");
//还可以是Properties对象
application.setDefaultProperties(defaultMap);
application.run(args);





@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
    }
}
  11. 应用（使用）属性
    1. @Value(“${xxx}”)
      1. 这种方式是最简单的，通过@Value注解可以将属性值注入进来。
    2. @ConfigurationProperties
      1. Spring Boot 可以方便的将属性注入到一个配置对象中。例如：
      2. name=isea533
jdbc.username=root
jdbc.password=root
...



对应的配置类：

@ConfigurationProperties
public class Config {
    private String name;
    private Jdbc jdbc;
    class Jdbc {
        private String username;
        private String password;
        //getter...
    }

    public Integer gePort(){
        return this.port;
    }
    public Jdbc getJdbc() {
        return this.jdbc;
    }
}

jdbc开头的属性都会注入到Jdbc对象中。
      3. 在@Bean方法上使用@ConfigurationProperties
        1. @ConfigurationProperties(prefix = "foo")
@Bean
public FooComponent fooComponent() {
    ...
}
    3. 属性占位符
      1. app.name=MyApp
app.description=${app.name} is a Spring Boot application

      2. 可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）。

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

        由于${}方式会被Maven处理。如果你pom继承的spring-boot-starter-parent，Spring Boot 已经将maven-resources-plugins默认的${}方式改为了@ @方式，例如@name@。

        如果你是引入的Spring Boot，你可以修改使用其他的分隔符

    4. 属性名匹配规则
      1. 例如有如下配置对象：
@Component
@ConfigurationProperties(prefix="person")
public class ConnectionSettings {
    private String firstName;
}

firstName可以使用的属性名如下：
person.firstName，标准的驼峰式命名
person.first-name，虚线（-）分割方式，推荐在.properties和.yml配置文件中使用
PERSON_FIRST_NAME，大写下划线形式，建议在系统环境变量中使用
    5. 属性验证
      1. 可以使用JSR-303注解进行验证，例如：
@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {

    @NotNull
    private InetAddress remoteAddress;

    // ... getters and setters

}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/jiangtao1218/p/10193232.html