超级详细的 springboot核心配置详解

4.springboot核心配置

入口类和@SpringBootApplication注解

SpringBoot程序通常有一个入口类,类中有一个main方法,这个main方法其实就是一个标准的Java应用程序的入口方法.

在main方法中使用 SpringApplication.run(入口类.class, args)方法,启动springBoot应用项目.

@SpringBootApplication是springBoot的核心注解,它是一个组合注解.

@SpringBootApplication注解主要组合了@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan

若不使用@SpringBootApplication注解,则在入口类上可以使用以上三个注解

1. @SpringBootConfiguration继承自@Configuration，二者功能也一致，类，并会将当前类标注当前类是配置内

声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。

2. @EnableAutoConfiguration的作用启动自动的配置.

@EnableAutoConfiguration注解的意思就是Springboot根据你添加的jar包来配置你项目的默认配置，

比如根据spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，

就会自动的帮你配置web项目中所需要的默认配置。

3. @ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入

到spring容器中进行管理。是以前的<context:component-scan>（以前使用在xml中使用的标签，用来扫描包配置的平行支持）.

注: 使用@SpringBootApplication注解 就相当于使用@ComponentScan的默认配置,所以使用@SpringBootApplication的入口类

最好放置在项目的根包中,这样在@ComponentScan扫描其当前包和子包时这样bean就不会被漏扫描．

@SpringBootApplication 参数

1. Class<?>[] exclude() default {}:

根据class来排除,排除特定的类加入spring容器，传入参数value类型是class类型

//排除加载TestUser类到springioc容器中 @SpringBootApplication(exclude={TestUser.class})

2. String[] excludeName() default {}:

根据class name来排除,排除特定的类加入spring容器，传入参数value类型是class的全类名字符串数组

//排除com.wangy.boot.bean包下的TestUser类. @SpringBootApplication(excludeName= {"com.wangy.boot.bean.TestUser"})

3. String[] scanBasePackages() default {}:

指定扫描包，参数是包名的字符串数组。

//指定扫描 com.wangy和com.test包及其子包 @SpringBootApplication(scanBasePackages= {"com.wangy","com.test"})

4. Class<?>[] scanBasePackageClasses() default {}:

扫描特定的包，参数类似是Class类型数组.

//指定扫描com.wangy.boot和com.test包及其子包 @SpringBootApplication(scanBasePackageClasses= {com.wangy.boot.MainApplication.class,com.test.TestBean.class})

设置banner(控制台启动log)

在src/main/resources 目录下创建 banner.txt 文件 在文件中设置在启动时打印的内容

springboot在启动时 会读取banner.txt文件中的内容 打印到控制台

可以到网站: http://patorjk.com/software/taag/ 在线生成字符串符号

关闭banner

main方法:

public static void main(String[] args) { SpringApplication app = new SpringApplication(MainApplication.class); app.setBannerMode(Banner.Mode.OFF);//关闭banner app.run(args); }

spring的全局配置文件

在 src/main/resources 目录下或者类路径的/config下 创建:application.properties或者application.yml文件

设置tomcat的端口号为8088

application.properties

server.port=8088

application.yml

server: {port: 9999} 或者 server: port: 8888 //注意 ":"后面 8888前面有一个空格

application.properties文件的优先级高于application.yml

目录类路径下的 /config下的配置文件优先级高于 src/main/resources目录下的文件

常规属性配置---加载外部资源文件

在 src/main/resources/ 目录下创建文件

value.properties

test.value=abcde

在入口类上使用注解 @PropertySource 加载资源文件

@RestController @SpringBootApplication @PropertySource("value.properties") //加载外部资源文件 位于src/main/resources/value.properties public class MainApplication { //使用value注入资源文件中的数据 @Value("${test.value}") private String testValue; @RequestMapping("/") String index() { return testValue; } }

加载外部资源文件 实现类型安全的配置

如果使用@value注入多个属性非常麻烦.

springboot提供了基于类型安全的配置方式,通过@ConfigurationProperties

将一个properties文件中的属性和一个JavaBean中的属性进行关联.

src/main/resources/user.properties 文件 注:也可以在applictaion.properties文件中配置这些属性

user.id=1 user.userName=bear user.userInfo=is a girl

创建Javabean

com.wangy.boot.bean.TestUser

使用 @PropertySource(value = { "classpath:user.properties" }) 加载资源文件

注:如果在application.properties 无需配置加载

使用 @ConfigurationProperties(prefix="user") prefix指定资源文件中属性前缀

@Component @PropertySource(value = {"classpath:user.properties"}) //加载资源那文件 @ConfigurationProperties(prefix="user") //prfix指定资源文件中属性前缀 public class TestUser { private Integer id; //bean属性名和资源文件除去前缀的属性名保持一致.并且提供对应的get和set方法 private String userName; private String userInfo; //get...set... 省略get和set方法 }

在程序入口类中 使用 @Autowired 直接注入javaBean

@RestController @SpringBootApplication public class MainApplication { //注入javaBean @Autowired private TestUser testUser; @RequestMapping("/") String index() { return testUser.getId()+testUser.getUserName()+testUser.getUserInfo(); }

启动程序 访问 index()映射的路径 可以得到 JavaBean中对应的资源那文件中的初始化数据

使用@bean注解的方式声明TestBean注入和属性绑定

com.wangy.boot.bean.TestUser

public class TestUser { //无需任何注解 private Integer id; private String userName; private String userInfo; //get...set... 省略get和set方法 }

入口类

com.wangy.boot.MainApplication

@SpringBootApplication //springBoot核心注解 @PropertySource(value = { "classpath:user.properties" })//加载资源文件 public class MainApplication { @Bean //使用@Bean注解 将方法的返回值对象装入spring容器 @ConfigurationProperties("user")// 配置资源文件中属性前缀 public TestUser getTestUser() { return new TestUser(); } //main方法 项目启动的入口 public static void main(String[] args) { SpringApplication app = new SpringApplication(MainApplication.class); // app.setBannerMode(Banner.Mode.OFF);//关闭banner app.run(args); } }

定义controller类

com.wangy.boot.controller.TestUserController

@RestController public class TestUserController { // 注入TestUser @Autowired private TestUser testUser; @RequestMapping("/") //访问http://127.0.0.1:8080/ String index() { return testUser.getId()+testUser.getUserName()+testUser.getUserInfo(); } }

日志配置

在application.properties

logging.file=D:/myLog/log.log //日志输出至D:/myLog/log.log loging.level.org.springframework.web= debug //配置 包 springframework.web的日志级别为 debug

Profile配置

可以指定不同的环境加载不同的资源配置文件.

全局的profile配置 使用application-xxxx.properties 命名

通过在application.properties中 配置 spring.profiles.active=XXXX来指定要加载的资源配置文件.

在src/main/resources 目录下 创建 application-dev.properties 配置在开发时使用的tomcat端口为8888

application-dev.properties

server.port= 8888 //配置tomcat端口号为8888

在src/main/resources 目录下 创建 application-prod.properties 配置在生产环境使用的tomcat端口为80

application-prod.properties

server.port= 80 //配置tomcat端口号为80

application.properties 配置 spring.profiles.active=XXXX 来指定当前运行项目时要加载哪个配置文件

#spring.profiles.active=dev //指定加载 application-dev.properties spring.profiles.active=prod //指定加载 application-prod.properties

在配置 spring.profiles.active=prod 就会加载 application-prod.properties 启动项目会使用端口80

在配置 spring.profiles.active=dev 就会加载 application-prod.properties 启动项目会使用端口8888

注: 如果application.properties 中配置的属性和 application-XXXX.properties 中有重复项,

application-XXXX.properties 中的配置会覆盖application.properties中的配置

开启debug 模式

1.在application.properties 中配置 debug=true 开启spring的debug模式

application.properties

debug=true

开启debug 在启动项目时 控制台会打印springboot关于 启用和未启用的 自动配置的报告信息,

自动配置 由(@EnableAutoConfiguration)注解提供 它包含在@SpringBootApplication中.

2.使用maven插件运行项目时 配置启动debug模式

3.使用cmd 命令行 启动项目时 开启debug

> java -jar springBootTest.jar --debug

开启debug模式后,打印的日志信息中

Positive matches: 已启用的配置

Negative matches: 未启用的配置

在 spring-boot-autoconfigure-XXX.RELEASE.jar 包中的META-INF文件夹内的 spring.factories文件中 声明了有哪些自动配置.

实现springboot自动配置

实现一个 starter pom

1.新建一个maven项目

2. pom.xml 加载 springboot 自身的自动配置作为依赖

<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.wangy.boot</groupId> <artifactId>wangy-starterpom</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- 添加 spring-boot-autoconfigure 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> <version>2.1.1.RELEASE</version> </dependency> </dependencies> </project>

3.创建一个JavaBean

package com.wangy.starter; import org.springframework.boot.context.properties.ConfigurationProperties; /** * @author wang.y 消息处理实体类 * @说明:使用@ConfigurationProperties注解配置属性 * 在applicaton.properties 文件中 配置 testmessage.msg=xxxx来设置属性msg的值 * 如果不配置 则使用默认值 MSG */ @ConfigurationProperties(prefix="testmessage") public class TestMessageBean { // 定义一个静态常量 作为默认值 private static final String MSG = "贝贝熊!"; // 定义属性 private String msg = MSG; public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } }

4. 创建一个 判断依据类

根据TestMessageService类是否存在来创建这个类的bean

package com.wangy.starter; /** * 判断依据类 * @author wang.y * */ public class TestMessageService { private String msg; public String sayMsg() { return "消息内容:"+msg; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } }

5. 创建 自动配置类

根据TestMessageBean提供的参数,通过@ConditionalOnClass判断TestMessageService在类路径中是否存在

当容器中没有TestMessageService对象存在时,自动配置TestMessageService对象

package com.wangy.starter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * * @说明:自动配置类 * * @author wang.y */ //定义该类为配置类 @Configuration //判断是否存在TestMessageService类,如果存在,则在Spring容器中加载这个类 @ConditionalOnClass(TestMessageService.class) //判断应用环境中(application.properties或者其他资源文件)中是否有TestMessage为前缀的属性 @ConditionalOnProperty(prefix="testmessage",value="enabled",matchIfMissing=true) //在TestMessageBean类上开启属性配置 @EnableConfigurationProperties(TestMessageBean.class) public class TestMessageAutoConfiguration { @Autowired private TestMessageBean testMessageBean; @Bean //当spring容器中没有TestMessageService对象时,执行该方法创建一个TestMessageService对象 @ConditionalOnMissingBean(TestMessageService.class) public TestMessageService testMessageService() { TestMessageService testMessageService = new TestMessageService(); testMessageService.setMsg(testMessageBean.getMsg()); return testMessageService; } }

6. 注册自动配置类

在src/main/resources目录下新 META-INF/spring.factories 文件

spring.factories

可以参照spring-boot-autoconfigure-2.1.1.RELEASE.jar内 META-INF/spring.factories # Auto Configure内的配置

把TestMessageAutoConfiguration注册为自动配置类

#将TestMessageAutoConfiguration类注册为自动配置类, 换行使用"\" 拼接,多个类使用 ","隔开 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.wangy.starter.TestMessageAutoConfiguration

7. 把自定义的starterpom自定义配置类 安装到maven库中

使用自定义starterpom 自动配置

1. 在项目springBootTest中 加载 wangy-starterpom依赖

pom.xml

<dependency> <groupId>com.wangy.boot</groupId> <artifactId>wangy-starterpom</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency>

会自动加载 spring-boot-autoconfigure.jar

2 .入口类

package com.wangy.boot; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class MainApplication { public static void main(String[] args) { SpringApplication.run(MainApplication.class, args); } }

3. controller类 注入:TestMessageService

package com.wangy.boot.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import com.wangy.starter.TestMessageService; @RestController public class TestUserController { @Autowired //注入TestMessageService private TestMessageService testMessageService; @RequestMapping("/") String index() { return testMessageService.sayMsg(); } }

4.运行程序

可以看到日志打印中

#Positive matches

======================= 自动配置了'com.wangy.starter.TestMessageService'

TestMessageAutoConfiguration matched:

- @ConditionalOnClass found required class 'com.wangy.starter.TestMessageService' (OnClassCondition)

- @ConditionalOnProperty (testmessage.enabled) matched (OnPropertyCondition)

TestMessageAutoConfiguration#testMessageService matched:

- @ConditionalOnMissingBean (types: com.wangy.starter.TestMessageService; SearchStrategy: all)

did not find any beans (OnBeanCondition)

访问项目 可以看到 执行了 testMessageService.sayMsg()方法 并且因为没有在application.properties文件中配置 testmessage.msg= 属性

所以使用了 默认值

在application.properties中配置

testmessage.msg=hello!

再次启动项目访问: 会读取appliaction.properties中配置的testmessage.msg 属性值

注:在使用spring-boot 自带的 自动配置项目时,想要查看哪些属性可以配置,

可以到spring-boot-autoconfigure-2.1.1.RELEASE.jar源码中所对应的类中进行查看

开启热加载

在pom.xml文件中加入spring-boot-devtools依赖

<!-- 开启spring-boot热加载 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency>

配置后 修改代码 会自动加载 无需重启web容器