[Spring] SpringBoot2 简介（一）—— 基础配置

目录

一、SpringBoot 简介

1、Spring 的缺点

2、SpringBoot 功能

二、SpringBoot 入门案例

1、实现步骤

2、访问服务器

3、入门小结

4、Idea 快速构建 SpringBoot 工程

5、起步依赖无需版本号

6、主启动类的在项目中的位置（*重要*）

三、SpringBoot 配置

1、配置文件分类

2、yaml 基本介绍

3、yaml 基本语法

4、yaml 数据格式

四、读取配置文件内容

1、@Value

2、Environment 类

3、@ConfigurationProperties

4、读取配置文件的问题汇总

五、Profile

1、为什么需要 profile

2、profile 的配置方式

3、profile 激活方式之多 profile 文件

4、profile 激活方式之 yml 多文档

5、虚拟机参数与命令行参数

6、激活 profile 问题汇总

7、项目内部配置文件加载顺序

六、SpringBoot 整合其他框架

1、整合 Junit

2、整合 Redis

3、整合 MyBatis（演示注解开发）

4、框架整合问题汇总

---

一、SpringBoot 简介

1、Spring 的缺点

（1）配置繁琐

• Spring 的组件代码是轻量级的，但是它的配置文件是重量级的。
• 在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写程序的时间。

（2）依赖繁琐

• 自己导入 maven 很可能会导致依赖冲突，还得自行判断版本号。

2、SpringBoot 功能

（1）自动配置（核心）

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

（2）起步依赖（核心）

• 起步依赖本质上是一个 Maven 项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
• 简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

（3）辅助功能

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

总的来说，SpringBoot 提供了一种快速开发 Spring 项目的方式，而不是对 Spring 功能上的增强。

二、SpringBoot 入门案例

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

1、实现步骤

在整个步骤中，不需要写一行配置，没有引入 Tomcat 的插件。

（1）导入 SpringBoot 起步依赖

• 我的 JDK 是 16 版本，只适合用 2.7.3，根据自己的 JDK 版本选择。 

    org.springframework.boot
    spring-boot-starter-parent
    2.7.3



    
    
        org.springframework.boot
        spring-boot-starter-web
    

    
    
        junit
        junit
        4.12
        test
    

（2）定义 Controller

• 需要注意的是，由于我们没有定义视图解析器，所以会导致 404。
• 既然没有解析器和对应 html，那么可以将返回值显示到 /hello 的页面上，加上 @ResponseBody 即可。

package com.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {
    @RequestMapping(value = "/hello")
    @ResponseBody
    public String hello() { // 在 /hello 页面输出 hello, springboot!
        System.out.println("/hello");
        return "hello, springboot!";
    }
}

（3）编写引导类

• 引导类一般以 Application 作为后缀。
• 这是 SpringBoot 的入口。

package com.demo.application;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloApplication {

}

（4）编写测试代码

• 测试类（假的，别用）

public class HelloApplicationTest {
    @Test
    public void test1() {
        SpringApplication.run(HelloApplication.class);
    }
}

• 在实际使用中，我们需要在 main 方法中执行 run 方法，因为服务器需要保持运行
• 也就是在引导类中的 main 方法，调用 run 方法

package com.demo.application;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

2、访问服务器

当我们在 main 方法中调用 run 方法后，该如何访问服务器呢？

在输出的信息中其实有这么一些信息：

显然 Tomcat 服务器已经在 8080 端口开放了，直接访问即可。

3、入门小结

• SpringBoot 在创建项目时，使用 jar 的打包方式。
• SpringBoot 的引导类，是项目入口，运行 main 方法就可以启动项目。
• 使用 SpringBoot 和 Spring 构建的项目，业务代码编与方式完全一样。

4、Idea 快速构建 SpringBoot 工程

如果我们连工程需要引入什么样的依赖都不想自己动手写，那么可以直接使用 SpringBoot 的生成器。但是需要一个联网环境。

（1）新建，选择 SpringInitial

• 服务器 URL：是 Spring 构建工程的服务器。

（2）直接选择我们需要的依赖

（3）项目结构

5、起步依赖无需版本号

在入门案例中，我们写的 POM 文件里，spring-boot-starter-web 是没有规定版本号的。

这是因为，在 SpringBoot 的父工程里，已经设定了大量的依赖的版本号，这也是 SpringBoot 能防止依赖冲突的原因之一。

6、主启动类的在项目中的位置（*重要*）

这是非常重要的一个问题，主启动类的位置决定了 SpringBoot 自动扫描的范围。

• 如果其他框架的包（如 mapper），不在主启动类的同目录、子目录下，那么 SpringBoot 自动扫描是找不到其他框架的包的。
• 要么将主启动类放置在父目录；
• 要么在主启动类中进行包扫描（缺点就是各类框架扫描注解不一样）；

三、SpringBoot 配置

1、配置文件分类

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

（1）语法的大致区别

• properties：

prop.driver=110

• yaml：

prop:
  port: 110

• yaml 的缩进以及 : 后的空格都有讲究。

（2）简单使用

• 当我们在 properties 中，将端口号修改为 8088，就会发现可以从 8088 访问服务器了。

• 还可以配置自定义属性，只不过需要我们手动加载这部分内容。

（3）加载顺序（优先级）

当 properties、yml、yaml 都存在 application 配置文件时，加载顺序为：

properties > yml > yaml

此时，在低优先级中的同一个名称的属性就会失效。

2、yaml 基本介绍

YAML全称是YAML Ain't Markup Language。

• YAML是一种直观的能够被电脑识别的的数据数据序列化格式；
• 容易被人类阅读，容易和脚本语言交互，可以被支持 YAML 库的不同的编程语言程序导入；
• YAML 文件的扩展名可以使用 .yml 或者 .yaml；
• 特点：简洁，以数据为核心；

可以发现，properties 不方便看出层级关系；xml 能看出层级关系，但是写标签繁琐；yaml 只需要相同缩进，就能得出层级关系。

3、yaml 基本语法

4、yaml 数据格式

（1）示例

（2）参数引用

• 使用 ${ } 可以引用其他对象。 

四、读取配置文件内容

读取配置文件的方法有好几种：

• @Value
• Environment 类
• @ConfigurationProperties

1、@Value

具体使用：https://blog.csdn.net/qq_31960623/article/details/116902786

（1）application.yml 文件：

address:
    - beijing
    - wuhan
    - shanghai

myUser:
    name: wyt
    age: 20
    hobby:
        - c++
        - python
        - java:
              web: 'java \n web'
              spring: "spring \n springboot"
    address: ${address[1]}

（2）Controller 代码：

@Value(value = "${myUser.hobby[2].java.web}")
private String web;

@Value(value = "${myUser.hobby[2].java.spring}")
private String spring;

@Value(value = "${myUser.address}")
private String address;

@RequestMapping(value = "/testAtValue")
@ResponseBody
public String testAtValue(@Value(value = "${myUser.name}") String username) {
    System.out.println("username = " + username);
    System.out.println("web = " + web);
    System.out.println("spring = " + spring);
    System.out.println("address = " + address);
    return "testAtValue";
}

（3）输出结果：

（4）结果分析：

• 从 web 和 spring 的获取中我们发现，数组中的对象，在使用 [ ] 后，还需要 .点运算 才能的到对象；
• 从 web 和 spring 的输出来看，单引号不会识别转义字符；
• 从 address 的获取来看，yml 可以实现参数引用；

2、Environment 类

• 从 @Value 的使用中可以发现，当参数很多时，使用起来就非常麻烦，要为每一个属性都加上 @Value。
• 而使用 Environment 只需要调用一个 getProperty() 方法，就可以获取到配置参数。
• Environment 是 Spring 提供的，直接 @Autowired 注入即可。

（1）Controller 代码：

@Autowired
private Environment environment;

@RequestMapping(value = "/testEnvironment")
@ResponseBody
public String testEnvironment() {
    for (int i = 0; i <= 2; ++ i) {
        System.out.println("address1 = " + environment.getProperty("address[" + i + "]"));
    }
    return "testEnvironment";
}

3、@ConfigurationProperties

使用这个注解，可以将配置文件中的对象，对应地注入到一个 POJO 对象中。

（1）编写 POJO 实体类

• @Component：让 Spring 识别，将其作为一个 bean 加入 IOC 中；
• @ConfigurationProperties(prefix = "person")：设置一个前缀，标识该 POJO 类的属性应该从 yml 的哪一个对象中获取值；
• get 和 set 方法不要忘记了；

package com.demo.pojo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

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

（2）application.yml 文件：

（3）测试代码：

@Autowired
private Person person;

@RequestMapping(value = "/testConfiguration")
@ResponseBody
public String testConfiguration() {
    System.out.println("name = " + person.getName());
    System.out.println("age = " + person.getAge());
    for (String s : person.getAddress()) {
        System.out.println("address = " + s);
    }
    return "testConfiguration";
}

（4）输出结果

（5）给 yml 添加提示功能

    org.springframework.boot
    spring-boot-configuration-processor
    true

• 添加这个依赖后，我们在 yml 中写配置信息时，就可以得到提示。

4、读取配置文件的问题汇总

（1）username

或许有一个疑问，在上面 @Value 中的 yml 配置文件里，为什么写 myUser，而不是直接写个 user 呢？

• 如果尝试过就知道，输出 user.name，得到的居然是个人操作系统当前的用户名。
• 显然 user 作为了一个保留的关键字，因此当我们以后实际开发中，最好给 user 加上前缀。

像数据库连接池需要使用 username 时，就要考虑这个问题了：https://blog.csdn.net/weixin_48841931/article/details/126671315

（2） @ConfigurationProperties 前缀命名问题

• prefix 的命名是由要求的。

https://blog.csdn.net/a2664181446/article/details/122581439

（3）@ConfigurationProperties 添加后，yml 还是没有提示

• 首先尝试重新 Build 项目，根据报错信息进行 Googel。

其中一种原因是编码问题：https://blog.csdn.net/gaogzhen/article/details/107348314

五、Profile

1、为什么需要 profile

我们在开发 SpringBoot 应用时，通常同一套程序要经过好几个环节，会被安装到不同的环境。

不同环境（开发、联调、预发、正式等）所需的配置不同，如果每改变一个环境就更改配置不但麻烦（修改代码、重新构建）而且容易出错。

profile 的功能就是来进行动态配置切换的。

2、profile 的配置方式

（1）多 profile 文件方式（properties），也是多 yml 文件方式

（2）yml 多文档方式（不是多 yml 文件方式）

3、profile 激活方式之多 profile 文件

profile 的激活方式有三种：配置文件、虚拟机参数、命令行参数。

下面以 配置文件 为例子，说明 profile 激活。

（1）创建配置文件

配置各个环境下对应的 properties 配置文件，并为他们设置不同的服务器端口（ server.port = xxxx）。各后缀意义如下：

• develoment：表示开发环境；
• product：表示生产环境；
• test：表示测试环境；

（2）激活配置

当我们创建好这几个配置文件后，启动 SpringBoot，会发现服务器端口还是 8080。这是因为还没有激活任一配置。

• 在 application.properties 中，使用 spring.profiles.active=后缀，就可激活指定的配置文件：

• 为 development 设置端口为 8081： 

• 启动 SpringBoot，此时端口已经改变： 

4、profile 激活方式之 yml 多文档

（1）创建配置文件

• 只需要一个 application.yml 即可，在其中使用 --- 来区分不同的配置。
• 每一个 --- 开头，表示一个新的配置区域。
• spring.config.activate.on-profile 用来表示配置的名称，作用于前面的“后缀”类似。
• 旧版本使用 spring.profiles 来表示配置名称。

（2）激活配置

• 同样也是 spring.profiles.active 来激活指定配置。

（3）文件代码

---
server:
    port: 8081
spring:
    config:
        activate:
            on-profile: development
---
server:
    port: 8082
spring:
    config:
        activate:
            on-profile: product
---
server:
    port: 8083
spring:
    config:
        activate:
            on-profile: test
---
spring:
    profiles:
        active: development

（4）启动结果

• 激活 development 配置，端口应为 8081。

5、虚拟机参数与命令行参数

（1）虚拟机参数

• 在 VM 选项中，输入 -Dspring.profiles.active=后缀，即可激活对应配置。 

（2）命令行参数

• 将我们当前的 SpringBoot 工程打包成 jar（可以使用 maven 的 package）；
• 在命令行窗口中，先 cd 到 jar 的目录下，然后运行命令：java  -jar  xxx.jar  --spring.profiles.active=development 即可；
• application.properties 和 appliaction.yml 都可以通过这种方式修改 spring.profiles.active 的值；

6、激活 profile 问题汇总

（1）Demo-Profile-0.0.1-SNAPSHOT.jar中没有主清单属性

• 请确保 pom.xml 中有一下内容：

    
        
            org.springframework.boot
            spring-boot-maven-plugin
        
    

7、项目内部配置文件加载顺序

六、SpringBoot 整合其他框架

1、整合 Junit

（1）引入依赖

• 引入 SpringBoot 的起步依赖 test。
• 引入 Junit。

    org.springframework.boot
    spring-boot-starter-test
    test


    junit
    junit
    test

（2）创建测试类（一个 Service）

（3）@RunWith 注解作用

@RunWith 就是一个运行器；

• @RunWith（JUnit4.class）就是指用 JUnit4 来运行；
• @RunWith（SpringJUnit4ClassRunner.class），让测试运行于 Spring 测试环境，以便在测试开始的时候自动创建 Spring 的应用上下文；
• @RunWith（Suite.class）的话就是一套测试集合；

（4）@SpringBootTest(classes = 启动类名称.class)

基本等同于启动了整个服务，此时便可以开始功能测试。

• 如果注解 @SpringBootTest(classes = 启动类名称.class) 中配置了项目启动类，则 test 测试类可以放在 test 下任何包中；

• 如果注解 @SpringBootTest 没有配置参数 classes = Application.class，则需要确保 test 测试类，在启动类的同目录或者子目录下；（网上一堆说是包路径一致的，都是片面的）

2、整合 Redis

Redis5 安装：https://github.com/tporadowski/redis/releases

（1）引入依赖

    org.springframework.boot
    spring-boot-starter-data-redis

（2）本机地址测试

• 先不配置远程，使用本机测试。
• 运行之前先启动 redis 本地服务器：redie-server.exe

package com.demo.demoredis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class DemoRedisApplicationTests {
    @Autowired
    // 本机才不用配置端口等信息
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
    }

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

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

}

（3）通过配置文件修改 ip 和 port

• 修改 properties 或者 yml 都可以。 

3、整合 MyBatis（演示注解开发）

（1）引入 MyBatis 起步依赖、PostgreSQL 驱动依赖

• MyBatis 起步依赖是由 MyBatis 官方编写的，Spring 没有提供；
• 根据自己所用的数据库更改 SQL 驱动；

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    2.3.1



    org.postgresql
    postgresql
    runtime

（2）建立相关表信息

（3）配置数据源

• 在配置文件中配置数据源的四个参数：driver、url、username、password。

（4）注解开发

• 注解开发则没有使用 Spring 配置文件，mapper 接口可以用 @Mapper 来识别；
• Spring 配置文件中用包扫描的方式将所有 mapper 都生成了 bean 对象，因此在这里用个 @Repository 来标识；

@Mapper
@Repository
public interface UserMapper {
    @Select("select * from \"MyUser\";")
    List queryForAll();
}

（5）测试及其结果

@Test
public void test() {
    List userList = userMapper.queryForAll();
    System.out.println(userList);
}

（6）注解开发小结

• From：https://blog.csdn.net/weixin_43591980/article/details/110043008
• 参考：https://blog.csdn.net/qq_40598321/article/details/117730759 

4、框架整合问题汇总

（1）是否必须添加 @RunWith 注解

其实不一定非要添加，主要看导入的 @Test 的包是哪一个：https://www.bmabk.com/index.php/post/121982.html