[TOC] # springboot  --- **加这个maven,配置的时候会给提示** ~~~ <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> ~~~ ## 自定义properties文件 在spring boot启动类或配置类中添加以下注解，可在启动时载入自定义的配置文件,**不能加载yaml** ~~~ @PropertySource("classpath:config/xxx.properties") ~~~ 如果要同时载入多个文件 ~~~ @PropertySource(value={"classpath:config/a.properties","classpath:config/b.properties"}) ~~~ ## 批量注入到类变量 在properties中配置两个以a为前缀的参数 ~~~ a.key1=values1 a.key2=values2 ~~~ 在JAVA中用`@ConfigurationProperties`将以a为前缀的参数注入到当前变量中，需要有`setXxx()`方法. 告诉这个类的属性都是配置文件里的属性，prefix 指定读取配置文件的前缀。 ~~~ @RestController @ConfigurationProperties(prefix = "a") public class SampleController { private String key1; private String key2; ~~~ ## 适合多处使用 配置文件先注入到配置类中,然后再使用配置类 首先配置文件为application.properties ~~~ jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/app jdbc.username=root jdbc.password=root jdbc.desc=${jdbc.url}--${jdbc.driverClassName} ~~~ 然后写个配置类 ~~~ import lombok.Data; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; //编写配置文件的属性的(prefix是配置文件中前缀的意思,要和配置文件对应) @ConfigurationProperties(prefix = "jdbc") @Data @Component public class JdbcProperties { private String driverClassName; private String url; private String username; private String password; } ~~~ idea中去除红线  然后要把这些配置使用起来的话 指定下就行 ~~~ @Configuration //指定要用的配置属性,找ConfigurationProperties被这个配置过的,括号指定是那个 @EnableConfigurationProperties(JdbcProperties.class) public class JdbcConfig { //这边参数就可以直接注入进来了,返回的在spring容器里面 @Bean public DataSource dataSource(JdbcProperties jdbcProperties) { DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(jdbcProperties.getDriverClassName()); dataSource.setUrl(jdbcProperties.getUrl()); dataSource.setUsername(jdbcProperties.getUsername()); dataSource.setPassword(jdbcProperties.getPassword()); return dataSource; } } ~~~ ## 适合自己使用 ~~~ ConfigurationProperties(prefix="") ~~~ 这个也可以用在类上,根据前缀找配置文件,然后给类的属性set值 还有就是在方法上把配置文件直接注入了 ~~~ @Bean //要使用以jdbc开头这个属性,检查你返回的类有没有这个属性的setXX方法,有就自动注入 @ConfigurationProperties(prefix = "jdbc") public DataSource dataSource() { return new DruidDataSource(); } ~~~ 外加个配置文件 ## 一些注解 `@SpringBootConfiguration`和`@Configuration`是一个应用中只能存在一个 `@EnableAutoConfiguration`是启动自动配置开关,是猜测想要怎么配置bean 扫描包`@ComponentScan`默认是扫描当前包和他子包,如果你把启动文件放到其他地方,可以重写这个注解来标注要扫哪些包 看springboot源码: `prefix = "server"` 表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类 的字段中。 ~~~ server.port=8888 #当前web应用的名称,url的前缀 server.servlet.context-path=/demo ~~~ `@ConditionalOnMissingBean`这个表示如果你没配置他就生效,你配置了他就不生效,默认配置,可覆盖的意思 ## 编码 ~~~ server.tomcat.uri-encoding=UTF-8 spring.http.encoding.charset=UTF-8 spring.http.encoding.enabled=true spring.http.encoding.force=true spring.messages.encoding=UTF-8 ~~~ ## 日志 ~~~ # DETECT：会检查终端是否支持ANSI，是的话就采用彩色输出（推荐项） # NEVER：禁用ANSI-colored输出（默认项）,ALWAYS总是 spring.output.ansi.enabled=DETECT # level后面是包,可以精细到包层级,TRACE < DEBUG < INFO < WARN < ERROR < FATAL。 logging.level.root=info #logging.level.com=debug #logging.level.root=WARN #logging.level.org.springframework.web=DEBUG #logging.level.org.hibernate=ERROR # 启动的时候 有大量的条件资源评估报告 logging.level.org.springframework.boot.autoconfigure=error # 日志输出到文件中 logging.file=/xx # 日志输出到文件夹中 #logging.path=mylog/test/ ~~~ >简单分析一下，日志分为以下部分 >时间日期：精确到毫秒 >日志级别：ERROR, WARN, INFO, DEBUG or TRACE >进程ID >分隔符：— 标识实际日志的开始 >线程名：方括号括起来（可能会截断控制台输出） >Logger名：通常使用源代码的类名 >日志内内容 **日志组** 能够将相关记录器组合在一起以便可以同时配置它们通常很有用. 了解决这个问题，Spring Boot允许您在Spring中定义日志记录组 。 application.properties ~~~ logging.group.tomcat=org.apache.catalina, org.apache.coyote, org.apache.tomcat logging.level.tomcat=TRACE ~~~ Spring Boot包含以下预定义的日志记录组，可以直接使用： | 名称 | 记录器 | | --- | --- | | web | org.springframework.core.codec, org.springframework.http,[org.springframework.web](http://org.springframework.web/) | | sql | org.springframework.jdbc.core, org.hibernate.SQL | # pom.xml指定启动类 在上面的插件源码中还有一个${start-class}，当我们的项目中有多个main启动类时，通过在pom.xml中覆盖这一参数，可以指定从哪一个类启动 ~~~ <properties> <java.version>1.8</java.version> <start-class>com.xxx.启动类</start-class> </properties> ~~~ # 外部配置文件 下面介绍几种常见的加载配置的顺序。 1. 命令行参数运行，所有的配置都可以在命令行上执行，多个配置空格隔开。 ~~~ java -jar springboot-0.0.1-SNAPSHOT.jar --server.port=9999 --sercer.context-path=/spring ~~~ 2. jar 包目录下的 application-{profile}.properties （或yml）文件 3. jar 包里的 application-{profile}.properties （或yml）文件 4. jar 包目录下的 application.properties （或yml）文件 5. jar 包里下的 application.properties （或yml）文件 # 环境属性绑定 **简单类型** 在环境变量中通过小写转换与`.`替换`_`来映射配置文件中的内容，比如：环境变量`SPRING_JPA_DATABASEPLATFORM=mysql`的配置会产生与在配置文件中设置`spring.jpa.databaseplatform=mysql`一样的效果。 **List类型** 由于环境变量中无法使用`[`和`]`符号，所以使用`_`来替代。任何由下划线包围的数字都会被认为是`[]`的数组形式。比如： ~~~ MY_FOO_1_ = my.foo[1] MY_FOO_1_BAR = my.foo[1].bar MY_FOO_1_2_ = my.foo[1][2] ~~~ 另外，最后环境变量最后是以数字和下划线结尾的话，最后的下划线可以省略，比如上面例子中的第一条和第三条等价于下面的配置： ~~~ MY_FOO_1 = my.foo[1] MY_FOO_1_2 = my.foo[1][2] ~~~ # 系统属性绑定 **简单类型** 系统属性与文件配置中的类似，都以移除特殊字符并转化小写后实现绑定，比如下面的命令行参数都会实现配置`spring.jpa.databaseplatform=mysql`的效果： ~~~ -Dspring.jpa.database-platform=mysql -Dspring.jpa.databasePlatform=mysql -Dspring.JPA.database_platform=mysql ~~~ **List类型** 系统属性的绑定也与文件属性的绑定类似，通过`[]`来标示，比如： ~~~ -D"spring.my-example.url[0]=http://example.com" -D"spring.my-example.url[1]=http://spring.io" ~~~ 同样的，他也支持逗号分割的方式，比如： ~~~ -Dspring.my-example.url=http://example.com,http://spring.io ~~~ # Binder绑定 在Spring Boot 2.0中增加了新的绑定API来帮助我们更容易的获取配置信息。 **application.properties** ~~~ com.didispace.foo=bar #推荐使用全小写配合-分割符的方式来配置 com.didispace.database-platform=sql #使用[]来定位列表类型 #也支持逗号分隔方式，两种方式等价 #com.didispace.post=Why Spring Boot,Why Spring Cloud com.didispace.post[0]=Why Spring Boot com.didispace.post[1]=Why Spring Cloud #Map类型的定义格式如下 com.didispace.posts[0].title=Why Spring Boot com.didispace.posts[0].content=It is perfect! com.didispace.posts[1].title=Why Spring Cloud com.didispace.posts[1].content=It is perfect too! ~~~ **PostInfo** ~~~ import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; @Data @ConfigurationProperties public class PostInfo { private String title; private String content; } ~~~ **FooProperties** ~~~ import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; @Data @ConfigurationProperties(prefix = "com.didispace") public class FooProperties { private String foo; public String getFoo() { return foo; } public String getDatabasePlatform() { return databasePlatform; } private String databasePlatform; } ~~~ **启动类** ~~~ import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.context.properties.ConfigurationPropertiesBinding; import org.springframework.boot.context.properties.bind.Bindable; import org.springframework.boot.context.properties.bind.Binder; import org.springframework.context.ApplicationContext; import java.util.List; @SpringBootApplication public class Application { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(Application.class, args); Binder binder = Binder.get(context.getEnvironment()); // 绑定简单配置 FooProperties foo = binder.bind("com.didispace", Bindable.of(FooProperties.class)).get(); System.out.println(foo.getFoo()); // 绑定List配置 List<String> post = binder.bind("com.didispace.post", Bindable.listOf(String.class)).get(); System.out.println(post); List<PostInfo> posts = binder.bind("com.didispace.posts", Bindable.listOf(PostInfo.class)).get(); System.out.println(posts); // 读取配置 System.out.println(context.getEnvironment().containsProperty("com.didispace.database-platform")); System.out.println(context.getEnvironment().containsProperty("com.didispace.databasePlatform")); } } ~~~ 还可以这样用 ~~~ List people = Binder.get(environment) .bind("my.property", Bindable.listOf(PersonName.class)) .orElseThrow(IllegalStateException::new); ~~~ **测试** ~~~ bar [Why Spring Boot, Why Spring Cloud] [PostInfo(title=Why Spring Boot, content=It is perfect!), PostInfo(title=Why Spring Cloud, content=It is perfect too!)] true false ~~~