入口类和@SpringBootApplication注解
SpringBoot程序通常有一个入口类,类中有一个main方法,这个main方法其实就是一个标准的Java应用程序的入口方法.
在main方法中使用 SpringApplication.run(入口类.class, args)方法,启动springBoot应用项目.
@SpringBootApplication是springBoot的核心注解,它是一个组合注解.
@SpringBootApplication注解主要组合了@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan
若不使用@SpringBootApplication注解,则在入口类上可以使用以上三个注解
- @SpringBootConfiguration继承自@Configuration，二者功能也一致，类，并会将当前类标注当前类是配置内
声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。
- @EnableAutoConfiguration的作用启动自动的配置.
@EnableAutoConfiguration注解的意思就是Springboot根据你添加的jar包来配置你项目的默认配置，
比如根据spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，
就会自动的帮你配置web项目中所需要的默认配置。
- @ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入
到spring容器中进行管理。是以前的<context:component-scan>（以前使用在xml中使用的标签，用来扫描包配置的平行支持）.
注: 使用@SpringBootApplication注解 就相当于使用@ComponentScan的默认配置,所以使用@SpringBootApplication的入口类
最好放置在项目的根包中,这样在@ComponentScan扫描其当前包和子包时这样bean就不会被漏扫描．
@SpringBootApplication 参数
- Class<?>[] exclude() default {}:
根据class来排除,排除特定的类加入spring容器，传入参数value类型是class类型
//排除加载TestUser类到springioc容器中 @SpringBootApplication(exclude={TestUser.class})
- String[] excludeName() default {}:
根据class name来排除,排除特定的类加入spring容器，传入参数value类型是class的全类名字符串数组
//排除com.wangy.boot.bean包下的TestUser类. @SpringBootApplication(excludeName= {"
com.wangy.boot.bean.TestUser"})
- String[] scanBasePackages() default {}:
指定扫描包，参数是包名的字符串数组。
//指定扫描 com.wangy和com.test包及其子包 @SpringBootApplication(scanBasePackages= {"com.wangy","com.test"})
- 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容器
阅读更多关于 永恒之塔 的文章
