这是项目的代码,在pom.xml依赖中需要引入swagger的依赖
<dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.2.2</version> </dependency>
整个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.tuling.springboot</groupId> <artifactId>vip-springboot-first</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>vip-springboot-first</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.10.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </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-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.2.2</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
2.创建Swagger2配置类,
在spring boot启动类所在包或子包中创建Swagger配置类SwaggerConfig.java,如果不再启动类包或者子包下面,一定要使用@ComponentScan(basePackages={"com.example.boot"}) 包扫描扫描到该配置类如下:
package com.tuling.springboot; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import springfox.documentation.builders.ApiInfoBuilder; import springfox.documentation.builders.PathSelectors; import springfox.documentation.builders.RequestHandlerSelectors; import springfox.documentation.service.ApiInfo; import springfox.documentation.spi.DocumentationType; import springfox.documentation.spring.web.plugins.Docket; import springfox.documentation.swagger2.annotations.EnableSwagger2; @Configuration @EnableSwagger2 public class SwaggerConfig { @Bean public Docket createRestApi() { return new Docket(DocumentationType.SWAGGER_2) .apiInfo(apiInfo()) .select() .apis(RequestHandlerSelectors.basePackage("com.tuling.springboot"))// 指定扫描包下面的注解 .paths(PathSelectors.any()) .build(); } // 创建api的基本信息 private ApiInfo apiInfo() { return new ApiInfoBuilder() .title("集成Swagger2构建RESTful APIs") .description("集成Swagger2构建RESTful APIs") .termsOfServiceUrl("https://www.baidu.com") .contact("zhangsan") .version("1.0.0") .build(); } }
这里配置 .apis(RequestHandlerSelectors.basePackage("com.tuling.springboot"))// 指定扫描包下面的注解 swagger扫描的包
3.创建Controller: SwaggerController.java
package com.tuling.springboot; import java.util.HashMap; import java.util.Map; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import io.swagger.annotations.ApiImplicitParam; import io.swagger.annotations.ApiOperation; @RestController @RequestMapping(value="/swagger") public class SwaggerController { @ApiOperation(value="获取用户信息", notes="根据id来获取用户详细信息") @ApiImplicitParam(name="id", value="用户ID", required=true, dataType="String") @RequestMapping(value="/{id}", method=RequestMethod.GET) public Map<String,String> getInfo(@PathVariable String id) { Map<String ,String> map = new HashMap<String, String>(); map.put("name", "张三"); map.put("age", "34"); return map; } }
4.启动Spring boot,访问Swagger UI界面:http://localhost:8081/swagger-ui.html
5.测试API:
springboot集成mybatis
1.修改pom.xml,增加依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version><!-- 版本号必须需要 --> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency>
整个工程的pom依赖如下所示
<?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.tuling.springboot</groupId> <artifactId>vip-springboot-first</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>vip-springboot-first</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.10.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </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-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version><!-- 版本号必须需要 --> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
2.mysql的连接配置2.mysql的连接配置
3.创建表t_user CREATE TABLE `t_user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(40) DEFAULT NULL, `age` int(11) DEFAULT NULL, `address` varchar(100) DEFAULT NULL, `phone` varchar(40) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
在application.properties配置数据库的连接
server.port=8081 spring.datasource.url=jdbc:mysql://localhost:3306/spring spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4.创建User.java文件
package com.tuling.springboot; public class User { private Integer id; private String name; private Integer age; private String address; private String phone; // getter,setter省略 }
5.创建UserMapper.java接口文件,这里我们采用注解的形式
package com.tuling.springboot; import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Select; @Mapper public interface UserMapper { /**根据id查询用户*/ @Select("SELECT * FROM T_USER WHERE ID = #{id}") User findById(@Param("id") String id); /**新增用户*/ @Insert("INSERT INTO T_USER(NAME, AGE, ADDRESS, PHONE) VALUES(#{name}, #{age}, #{address}, #{phone})") int insert(@Param("name") String name, @Param("age") Integer age,@Param("address") String address,@Param("phone") String phone); }
启动类的代码如下
package com.tuling.springboot; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class VipSpringbootFirstApplication { public static void main(String[] args) { SpringApplication.run(VipSpringbootFirstApplication.class, args); } }
这里有个最关键需要注意的地方:UserMapper.java这个类中的@Mapper注解在启动的时候要被springboot扫描到,所以UserMapper.java这个类要位于启动类的包或者子包目录下
接下来,我们创建一个测试类,对上面的代码进行测试
package com.tuling.springboot; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import junit.framework.TestCase; @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = VipSpringbootFirstApplication.class) public class MybatisTest { @Autowired private UserMapper userMapper; @Test public void testInsert() throws Exception { int num = userMapper.insert("zhangsan", 20,"长沙","13100000000"); TestCase.assertEquals(num,1); } @Test public void testFindById() throws Exception { User u = userMapper.findById(14+""); TestCase.assertNotNull(u); System.out.println(u.getName()); } }
这里classes要写成对于的启动类
springboot集成redis组件
这里我们下载windows版本的redis进行测试
启动redis使用下面的命令
3.启动redis windows: redis-server redis.windows.conf
集成Redis集成步骤:
1.修改pom.xml,增加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
整个pom文件如下
<?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.tuling.springboot</groupId> <artifactId>vip-springboot-first</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>vip-springboot-first</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.10.RELEASE</version> <relativePath /> <!-- lookup parent from repository --> </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-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version><!-- 版本号必须需要 --> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
接下来进行redis的配置
server.port=8081 spring.datasource.url=jdbc:mysql://localhost:3306/spring spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver # REDIS (RedisProperties) # Redisu6570u636Eu5E93u7D22u5F15uFF08u9ED8u8BA4u4E3A0uFF09 spring.redis.database=0 # Redisu670Du52A1u5668u5730u5740 spring.redis.host=127.0.0.1 # Redisu670Du52A1u5668u8FDEu63A5u7AEFu53E3 spring.redis.port=6379 # Redisu670Du52A1u5668u8FDEu63A5u5BC6u7801uFF08u9ED8u8BA4u4E3Au7A7AuFF09 spring.redis.password= # u8FDEu63A5u6C60u6700u5927u8FDEu63A5u6570uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-active=8 # u8FDEu63A5u6C60u6700u5927u963Bu585Eu7B49u5F85u65F6u95F4uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-wait=-1 # u8FDEu63A5u6C60u4E2Du7684u6700u5927u7A7Au95F2u8FDEu63A5 spring.redis.pool.max-idle=8 # u8FDEu63A5u6C60u4E2Du7684u6700u5C0Fu7A7Au95F2u8FDEu63A5 spring.redis.pool.min-idle=0 # u8FDEu63A5u8D85u65F6u65F6u95F4uFF08u6BEBu79D2uFF09 spring.redis.timeout=0
注意:spring.redis.database的配置通常使用0即可,Redis在配置的时候可以设置数据库数量,默认为16,可以理解为数据库的schema
4.测试
package com.tuling.springboot; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.ValueOperations; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import junit.framework.TestCase; @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(classes = VipSpringbootFirstApplication.class) public class SpringRedisTest { @Autowired private RedisTemplate<String,String> redisTemplate; @Test public void testRedis() throws Exception { ValueOperations<String, String> ops = redisTemplate.opsForValue(); ops.set("name", "zhangsan"); String value = ops.get("name"); System.out.println(value); TestCase.assertEquals("zhangsan", value); } }
注意:redis中存储对象,需要我们自己实现RedisSerializer<T>接口来对传入对象进行序列化和反序列化
springboot集成rabbitmq组件
首先在windows上面安装rabbitmq组件
1.安装RabbitMQ[windows] Erlang/OTP 20.3下载地址: http://erlang.org/download/otp_win64_20.3.exe Erlang/OTP其它版本下载地址:http://www.erlang.org/downloads RabbitMQ Server 3.7.4下载地址: https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.7.4/rabbitmq-server-3.7.4.exe RabbitMQ其它版本下载地址:https://www.rabbitmq.com/download.html 关于Linux平台怎么安装,同学们自行百度即可
2.启动RabbitMQ Server
RabbitMQ Server安装之后,会自动注册为windows服务,并以默认配置启动起来
3.RabbitMQ管理页面
1.开启Web管理插件
进入rabbitmq安装目录的sbin目录,在此打开dos命令窗口,执行以下命令
rabbitmq-plugins enable rabbitmq_management
执行这个配置之前需要先在电脑的系统环境变量中添加Erlang的环境变量设置
出现上面说明插件安装成功了
然后重新启动RabbitMQ 服务,打开浏览器并访问:http://localhost:15672/,并使用默认用户guest登录,密码也为guest,即可进入管理界面
4.Spring Boot整合
1.修改pom.xml,增加依赖支持
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2.新增管理用户并设置权限
注意tags一定要勾选正确
username:springboot
password:123456
2.切换到springboot用户登陆,在All users中,点击Name为springboot, 进入权限设置页面
3.在权限设置页面,进入Permissions页面,点击“Set permission"
3.rabbit mq连接配置
## rabbitmq config
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=springboot
spring.rabbitmq.password=123456
4.创建Rabbit配置类
配置类主要用来配置队列、交换器、路由等高级信息
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
@Bean
public Queue firstQueue() {
// 创建一个队列,名称为:first
return new Queue("first");
}
}
5.创建消息产生者类
@Component
public class Sender {
@Autowired
private AmqpTemplate rabbitTemplate;
public void send() {
rabbitTemplate.convertAndSend("first", "test rabbitmq message !!!");
}
}
说明:通过注入AmqpTemplate接口的实例来实现消息的发送,AmqpTemplate接口定义了一套针对AMQP协议的基础操作
6.创建消息消费者
@Component
@RabbitListener(queues = "first")
public class Receiver {
@RabbitHandler
public void process(String msg) {
System.out.println("receive msg : " + msg);
}
}
说明:
@RabbitListener注解:定义该类需要监听的队列
@RabbitHandler注解:指定对消息的处理
6.创建测试类
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringBootMain.class)
public class RabbitmqTest {
@Autowired
private Sender sender;
@Test
public void testRabbitmq() throws Exception {
sender.send();
}
}
7.启动主程序:SpringBootMain
控制台如果出现以下信息,则说明rabbitmq连接成功
Created new connection: rabbitConnectionFactory#29102d45:0/SimpleConnection@1dcfb5ba [delegate=amqp://springboot@127.0.0.1:5672/, localPort= 55088]
8.运行Junit测试类
控制台输出:
receive msg : test rabbitmq message !!!
集成Rabbit MQ完毕!
spring boot 日志框架
Spring boot 日志日志实现默认使用的logback
Spring Boot 应用将自动使用 logback 作为应用日志框架, Spring Boot 启动的时候,由 org.springframework.boot.logging.Logging.LoggingApplicationListener 根据情况初始化并使用。
值得注意的是,默认情况下,Spring Boot 使用 logback 作为应用日志框架。因为 spring-boot-starter 其中包含了 spring-boot-starter-logging,该依赖就是 使用Spring Boot 默认的日志框架 logback,所以不用再
添加logback的依赖
【程序中使用】:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final Logger logger = LoggerFactory.getLogger(SampleController.class);
默认情况下,Spring Boot 配置的是INFO 日志级别,也就是会输出INFO级别以上的日志( ERROR, WARN, INFO )。如果需要 Debug 级别的日志。在 src/main/resources/application.properties 中配置。
debug=true
此外,配置 logging.level.* 来具体输出哪些包的日志级别。
例如
logging.level.root=INFO
logging.level.org.springframework.web=DEBUG
logging.level.com.example.boot.controller=DEBUG
日志文件
默认情况下, Spring Boot 日志只会输出到控制台,并不会写入到日志文件,因此,对于正式环境的应用,我们需要通过在 application.properites 文件中配置 logging.file 文件名称和 logging.path 文件路径,将日志输出到日志文件中。
logging.path = /var/tmp
logging.file = xxx.log
logging.level.root = info
如果只配置 logging.path,在 /var/tmp文件夹生成一个日志文件为 spring.log。如果只配置 logging.file,会在项目的当前路径下生成一个 xxx.log 日志文件。
值得注意的是,日志文件会在 10MB 大小的时候被截断,产生新的日志文件。
常用的日志框架 log4j
如果,我们希望使用 log4j 或者 log4j2,我们可以采用类似的方式将它们对应的依赖模块加到 Maven 依赖中。
集成log4j2
在spring-boot-dependencies POMs中搜索spring-boot-starter-log4j2
发现Spring boot父Pom中自己提供了这个依赖,于是我们加入如下jar依赖:
<!-- log4j2 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
日志使用跟上面logback一样。
集成log4j
在spring-boot-dependencies POMs中搜索spring-boot-starter-log4j
发现Spring boot的父Poms中自己并没有提供了这个依赖, 我们在http://mvnrepository.com
中央仓库中查找spring-boot-starter-log4j
1.加入pom依赖
<!-- log4j start -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j</artifactId>
<version>1.3.8.RELEASE</version>
</dependency>
<!-- log4j end -->
- classpath下增加log4j.properties
log4j.rootCategory=INFO, stdout, file, errorfile
log4j.category.com.example.boot=INFO, myFile
log4j.logger.error=errorfile
# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n
# root日志输出
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=logs/all.log
log4j.appender.file.DatePattern='.'yyyy-MM-dd
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n
# error日志输出
log4j.appender.errorfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorfile.file=logs/error.log
log4j.appender.errorfile.DatePattern='.'yyyy-MM-dd
log4j.appender.errorfile.Threshold = ERROR
log4j.appender.errorfile.layout=org.apache.log4j.PatternLayout
log4j.appender.errorfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n
# com.example.boot下的日志输出
log4j.appender.myFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.myFile.file=logs/my.log
log4j.appender.myFile.DatePattern='.'yyyy-MM-dd
log4j.appender.myFile.layout=org.apache.log4j.PatternLayout
log4j.appender.myFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n
3.代码中使用log4j
import org.apache.log4j.Logger;
private final Logger logger = Logger.getLogger(xxx.class);
springboot的启动流程原理
下一步会调用生成一个springapplication的对象,然后调用改对象的run方法
我们看如何生成springapplication的对象,会首先调用方法
initalize的方法如下
启动流程:
1、创建SpringApplication对象
initialize(sources); private void initialize(Object[] sources) { //保存主配置类 if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } //判断当前是否一个web应用 this.webEnvironment = deduceWebEnvironment(); //从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer;然后保存起来 setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class)); //从类路径下找到ETA-INF/spring.factories配置的所有ApplicationListener setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); //从多个配置类中找到有main方法的主配置类 this.mainApplicationClass = deduceMainApplicationClass(); }
上面就完成了第一步,成功了创建了一个SpringApplication对象,接下来重点看下调用SpringApplication对象的run方法
public static ConfigurableApplicationContext run(Object[] sources, String[] args) { return new SpringApplication(sources).run(args); }
run方法的代码如下,我们进入断点进行调试
public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; FailureAnalyzers analyzers = null; configureHeadlessProperty(); SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); try { ApplicationArguments applicationArguments = new DefaultApplicationArguments( args); ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); Banner printedBanner = printBanner(environment); context = createApplicationContext(); analyzers = new FailureAnalyzers(context); prepareContext(context, environment, listeners, applicationArguments, printedBanner); refreshContext(context); afterRefresh(context, applicationArguments); listeners.finished(context, null); stopWatch.stop(); if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass) .logStarted(getApplicationLog(), stopWatch); } return context; } catch (Throwable ex) { handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex); } }
environment的值如下
StandardServletEnvironment {activeProfiles=[], defaultProfiles=[default], propertySources=[StubPropertySource {name='servletConfigInitParams'}, StubPropertySource {name='servletContextInitParams'}, MapPropertySource {name='systemProperties'}, SystemEnvironmentPropertySource {name='systemEnvironment'}, RandomValuePropertySource@1068586139 {name='random', properties=java.util.Random@ea6147e}, ConfigurationPropertySources@1292040526 {name='applicationConfigurationProperties', properties=[EnumerableCompositePropertySource@726181440 {name='applicationConfig: [profile=]', properties=[PropertiesPropertySource {name='applicationConfig: [classpath:/application.properties]'}]}]}]}
public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; FailureAnalyzers analyzers = null; configureHeadlessProperty(); //获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories SpringApplicationRunListeners listeners = getRunListeners(args); //回调所有的获取SpringApplicationRunListener.starting()方法 listeners.starting(); try { //封装命令行参数 ApplicationArguments applicationArguments = new DefaultApplicationArguments( args); //准备环境 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); //创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成 Banner printedBanner = printBanner(environment); //创建ApplicationContext;决定创建web的ioc还是普通的ioc context = createApplicationContext(); //异常报告 analyzers = new FailureAnalyzers(context); //准备上下文环境;将environment保存到ioc中;而且applyInitializers(); //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法 //回调所有的SpringApplicationRunListener的contextPrepared(); //prepareContext运行完成以后回调所有的 SpringApplicationRunListener的contextLoaded(); prepareContext(context, environment, listeners, applicationArguments, printedBanner); //s刷新容器;ioc容器初始化(如果是web应用还会创建嵌入式的Tomcat);Spring注解版 //扫描,创建,加载所有组件的地方;(配置类,组件,自动配置) refreshContext(context); //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调 //ApplicationRunner先回调,CommandLineRunner再回调 afterRefresh(context, applicationArguments); //所有的SpringApplicationRunListener回调finished方法 listeners.finished(context, null); stopWatch.stop(); if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass) .logStarted(getApplicationLog(), stopWatch); } //整个SpringBoot应用启动完成以后返回启动的ioc容器; return context; } catch (Throwable ex) { handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex); } }
//获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
//准备上下文环境;将environment保存到ioc中;而且applyInitializers(); //applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法 //回调所有的SpringApplicationRunListener的contextPrepared(); //prepareContext运行完成以后回调所有的 SpringApplicationRunListener的contextLoaded();
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) { context.setEnvironment(environment); postProcessApplicationContext(context); applyInitializers(context); listeners.contextPrepared(context); if (this.logStartupInfo) { logStartupInfo(context.getParent() == null); logStartupProfileInfo(context); } // Add boot specific singleton beans context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { context.getBeanFactory().registerSingleton("springBootBanner", printedBanner); } // Load the sources Set<Object> sources = getSources(); Assert.notEmpty(sources, "Sources must not be empty"); load(context, sources.toArray(new Object[sources.size()])); listeners.contextLoaded(context); }
package com.tuling.springboot; import org.springframework.context.ApplicationContextInitializer; import org.springframework.context.ConfigurableApplicationContext; public class HelloApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> { @Override public void initialize(ConfigurableApplicationContext applicationContext) { System.out.println("123456 ApplicationContextInitializer...initialize..."+applicationContext); } }
package com.tuling.springboot; import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringApplicationRunListener; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.core.env.ConfigurableEnvironment; public class HelloSpringApplicationRunListener implements SpringApplicationRunListener { //必须有的构造器 public HelloSpringApplicationRunListener(SpringApplication application, String[] args){ } @Override public void starting() { System.out.println("123456 :SpringApplicationRunListener...starting..."); } @Override public void environmentPrepared(ConfigurableEnvironment environment) { Object o = environment.getSystemProperties().get("os.name"); System.out.println("123456 SpringApplicationRunListener...environmentPrepared.."+o); } @Override public void contextPrepared(ConfigurableApplicationContext context) { System.out.println("123456 SpringApplicationRunListener...contextPrepared..."); } @Override public void contextLoaded(ConfigurableApplicationContext context) { System.out.println("123456 SpringApplicationRunListener...contextLoaded..."); } @Override public void finished(ConfigurableApplicationContext context, Throwable exception) { System.out.println("123456 SpringApplicationRunListener...finished..."); } }
对于实现了SpringApplicationRunListener和ApplicationContextInitializer 以上两个起作用,必须配置在resources下META-INF/spring.factories
org.springframework.context.ApplicationContextInitializer= com.tuling.springboot.HelloApplicationContextInitializer org.springframework.boot.SpringApplicationRunListener= com.tuling.springboot.HelloSpringApplicationRunListener
package com.tuling.springboot; import org.springframework.boot.ApplicationArguments; import org.springframework.boot.ApplicationRunner; import org.springframework.stereotype.Component; //放在ioc容器中即可 @Component public class HelloApplicationRunner implements ApplicationRunner { @Override public void run(ApplicationArguments args) throws Exception { System.out.println("123456 ApplicationRunner...run...."); } }
package com.tuling.springboot; import java.util.Arrays; import org.springframework.boot.CommandLineRunner; import org.springframework.stereotype.Component; @Component public class HelloCommandLineRunner implements CommandLineRunner { @Override public void run(String... args) throws Exception { System.out.println("123456 CommandLineRunner...run..."+ Arrays.asList(args)); } }
对于实现了CommandLineRunner和ApplicationRunner我们只需要添加到IOC容器中,使用@Component注解,不需要在META-INF/spring.factories中配置
我们运行程序,我们来看下程序运行的结果打印
s1:
//获取SpringApplicationRunListeners;从类路径下META-INF/spring.factories
s2:
//回调所有的获取SpringApplicationRunListener.starting()方法
打印输出123456 :SpringApplicationRunListener...starting...
S3:
//创建环境完成后回调SpringApplicationRunListener.environmentPrepared();表示环境准备完成
打印输出:
123456 SpringApplicationRunListener...environmentPrepared..Windows 7
s4:
//准备上下文环境;将environment保存到ioc中;而且applyInitializers();
//applyInitializers():回调之前保存的所有的ApplicationContextInitializer的initialize方法
//回调所有的SpringApplicationRunListener的contextPrepared();
//prepareContext运行完成以后回调所有的 SpringApplicationRunListener的contextLoaded();
打印输出:
123456 ApplicationContextInitializer...initialize...org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@770c2e6b: startup date [Thu Jan 01 08:00:00 CST 1970]; root of context hierarchy
123456 SpringApplicationRunListener...contextPrepared...
123456 SpringApplicationRunListener...contextLoaded...
s5:
//从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调
//ApplicationRunner先回调,CommandLineRunner再回调
打印输出:
123456 ApplicationRunner...run....
123456 CommandLineRunner...run...[]
s6: //所有的SpringApplicationRunListener回调finished方法
123456 SpringApplicationRunListener...finished...
springboot自定义starter
我们首先按照自定义命名空间定义一个starer
整个pom文件的依赖如下
<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.aitiguigu</groupId>
<artifactId>springboottest-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
<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>
<!--引入自动配置模块-->
<!--引入spring-boot-starter-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>1.5.10.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
创建自己的starter项目
创建普通maven项目,修改pom.xml,增加自动配置依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<version>1.5.10.RELEASE</version>
</dependency>
我们这个starter并不做其他复杂逻辑的编写,所以这里的依赖只是添加了spring-boot-autoconfigure,实战开发时可以添加任意依赖到项目中。
接下来我们要在配置文件中配置下面的形式的配置
springboottest.hello.prefix=sss
springboottest.hello.suffix=222
要让springboot能够自动给我们加载如何实现了
首先把上面的配置文件封装成一个对象
package com.springboottest.starter; import org.springframework.boot.context.properties.ConfigurationProperties; //绑定文件中所有以springboottest.hello 开始的配置 @ConfigurationProperties(prefix = "springboottest.hello") public class HelloProperties { private String prefix; private String suffix; public String getPrefix() { return prefix; } public void setPrefix(String prefix) { this.prefix = prefix; } public String getSuffix() { return suffix; } public void setSuffix(String suffix) { this.suffix = suffix; } }
配置映射参数实体
starter是如何读取application.properties或者application.yml配置文件内需要的配置参数的呢?那么接下来我们就看看如何可以获取自定义的配置信息。
SpringBoot在处理这种事情上早就已经考虑到了,所以提供了一个注解@ConfigurationProperties,该注解可以完成将application.properties配置文件内的有规则的配置参数映射到实体内的field内,不过需要提供setter方法,自定义配置参数实体代码如下所示:
这里一定要使用注解@ConfigurationProperties,说明这个是一个属性对于的配置文件类,指定配置文件的属性以springboottest.hello开头
接下来我们编写一个业务类来操作HelloProperties
package com.springboottest.starter; public class HelloService { HelloProperties helloProperties; public HelloProperties getHelloProperties() { return helloProperties; } public void setHelloProperties(HelloProperties helloProperties) { this.helloProperties = helloProperties; } public String sayHello(String name){ return helloProperties.getPrefix()+"-"+ name + helloProperties.getSuffix(); }; }
这里一定要实现HelloProperties对象的getter和setter方法
接下来我们编写一个配置类HelloServiceAutoConfiguration,把HelloService注入到spring IOC容器 中,然后能够自动扫描@ConfigurationProperties的注解
我们为自定义starter提供一个Service,并且提供一个名为sayHello的方法用于返回我们配置的msg内容。代码如下所示:
package com.springboottest.starter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration @ConditionalOnWebApplication//web应用才生效 @EnableConfigurationProperties(HelloProperties.class)//让属性生效 HelloProperties helloProperties; public class HelloServiceAutoConfiguration { //让属性生效 HelloProperties helloProperties; @Autowired HelloProperties helloProperties; @Bean public HelloService helloService(){ HelloService service = new HelloService(); service.setHelloProperties(helloProperties); return service; } }
自动化配置代码中有很多我们之前没有用到的注解配置,我们从上开始讲解
@Configuration:这个配置就不用多做解释了,我们一直在使用
@EnableConfigurationProperties:这是一个开启使用配置参数的注解,value值就是我们配置实体参数映射的ClassType,将配置实体作为配置来源。
SpringBoot内置条件注解
有关@ConditionalOnXxx相关的注解这里要系统的说下,因为这个是我们配置的关键,根据名称我们可以理解为具有Xxx条件,当然它实际的意义也是如此,条件注解是一个系列,下面我们详细做出解释
@ConditionalOnBean:当SpringIoc容器内存在指定Bean的条件
@ConditionalOnClass:当SpringIoc容器内存在指定Class的条件
@ConditionalOnExpression:基于SpEL表达式作为判断条件
@ConditionalOnJava:基于JVM版本作为判断条件
@ConditionalOnJndi:在JNDI存在时查找指定的位置
@ConditionalOnMissingBean:当SpringIoc容器内不存在指定Bean的条件
@ConditionalOnMissingClass:当SpringIoc容器内不存在指定Class的条件
@ConditionalOnNotWebApplication:当前项目不是Web项目的条件
@ConditionalOnProperty:指定的属性是否有指定的值
@ConditionalOnResource:类路径是否有指定的值
@ConditionalOnSingleCandidate:当指定Bean在SpringIoc容器内只有一个,或者虽然有多个但是指定首选的Bean
@ConditionalOnWebApplication:当前项目是Web项目的条件
以上注解都是元注解@Conditional演变而来的,根据不用的条件对应创建以上的具体条件注解。
到目前为止我们还没有完成自动化配置starter,我们需要了解SpringBoot运作原理后才可以完成后续编码。
接下来配置配置spring.factories让自动配置类生效,在spring.factories文件中配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.springboottest.starter.HelloServiceAutoConfiguration
这里我们使用maven打包,其他模块就可以使用上面我们定义的starter了
我们在vip-springboot-first中因人我们上面创建的starter
在vip-springboot-first的pom文件中添加下面的依赖
<dependency> <groupId>com.aitiguigu</groupId> <artifactId>springboottest-spring-boot-starter</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency>
controller引入自定义starter中的service调用业务:
package com.tuling.springboot;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.springboottest.starter.HelloService;
@RestController
public class AA {
@Autowired
HelloService helloService;
@RequestMapping("/hello")
public String aa(){
return helloService.sayHello("你好");
}
}
在application.properties中配置下面属性
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/spring
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# REDIS (RedisProperties)
# Redisu6570u636Eu5E93u7D22u5F15uFF08u9ED8u8BA4u4E3A0uFF09
spring.redis.database=0
# Redisu670Du52A1u5668u5730u5740
spring.redis.host=127.0.0.1
# Redisu670Du52A1u5668u8FDEu63A5u7AEFu53E3
spring.redis.port=6379
# Redisu670Du52A1u5668u8FDEu63A5u5BC6u7801uFF08u9ED8u8BA4u4E3Au7A7AuFF09
spring.redis.password=
# u8FDEu63A5u6C60u6700u5927u8FDEu63A5u6570uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09
spring.redis.pool.max-active=8
# u8FDEu63A5u6C60u6700u5927u963Bu585Eu7B49u5F85u65F6u95F4uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09
spring.redis.pool.max-wait=-1
# u8FDEu63A5u6C60u4E2Du7684u6700u5927u7A7Au95F2u8FDEu63A5
spring.redis.pool.max-idle=8
# u8FDEu63A5u6C60u4E2Du7684u6700u5C0Fu7A7Au95F2u8FDEu63A5
spring.redis.pool.min-idle=0
# u8FDEu63A5u8D85u65F6u65F6u95F4uFF08u6BEBu79D2uFF09
spring.redis.timeout=0
## rabbitmq config
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=springboot
spring.rabbitmq.password=123456
debug=true
springboottest.hello.prefix=sajdjsakdsa
springboottest.hello.suffix=2wwww
在浏览器中访问结果如下
接下来我们启动项目,在控制台查找是否存在我们的HelloAutoConfiguration日志输出
在控制台可以看到我们的自定义starter的自动化配置已经生效了,并且根据@ConditionalOnMissingBean(HelloService.class)做出了条件注入HelloService实体bean到SpringIoc容器内
我们的配置生效了,到目前为止我相信大家已经明白了我们application.properties配置文件为什么可以作为统一配置入口,为什么配置后可以被对应starter所使用
【尚硅谷】springBoot技术 springboot admin的监控
需要因人依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
整个应用的配置如下
<?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.tuling.springboot</groupId> <artifactId>vip-springboot-first</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>vip-springboot-first</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.10.RELEASE</version> <relativePath /> <!-- lookup parent from repository --> </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-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger-ui</artifactId> <version>2.2.2</version> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version><!-- 版本号必须需要 --> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>com.aitiguigu</groupId> <artifactId>springboottest-spring-boot-starter</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
actoator默认给我们提供了下面很多的端口的端点信息
端点(Endpoints)
端点可用于监控应用或者与应用进行交互,Spring Boot包含很多内置的端点,每个断电都可以禁用或者启用,要访问远程端点必须通过JMX或者http进行暴露 。
端点列表:
我们在浏览器访问/beans提供的端口
提示当前我们没有权限
我们需要进行配置下
三、去官网查看2.0暴露端点的方式 方式1: # 启用端点 env management.endpoint.env.enabled=true # 暴露端点 env 配置多个,隔开 management.endpoints.web.exposure.include=env 方式2: 方式1中的暴露方式需要一个一个去开启需要暴露的端点,方式2直接开启和暴露所有端点 management.endpoints.web.exposure.include=* 注意在使用Http访问端点时,需要加上默认/actuator 前缀
———————————————— 版权声明:本文为CSDN博主「wallfeacers」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。 原文链接:https://blog.csdn.net/qq_27385301/article/details/82899303
我们来看下当前info接口的信息
我们在配置文件中配置一info开头的配置
server.port=8081 spring.datasource.url=jdbc:mysql://localhost:3306/spring spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver # REDIS (RedisProperties) # Redisu6570u636Eu5E93u7D22u5F15uFF08u9ED8u8BA4u4E3A0uFF09 spring.redis.database=0 # Redisu670Du52A1u5668u5730u5740 spring.redis.host=127.0.0.1 # Redisu670Du52A1u5668u8FDEu63A5u7AEFu53E3 spring.redis.port=6379 # Redisu670Du52A1u5668u8FDEu63A5u5BC6u7801uFF08u9ED8u8BA4u4E3Au7A7AuFF09 spring.redis.password= # u8FDEu63A5u6C60u6700u5927u8FDEu63A5u6570uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-active=8 # u8FDEu63A5u6C60u6700u5927u963Bu585Eu7B49u5F85u65F6u95F4uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-wait=-1 # u8FDEu63A5u6C60u4E2Du7684u6700u5927u7A7Au95F2u8FDEu63A5 spring.redis.pool.max-idle=8 # u8FDEu63A5u6C60u4E2Du7684u6700u5C0Fu7A7Au95F2u8FDEu63A5 spring.redis.pool.min-idle=0 # u8FDEu63A5u8D85u65F6u65F6u95F4uFF08u6BEBu79D2uFF09 spring.redis.timeout=0 ## rabbitmq config spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=springboot spring.rabbitmq.password=123456 debug=true springboottest.hello.prefix=sajdjsakdsa springboottest.hello.suffix=2wwww ##actuator config # u542Fu7528u7AEFu70B9 env management.endpoint.env.enabled=true # u66B4u9732u7AEFu70B9 env u914Du7F6Eu591Au4E2A,u9694u5F00 management.endpoints.web.exposure.include=env management.endpoints.web.exposure.include=* info.sb=aa
可以看到配置的信息info信息
现在我们要修改访问的路径,指定beans的访问路口
server.port=8081 spring.datasource.url=jdbc:mysql://localhost:3306/spring spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver # REDIS (RedisProperties) # Redisu6570u636Eu5E93u7D22u5F15uFF08u9ED8u8BA4u4E3A0uFF09 spring.redis.database=0 # Redisu670Du52A1u5668u5730u5740 spring.redis.host=127.0.0.1 # Redisu670Du52A1u5668u8FDEu63A5u7AEFu53E3 spring.redis.port=6379 # Redisu670Du52A1u5668u8FDEu63A5u5BC6u7801uFF08u9ED8u8BA4u4E3Au7A7AuFF09 spring.redis.password= # u8FDEu63A5u6C60u6700u5927u8FDEu63A5u6570uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-active=8 # u8FDEu63A5u6C60u6700u5927u963Bu585Eu7B49u5F85u65F6u95F4uFF08u4F7Fu7528u8D1Fu503Cu8868u793Au6CA1u6709u9650u5236uFF09 spring.redis.pool.max-wait=-1 # u8FDEu63A5u6C60u4E2Du7684u6700u5927u7A7Au95F2u8FDEu63A5 spring.redis.pool.max-idle=8 # u8FDEu63A5u6C60u4E2Du7684u6700u5C0Fu7A7Au95F2u8FDEu63A5 spring.redis.pool.min-idle=0 # u8FDEu63A5u8D85u65F6u65F6u95F4uFF08u6BEBu79D2uFF09 spring.redis.timeout=0 ## rabbitmq config spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=springboot spring.rabbitmq.password=123456 debug=true springboottest.hello.prefix=sajdjsakdsa springboottest.hello.suffix=2wwww ##actuator config # u542Fu7528u7AEFu70B9 env management.endpoint.env.enabled=false # u66B4u9732u7AEFu70B9 env u914Du7F6Eu591Au4E2A,u9694u5F00 management.endpoints.web.exposure.include=env management.endpoints.web.exposure.include=* info.sb=aa indo.aa=bb
上面的配置表示除了env之外的端口,其他的端口都可以访问
接下来我们重点讲解下/health这个端口接口的信息
这这些包下面
暴露的endpoint为health,在浏览器就可以通过/health访问
健康检查调用了
@ReadOperation
public Health health() {
return this.healthIndicator.health();
}
这个方法