1. SpringBoot3 基础

文章目录

• 1. SpringBoot 概述
• 2. SpringBoot 入门
• 3. SpringBoot 配置文件
• • 3.1 SpringBoot 配置文件基本使用
  • 3.2 yml 配置文件
• 4. SpringBoot 整合 Mybatis
• 5. Bean 管理
• • 5.1 Bean 扫描
  • 5.2 Bean 注册
  • 5.3 注册条件
• 6. 组合注解
• 7. 自动配置原理
• 8. 自定义 Starter

1. SpringBoot 概述

在 SpringBoot 之前，通过 Spring Framework 整合各种子项目，来构建 Spring应用程序：

传统方式构建 spring 应用程序，需要挨个导入依赖，项目配置繁琐：

SpringBoot 是 Spring 提供的一个子项目，用于快速构建 Spring 应用程序：

SpringBoot 的特性，用于简化开发：

(1) 起步依赖：本质上就是一个 Maven 坐标，整合了完成一个功能需要的所有坐标。

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

(2) 自动配置：遵循约定大约配置的原则，在 boot 程序启动后，一些 bean 对象会自动注入到 ioc 容器，不需要手动声明，简化开发。

比如现在要整合 mybatis：

• 传统的方法，首先要整合 mybatis 依赖，还要声明两个 bean 对象。
• 使用 SpringBoot 整合 mybatis 时，只需要引入 mybatis 起步依赖，因为起步依赖会自动引入前述的两个 bean 对象。

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

(3) 其他特性

• 内嵌的 Tomcat、Jetty（无需部署WAR文件）
• 外部化配置
• 不需要 XML 配置，只需在 properties / yml 中进行少量的配置

2. SpringBoot 入门

需求：使用 SpringBoot 开发一个 web 应用，浏览器发起请求 /hello 后，给浏览器返回字符串 hello world~。

使用 SpringBoot 后，不必再像之前那样繁琐，只需以下两个步骤：

下面从用 idea 创建工程开始，实现上面的需求：

(1) 创建 springboot 工程

(2) 下面来看一下新创建的 SpringBoot 工程中有什么内容。
pom.xml 文件中有自动导入的起步依赖：

@SpringBootApplication 标识当前类是 SpringBoot 启动类，是程序的入口：

资源目录：

(3) 新建 controller 目录，编写 HelloController

(4) 运行 main 方法
当 main 方法运行时，SpringBoot 工程就会启动，它内置的 tomcat 也会自动启动，并且把 Controller 这样的资源部署好，这样就能够通过浏览器访问了。

3. SpringBoot 配置文件

3.1 SpringBoot 配置文件基本使用

SpringBoot 提供了多种属性配置方式，一种是 properties 配置文件，另一种是 yml / yaml 配置文件（yml 和 yaml 只是名字不同，没其他区别）。

首先来看 properties 配置文件，在使用 Spring Initializer 创建 SpringBoot 工程时，会自动生成application.properties 配置文件。

我们可以在其中配置一些信息，且该配置文件是 SpringBoot 可以自动识别的。下面这个链接中给出了在该配置文件中可以配置的内容：
docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties

可以看到，这些配置都有一些默认值。如：tomcat 启动时默认绑定 8080 端口，当前项目的虚拟目录默认没有配置。

对于这些默认配置，我们可以在 application.properties 进行修改：

修改后再次启动 SpringBoot 工程：

在浏览器中访问：

下面简单介绍 yml / yaml 配置文件（只是名字不同，没其他区别，常写作 yml）。

该配置文件与 properties 配置文件的内容相同，只是格式不同。properties 配置文件的层级关系通过 . 来体现，yml 配置文件的层级关系通过 换行和缩进 来体现。

创建 yml 文件，写入配置信息：

启动工程：

浏览器访问：

3.2 yml 配置文件

在实际开发中，yml 配置文件与 properties 配置文件相比，书写格式相对清晰，所以更常用。下面对 yml 配置文件展开详细介绍。

yml 配置文件在实际开发中有两种使用方式:

(1) 书写三方技术所需的配置信息
例如，程序中要使用 redis，要做的就是：① 引入 redis 起步依赖；② 根据 redis文档编写配置信息。起步依赖会在工程启动之后，自动获取编写的配置信息，所以无需手动获取。后续会详细介绍 SpringBoot 如何整合三方技术。

(2) 书写自己程序所需的自定义配置信息（本节重点）
举个例子：在使用阿里云对象服务时，Java 代码中会有一些服务相关的配置信息：

如果这样，配置信息就跟 Java 代码耦合了。一旦配置信息发生变化，就必须去修改 Java 代码，重新进行编译、测试、打包、部署等操作，十分耗时。在实际开发中，常常将配置信息书写到配置文件中。这样，当配置文件中的信息发生改变时，重启服务器即可，不需要重新编译、测试、打包、部署等操作。

当配置信息书写到配置文件中时，Java 代码想要获取这些配置信息，就要通过代码来手动获取，因为不能自动获取。

书写配置信息

下面是发送邮件的代码所用到的一个实体类，其中有一些配置信息，需要将它们抽取到 properties 或 yml 配置文件中：

上面的配置文件中的键为什么要用 email 做前缀？ 因为其他地方也可能有 user、code 等这种键名，加上前缀是为了防止冲突。

注意 yml 文件的书写格式：

• 值前边必须有空格，作为分隔符
• 缩进表示层级关系，相同的层级左侧对齐

扩展：数组配置项的书写格式

hobbies:
  - "eat"
  - "drink"
  - "play"

获取配置信息

方法 1： 在 Java 代码的成员变量上添加 @Value("${键名}")

方法 2： 使用 @ConfigurationProperties(prefix="前缀") 注解，同时成员变量名与配置文件中的键名保持一致。(更简洁)

4. SpringBoot 整合 Mybatis

Spring 整合 mybatis 时，需要引入 mybatis 依赖以及 mybatis 和 spring 的整合依赖，此外还需要配置一些 bean 对象，如：SqlSessionFactoryBean、MapperScannerConfigurer、Datasource。

上面的过程相对繁琐，SpringBoot提供了更为简洁的方式：

(1) 引入 mybatis 起步依赖：相当于将 mybatis 依赖以及 mybatis 和 spring 的整合依赖全部引进来了。同时，该起步依赖会自动将 bean 对象注入 IOC 容器中，也就是前述的 bean 对象都无需再手动配置。

(2) 配置 yml 文件：让 mybatis 去操作数据库。

接下来就可以正常地去编写 Controller、Service、Mapper。当浏览器访问 Controller 时，Controller 去访问 Service，Service 去访问 Mapper，Mapper 最终去操作数据库。

案例：查询 User 表中指定 id 的数据，相应给浏览器

(1) 创建数据库表

create database if not exists mybatis;

use mybatis;

create table user(
    id int unsigned primary key auto_increment comment 'ID',
    name varchar(100) comment '姓名',
    age tinyint unsigned comment '年龄',
    gender tinyint unsigned comment '性别, 1:男, 2:女',
    phone varchar(11) comment '手机号'
) comment '用户表';

insert into user(id, name, age, gender, phone) VALUES (null,'白眉鹰王',55,'1','18800000000');
insert into user(id, name, age, gender, phone) VALUES (null,'金毛狮王',45,'1','18800000001');
insert into user(id, name, age, gender, phone) VALUES (null,'青翼蝠王',38,'1','18800000002');
insert into user(id, name, age, gender, phone) VALUES (null,'紫衫龙王',42,'2','18800000003');
insert into user(id, name, age, gender, phone) VALUES (null,'光明左使',37,'1','18800000004');
insert into user(id, name, age, gender, phone) VALUES (null,'光明右使',48,'1','18800000005');

(2) 在 pom.xml 中添加依赖

(3) 配置数据源信息

(4) 到这里，SpringBoot 整合 mybatis 就完成了，下面开始各个类的编写。

① pojo 类

package com.itheima.springbootmybatis.pojo;

public class User {
    // 与数据库表中的字段名称是一一对应的
    private Integer id;
    private String name;
    private Short age;
    private Short gender;
    private String phone;

    public User() {
    }

    public User(Integer id, String name, Short age, Short gender, String phone) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Short getAge() {
        return age;
    }

    public void setAge(Short age) {
        this.age = age;
    }

    public Short getGender() {
        return gender;
    }

    public void setGender(Short gender) {
        this.gender = gender;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", phone='" + phone + '\'' +
                '}';
    }
}

② Mapper (数据层)

@Mapper
public interface UserMapper {

    @Select("select * from user where id = #{id}")
    public User findById(Integer id);
}

③ Service 接口和实现类 (业务层)

public interface UserService {
    public User findById(Integer id);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired //按类型注入IOC中的bean对象
    private UserMapper userMapper;

    @Override
    public User findById(Integer id) {
        return userMapper.findById(id);
    }
}

④ Controller (表现层)

@RestController
public class UserController {

    @Autowired 
    private UserService userService;

    @RequestMapping("/findById")
    public User findById(Integer id){
        return userService.findById(id);
    }
}

运行结果：

5. Bean 管理

5.1 Bean 扫描

在 SpringBoot 之前，需要用以下方式来扫描 Bean：

但是，使用 SpringBoot 时，两种方法都没有用到，却依然能扫描到我们写的 Controller、Service 等等，这是因为 SpringBoot 的启动类上有 @SpringBootApplication 注解，且该注解整合了 @ComponentScan 注解：

需要要注意的是，该注解并没有指定要扫描的包路径，那么 Controller、Service 等是如何被扫描到的呢？

如果不指定扫描路径，默认扫描的是添加了该注解的类所在的包及其子包。

在此工程中，默认扫描的包就是 springbootmybatis。如果将 Controller 移出该包，就扫描不到它了：

此时，如果还想要 Controller 被扫描到，就要在启动类上添加 @ConponentScan 注解，指明要扫描的包：

5.2 Bean 注册

Bean 注册：把 Bean 对象注册到 IOC 容器中。

可以在类上添加下面的注解，从而把该类的对象注册到 IOC 容器中：

用 @Controller、@Service、@Repository 的地方也可以用 @Component，只是用这三个注解能够增强可读性。

但是针对三方的类（不是自定义的），就不能再使用这些注解将其 Bean 对象注入到 IOC 容器。那该怎么办呢？Spring 提供了 @Bean 和 @Import 两个注解来解决这个问题。

在使用这两个注解之前，首先要做一些准备工作：

pom.xml 文件：并没有引入 web 起步依赖，而是引入了 SpringBoot 核心依赖。因为在本节不做 web 的开发，只是注册 bean 对象。用 web 起步依赖的话，每次都要启动 tomcat，比较麻烦。

在 pom.xml 中导入一个三方 jar 包

我们的目标是将该 jar 包中的 Country 和 Province 的 bean 对象注入到 IOC 容器中。

(1) 用 @Bean 将三方 bean 对象注入 IOC 容器

用 @Bean 将第三方 bean 对象注入到 IOC 容器，可以通过在启动类中声明一个方法来实现。该方法有 @Bean 注解，并返回一个创建好的对象。当 Spring 解析到该方法时，就会将该方法的返回值自动注入 IOC 容器。

如果能将上面的 bean 对象从 IOC 容器中拿出来，就能够验证操作有效。

验证方法：启动类中的 SpringApplication.run() 方法用于启动工程，同时也会返回 Spring 初始化好的容器，所以可以通过该方法接收到 IOC 容器，进而拿到刚刚放入的 bean 对象。

输出结果：

Country{name='null', system='null'}

但是，启动类中写其他的功能不是一种好的编程习惯，所以以这种方式将三方 bean 注入 IOC 容器不推荐。

如果要注册第三方的 bean，建议在配置类（用@Configuration 标识）中集中注册。

具体就是，在配置类中声明与启动类中相同的方法（带 @Bean 注解）就能将该方法的返回值注入到 IOC 容器中了。需要注意的是，该配置类需要放到启动类所在的包或其子包下（为了能被扫描到）。

如果想要在 IOC 中注入多个三方 bean 对象，声明类似的方法即可。

还是用与前面形同的方法进行验证：

输出结果：

Country{name='null', system='null'}
Province{name='null', direction='null'}

在启动类中获取已经注入 IOC 容器中的 bean 对象时，也可以通过 bean 对象的名称来获取。bean 对象的默认名称是将其注入到 IOC 容器的方法的名称。

System.out.println(context.getBean("province"));

当然，bean 对象的名称也可以指定：

此时，启动类中，根据名称获取 bean 对象的操作应为：

System.out.println(context.getBean("aa"));

如果方法内部需要使用 IOC 容器中已经存在的 bean 对象，只需在方法上声明即可，Spring 会自动注入：

输出结果：

province: Country{name='null', system='null'}
Country{name='null', system='null'}
Province{name='null', direction='null'}

(2) 用 @Import 将三方 bean 对象注入 IOC 容器

只要在启动类上添加 @Import 注解，导入一个 xxx 类，Spring 就会把 xxx 对应的 bean 对象注入到 IOC 容器中。（相当于手动扫描）

xxx 类可以是一个普通类，也可以是一个配置类。在实际开发中，通常是配置类或 ImportSelector 接口的实现类。

为了演示 @Import 的作用，首先将 Controller 移出启动类的扫描范围：

CommonConfig.java：

① Import 配置类

如果有多个这样的配置类，可以把多个配置类放到一个数组中：

@Import({CommonConfig1.class, CommonConfig2.class, CommonConfig3.class})

但是，如果类似的配置文件过多，就会使这段代码很臃肿。此时，可以使用 ImportSelector 接口的实现类来解决。

② Import ImportSelector 接口的实现类

首先要定义一个类去实现 ImportSelector 接口，并重写其中的 selectImports() 方法。

selectImports() 方法返回一个字符串数组，每个元素就是要注入到 IOC 容器中的 bean 对象全类名。

需要注意的是，SpringBoot 会自动调用 selectImports() 方法，得到含全类名的数组，并把这些类的 bean 对象注入到 IOC 容器中。

此时，就不再 Import 配置类了，而是 ImportSelector 接口的实现类：

这样，工程启动之后，就会扫描到 @Import 注解，再去找到 CommonImportSelector 这个实现类，自动执行 selectImports() 方法，得到 bean 对象的全类名，并将对应的 bean 对象注入到 IOC 容器中。

在实际开发中，selectImports() 方法中的全类名数组并不是写死的，而是从配置文件中获取到的。这样的话，有哪些 bean 对象需要注入，就只需要将其对应的全类名写在配置文件里。下面介绍具体操作：

首先，新建 common.imports 文件，写入 bean 对象对应的全类名（如果有多个，就写多行）：

然后，在 CommonImportSelector 类中读取 common.imports 文件中的内容：

public class CommonImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //读取配置文件的内容
        List<String> imports = new ArrayList<>();
        //通过类加载器读取配置文件
        InputStream is = CommonImportSelector.class.getClassLoader().getResourceAsStream("common.imports");

        //下面看不懂，去补一下java基础中的反射和io流
        //为了方便使用，将输入流封装一下
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String line = null;
        try {
            while ((line = br.readLine()) != null){
                imports.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null){
                try {
                    br.close();//释放资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return imports.toArray(new String[0]);
    }
}

5.3 注册条件

可以发现，之前的代码输出的 Country 对象和 Province 对象的属性都为 null，这是因为没有初始化。如何对其进行初始化呢？可以在 CommonConfig.java 中通过各自的 setter 方法直接赋值，但是这样的话，值就又写到了 java 代码中，值发生改变就要修改 java 代码，从而需要重新编译等工作。

规范的写法是：将这些值写到配置文件中：

再用 @Value 注解将配置文件中的值注入到 java 代码的相应变量中
【注】@Value 不仅可以添加到成员变量上，也可以添加到参数列表上

此时如果将配置文件中的内容全部注释掉，代码就会因无法解析变量而报错。如果我们想要：配置文件里有值，就注入变量；没有值，就不注入。该怎么办呢？

要达到这种效果，需要用到注册条件相关知识。

SpringBoot 提供了设置注册生效条件的注解 @Conditional，可以借助该注解设置 Bean 注册的条件。但是该注解的使用较为繁琐，SpringBoot 提供了其衍生注解：

(1) @ConditionalOnProperty 注解：配置文件中存在对应的属性，才将该 bean 注入 IOC 容器

(2) @ConditionalOnMissingBean 注解：当不存在某类型的 bean 时，才将该 bean 注入 IOC 容器

(3) @ConditionalOnClass 注解：当前环境存在某个类时，才将该 bean 注入 IOC 容器

获取 DispatcherServlet 类的全类名的方式：按两下 Shift ➡ 输入类名 DispatcherServlet ➡ 选择 Classes ➡ 进入类。

在类名上右键，Copy ➡ Copy Reference

可以看到，当前的工程没有引入 web 起步依赖：

所以就不能在 IOC 容器中获取到 Province 的 bean 对象，只有添加了 web 起步依赖，当前环境才会有 DispatcherServlet 类，进而向 IOC 容器注入 Province 的 bean 对象。

以上三个注解，经常会在自定义 starter 或 SpringBoot 源码中看到。

6. 组合注解

定义一个注解类

这样就能把 @Import(CommonImportSelector.class) 注解整合到 @EnableCommonConfig 注解中。