从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

SpringBoot总结-yaml语法、配置，常见注解详解_yml注解

作者：从前慢现在也慢 | 2024-02-16 04:05:18

踩

yml注解

基础

1 SpringBoot概述

SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到业务逻辑的代码编写中，从而大大提高开发的效率。

官网：https://spring.io/projects/spring-boot

SpringBoot功能

1） 自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2） 起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3） 辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

2 SpringBoot快速入门

需求：搭建SpringBoot工程，定义HelloController.hello()方法，返回”Hello SpringBoot!”。

实现步骤：

①创建Maven项目

②导入SpringBoot起步依赖

<!--springboot工程需要继承的父工程-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
</parent>

<dependencies>
    <!--web开发的起步依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

③定义Controller: 新建包package com.lichee.controller

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return " hello Spring Boot !";
    }
}
1
2
3
4
5
6
7

④编写引导类

/**
 * 引导类。 SpringBoot项目的入口
 */
@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class,args);
    }
}
1
2
3
4
5
6
7
8
9

⑤启动测试

注意：HelloApplication 和 HelloController必须都在com.lichee包下

快速构建SpringBoot工程

Spring提供快速创建模版：https://start.spring.io/

3 SpringBoot起步依赖原理分析

在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。
我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

4 SpringBoot配置-配置文件分类

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

默认配置文件名称：application
在同一级目录下优先级为：properties>yml > yaml

例如：配置内置Tomcat的端口

properties：

server.port=8080
1

yml:

server: 
  port: 8080
1
2

5 SpringBoot配置-yaml基本语法

大小写敏感
数据值前边必须有空格，作为分隔符
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的空格数目可能不同，导致层次混乱）。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
‘’#" 表示注释，从这个字符一直到行尾，都会被解析器忽略。

server: 
	port: 8080 #访问端口  
    address: 127.0.0.1
name: abc 
1
2
3
4

6 SpringBoot配置-yaml数据格式

对象(map)：键值对的集合。

#常用方式
person:  
   name: zhangsan
1
2
3

# 行内写法
person: {name: zhangsan}
1
2

数组：一组按次序排列的值

#常用方式
address:
  - beijing
  - shanghai
1
2
3
4

# 行内写法
address: [beijing,shanghai]
1
2

纯量：单个的、不可再分的值

msg1: 'hello \n world'  # 单引忽略转义字符
msg2: "hello \n world"  # 双引识别转义字符
1
2

参数引用

name: lisi 
person:
  name: ${name} # 引用上边定义的name值
1
2
3

7 SpringBoot配置-获取数据

@Value

 //获取普通配置
 @Value("${name}")
 private String name;
 
 //获取对象属性
 @Value("${person.name}")
 private String name2;
 
   //获取数组
 @Value("${address[0]}")
 private String address1;
 
//获取纯量
 @Value("${msg1}")
 private String msg1;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Evironment

@Autowired
private Environment env;

@RequestMapping("/hello2")
public String hello2() {
    System.out.println(env.getProperty("person.name"));
 	System.out.println(env.getProperty("address[0]"));
}
1
2
3
4
5
6
7
8

使用 @Component + @ConfigurationProperties组合注解读取对象的属性

注意：prefix一定要写

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private int age;
    private String[] address;

    //Getter and Setter
    //toString
}
1
2
3
4
5
6
7
8
9
10

完整读取代码：HelloController

@RestController
public class HelloController {
    @Value("${name}")
    private String name;

    @Value("${person.name}")
    private String name2;

    @Value("${person.age}")
    private int age;

    @Value("${address[0]}")
    private String address1;

    @Value("${msg1}")
    private String msg1;

    @Value("${msg2}")
    private String msg2;

    @Autowired
    private Environment env;

    @Autowired
    private Person person;

    @RequestMapping("/hello2")
    public String hello2() {
        System.out.println(name);
        System.out.println(name2);
        System.out.println(age);
        System.out.println(address1);
        System.out.println(msg1);
        System.out.println(msg2);

        System.out.println("----------------------");

        System.out.println(env.getProperty("person.name"));
        System.out.println(env.getProperty("address[0]"));

        System.out.println("-------------------");

        System.out.println(person);
        String[] address = person.getAddress();
        System.out.println("addressArray: " + Arrays.toString(address));

        return "hello Spring Boot 222!";
    }

    @RequestMapping("/hello")
    public String hello() {
        return "hello Spring Boot 222!";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

8 SpringBoot配置-profile（了解）

profile是用来完成不同环境下，配置动态切换功能的。
profile配置方式

多profile文件方式：提供多个配置文件，每个代表一种环境。

application-dev.properties/yml 开发环境

application-test.properties/yml 测试环境

application-pro.properties/yml 生产环境

yml多文档方式：

在yml中使用 --- 分隔不同配置（固定3个-）

profile激活方式

配置文件：再配置文件中配置：spring.profiles.active=dev
虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
命令行参数：java –jar xxx.jar --spring.profiles.active=dev

9 SpringBoot配置-项目内部配置文件加载顺序（了解）

加载顺序为上文的排列顺序，高优先级配置的属性会生效

file:./config/：当前项目下的/config目录下
file:./ ：当前项目的根目录
classpath:/config/：classpath的/config目录
classpath:/ ：classpath的根目录

10 SpringBoot配置-项目外部配置加载顺序（了解）

1.命令行

java -jar app.jar --name="Spring“ --server.port=9000
1

2.指定配置文件位置

 java -jar myproject.jar --spring.config.location=e://application.properties
1

3.外部不带profile的properties文件

classpath:/config/application.properties
classpath:/application.properties
1
2

官方文档：https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

11 SpringBoot整合Junit

搭建SpringBoot工程
引入starter-test起步依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

编写测试类

/**
 * 测试类
 */

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootJunitApplication.class )
public class UserServiceTest {

    @Test
    public void test(){
        System.out.println(111);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.测试

12 SpringBoot整合mybatis

准备工作

创建数据库springboot和表t_user

/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`springboot` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci */;

USE `springboot`;

/*Table structure for table `t_user` */

DROP TABLE IF EXISTS `t_user`;

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  `password` varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

/*Data for the table `t_user` */

insert  into `t_user`(`id`,`username`,`password`) values (1,'zhangsan','123'),(2,'lisi','234');

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

整合工作

①搭建SpringBoot工程

②引入mybatis起步依赖，添加mysql驱动

<dependencies>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.0</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <!--<scope>runtime</scope>-->
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

③编写DataSource和MyBatis相关配置

application.yml

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot?serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

# mybatis
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.lichee.springbootmybatis.domain
1
2
3
4
5
6
7
8
9
10
11
12

④定义表和实体类

public class User {
    private int id;
    private String username;
    private String password;

	//Getter and Setter
    //toString
}
1
2
3
4
5
6
7
8

⑤编写dao和mapper文件/纯注解开发

编写dao

@Mapper
@Repository
public interface UserXmlMapper {
    public List<User> findAll();
}
1
2
3
4
5

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lichee.springbootmybatis.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
</mapper>
1
2
3
4
5
6
7

纯注解开发

@Mapper
@Repository
public interface UserMapper {
    @Select("select * from t_user")
    public List<User> findAll();
}
1
2
3
4
5
6

⑥测试

13 SpringBoot整合redis

①搭建SpringBoot工程

②引入redis起步依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

③配置redis相关属性

spring:
  redis:
    host: 127.0.0.1 # redis的主机ip
    port: 6379
1
2
3
4

④注入RedisTemplate模板

⑤编写测试方法，测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSet() {
        //存入数据
        redisTemplate.boundValueOps("name").set("zhangsan");
    }

    @Test
    public void testGet() {
        //获取数据
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

高级

14 SpringBoot自动配置-Condition-1

Condition是Spring4.0后引入的条件化配置接口，通过实现Condition接口可以完成有条件的加载相应的Bean

@Conditional要配和Condition的实现类（ClassCondition）进行使用

ClassCondition

public class ClassCondition implements Condition {
    /**
     *
     * @param context 上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1.需求： 导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

UserConfig

@Configuration
public class UserConfig {
    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }
}
1
2
3
4
5
6
7
8

测试

@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
        Object user = context.getBean("user");
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9

15 SpringBoot自动配置-Condition-2

需求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定。

自定义条件注解类

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}
1
2
3
4
5
6
7

**注意：**此处@ConditionOnClass为自定义注解

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("com.alibaba.fastjson.JSON")
    public User user(){
        return new User();
    }

    @Bean
    @ConditionalOnProperty(name = "zs",havingValue = "zhangsan")
    public User user2(){
        return new User();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试User对象的创建

@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
        Object user = context.getBean("user");
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9

SpringBoot 提供的常用条件注解：

ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean

ConditionalOnClass：判断内存在中是否有对应字节码文件才初始化Bean (jar 包有没有导入)

ConditionalOnMissingBean：判断容器中没有对应Bean才初始化Bean(执行这个方法时要求所依赖的bean 已经被初始化了)

16 SpringBoot自动配置-切换内置web服务器

排除Tomcat

pom文件中的排除依赖效果

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!--排除tomcat依赖-->
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!--引入jetty的依赖-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

17 SpringBoot自动配置-Enable注解原理

SpringBoot不能直接获取在其他工程中定义的Bean

演示代码：

springboot-enable工程

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.lichee.springbootenable
 * com.lichee.config
 * //1.使用@ComponentScan扫描com.lichee.config包
 * //2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
 * //3.可以对Import注解进行封装。
 */

//@ComponentScan("com.lichee.config")
//@Import(UserConfig.class)
@EnableUser
@SpringBootApplication
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
		//获取Bean
        Object user = context.getBean("user");
        System.out.println(user);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

pom中引入springboot-enable-other

<dependency>
    <groupId>com.lichee</groupId>
    <artifactId>springboot-enable-other</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
1
2
3
4
5

springboot-enable-other工程

UserConfig

@Configuration
public class UserConfig {
    @Bean
    public User user() {
        return new User();
    }
}
1
2
3
4
5
6
7

EnableUser注解类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}
1
2
3
4
5
6

原因：@ComponentScan 扫描范围：当前引导类所在包及其子包

三种解决方案：

1.使用@ComponentScan扫描com.lichee.config包

2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器

3.可以对Import注解进行封装。

重点：Enable注解底层原理是使用@Import注解实现Bean的动态加载

18 SpringBoot自动配置-@Import详解

@Enable*底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：

①导入Bean

②导入配置类

③导入 ImportSelector 实现类。一般用于加载配置文件中的类

④导入 ImportBeanDefinitionRegistrar 实现类。

导入Bean @Import(User.class)
导入配置类 @Import(UserConfig.class)

导入 ImportSelector 实现类 @Import(MyImportSelector.class)

MyImportSelector

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.lichee.domain.User", "com.lichee.domain.Role"};
    }
}
1
2
3
4
5
6

导入 ImportBeanDefinitionRegistrar 实现类。@Import({MyImportBeanDefinitionRegistrar.class})

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);
    }
}
1
2
3
4
5
6
7

SpringbootEnableApplication测试代码

 /**
 - Import4中用法：
  - 1. 导入Bean
  - 2. 导入配置类
  - 3. 导入ImportSelector的实现类。
  - 4. 导入ImportBeanDefinitionRegistrar实现类
*/

  //@Import(User.class)
  //@Import(UserConfig.class)
  //@Import(MyImportSelector.class)
  //@Import({MyImportBeanDefinitionRegistrar.class})

@SpringBootApplication
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context =SpringApplication.run(SpringbootEnableApplication.class, args);  
        /*//获取Bean
      	Object user = context.getBean("user");
      	System.out.println(user);*/

        /*User user = context.getBean(User.class);
      	System.out.println(user);

      	Role role = context.getBean(Role.class);
      	System.out.println(role);*/

        /*  Object user = context.getBean("user");
      	System.out.println(user);*/
        
        Map<String, User> map = context.getBeansOfType(User.class);
        System.out.println(map);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@EnableAutoConfiguration中使用的是第三种方式：@Import(AutoConfigurationImportSelector.class)

19 SpringBoot自动配置-@EnableAutoConfiguration详解

@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。
配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean
并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

20 SpringBoot自动配置-自定义starter步骤分析

**需求：**自定义redis-starter。要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean。

步骤：

①创建 redis-spring-boot-autoconfigure 模块

②创建 redis-spring-boot-starter 模块,依赖 redis-spring-boot-autoconfigure的模块

③在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。并定义META-INF/spring.factories 文件

④在测试模块中引入自定义的 redis-starter 依赖，测试获取 Jedis 的Bean，操作 redis。

21 SpringBoot自动配置-自定义starter实现-1

创建redis-spring-boot-starter工程

pom文件中引入redis-spring-boot-autoconfigure

<!--引入configure-->
<dependency>
    <groupId>com.lichee</groupId>
    <artifactId>redis-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
1
2
3
4
5
6

创建redis-spring-boot-autoconfigure配置工程

创建RedisProperties配置文件参数绑定类

@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
    private String host = "localhost";
    private int port = 6379;

    //Getter and Setter...
}
1
2
3
4
5
6
7

创建RedisAutoConfiguration自动配置类

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    /**
     * 提供Jedis的bean
     */
    @Bean
    public Jedis jedis(RedisProperties redisProperties) {

        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在resource目录下创建META-INF文件夹并创建spring.factories

注意：”\ “是换行使用的

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.lichee.redis.config.RedisAutoConfiguration
1
2

在springboot-enable工程中引入自定义的redis的starter

<!--自定义的redis的starter-->
<dependency>
    <groupId>com.lichee</groupId>
    <artifactId>redis-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>
1
2
3
4
5
6

在SpringbootEnableApplication启动类中测试

    Jedis jedis = context.getBean(Jedis.class);
    System.out.println(jedis);
1
2

22 SpringBoot自动配置-自定义starter实现-2

测试springboot-enable工程中的application.properties中的配置参数

redis.port=6666
1

使用注解完成有条件加载配置类

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass(Jedis.class)
public class RedisAutoConfiguration {
    /**
     * 提供Jedis的bean
     */
    @Bean
    @ConditionalOnMissingBean(name = "jedis")
    public Jedis jedis(RedisProperties redisProperties) {
        System.out.println("RedisAutoConfiguration....");
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

23 SpringBoot事件监听

Java中的事件监听机制定义了以下几个角色：

①事件：Event，继承 java.util.EventObject 类的对象

②事件源：Source ，任意对象Object

③监听器：Listener，实现 java.util.EventListener 接口的对象

SpringBoot 在项目启动时，会对几个监听器进行回调，我们可以实现这些监听器接口，在项目启动时完成一些操作。

ApplicationContextInitializer、
SpringApplicationRunListener、
CommandLineRunner、
ApplicationRunner

自定义监听器的启动时机：MyApplicationRunner和MyCommandLineRunner都是当项目启动后执行，使用@Component放入容器即可使用

MyApplicationRunner

/**
 * 当项目启动后执行run方法。
 */
@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner...run");
        System.out.println(Arrays.asList(args.getSourceArgs()));
    }
} 
1
2
3
4
5
6
7
8
9
10
11

MyCommandLineRunner

@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner...run");
        System.out.println(Arrays.asList(args));
    }
}
1
2
3
4
5
6
7
8

MyApplicationContextInitializer的使用要在resource文件夹下添加META-INF/spring.factories

org.springframework.context.ApplicationContextInitializer=com.lichee.springbootlistener.listener.MyApplicationContextInitializer
1

@Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer....initialize");
    }
}
1
2
3
4
5
6
7

MySpringApplicationRunListener的使用要添加构造器

public class MySpringApplicationRunListener implements SpringApplicationRunListener {
    public MySpringApplicationRunListener(SpringApplication application, String[] args) {
    }

    @Override
    public void starting() {
        System.out.println("starting...项目启动中");
    }

    @Override
    public void environmentPrepared(ConfigurableEnvironment environment) {
        System.out.println("environmentPrepared...环境对象开始准备");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("contextPrepared...上下文对象开始准备");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("contextLoaded...上下文对象开始加载");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("started...上下文对象加载完成");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("running...项目启动完成，开始运行");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("failed...项目启动失败");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

ApplicationRunner / CommandLineRunner : 在项目启动后加载完毕其他所有配置后,执行
ApplicationContextInitializer/SpringApplicationRunListener : 在项目启动后,容器初始化前执行

24 SpringBoot流程分析-初始化

配置启动引导类（判断是否有启动主类）
判断是否是Web环境
获取初始化类、监听器类

25 SpringBoot流程分析-run

启动计时器
执行监听器
准备环境
打印banner：可以resource下粘贴自定义的banner
创建context
```
refreshContext(context);
1
```
执行refreshContext方法后才真正创建Bean

26 SpringBoot监控-actuator基本使用

①导入依赖坐标

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
1
2
3
4

②访问http://localhost:8080/acruator

{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-component-instance":{
            "href":"http://localhost:8080/actuator/health/{component}/{instance}",
            "templated":true
        },
        "health-component":{
            "href":"http://localhost:8080/actuator/health/{component}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

http://localhost:8080/actuator/info

在application.properties中配置

info.name=lucy
info.age=99
1
2

http://localhost:8080/actuator/health

开启健康检查详细信息

management.endpoint.health.show-details=always
1

{
    "status":"UP",
    "details":{
        "diskSpace":{
            "status":"UP",
            "details":{
                "total":159579508736,
                "free":13558104064,
                "threshold":10485760
            }
        },
        "redis":{
            "status":"UP",
            "details":{
                "version":"2.4.5"
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

27 SpringBoot监控-actuator开启所有endpoint

开启所有endpoint

在application.properties中配置：

management.endpoints.web.exposure.include=*
1

开启所有endpoint的返回结果：

{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "auditevents":{
            "href":"http://localhost:8080/actuator/auditevents",
            "templated":false
        },
        "beans":{
            "href":"http://localhost:8080/actuator/beans",
            "templated":false
        },
        "caches-cache":{
            "href":"http://localhost:8080/actuator/caches/{cache}",
            "templated":true
        },
        "caches":{
            "href":"http://localhost:8080/actuator/caches",
            "templated":false
        },
        "health-component-instance":{
            "href":"http://localhost:8080/actuator/health/{component}/{instance}",
            "templated":true
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-component":{
            "href":"http://localhost:8080/actuator/health/{component}",
            "templated":true
        },
        "conditions":{
            "href":"http://localhost:8080/actuator/conditions",
            "templated":false
        },
        "configprops":{
            "href":"http://localhost:8080/actuator/configprops",
            "templated":false
        },
        "env":{
            "href":"http://localhost:8080/actuator/env",
            "templated":false
        },
        "env-toMatch":{
            "href":"http://localhost:8080/actuator/env/{toMatch}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        },
        "loggers":{
            "href":"http://localhost:8080/actuator/loggers",
            "templated":false
        },
        "loggers-name":{
            "href":"http://localhost:8080/actuator/loggers/{name}",
            "templated":true
        },
        "heapdump":{
            "href":"http://localhost:8080/actuator/heapdump",
            "templated":false
        },
        "threaddump":{
            "href":"http://localhost:8080/actuator/threaddump",
            "templated":false
        },
        "metrics-requiredMetricName":{
            "href":"http://localhost:8080/actuator/metrics/{requiredMetricName}",
            "templated":true
        },
        "metrics":{
            "href":"http://localhost:8080/actuator/metrics",
            "templated":false
        },
        "scheduledtasks":{
            "href":"http://localhost:8080/actuator/scheduledtasks",
            "templated":false
        },
        "httptrace":{
            "href":"http://localhost:8080/actuator/httptrace",
            "templated":false
        },
        "mappings":{
            "href":"http://localhost:8080/actuator/mappings",
            "templated":false
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

28 SpringBoot监控-springboot admin图形化界面使用

SpringBoot Admin 有两个角色，客户端(Client)和服务端(Server)。

以下为创建服务端和客户端工程步骤：

admin-server：

①创建 admin-server 模块

②导入依赖坐标 admin-starter-server

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>
1
2
3
4

③在引导类上启用监控功能@EnableAdminServer

@EnableAdminServer
@SpringBootApplication
public class SpringbootAdminServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootAdminServerApplication.class, args);
    }
}
1
2
3
4
5
6
7

admin-client：

①创建 admin-client 模块

②导入依赖坐标 admin-starter-client

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
</dependency>
1
2
3
4

③配置相关信息：server地址等

# 执行admin.server地址
spring.boot.admin.client.url=http://localhost:9000

management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=*
1
2
3
4
5

④启动server和client服务，访问server

29 SpringBoot部署

SpringBoot 项目开发完毕后，支持两种方式部署到服务器：

①jar包(官方推荐)

②war包

更改pom文件中的打包方式为war

修改启动类

@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootDeployApplication.class, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDeployApplication.class);
    }
}
1
2
3
4
5
6
7
8
9
10
11

指定打包的名称

<build>
    <finalName>springboot</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
1
2
3
4
5
6
7
8
9

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/90579