SpringBoot简介

• SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程

SpringBoot快速入门

• 新建maven工程，导入SpringBoot父工程以及依赖

<?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.itheima</groupId>
    <artifactId>day37-01-spring-boot-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--
        配置父模块
        推荐版本：
            2.6.2
            2.5.0
            2.3.9.RELEASE
     -->
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.5.0</version>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 导入SpringBoot的Web启动器：SpringMVC环境依赖的所有Jar包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

• 创建SpringBoot启动类

//springboot启动引导类注解，里面有@ComponentScan
//@ComponentScan 开启IOC注解扫描，没有配置包名，默认当前包及其子包所有类
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        //启动springboot程序运行当前引导类
        SpringApplication.run(DemoApplication.class, args);
    }
}

• 开发控制器类

@RestController
@RequestMapping("/book")
public class BookController {
    @GetMapping
    public String hello() {
        return "hello spring boot";
    }
}

• 测试

运行DemoApplication的main方法，浏览器访问http://localhost:8080/book，浏览器显示hello spring boot就为SpringBoot工程搭建成功

打包SpringBoot工程为jar包

如果需要将SpringBoot工程打包为jar，并使用命令行运行，则需要配置一个maven插件

• 配置maven插件

<!-- 配置插件，独立运行 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

• 执行maven打包命令

运行以下命令，如打包成功，将会在工程模块的target目录下生成jar包，在改目录下进行终端命令行，使用java -jar xx.jar即可启动

mvn package

SpringBoot项目配置

SpringBoot提供了多种属性配置方式，properties、yml、yaml，一共3种方式

以修改服务器端口为例，修改端口从8080修改为80

• application.properties

server.port=80

• application.yml

server:
  port: 81

• application.yaml

server:
  port: 82

SpringBoot配置文件加载顺序

综上所述，3种配置文件如果都同时存在，那么配置文件加载顺序是怎样呢？

• application.properties > application.yml > application.yaml

yaml介绍

什么是yaml，和properties有什么区别？

• YAML（YAML Ain't Markup Language），一种数据序列化格式
• 优点：
  • 容易阅读
  • 容易与脚本语言交互
  • 以数据为核心，重数据轻格式
• YAML文件扩展名
  • .yml（主流）
  • .yaml

yaml语法规则

• 大小写敏感
• 属性层级关系使用多行描述，每行结尾使用冒号结束
• 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
• 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）

• 表示注释

• 核心规则：数据前面要加空格与冒号隔开

yaml数组数据

• 数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

lesson: SpringBoot

server:
  port: 8080

enterprise:
  name: itheima
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大数据

yaml数据读取

一共有3种获取yaml数据的方式

• 使用@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

注：这种方式只能注入单个数值

@RestController
@RequestMapping("/book")
public class BookController {
    @Value("${lesson}")
    private String lesson;

    @Value("${server.port}")
    private Integer port;

    /**
     * 注解 @Value，这个注解不能读取整个数组，只能获取数组中的其中一个元素
     * 使用注意：读取配置文件的数据，配置文件配置这个数据，并且要正确，否则就会报错
     */
    @Value("${enterprise.subject[0]}")
    private String subject;

    @GetMapping("hello")
    public String hello() {
        System.out.println("lesson = " + lesson);
        System.out.println("server.port = " + port);
        System.out.println("enterprise.subject = " + subject);
        return "hello spring boot";
    }
}

• 封装全部数据到Environment对象

注：数组元素也只能一个个取出来

@RestController
@RequestMapping("/book")
public class BookController {
    /**
     * 环境对象，最灵活，但是可读性差
     */
    @Autowired
    private Environment environment;

    @GetMapping("/hello2")
    public String hello2() {
        System.out.println("lesson = " + environment.getProperty("lesson"));
        System.out.println("server.port = " + environment.getProperty("server.port"));
        System.out.println("enterprise.subject[0] = " + environment.getProperty("enterprise.subject[0]"));
        System.out.println("enterprise.subject[1] = " + environment.getProperty("enterprise.subject[1]"));
        System.out.println("enterprise.subject[2] = " + environment.getProperty("enterprise.subject[2]"));
        return "hello spring boot";
    }
}

• 自定义对象封装指定数据【常用】

1. 将对象添加Spring容器中，在类上添加@Component注解
2. 在类上添加@ConfigurationProperties(prefix="指定前缀")
3. 添加get和set方法，toString方法
4. 在控制器中注入下面Enterprise对象

注：使用lombok需要在pom.xml中导入坐标

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

• 编写实体类

//封装yml数据到一个实体类中
//lombok生成getter、setter、toString方法
@Data
//将该类创建对象，并加入IOC容器
@Component
//指定封装的数据的前缀
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private Integer age;
    private List<String> subject;
}

• 使用实体类获取数据

@RestController
@RequestMapping("/book")
public class BookController {
    /**
     * 读取到的配置会封装到这个对象
     */
    @Autowired
    private Enterprise enterprise;

    @GetMapping("/hello3")
    public String hello3() {
        System.out.println("name = " + enterprise.getName());
        System.out.println("age = " + enterprise.getAge());
        System.out.println("enterprise.subject[0] = " + enterprise.getSubject().get(0));
        return "hello spring boot";
    }
}

• 当输入@ConfigurationProperties注解的时候，自定义对象封装数据警告解决方案，添加一个依赖即可

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

多环境开发配置

项目的开发环境、测试环境、生产环境的配置信息一般都不一致，SpringBoot提供了多环境配置满足该需求

多环境配置分类yaml文件多环境配置以及properties文件多环境配置

• yaml文件多环境配置

yaml文件多环境配置，是将多个环境的配置写到同一个yaml文件中

application.yml中，添加如下配置，每种配置以---分割，通过active激活（使用）指定的环境

spring:
  profiles:
    active: pro
    
---
spring:
  config:
    activate:
      on-profile: pro
server:
  port: 80

---
spring:
  config:
    activate:
      on-profile: test
server:
  port: 81

---
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 82

• properties文件多环境配置

properties多环境配置，是将多个环境的配置单独配置在一个properties文件中，配置文件都以application-开头，-后加上环境的名称，以properties作为文件拓展名

#主启动配置文件 application.properties
spring.profiles.active=pro

#环境分类配置文件 application-pro.properties
server.port=80

#环境分类配置文件 application-dev.properties
server.port=81

#环境分类配置文件application-test.properties
server.port=82

多环境启动

通过mvn package命令打包后，就可以通过java -jar springboot.jar的方式启动，在该命令后面添加环境参数，即可切换对应的环境以及端口号

# 指定哪个配置名
java –jar springboot.jar --spring.profiles.active=test
# 指定具体的参数
java –jar springboot.jar --server.port=88
# 同时指定配置名 端口号
java –jar springboot.jar --server.port=88 --spring.profiles.active=test

SpringBoot多环境与Maven多环境兼容

本身maven就提供了多环境切换的功能，它提供了idea的GUI页面进行切换，而SpringBoot的多环境配置切换只能使用命令行

但SpringBoot也提供了与Maven多环境的兼容，使得在IDEA的maven多环境切换页面中，切换SpringBoot的多环境配置

• Maven中设置多环境属性

<!-- 多环境配置，在这里配置SpringBoot的环境名字，用户通过勾选界面，获取指定的SpringBoot名字 -->
<profiles>
    <profile>
        <!-- maven环境的名字 -->
        <id>dev_env</id>
        <!-- SpringBoot的环境名字 -->
        <properties>
            <profile.active>dev</profile.active>
        </properties>
        <!-- 默认激活 -->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>

    <profile>
        <id>pro_env</id>
        <properties>
            <profile.active>pro</profile.active>
        </properties>
    </profile>

    <profile>
        <id>test_env</id>
        <properties>
            <profile.active>test</profile.active>
        </properties>
    </profile>
</profiles>

• SpringBoot中引用Maven属性

注：Maven的多环境配置，需要配合propertis配置文件，所以需要将该配置文件中的多环境配置先注释，再加上配置占位符

# 配合maven进行多环境配置
spring.profiles.active=${profile.active}

• 配置maven插件，对资源文件开启默认占位符的解析

注：如果不配置，propertis配置文件中的${profile.active}将不会生效！！！

<build>
    <plugins>
        <!-- 配置maven去 resource 目录下，解析里面的 ${profile.active} 替换为上面用户在勾选页面对应的配置值 -->
        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>utf-8</encoding>
                <useDefaultDelimiters>true</useDefaultDelimiters>
            </configuration>
        </plugin>
    </plugins>
</build>

SpringBoot集成第三方技术

SpringBoot集成JUnit

• 添加SpringBoot的test启动器依赖

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

• 编写启动类（引导类）

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

• 编写业务层接口以及实现类

/**
 * 业务层接口
 */
public interface BookService {
    void save();
}

/**
 * 业务层实现类
 */
//创建对象，并加入IOC容器
@Service
public class BookServiceImpl implements BookService {
    @Override
    public void save() {
        System.out.println("book service success...");
    }
}

• 编写测试类

/**
 * 注解 @SpringBootTest，会去找引导类 JunitApplication ，并且运行引导类（里面有创建IOC容器对象，并扫描IOC注解）
 * <p>
 * 第一种用法：@SpringBootTest 测试的类必须放在与引导类同包名及其子包下，就不用手动指定引导类，会自动查找运行
 * 第二种用法：@SpringBootTest(classes = JunitApplication.class)
 * - 当测试类不在引导类所在包及其子包下时，都需要手动指定引导类
 * 注意：只用这个注解的前提是，必须Junit5
 * 如果是Junit4，必须再加一个 @RunWith(SpringJUnit4ClassRunner.class) 注解，并把 @Test 注解的导包换成 org.junit.Test 才可以
 * Junit5，导包是 org.junit.jupiter.api.Test
 * 即是：
 * - @RunWith(SpringJUnit4ClassRunner.class)
 * - @SpringBootTest
 */
@SpringBootTest
public class BookServiceTest {
    @Autowired
    private BookService bookService;

    @Test
    public void testSave() {
        bookService.save();
    }
}

SpringBoot集成SSM

SpringBoot的web启动器，已经将Spring与SpringMVC进行了整合，我们只需要将MyBatis在进行整合即可！

1. SpringBoot整合Spring（不存在）
2. SpringBoot整合SpringMVC（不存在）
3. SpringBoot整合MyBatis（主要）

• 配置依赖

<dependencies>
    <!-- mybatis启动器 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <!-- web启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.6</version>
    </dependency>

    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

• yaml配置文件配置中，配置Druid数据库连接池以及MyBatis

注意：SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区，或在MySQL数据库端配置时区解决此问题

# 配置连接池
spring:
  datasource:
    # 配置MySQL驱动
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 配置使用Druid连接池
    type: com.alibaba.druid.pool.DruidDataSource
    # 配置连接地址以及用户名和密码
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useUnicode=true&useSSL=false
    username: root
    password: root

# mybatis配置
mybatis:
  # 配置实体类别名的包扫描
  type-aliases-package: com.itheima.pojo
  configuration:
    # 开启小驼峰命名映射
    map-underscore-to-camel-case: true
    # 开启控制台sql语句日志打印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

• 创建SpringBoot启动类（引导类）

@SpringBootApplication
//SpringBoot 扫描MyBatis接口，生成代理对象，加入IOC容器（推荐使用）
@MapperScan("com.itheima.mapper")
public class SSMApplication {
    public static void main(String[] args) {
        SpringApplication.run(SSMApplication.class, args);
    }
}

• 创建数据库表实体类

@Data //lombok的注解，可以给实体类生成set\get和重写toString()方法
@AllArgsConstructor //2.生成全参构造函数
@NoArgsConstructor //3.生成无参构造函数
public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
}

• 创建Mapper接口类（数据持久层）

Mapper接口类，需要添加@Mapper接口或在启动类上添加@MapperScan注解，包扫描包下的Mapper接口

//注解 @Mapper，标识这是MyBatis接口，会自动创建对象，加入IOC容器
//不推荐，因为每个Mapper接口都需要设置，代码冗余，推荐在启动类中使用 @MapperScan("com.itheima.mapper") 进行包扫描
//@Mapper
public interface BookMapper {
    /**
     * 查询所有图书
     */
    @Select("select * from tbl_book")
    List<Book> findAll();
}

• 创建业务层接口以及实现类

/**
 * 业务层接口
 */
//开启事务，在SpringBoot中，不需要开启事务注解扫描，因为默认已经开启，所以该注解可以直接使用
@Transactional
public interface BookService {
    /**
     * 查询所有图书
     */
    List<Book> findAll();
}

/**
 * 业务层实现类
 */
//创建对象，并加入IOC容器
@Service
public class BookServiceImpl implements BookService {
    @Autowired(required = false)
    private BookMapper bookMapper;

    @Override
    public List<Book> findAll() {
        return bookMapper.findAll();
    }
}

• 创建Controller控制器（Web层）

运行SSMApplication的main方法，浏览器访问http://localhost:8080/book/findAll，浏览器显示json数据即为成功

@RestController
@RequestMapping("/book")
public class BookController {
    @Autowired
    private BookService bookService;

    @GetMapping("/findAll")
    public List<Book> findAll() {
        return bookService.findAll();
    }
}

• 测试

也可以使用SpringBoot集成Junit，进行Mapper（数据持久层）的单元测试

@SpringBootTest
class BookMapperTest {
    @Autowired
    private BookMapper bookMapper;

    @Test
    public void testFindAll() {
        List<Book> bookList = bookMapper.findAll();
        for (Book book : bookList) {
            System.out.println(book);
        }
    }
}

SpringBoot静态资源处理

SpringBoot的默认的静态资源访问路径有四个，我们只需要将前端静态资源方法四个路径中的任意一个，都可以实现前端资源的访问（注：访问时，不需要添加具体存放的目录，直接访问资源即可）

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public

例如，在static目录中提供index.html页面，并通过浏览器访问该页面

• index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index3</title>
</head>
<body>
static目录下的index.html
</body>
</html>

• 访问index.html页面

http://localhost:8080/index.html