SpringBoot基础

一、SpringBoot配置

1、配置文件

SpringBoot使用一个全局的配置文件，配置文件的名称是固定的

application.properties
- 语法结构：key=value
application.yml
- 语法结构：key:(空格)value

配置文件的作用：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了

# 对空格的要求非常高
name: yanheng

# 对象
student1:
  name: cyh
  age: 14
# 行内写法
student2: {name: cyh, age: 14}

# 数组
pets:
  - cat
  - dog
  - pig

pets2: [cat,dog,pig]

server.port=8081

student.name=cyh
student.age=14

2、给属性赋值的几种方式

@ConfigurationProperties

将配置文件中配置的每一个属性的值，映射到这个组件中；

告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定

参数prefix=”person“：将配置文件中的person下面的所有属性一一对应

只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
</dependency>

@Repository
@ConfigurationProperties(prefix = "person")
public class Person {
    private Integer id;
    private String name;
    private String hello;
    private Dog dog;
}

person:
  id: ${random.uuid}
  name: cyh
  hello: hha
  dog:
    name: ${person.hello:hello}旺财
    age: 3

PropertySource

@PropertySource(value = "classpath:application.properties")
public class Dog {
    @Value("${name}")
    private String name;
    private Integer age;
}

name=cccc

引入environment

@Resource
private Environment env;
@RequestMapping("/hello")
public String hello(){
    String property = env.getProperty("server.port");
    System.out.println(property);
    return "index";
}

对比

@ConfigurationPropertie只需要写一次即可，value则需要每一个字段都添加
yaml支持松散绑定
- yaml里last-name和java里的lastName可以绑定
yaml支持JSR303数据校验
- 可以在字段增加一层过滤器验证，保证数据的合法性
yaml支持复杂类型封装，可以封装对象

@Repository
@ConfigurationProperties(prefix = "person")
@Validated//JSR303数据校验
public class Person {
    private String id;
    @Email(message = "邮箱错了！！")//数据不合法则控制台提示邮箱错了
    private String name;
    private String hello;
    private Dog dog;

3、多环境配置及配置文件位置

优先级

properties>yaml

项目路径下的config文件夹配置文件
项目路径下的配置文件
资源路径下的config文件夹配置文件
资源路径下的配置文件

打成jar包之后不会包含项目根路径的config文件夹（不属于springboot的基本项目结构），故使用jar包运行时项目根路径下的config中的配置会失效

多环境配置

默认执行application.properties

profile用来完成不同环境下，配置动态切换功能的
profile配置方式
- 多profile文件方式：提供多个配置文件，每一个代表一种环境
  - application-dev.properties/yaml开发环境
  - application-pro.properties/yaml生产环境
  - application-test.properties/yaml测试环境
- yaml多文档方式
  - 在yaml中使用—分隔不同配置
  - 通过spring.config.activate.on-profile:pro/dev/test区分各个分区
profile的激活方式
- 配置文件：在配置文件(application.properties或yaml中的独立分区)中配置：spring.profiles.active=dev
- 虚拟机参数：在VM options指定：-Dspring.profiles.active=dev
- 命令行参数：java-jar xxx.jar --spring.profiles.active=dev
使用外部配置文件
- 在命令行参数：java-jar xxx.jar --spring.config.location=e://application.properties
- 配置文件放在和jar包同级的目录，运行jar包时配置文件会被自动读取
- 配置文件放在和jar包同级的config文件夹下，运行jar包时配置文件会被自动读取，优先级大于上者

4、整合其他框架

1）整合Junit

实现步骤：

搭建SpringBoot工程
引入starter-test起步依赖
编写测试类
添加测试相关注解
- @RunWith(SpringRunner.class)
- @SpringBootTest(classes=启动类.class)
编写测试方法

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>

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

    @Autowired
    private UserService userService;

    @Test
    public void testAdd(){
        userService.add();
    }
}

@SpringBootTest中的classes参数为springboot启动类的字节码文件

如果该Test文件所在的包和springboot启动类所在包一致或为其子包（都为cn.ken），则可以省略该参数

2）整合redis

实现步骤：

搭建SpringBoot工程
引入redis起步依赖
配置redis相关属性(默认本机6379端口)
注入RedisTemplate模板
编写测试方法，测试

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testSet() {
        redisTemplate.boundValueOps("name").set("cyh");
    }

    @Test
    void testGet() {
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }

}

需先运行redis-server.exe

3）整合MyBatis

实现步骤：

搭建SpringBoot工程
引入MyBatis起步依赖，添加mysql驱动
编写DataSource和MyBatis相关配置
定义表和实体类
编写dao和mapper文件/纯注解开发
测试

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimeZone=UTC
    username: root
    password: 129496
mybatis:
  #config-location: #指定mybatis的核心配置文件
  mapper-locations: classpath:mapper/*Mapper.xml #mapper映射文件地址
  type-aliases-package: cn.ken.springbootmybatis.domain

// 注解方式（也不需要上面yaml的配置）
@Mapper
public interface UserMapper {
    @Select("select * from user")
    List<User> findAll();
}

// 配置文件方式
@Mapper
public interface UserXmlMapper {
    List<User> findAll();
}

<?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="cn.ken.springbootmybatis.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from user;
    </select>
</mapper>

// 测试
@SpringBootTest
class SpringbootMybatisApplicationTests {
    @Resource
    private UserMapper userMapper;
    @Resource
    private UserXmlMapper userXmlMapper;
    @Test
    public void testUserMapper(){
        System.out.println(userMapper.findAll());
    }
    @Test
    public void testUserMapper2(){
        System.out.println(userXmlMapper.findAll());
    }
}

二、SpringBoot自动配置

1、condition

Condition是在Spring4.0增加的条件判断功能，通过这个功能可以实现选择性创建Bean的操作

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        boolean flag = true;
        try {
            Class<?> aClass = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            flag = false;
        }
        return flag;
    }
}

如果已经导入了Jedis坐标，则返回true，否则返回false

@Configuration
public class UserConfig {

    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }
}

参数是一个实现了Condition接口的类，只有参数ClassCondition中的matches方法返回true时才创建

@Bean返回的bean的id为函数名

@SpringBootApplication
public class SpringbootMybatisApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootMybatisApplication.class, args);
        Object user = run.getBean("user");
        System.out.println(user);
    }

}

@ConditionalOnClass等注解则是在@Conditional注解外面再包一层，传入需要的类的字节码文件，而在Conditional注解的OnClassCondition类上通过反射（该类实现matches方法，其中有两个参数context和metadata，metadata就可以通过反射获取到注解的属性）获取这些需要的字节码文件，来判断是否满足创建bean的需求，实现动态判断。

SpringBoot提供的常用条件注解：

ConditionalOnProperty(name=“x”, havingValue=“xx”)：判断配置文件中是否有对应属性和值才初始化Bean
ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
ConditionalOnMissingBean：判断环境中没有对应的Bean才初始化Bean

2、切换内置Web服务器

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

排除内置tomcat，引入jetty依赖

3、Enable*注解

SpringBoot提供了很多Enable开头的注解，这些注解都是用于动态开启某些功能的，而其底层原理是使用@Import注解导入一些类配置类，实现Bean的动态加载。

@SpringBootApplication注解中包含的@ComponentScan的扫描范围为当前类所在包及其子包，故导入其他依赖中的bean无法直接使用，因为对应的bean所在的包不是当前包所在包的子包。

为了解决这个问题可以采取：

增加@Component扫描对应bean的包
使用@Import注解加载对应的类，这些类都会被Spring创建并放入IOC容器
定义@Enable*注解对@Import注解进行封装

@Import

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

导入Bean
导入配置类（配置类里注册的Bean也会被导入）
导入ImportSelector实现类，一般用于加载配置文件中的配置类
导入ImportBeanDefinitionRegistrar实现类

EnableAutoConfiguration注解

@EnableAutoConfiguration注解内部使用@Import(AutoConfigurationImportSelector.class)来加载配置类(selectImports方法返回要加载的类的字符串数组)

配置文件位置：META/spring.properties(SpringFactoriesLoader类去加载)，该配置文件中定义了大量的配置类，当SpringBoot应用启动时，会自动加载这些配置类，初始化Bean

并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足的Bean

4、自动装配原理

SpringBoot启动会加载大量的自动配置类，自动装配类中配置了一些组件，配置时从properties类中获取属性，我们只需要在配置文件中指定这些属性的值即可。

xxxAutoConfiguration：自动装配类

xxxProperties：封装配置文件中相关属性

可以通过debug=true查看哪些配置类生效，哪些没有生效

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({MongoClient.class, MongoTemplate.class})
@EnableConfigurationProperties({MongoProperties.class})
@Import({MongoDataConfiguration.class, MongoDatabaseFactoryConfiguration.class, MongoDatabaseFactoryDependentConfiguration.class})
@AutoConfigureAfter({MongoAutoConfiguration.class})
public class MongoDataAutoConfiguration {
    public MongoDataAutoConfiguration() {
    }
}

@Configuration：配置类

@ConditionalOnClass：满足具有后面类地条件才生效（即导入了该依赖）

@EnableConfigurationProperties({MongoProperties.class})：封装配置文件

@Import：导入其他配置类

三、SpringBoot监听机制

1、事件监听

Java监听机制

SpringBoot的监听机制其实是对Java提供的事件监听机制的封装

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

事件(Event)：继承Java.util.EventObject类的对象
事件源(Source)：任意对象Object
监听器(Listener)：实现java.util.EventListener接口的对象

SpringBoot监听机制

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

ApplicationContextInitializer、SpringApplicationRunListener、CommandLineRunner、ApplicationRunner

@Component
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializer...initialize");
    }
}

public class MySpringApplicationRunListener implements SpringApplicationRunListener {

    public MySpringApplicationRunListener(SpringApplication springApplication, String[] args) {
    }

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

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

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

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

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

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

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("项目启动失败");
    }
}

/**
 * 当项目启动后执行run方法 等同于ApplicationRunner
 */
@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("CommandLineRunner");
    }
}

/**
 * 当项目启动后执行run方法 等同于CommandLineRunner
 * 一般可以用于redis缓存预热等（将数据库中某些数据提前存入redis）
 */
@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("ApplicationRunner");
    }
}

# resources下的META-INF目录下的spring.factories
org.springframework.boot.SpringApplicationRunListener=cn.ken.listener.MySpringApplicationRunListener

org.springframework.context.ApplicationContextInitializer=cn.ken.listener.MyApplicationContextInitializer

2、监控使用

使用步骤：

导入依赖坐标

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

访问http://localhost:8080/actuator
配置

# info下的信息
info.name=zhangsan
info.age=13

# 开启健康检查的完整信息
# 默认关闭，因为上线时展示所有信息有风险
management.endpoint.health.show-details=always

# 将所有监控的endpoint暴露出来
management.endpoints.web.exposure.include=*

3、Spring Boot Admin

Spring Boot Admin是一个开源社区项目，用于管理和监控SpringBoot应用程序
Spring Boot Admin有两个角色，客户端(Client)和服务端(Server)
应用程序作为Spring Boot Admin Client向Spring Boot Admin Server注册
Spring Boot Admin Server的UI界面将Spring Boot Admin Client的Actuator Endpoint上的一些监控信息进行展示

使用步骤：

admin-server：
1. 创建admin-server模块
2. 导入依赖坐标admin-starter-server
3. 在引导类上启用监控功能@EnableAdminServer
admin-client：
1. 创建admin-client模块
2. 导入依赖坐标admin-starter-client
3. 配置相关信息：server地址等
4. 启动server和client程序，访问server

server.port=8081

# 开启健康检查的完整信息
# 默认关闭，因为上线时展示所有信息有风险
management.endpoint.health.show-details=always

# 将所有监控的endpoint暴露出来
management.endpoints.web.exposure.include=*

# 注册到server上(url即为server的地址)
spring.boot.admin.client.url=http://localhost:8080

// server的设置
@EnableAdminServer
@SpringBootApplication
public class SpringbootAdminServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootAdminServerApplication.class, args);
    }

}

四、SpringBoot Web开发

1、静态资源导入

在SpringBoot，我们可以使用以下方式处理静态资源

webjars：localhost:8080/webjars/
public、static、resources：localhost:8080/

localhost:8080/webjars/jquery/3.4.1/jquery.js

localhost:8080/1.js

优先级：resources>static>public

2、Thymeleaf模板引擎

<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring5</artifactId>
</dependency>

<dependency>
    <groupId>org.thymeleaf.extras</groupId>
    <artifactId>thymeleaf-extras-java8time</artifactId>
</dependency>

随后将html页面放在templates文件夹下，将静态资源放在static文件夹下

templates下的资源不能直接访问，只能通过控制器

默认情况下：

public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";

五、SpringBoot项目部署

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

jar包(官方推荐)
war包