• 01【SpringBoot快速入门、yml语法、自动配置、整合框架】

    目录

    一、SpringBoot简介

    1.1 Spring优缺点

    1.1.1 Spring的优点

    1.1.2 Spring的缺点

    1.2 SpringBoot的概述

    1.2.1 SpringBoot概述

    1.2.2 SpringBoot的核心功能

    二、SpringBoot快速入门

    2.1 创建Maven工程

    2.2 添加起步依赖

    2.3 编写Controller

    2.4 编写SpringBoot引导类

    三、SpringBoot的配置文件

    3.1 yml配置文件

    3.1.1 yml配置文件的语法

    1）配置普通数据

    2）配置对象数据

    3）配置Map数据

    4）配置数组（List、Set）数据

    3.2 修改默认配置

    3.3 配置信息查询

    3.4 配置多个Profile

    3.4.1 配置多文档块Profile

    3.4.2 配置yml多profile

    四、SpringBoot自动配置原理

    4.1 起步依赖原理

    4.1.1 版本锁定

    4.1.2 起步依赖

    4.2 自动配置原理

    4.2.1 @SpringBootApplication源码

    4.2.2 @SpringBootConfiguration源码

    4.2.3 @EnableAutoConfiguration源码

    1）Registrar

    2）AutoConfigurationImportSelector

    4.2.4 @ComponentScan

    1）AutoConfigurationExcludeFilter

    2）TypeExcludeFilter

    3）自定义排除器

    4.3 自动配置类

    4.3.1 自动配置类说明

    4.3.2 @Conditional派生注解

    4.3.3 自定义自动配置类

    4.4 属性配置类

    4.4.1 属性配置类说明

    4.4.2 自定义属性配置类

    4.5 自定义场景启动器

    4.5.1 场景启动器包含内容

    4.5.2 搭建自动配置工程

    4.5.2.1 依赖

    4.5.2.2 自动配置类

    4.5.2.3 属性配置类

    4.5.2.4 具体配置的类

    4.5.2.5 spring.factories

    4.5.3 搭建测试工程

    4.5.3.1 依赖

    4.5.2.2 Controller

    4.5.2.3 application.yml

    4.5.2.4 引导类

    五、SpringBoot与整合其他技术

    5.1 SpringBoot整合Mybatis

    5.1.1 搭建工程

    1）依赖：

    2）创建表

    3）创建实体Bean

    4）application.yml

    5）UserMapper

    6）UserMapper.xml

    5.1.2 测试

    5.1.3 MyBatis自动配置

    1）MybatisAutoConfiguration

    2）MybatisProperties

    5.2 SpringBoot整合Junit

    5.2.1 添加Junit的场景启动器

    5.2.2 编写测试类

    5.3 SpringBoot整合Spring Data JPA

    5.3.1 添加Spring Data JPA的起步依赖

    5.3.2 jpa相关配置

    5.3.3 建立映射

    5.3.3 编写UserDao

    5.3.4 编写测试类

    5.4 SpringBoot整合Redis

    5.4.1 添加Redis的起步依赖

    5.4.2 Redis相关配置

    5.4.3 测试类

    一、SpringBoot简介

    1.1 Spring优缺点

    1.1.1 Spring的优点

    Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程

    简单来说，Spring是一个JavaEE轻量级的一站式开发框架。

    1.1.2 Spring的缺点

    虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。我们在整合MyBatis时需要配置SqlSessionFactory以及一些其他的配置，整合Jpa时需要配置LocalContainerEntityManagerFactoryBean等....

    所有配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。

    除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

    总结：

    • 1）项目的配置编写占据了我们大量的时间（能否默认配置？）
    • 2）jar包的依赖管理非常不便（能否有专人帮我们管理？）

    1.2 SpringBoot的概述

    1.2.1 SpringBoot概述

    Spring Boot 是由 Pivotal 团队提供的全新框架。Spring Boot 是所有基于 Spring Framework 5.0 开发的项目的起点。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。

    SpringBoot提倡"约定大于配置"的理念让你的项目快速运行起来，即所有配置都是基于约定的（采用默认配置），这种开箱即用的方式大大提高了我们开发的效率，缩短了项目周期。

    SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

    1.2.2 SpringBoot的核心功能

    • 1）起步依赖（场景启动器）

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

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

    • 2）自动配置

    Spring Boot的自动配置是一个运行时的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

    二、SpringBoot快速入门

    2.1 创建Maven工程

    创建一个普通的Mave工程（模块/项目）

    2.2 添加起步依赖

    SpringBoot项目要继承SpringBoot的起步依赖spring-boot-starter-parent

    1. <parent>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-starter-parent</artifactId>
    4.     <version>2.0.1.RELEASE</version>
    5. </parent>

    引入相关场景依赖：

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.boot</groupId>
    4.         <artifactId>spring-boot-starter-web</artifactId>
    5.     </dependency>
    6. </dependencies>

    2.3 编写Controller

    1. package com.dfbz.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6.  
    7. /**
    8.  * @author lscl
    9.  * @version 1.0
    10.  * @intro:
    11.  */
    12. @Controller
    13. public class HelloController {
    14.  
    15.     @GetMapping("/hello")
    16.     @ResponseBody
    17.     public String hello(){
    18.         return "Hello SpringBoot!";
    19.     }
    20. }

    2.4 编写SpringBoot引导类

    1. package com.dfbz;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. /**
    7.  * @author lscl
    8.  * @version 1.0
    9.  * @intro:
    10.  */
    11. @SpringBootApplication          // 标注这是一个引导类
    12. public class HelloApplication {
    13.  
    14.     public static void main(String[] args) {
    15.         SpringApplication.run(HelloApplication.class);
    16.     }
    17. }

    访问：http://localhost:8080/hello

    就这样，我们就搭建完成了一个SpringMVC的环境；

    三、SpringBoot的配置文件

    SpringBoot是基于约定的，所以很多配置都有默认值，但是我们可以修改SpringBoot的默认配置

    SpringBoot支持三种配置文件：

    • 1）application-{profile}.yml；
    • 2）application-{profile}.yaml；
    • 3）application-{profile}.properties；

    SpringBoot启动时默认会从classes目录以及classes/config目录下加载这三种配置文件

    其中properties配置文件优先级高，其次yml，优先级最低的为yaml

    3.1 yml配置文件

    YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。

    YML文件的扩展名可以使用.yml或者.yaml；

    3.1.1 yml配置文件的语法

    1）配置普通数据

    语法： key: value

    示例代码：

    book: 《孙子兵法》

    注意：value之前必须有一个空格

    2）配置对象数据

    语法：

    1. key:
    2. 	key1: value1
    3. 	key2: value2

    或者：

    key: {key1: value1,key2: value2}

    示例代码：

    1. book:
    2.   name: 《聊斋志异》
    3.   author: 蒲松龄
    4.   
    5. #或者
    6. book: {name: 《聊斋志异》,author: 蒲松龄}

    3）配置Map数据

    1. book:
    2.   name: 《三国志》
    3.   author: 陈寿

    4）配置数组（List、Set）数据

    语法：

    1. key:
    2. 	- value1
    3. 	- value2

    或者：

    key: [value1,value2]

    示例代码：

    1. books:
    2.   - 《三国演义》
    3.   - 《西游记》
    4.   - 《红楼梦》
    5.   - 《水浒传》
    6. #或者
    7. cities: [武汉,长沙,南昌,合肥]
    8. #集合中的元素是对象形式
    9. books:
    10.   - name: 《三国演义》
    11.     author: 罗贯中
    12.     
    13.   - name: 《西游记》
    14.     author: 吴承恩
    15.     
    16.   - name: 《红楼梦》
    17.     addr: 曹雪芹
    18.   
    19.   - name: 《水浒传》
    20.   	author: 施耐庵

    注意：value与之间的 - 之间存在一个空格

    3.2 修改默认配置

    我们可以通过配置application.poperties 或者 application.yml 来修改SpringBoot的默认配置

    例如：

    application.properties文件

    1. server.port=8888
    2. server.servlet.context-path=/demo

    application.yml文件

    1. server:
    2.  port: 8888
    3.  servlet:
    4.    context-path: /demo

    3.3 配置信息查询

    SpringBoot的配置文件，主要的目的就是对配置信息进行修改的，但在配置时的key从哪里去查询呢？我们可以查阅SpringBoot的官方文档

    文档URL：

    Spring Boot Reference Guide

    1. 常用的配置摘抄如下：
    2.  
    3.  ```properties
    4. # QUARTZ SCHEDULER (QuartzProperties)
    5. spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
    6. spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql # Path to the SQL file to use to initialize the database schema.
    7. spring.quartz.job-store-type=memory # Quartz job store type.
    8. spring.quartz.properties.*= # Additional Quartz Scheduler properties.
    9.  
    10.  
    11. # ----------------------------------------
    12. # WEB PROPERTIES
    13. # ----------------------------------------
    14. # EMBEDDED SERVER CONFIGURATION (ServerProperties)
    15. server.port=8080 # Server HTTP port.
    16. server.servlet.context-path= # Context path of the application.
    17. server.servlet.path=/ # Path of the main dispatcher servlet.
    18.  
    19.  
    20. # HTTP encoding (HttpEncodingProperties)
    21. spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to the "Content-Type" header if not set explicitly.
    22.  
    23. # JACKSON (JacksonProperties)
    24. spring.jackson.date-format= # Date format string or a fully-qualified date format class name. For instance, `yyyy-MM-dd HH:mm:ss`.
    25.  
    26.  
    27. # SPRING MVC (WebMvcProperties)
    28. spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher servlet.
    29. spring.mvc.static-path-pattern=/ # Path pattern used for static resources.
    30. spring.mvc.view.prefix= # Spring MVC view prefix.
    31. spring.mvc.view.suffix= # Spring MVC view suffix.
    32.  
    33.  
    34. # DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
    35. spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
    36. spring.datasource.url= # JDBC URL of the database.
    37. spring.datasource.username= # Login username of the database.
    38. spring.datasource.password= # Login password of the database.
    39.  
    40.  
    41. # JEST (Elasticsearch HTTP client) (JestProperties)
    42. spring.elasticsearch.jest.password= # Login password.
    43. spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use.
    44. spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use.
    45. spring.elasticsearch.jest.read-timeout=3s # Read timeout.
    46. spring.elasticsearch.jest.uris=http://localhost:9200 # Comma-separated list of the Elasticsearch instances to use.
    47. spring.elasticsearch.jest.username= # Login username.

    3.4 配置多个Profile

    SpringBoot默认支持的配置文件有.yml、.yaml、.properties，其命名格式都为application-{profile}，我们可以配置多档环境，在开发过程中可以轻松切换

    3.4.1 配置多文档块Profile

    1. server:
    2.   port: 8080
    3. spring:
    4.   profiles:
    5.     active: test		# 激活test环境
    6.  
    7. ---
    8. server:
    9.   port: 8081
    10. spring:
    11.   profiles: dev			# 指定所属环境
    12.  
    13. ---
    14. server:
    15.   port: 8082
    16. spring:
    17.   profiles: prod
    18.  
    19. ---
    20. server:
    21.   port: 8083
    22. spring:
    23.   profiles: test

    3.4.2 配置yml多profile

    • application-dev.yml：

    1. server:
    2.   port: 8081
    3. spring:
    4.   profiles: dev

    application-prod.yml：

    1. server:
    2.   port: 8082
    3. spring:
    4.   profiles: prod

    • application-test.yml：

    1. server:
    2.   port: 8083
    3. spring:
    4.   profiles: test

    • application.yml：

    1. server:
    2.   port: 8080
    3. spring:
    4.   profiles:
    5.     active: dev     # 激活dev

    Tips：当多个配置文件产生互补配置；即application.yml配置与被激活的yml配置同时生效，如有冲突则以被激活的yml文件为准；

    四、SpringBoot自动配置原理

    SpringBoot能够快速项目运行起来，不需要我们自己来搭建框架所属的环境，其核心原因是SpringBoot在项目启动时即帮我们搭建好了所需环境，做到开箱即用，接下来我们重点探究一下SpringBoot是如何做到让项目快速运行起来的！

    4.1 起步依赖原理

    4.1.1 版本锁定

    SpringBoot项目都是继承于spring-boot-starter-parent工程的，我们点进去看看这个工程中配置了什么？

    1. <parent>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-dependencies</artifactId>
    4.     <version>2.0.1.RELEASE</version>
    5.     <relativePath>../../spring-boot-dependencies</relativePath>
    6. </parent>
    7.  
    8. ...
    9. <properties>
    10.     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    11.     <java.version>1.8</java.version>
    12.     <resource.delimiter>@</resource.delimiter>
    13.     <maven.compiler.source>${java.version}</maven.compiler.source>
    14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    15.     <maven.compiler.target>${java.version}</maven.compiler.target>
    16. </properties>
    17.  
    18. <pluginManagement>
    19.     <plugins>
    20.         <plugin>
    21.             <groupId>org.jetbrains.kotlin</groupId>
    22.             <artifactId>kotlin-maven-plugin</artifactId>
    23.             <version>${kotlin.version}</version>
    24.         </plugin>
    25.         ...
    26.     </plugins>
    27. </pluginManagement>

    我们发现spring-boot-starter-parent工程是继承于spring-boot-dependencies工程，在spring-boot-starter-parent工程中锁定了部分插件使用的版本：

    我们继续点进spring-boot-dependencies工程：

    1. <properties>
    2.         <activemq.version>5.15.3</activemq.version>
    3.         <antlr2.version>2.7.7</antlr2.version>
    4.         <appengine-sdk.version>1.9.63</appengine-sdk.version>
    5.         <artemis.version>2.4.0</artemis.version>
    6.         <aspectj.version>1.8.13</aspectj.version>
    7.         <assertj.version>3.9.1</assertj.version>
    8.         <atomikos.version>4.0.6</atomikos.version>
    9.         <bitronix.version>2.1.4</bitronix.version>
    10.     .....
    11. </properties>
    12.  
    13. <dependencyManagement>
    14.         <dependencies>
    15.             <dependency>
    16.                 <groupId>org.springframework.boot</groupId>
    17.                 <artifactId>spring-boot</artifactId>
    18.                 <version>2.0.1.RELEASE</version>
    19.             </dependency>
    20.             <dependency>
    21.                 <groupId>org.springframework.boot</groupId>
    22.                 <artifactId>spring-boot-test</artifactId>
    23.                 <version>2.0.1.RELEASE</version>
    24.             </dependency>
    25.             <dependency>
    26.                 <groupId>org.springframework.boot</groupId>
    27.                 <artifactId>spring-boot-test-autoconfigure</artifactId>
    28.                 <version>2.0.1.RELEASE</version>
    29.             </dependency>
    30.             <dependency>
    31.                 <groupId>org.springframework.boot</groupId>
    32.                 <artifactId>spring-boot-actuator</artifactId>
    33.                 <version>2.0.1.RELEASE</version>
    34.             </dependency>
    35.             
    36.             ....
    37.     </dependencies>
    38. </dependencyManagement>

    从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了（解决了版本冲突问题）。

    这些版本的搭配经过了SpringBoot官方团队的测试，我们在使用过程中，采用SpringBoot搭配的版本匹配，就避免了版本冲突、不稳定等因素；

    4.1.2 起步依赖

    在继承的父工程中我们并没有看到依赖的引入（只是版本的锁定），真正的依赖是在我们引入场景启动器时引入的，我们点击spring-boot-starter-web场景启动器查看：

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.boot</groupId>
    4.         <artifactId>spring-boot-starter</artifactId>
    5.         <version>2.0.1.RELEASE</version>
    6.         <scope>compile</scope>
    7.     </dependency>
    8.     <dependency>
    9.         <groupId>org.springframework.boot</groupId>
    10.         <artifactId>spring-boot-starter-json</artifactId>
    11.         <version>2.0.1.RELEASE</version>
    12.         <scope>compile</scope>
    13.     </dependency>
    14.     <dependency>
    15.         <groupId>org.springframework.boot</groupId>
    16.         <artifactId>spring-boot-starter-tomcat</artifactId>
    17.         <version>2.0.1.RELEASE</version>
    18.         <scope>compile</scope>
    19.     </dependency>
    20.     <dependency>
    21.         <groupId>org.hibernate.validator</groupId>
    22.         <artifactId>hibernate-validator</artifactId>
    23.         <version>6.0.9.Final</version>
    24.         <scope>compile</scope>
    25.     </dependency>
    26.     <dependency>
    27.         <groupId>org.springframework</groupId>
    28.         <artifactId>spring-web</artifactId>
    29.         <version>5.0.5.RELEASE</version>
    30.         <scope>compile</scope>
    31.     </dependency>
    32.     <dependency>
    33.         <groupId>org.springframework</groupId>
    34.         <artifactId>spring-webmvc</artifactId>
    35.         <version>5.0.5.RELEASE</version>
    36.         <scope>compile</scope>
    37.     </dependency>
    38. </dependencies>

    我们发现在spring-boot-starter-web依赖中引入了大量web场景需要的依赖，如Spring-web、Spring-webmvc、json转换、tomcat等，SpringBoot中的场景启动器（starter）对场景的依赖进行"打包"，这样以后我们的项目只需要引入对应场景的starter即可；

    • 官方提供的场景命名规则为：spring-boot-starter-xxx
    • 第三方提供场景命名规则为：xxx-spring-boot-starter

    4.2 自动配置原理

    我们在前面说到过，SpringBoot所有的配置基于约定理念，并不是不需要配置，而是SpringBoot在项目启动时帮我们配置了，所有的配置基于约定的参数已经配置好了；那么SpringBoot是如何做到"自动配置"的呢？

    我们点击标注在引导类上的@SpringBootApplication注解：

    1. @SpringBootApplication          // 标注这是一个引导类
    2. public class HelloApplication {
    3.  
    4.     public static void main(String[] args) {
    5.         SpringApplication.run(HelloApplication.class);
    6.     }
    7. }

    4.2.1 @SpringBootApplication源码

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @SpringBootConfiguration
    6. @EnableAutoConfiguration
    7. @ComponentScan(
    8.     excludeFilters = {@Filter(
    9.     type = FilterType.CUSTOM,
    10.     classes = {TypeExcludeFilter.class}
    11. ), @Filter(
    12.     type = FilterType.CUSTOM,
    13.     classes = {AutoConfigurationExcludeFilter.class}
    14. )}
    15. )
    16. public @interface SpringBootApplication {
    17.     ...
    18.  
    19. }

    • 1）@Target({ElementType.TYPE})：元注解，标注这个注解只能在类上使用
    • 2）@Retention(RetentionPolicy.RUNTIME)：元注解，标注这个注解的生命周期是RUNTIME，可以在运行时解析到这个注解
    • 3）@Documented ：元注解，表明这个注解应该被 javadoc工具记录
    • 4）@Inherited ：元注解，标注在类上面时，该类的子类会自动继承此注解

    4.2.2 @SpringBootConfiguration源码

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Configuration
    5. public @interface SpringBootConfiguration {
    6. }

    上面三个都是元注解

    @Configuration ：Spring提供的注解，表示这是一个配置类

    也就是说标注了@SpringBootApplication、@SpringBootConfiguration等注解的类都可以当做一个配置类使用

    4.2.3 @EnableAutoConfiguration源码

    @EnableAutoConfiguration是SpringBoot自动配置的核心；

    1. @Target({ElementType.TYPE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @AutoConfigurationPackage
    6. @Import({AutoConfigurationImportSelector.class})
    7. public @interface EnableAutoConfiguration {
    8.     String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    9.  
    10.     Class[] exclude() default {};
    11.  
    12.     String[] excludeName() default {};
    13. }

    标注了两个注解：@AutoConfigurationPackage、@Import({AutoConfigurationImportSelector.class})

    1）Registrar

    • 1）@AutoConfigurationPackage：在该注解上标注了@Import注解，导入了一个Registrar导入器，开启包的自动导入配置，扫描注解标注类所在的包及其下面的子包

    1. @Target(ElementType.TYPE)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Inherited
    5. @Import(AutoConfigurationPackages.Registrar.class)
    6. public @interface AutoConfigurationPackage {
    7. }

    往容器中注册了一个Registrar，查看Registrar：

    1. static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    2.  
    3.     @Override
    4.     public void registerBeanDefinitions(AnnotationMetadata metadata,
    5.                                         BeanDefinitionRegistry registry) {
    6.         // 配置包注册(注册标注了AutoConfigurationPackage注解的类所在的全路径下面的所有类)
    7.         register(registry, new PackageImport(metadata).getPackageName());
    8.     }
    9.  
    10.     @Override
    11.     public Set<Object> determineImports(AnnotationMetadata metadata) {
    12.         return Collections.singleton(new PackageImport(metadata));
    13.     }
    14.  
    15. }

    SpringBoot应用的默认扫描规则是只扫描主程序所在包及其子包

    也可以通过指定参数让SpringBoot来扫描其他包（主程序所在包就不会扫描了）

    1. @SpringBootApplication(scanBasePackages = "com.dfbz.controller")
    2. public class HelloApplication {
    3. }

    2）AutoConfigurationImportSelector

    在@EnableAutoConfiguration还标注了一个@Import(AutoConfigurationImportSelector.class)，导入了一个AutoConfigurationImportSelector类；

    查看继承体系：

    发现AutoConfigurationImportSelector实现接口ImportSelector，在导入时，一定会调用selectImports进行Bean配置；

    1. @Override
    2. public String[] selectImports(AnnotationMetadata annotationMetadata) {
    3.     if (!isEnabled(annotationMetadata)) {
    4.         return NO_IMPORTS;
    5.     }
    6.     AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    7.         .loadMetadata(this.beanClassLoader);
    8.     AnnotationAttributes attributes = getAttributes(annotationMetadata);
    9.     
    10.     // 给容器中导入一批组件(xxxAutoConfiguration)
    11.     List<String> configurations = getCandidateConfigurations(annotationMetadata,
    12.                                                              attributes);
    13.     configurations = removeDuplicates(configurations);
    14.     Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    15.     checkExcludedClasses(configurations, exclusions);
    16.     configurations.removeAll(exclusions);
    17.     
    18.     // 过滤掉一些不生效的组件
    19.     configurations = filter(configurations, autoConfigurationMetadata);
    20.     fireAutoConfigurationImportEvents(configurations, exclusions);
    21.     
    22.     // 其他全部导入到IOC容器给中
    23.     return StringUtils.toStringArray(configurations);
    24. }
    25.  
    26. protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
    27.                                                   AnnotationAttributes attributes) {
    28.     List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
    29.         getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    30.     Assert.notEmpty(configurations,
    31.                     "No auto configuration classes found in META-INF/spring.factories. If you "
    32.                     + "are using a custom packaging, make sure that file is correct.");
    33.     return configurations;
    34. }

    configurations值：

    • SpringFactoriesLoader源码：

    1. public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    2.     String factoryClassName = factoryClass.getName();
    3.     return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    4. }
    5.  
    6. private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    7.     MultiValueMap<String, String> result = cache.get(classLoader);
    8.     if (result != null) {
    9.         return result;
    10.     }
    11.  
    12.     try {
    13.         Enumeration<URL> urls = (classLoader != null ?
    14.                                  // META-INF/spring.factories
    15.                                  classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
    16.                                  ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    17.         result = new LinkedMultiValueMap<>();
    18.         while (urls.hasMoreElements()) {
    19.             URL url = urls.nextElement();
    20.             UrlResource resource = new UrlResource(url);
    21.             Properties properties = PropertiesLoaderUtils.loadProperties(resource);
    22.             for (Map.Entry<?, ?> entry : properties.entrySet()) {
    23.                 List<String> factoryClassNames = Arrays.asList(
    24.                     StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
    25.                 result.addAll((String) entry.getKey(), factoryClassNames);
    26.             }
    27.         }
    28.         cache.put(classLoader, result);
    29.         return result;
    30.     }
    31.     catch (IOException ex) {
    32.         throw new IllegalArgumentException("Unable to load factories from location [" +
    33.                                            FACTORIES_RESOURCE_LOCATION + "]", ex);
    34.     }
    35. }

    4.2.4 @ComponentScan

    @SpringBootApplication注解上除了标注了上面两个注解外，还标注了一个@ComponentScan注解，其内容如下：

    1. @ComponentScan(excludeFilters = {
    2.       @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    3.       @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

    添加了两个排除过滤器，分别是TypeExcludeFilter和AutoConfigurationExcludeFilter；两个排除过滤器都继承与TypeFilter接口，并且是一个函数式接口；IOC容器启动时，会将被扫描的Bean的元数据信息传递到该match，由该方法的返回值来决定是否要排除这个Bean；

    1. @FunctionalInterface
    2. public interface TypeFilter {
    3.  
    4.     /**
    5.      * 根据match方法的返回值来决定当前Bean是否要注册到IOC容器
    6.      * @param metadataReader: 这个注解标注的目标类的元数据读取器
    7.      * @param metadataReaderFactory: 获取元数据读取器的工厂
    8.      */
    9.     boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
    10.             throws IOException;
    11.  
    12. }

    1）AutoConfigurationExcludeFilter

    • AutoConfigurationExcludeFilter：

    1. package org.springframework.boot.autoconfigure;
    2.  
    3. import java.io.IOException;
    4. import java.util.List;
    5.  
    6. import org.springframework.beans.factory.BeanClassLoaderAware;
    7. import org.springframework.context.annotation.Configuration;
    8. import org.springframework.core.io.support.SpringFactoriesLoader;
    9. import org.springframework.core.type.classreading.MetadataReader;
    10. import org.springframework.core.type.classreading.MetadataReaderFactory;
    11. import org.springframework.core.type.filter.TypeFilter;
    12.  
    13. /**
    14.  * A {@link TypeFilter} implementation that matches registered auto-configuration classes.
    15.  *
    16.  * @author Stephane Nicoll
    17.  * @since 1.5.0
    18.  */
    19. public class AutoConfigurationExcludeFilter implements TypeFilter, BeanClassLoaderAware {
    20.  
    21. 	private ClassLoader beanClassLoader;
    22.  
    23. 	private volatile List autoConfigurations;
    24.  
    25. 	@Override
    26. 	public void setBeanClassLoader(ClassLoader beanClassLoader) {
    27. 		this.beanClassLoader = beanClassLoader;
    28. 	}
    29.  
    30.     // 作用: 当前这个类不能是一个配置类 并且 也不能是一个自动配置类(不能写在META-INF/spring.factroies文件中)
    31. 	@Override
    32. 	public boolean match(MetadataReader metadataReader,
    33. 			MetadataReaderFactory metadataReaderFactory) throws IOException {
    34. 		return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);
    35. 	}
    36.  
    37.     // 当前这个类上是否标注了Configuration注解
    38. 	private boolean isConfiguration(MetadataReader metadataReader) {
    39. 		return metadataReader.getAnnotationMetadata()
    40. 				.isAnnotated(Configuration.class.getName());
    41. 	}
    42.  
    43.     // 当前这个类是否是一个自动配置类
    44. 	private boolean isAutoConfiguration(MetadataReader metadataReader) {
    45. 		return getAutoConfigurations()
    46. 				.contains(metadataReader.getClassMetadata().getClassName());
    47. 	}
    48.  
    49. 	protected List getAutoConfigurations() {
    50. 		if (this.autoConfigurations == null) {
    51. 			this.autoConfigurations = SpringFactoriesLoader.loadFactoryNames(
    52. 					EnableAutoConfiguration.class, this.beanClassLoader);
    53. 		}
    54. 		return this.autoConfigurations;
    55. 	}
    56. }

    说明：SpringBoot项目启动后，通过@Import(AutoConfigurationImportSelector.class)加载每个jar包下的/META-INF/spring.factories文件中的org.springframework.boot.autoconfigure.EnableAutoConfiguration指定的自动配置类，因此如果我们编写的类上标注了@Configuration注解（确定是一个配置类）并且还写在了/META-INF/spring.factories文件中，那么这个类已经被加载过了，不需要重复再加载，通过该排除器对这个配置类进行排除；

    如果我们自己想要自定义自动配置类让其生效，有两种方法：

    • 1）在类上只标注一个@Configuration注解，没有写在/META-INF/spring.factories文件中，不会被排除，但也被默认的规则扫描到了（Registrar导入器）；
    • 2）在类上只标注一个@Configuration注解，写在/META-INF/spring.factories文件中，被排除（但被SpringBoot扫描到了），这是SpringBoot推荐的写法，标准的自动配置类

    Tips：自动配置类和普通的配置类的作用都是一模一样的，只不过自动配置类一般用于加载某些场景，而且是写在/META-INF/spring.factories中的；

    2）TypeExcludeFilter

    • TypeExcludeFilter：

    1.  
    2. package org.springframework.boot.context;
    3.  
    4. import java.io.IOException;
    5. import java.util.Collection;
    6.  
    7. import org.springframework.beans.BeansException;
    8. import org.springframework.beans.factory.BeanFactory;
    9. import org.springframework.beans.factory.BeanFactoryAware;
    10. import org.springframework.beans.factory.ListableBeanFactory;
    11. import org.springframework.core.type.classreading.MetadataReader;
    12. import org.springframework.core.type.classreading.MetadataReaderFactory;
    13. import org.springframework.core.type.filter.TypeFilter;
    14.  
    15. public class TypeExcludeFilter implements TypeFilter, BeanFactoryAware {
    16.  
    17. 	private BeanFactory beanFactory;
    18.  
    19. 	@Override
    20. 	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    21. 		this.beanFactory = beanFactory;
    22. 	}
    23.  
    24.     // 作用: 获取IOC容器中,所有有关于TypeExcludeFilter的后代类,然后执行这些后代类的match方法
    25. 	@Override
    26. 	public boolean match(MetadataReader metadataReader,
    27. 			MetadataReaderFactory metadataReaderFactory) throws IOException {
    28. 		if (this.beanFactory instanceof ListableBeanFactory
    29. 				&& getClass() == TypeExcludeFilter.class) {
    30.             
    31.             // 从IOC容器中获取有关于TypeExcludeFilter的所有Bean(包括后代类)
    32. 			Collection delegates = ((ListableBeanFactory) this.beanFactory)
    33. 					.getBeansOfType(TypeExcludeFilter.class).values();
    34.             
    35. 			for (TypeExcludeFilter delegate : delegates) {
    36.                 // 调用TypeExcludeFilter后代类的所有match方法
    37. 				if (delegate.match(metadataReader, metadataReaderFactory)) {
    38. 					return true;
    39. 				}
    40. 			}
    41. 		}
    42. 		return false;
    43. 	}
    44.  
    45. 	@Override
    46. 	public boolean equals(Object obj) {
    47. 		throw new IllegalStateException(
    48. 				"TypeExcludeFilter " + getClass() + " has not implemented equals");
    49. 	}
    50.  
    51. 	@Override
    52. 	public int hashCode() {
    53. 		throw new IllegalStateException(
    54. 				"TypeExcludeFilter " + getClass() + " has not implemented hashCode");
    55. 	}
    56. }

    TypeExcludeFilter过滤器是SpringBoot提供给我们用的排除过滤器，我们可以根据一些条件来决定是否要过滤某些Bean；

    SpringBoot的引导类上面只配置了两个排除器，一个是AutoConfigurationExcludeFilter，另一个是TypeExcludeFilter，也就是说SpringBoot扫描到的Bean只会经过这个两个过滤器，那如果我们想要自定义排除器并且参与SpringBoot的Bean的过滤，那么就可以继承TypeExcludeFilter参与过滤；

    3）自定义排除器

    • 自定义排除器：

    1. package com.dfbz;
    2.  
    3. import com.dfbz.controller.HelloController;
    4. import org.springframework.boot.context.TypeExcludeFilter;
    5. import org.springframework.core.type.classreading.MetadataReader;
    6. import org.springframework.core.type.classreading.MetadataReaderFactory;
    7.  
    8. import java.io.IOException;
    9.  
    10. /**
    11.  * @author lscl
    12.  * @version 1.0
    13.  * @intro:
    14.  */
    15. //@Component          // 不能用这种方式注册到IOC容器,因为这个排除器需要在Spring扫描组件之前生效
    16. public class MyTypeExcludeFilter extends TypeExcludeFilter {
    17.     @Override
    18.     public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    19.         // 排除HelloController
    20.         return metadataReader.getClassMetadata().getClassName().equals(HelloController.class.getName());
    21.     }
    22. }

    排除器（MyTypeExcludeFilter）需要注册到IOC容器中才会生效，但不能使用@Component 注册，因为排除器在容器扫描之前就要生效

    • 编写初始化器：

    1. package com.dfbz;
    2.  
    3. import org.springframework.context.ApplicationContextInitializer;
    4. import org.springframework.context.ConfigurableApplicationContext;
    5.  
    6. /**
    7.  * @author lscl
    8.  * @version 1.0
    9.  * @intro:
    10.  */
    11. public class MyApplicationContextInitializer implements ApplicationContextInitializer {
    12.     @Override
    13.     public void initialize(ConfigurableApplicationContext applicationContext) {
    14.         // 往IOC容器中注册一个单例Bean(在IOC容器初始化后,@ComponentScan组件扫描之前执行)
    15.         applicationContext.getBeanFactory().registerSingleton("myTypeExcludeFilter",new MyTypeExcludeFilter());
    16.     }
    17. }

    • 让初始化器生效：

    在resources目录下编写META-INF/spring.factories，内容如下：

    1. # Initializers
    2. org.springframework.context.ApplicationContextInitializer=\
    3. com.dfbz.MyApplicationContextInitializer

    4.3 自动配置类

    4.3.1 自动配置类说明

    通过刚刚的自动配置原理我们发现，SpringBoot在启动时，就加载了非常多的一些配置类（xxxAutoConfiguration），这些配置类中配置了非常多的信息，包括根据条件导入一些Bean、配置一些属性、绑定一些配置；

    我们之所以能够启动SpringBoot环境就配置好了大量的环境（SpringMVC环境/MyBatis环境/JPA环境等）都是因为这些自动配置类在SpringBoot启动时帮我们在IOC容器里注册了大量的Bean；

    Tips：配置类的地址在META-INF/spring.factories文件中org.springframework.boot.autoconfigure.EnableAutoConfigurationkey所指定的内容；

    以DispatcherServletAutoConfiguration配置类举例：

    1. // 配置顺序(数字越小，越优先加载，负数也可以)
    2. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)	
    3.  
    4. // 标注这是一个配置类
    5. @Configuration
    6.  
    7. // 如果是web环境才配置此类
    8. @ConditionalOnWebApplication(type = Type.SERVLET)
    9.  
    10. // 如果系统中有DispatcherServlet类才配置此类(导入了这个依赖就配置这个类)
    11. @ConditionalOnClass(DispatcherServlet.class)
    12.  
    13. // 在ServletWebServerFactoryAutoConfiguration类加载之后再加载此类
    14. @AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
    15. // 开启属性配置
    16. @EnableConfigurationProperties(ServerProperties.class)
    17. public class DispatcherServletAutoConfiguration {
    18.     
    19. 	public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
    20. 	
    21. 	public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";
    22.  
    23.     // 标注这是一个配置类
    24. 	@Configuration
    25.     // 满足DefaultDispatcherServletCondition的matches方法时配置该类
    26. 	@Conditional(DefaultDispatcherServletCondition.class)
    27.     // 容器中有ServletRegistration类时配置该类
    28. 	@ConditionalOnClass(ServletRegistration.class)
    29.     // 开启配置属性
    30. 	@EnableConfigurationProperties(WebMvcProperties.class)
    31. 	protected static class DispatcherServletConfiguration {
    32.  
    33. 		private final WebMvcProperties webMvcProperties;
    34.  
    35. 		public DispatcherServletConfiguration(WebMvcProperties webMvcProperties) {
    36. 			this.webMvcProperties = webMvcProperties;
    37. 		}
    38.  
    39.         // 往IOC容器中配置一个DispatcherServlet类
    40. 		@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    41. 		public DispatcherServlet dispatcherServlet() {
    42. 			DispatcherServlet dispatcherServlet = new DispatcherServlet();
    43. 			dispatcherServlet.setDispatchOptionsRequest(
    44. 					this.webMvcProperties.isDispatchOptionsRequest());
    45. 			dispatcherServlet.setDispatchTraceRequest(
    46. 					this.webMvcProperties.isDispatchTraceRequest());
    47. 			dispatcherServlet.setThrowExceptionIfNoHandlerFound(
    48. 					this.webMvcProperties.isThrowExceptionIfNoHandlerFound());
    49. 			return dispatcherServlet;
    50. 		}
    51.  
    52. 		@Bean
    53. 		@ConditionalOnBean(MultipartResolver.class)
    54. 		@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
    55. 		public MultipartResolver multipartResolver(MultipartResolver resolver) {
    56. 			// Detect if the user has created a MultipartResolver but named it incorrectly
    57. 			return resolver;
    58. 		}
    59.  
    60. 	}
    61.  
    62. 	@Configuration
    63. 	@Conditional(DispatcherServletRegistrationCondition.class)
    64. 	@ConditionalOnClass(ServletRegistration.class)
    65. 	@EnableConfigurationProperties(WebMvcProperties.class)
    66. 	@Import(DispatcherServletConfiguration.class)
    67. 	protected static class DispatcherServletRegistrationConfiguration {
    68.  
    69. 		private final ServerProperties serverProperties;
    70.  
    71. 		private final WebMvcProperties webMvcProperties;
    72.  
    73. 		private final MultipartConfigElement multipartConfig;
    74.  
    75. 		public DispatcherServletRegistrationConfiguration(
    76. 				ServerProperties serverProperties, WebMvcProperties webMvcProperties,
    77. 				ObjectProvider multipartConfigProvider) {
    78. 			this.serverProperties = serverProperties;
    79. 			this.webMvcProperties = webMvcProperties;
    80. 			this.multipartConfig = multipartConfigProvider.getIfAvailable();
    81. 		}
    82.  
    83. 		@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
    84. 		@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    85. 		public ServletRegistrationBean dispatcherServletRegistration(
    86. 				DispatcherServlet dispatcherServlet) {
    87. 			ServletRegistrationBean registration = new ServletRegistrationBean<>(
    88. 					dispatcherServlet,
    89. 					this.serverProperties.getServlet().getServletMapping());
    90. 			registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
    91. 			registration.setLoadOnStartup(
    92. 					this.webMvcProperties.getServlet().getLoadOnStartup());
    93. 			if (this.multipartConfig != null) {
    94. 				registration.setMultipartConfig(this.multipartConfig);
    95. 			}
    96. 			return registration;
    97. 		}
    98.  
    99. 	}
    100. }

    4.3.2 @Conditional派生注解

    我们已经知道了自动配置类的加载规则，只要配置在META-INF/spring.factories文件的org.springframework.boot.autoconfigure.EnableAutoConfigurationkey中的全类名，该配置类即可被加载，但有些时候我们并不希望这些配置类能够被立即加载，而是需要符合某些条件时这些配置类才会被加载；

    SpringBoot内置了非常多的条件判断注解，这些注解可以帮助我们在符合条件的清空下，该配置类/方法才会生效；这些注解我们统一称为派生注解；为@ConditionalXxx；

    • @Conditional表格：

    @Conditional扩展注解

    作用（判断是否满足当前指定条件）

    @ConditionalOnJava

    系统的java版本是否符合要求

    @ConditionalOnBean

    容器中存在指定Bean；

    @ConditionalOnMissingBean

    容器中不存在指定Bean；

    @ConditionalOnExpression

    满足SpEL表达式指定

    @ConditionalOnClass

    系统中有指定的类

    @ConditionalOnMissingClass

    系统中没有指定的类

    @ConditionalOnSingleCandidate

    容器中只有一个指定的Bean，或者这个Bean是首选Bean

    @ConditionalOnProperty

    系统中指定的属性是否有指定的值

    @ConditionalOnResource

    类路径下是否存在指定资源文件

    @ConditionalOnWebApplication

    当前是web环境

    @ConditionalOnNotWebApplication

    当前不是web环境

    @ConditionalOnJndi

    JNDI存在指定项

    4.3.3 自定义自动配置类

    自动配置类的加载说明：

    • 1）必须是一个配置类
    • 2）必须配置在META-INF/spring.factories中的org.springframework.boot.autoconfigure.EnableAutoConfigurationkey中；
    • 3）可能还会包含一些派生注解（@ConditionalXxx）

    1. package com.dfbz.config;
    2.  
    3. import com.dfbz.controller.HelloController;
    4. import com.dfbz.entity.City;
    5. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
    6. import org.springframework.boot.autoconfigure.condition.ConditionalOnJava;
    7. import org.springframework.boot.autoconfigure.condition.ConditionalOnResource;
    8. import org.springframework.boot.system.JavaVersion;
    9. import org.springframework.context.annotation.Bean;
    10. import org.springframework.context.annotation.Configuration;
    11.  
    12. /**
    13.  * @author lscl
    14.  * @version 1.0
    15.  * @intro:
    16.  */
    17. @Configuration
    18. @ConditionalOnJava(JavaVersion.EIGHT)           // Java版本必须是1.8
    19. @ConditionalOnBean(HelloController.class)       // IOC容器中必须存在HelloController这个对象
    20. @ConditionalOnResource(resources = "application.properties")        // 类路径下必须存在application.properties
    21. public class MyAutoConfiguration {
    22.  
    23.     @Bean
    24.     public City city() {
    25.         return new City();
    26.     }
    27. }

    在META-INF/spring.factories文件中添加：

    1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    2. com.dfbz.MyAutoConfiguration

    4.4 属性配置类

    4.4.1 属性配置类说明

    自动配置类中通常会绑定（通过EnableConfigurationProperties开启）一些属性配置类（xxxProperties.class），这些属性配置类通过@ConfigurationProperties注解标识；

    在自动配置类中根据条件配置了大量的Bean，而这些Bean上面大都开启（@EnableConfigurationProperties）了属性配置类（xxxProperties.class），这些属性配置类是SpringBoot"基于约定配置"的保障；

    • 查看DispatcherServletAutoConfiguration自动配置类：

    1. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    2. @Configuration
    3. @ConditionalOnWebApplication(type = Type.SERVLET)
    4. @ConditionalOnClass(DispatcherServlet.class)
    5. @AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
    6. @EnableConfigurationProperties(ServerProperties.class)			// 开启属性配置
    7. public class DispatcherServletAutoConfiguration {

    • 查看ServerProperties属性配置类：

    1. // 与配置文件进行绑定
    2. @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)		// 与application.yml/properties配置文件进行绑定；
    3. public class ServerProperties {
    4.  
    5. 	private Integer port;
    6.  
    7. 	private InetAddress address;
    8.  
    9. 	@NestedConfigurationProperty
    10. 	private final ErrorProperties error = new ErrorProperties();
    11.  
    12. 	private Boolean useForwardHeaders;
    13.  
    14. 	private String serverHeader;
    15.  
    16. }

    4.4.2 自定义属性配置类

    • 自定义属性配置类：

    1. package com.dfbz.entity;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6. import org.springframework.boot.context.properties.ConfigurationProperties;
    7. import org.springframework.stereotype.Component;
    8.  
    9. /**
    10.  * @author lscl
    11.  * @version 1.0
    12.  * @intro:
    13.  */
    14. @Data                       // 提供get/set/toString...
    15. @AllArgsConstructor         // 有参构造
    16. @NoArgsConstructor          // 无参构造
    17.  
    18. @Component                              // 必须要放入IOC容器才能使用@ConfigurationProperties注解
    19. @ConfigurationProperties(prefix = "com.dfbz.book")          // 绑定的前缀为: com.dfbz.book
    20. public class Book {
    21.     private String name;
    22.     private Double price;
    23. }

    • application.yml：

    1. com:
    2.   dfbz:
    3.     book:
    4.       name: 《Java入门到精通》
    5.       price: 38.8

    • DemoController：

    1. package com.dfbz.controller;
    2.  
    3. import com.dfbz.entity.Book;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.web.bind.annotation.GetMapping;
    6. import org.springframework.web.bind.annotation.ResponseBody;
    7. import org.springframework.web.bind.annotation.RestController;
    8.  
    9. /**
    10.  * @author lscl
    11.  * @version 1.0
    12.  * @intro:
    13.  */
    14. @RestController
    15. public class DemoController {
    16.  
    17.     @Autowired
    18.     private Book book;
    19.  
    20.     @GetMapping("/getBook")
    21.     @ResponseBody
    22.     public Book getBook() {
    23.         return book;
    24.     }
    25. }

    访问：http://localhost:8080/getBook：

    也可以使用@EnableConfigurationProperties注解来指定要开启某个类上面的属性配置；该类会自动被加载到IOC容器

    1. package com.dfbz;
    2.  
    3. import com.dfbz.entity.Book;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
    7.  
    8. /**
    9.  * @author lscl
    10.  * @version 1.0
    11.  * @intro:
    12.  */
    13. @SpringBootApplication
    14. @EnableConfigurationProperties(Book.class)          // 开启Book类的属性配置功能
    15. public class HelloApplication {
    16.     public static void main(String[] args) {
    17.         SpringApplication.run(HelloApplication.class);
    18.     }
    19. }

    注释Book类中的@Component注解；

    重启服务器，再次访问：http://localhost:8080/getBook发现配置依旧可以；

    4.5 自定义场景启动器

    4.5.1 场景启动器包含内容

    1）自动配置类；

    xxxAutoConfiguration

    2）开启属性配置，并绑定属性配置类；

    xxxProperties

    3）加入到META-INF/spring.factories中；

    4.5.2 搭建自动配置工程

    自动配置场景启动器名称规范：{name}-springboot-starter-autoconfigurer

    4.5.2.1 依赖

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>com.dfbz</groupId>
    8.     <artifactId>02-mystarter-springboot-starter-autoconfigurer</artifactId>
    9.     <version>1.0-SNAPSHOT</version>
    10.  
    11.     <parent>
    12.         <groupId>org.springframework.boot</groupId>
    13.         <artifactId>spring-boot-starter-parent</artifactId>
    14.         <version>2.0.1.RELEASE</version>
    15.         <relativePath/> <!-- lookup parent from repository -->
    16.     </parent>
    17.  
    18.     <dependencies>
    19.         <!--springboot的启动器,包含所有starter的基本配置-->
    20.         <dependency>
    21.             <groupId>org.springframework.boot</groupId>
    22.             <artifactId>spring-boot-starter</artifactId>
    23.         </dependency>
    24.     </dependencies>
    25.  
    26. </project>

    4.5.2.2 自动配置类

    1. package com.mystarter.autoconfig;
    2.  
    3. import com.mystarter.service.HelloService;
    4. import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
    5. import org.springframework.boot.autoconfigure.web.ServerProperties;
    6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.context.annotation.Configuration;
    9.  
    10. /**
    11.  * @author lscl
    12.  * @version 1.0
    13.  * @intro: 自动配置类
    14.  */
    15. // 标注这是一个配置类
    16. @Configuration
    17. // 如果是web环境才配置此类
    18. @ConditionalOnWebApplication
    19. // 开启配置属性
    20. @EnableConfigurationProperties(MyStarterProperties.class)
    21. public class MyStarterAutoConfiguration {
    22.  
    23.     @Bean
    24.     public HelloService helloService(){
    25.         return new HelloService();
    26.     }
    27. }

    4.5.2.3 属性配置类

    1. package com.mystarter.properties;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4.  
    5. /**
    6.  * @author lscl
    7.  * @version 1.0
    8.  * @intro: 属性配置类,绑定配置文件,指定前缀
    9.  */
    10. @ConfigurationProperties(prefix = "mystarter")
    11. public class MyStarterProperties {
    12.  
    13.     private String text;
    14.  
    15.     public String getText() {
    16.         return text;
    17.     }
    18.  
    19.     public void setText(String text) {
    20.         this.text = text;
    21.     }
    22. }

    4.5.2.4 具体配置的类

    1. package com.mystarter.service;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4.  
    5. /**
    6.  * @author lscl
    7.  * @version 1.0
    8.  * @intro:
    9.  */
    10. public class HelloService {
    11.  
    12.     @Autowired
    13.     private MyStarterProperties properties;
    14.  
    15.     public String sayHello() {
    16.         return properties.getText();
    17.     }
    18. }

    4.5.2.5 spring.factories

    在/MATA-INF/目录下新建spring.factories文件；

    1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    2.   com.mystarter.autoconfig.MyStarterAutoConfiguration

    4.5.3 搭建测试工程

    4.5.3.1 依赖

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>org.example</groupId>
    8.     <artifactId>03-MyStarterTest</artifactId>
    9.     <version>1.0-SNAPSHOT</version>
    10.     <parent>
    11.         <groupId>org.springframework.boot</groupId>
    12.         <artifactId>spring-boot-starter-parent</artifactId>
    13.         <version>2.0.1.RELEASE</version>
    14.     </parent>
    15.     <dependencies>
    16.         <!--导入我们自定义的starter-->
    17.         <dependency>
    18.             <groupId>com.dfbz</groupId>
    19.             <artifactId>02-mystarter-springboot-starter-autoconfigurer</artifactId>
    20.             <version>1.0-SNAPSHOT</version>
    21.         </dependency>
    22.  
    23.         <!--web场景的starter-->
    24.         <dependency>
    25.             <groupId>org.springframework.boot</groupId>
    26.             <artifactId>spring-boot-starter-web</artifactId>
    27.         </dependency>
    28.     </dependencies>
    29.  
    30. </project>

    4.5.2.2 Controller

    1. package com.dfbz.controller;
    2.  
    3. import com.mystarter.service.HelloService;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7. import org.springframework.web.bind.annotation.ResponseBody;
    8.  
    9. /**
    10.  * @author lscl
    11.  * @version 1.0
    12.  * @intro:
    13.  */
    14. @Controller
    15. public class HelloController {
    16.  
    17.     @Autowired
    18.     private HelloService helloService;
    19.  
    20.     @GetMapping("/hello")
    21.     @ResponseBody
    22.     public String hello() {
    23.         return helloService.sayHello();
    24.     }
    25. }

    4.5.2.3 application.yml

    1. mystarter:
    2.   text: hello~

    4.5.2.4 引导类

    1. package com.dfbz;
    2.  
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    5.  
    6. /**
    7.  * @author lscl
    8.  * @version 1.0
    9.  * @intro:
    10.  */
    11. @SpringBootApplication
    12. public class Application {
    13.     public static void main(String[] args) {
    14.         SpringApplication.run(Application.class);
    15.     }
    16. }

    五、SpringBoot与整合其他技术

    5.1 SpringBoot整合Mybatis

    5.1.1 搭建工程

    1）依赖：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>com.dfbz</groupId>
    8.     <artifactId>04-SpringBoot-MyBatis</artifactId>
    9.     <version>1.0-SNAPSHOT</version>
    10.  
    11.     <parent>
    12.         <artifactId>spring-boot-parent</artifactId>
    13.         <groupId>org.springframework.boot</groupId>
    14.         <version>2.0.1.RELEASE</version>
    15.     </parent>
    16.  
    17.     <dependencies>
    18.         <dependency>
    19.             <groupId>org.springframework.boot</groupId>
    20.             <artifactId>spring-boot-starter-web</artifactId>
    21.         </dependency>
    22.         
    23.         <!--mybatis起步依赖-->
    24.         <dependency>
    25.             <groupId>org.mybatis.spring.boot</groupId>
    26.             <artifactId>mybatis-spring-boot-starter</artifactId>
    27.             <version>1.1.1</version>
    28.         </dependency>
    29.  
    30.         <!-- MySQL连接驱动 -->
    31.         <dependency>
    32.             <groupId>mysql</groupId>
    33.             <artifactId>mysql-connector-java</artifactId>
    34.         </dependency>
    35.         
    36.         <dependency>
    37.             <groupId>org.projectlombok</groupId>
    38.             <artifactId>lombok</artifactId>
    39.         </dependency>
    40.     </dependencies>
    41. </project>

    2）创建表

    1. /*Table structure for table `user` */
    2. CREATE TABLE `user` (
    3.   `id` INT(11) NOT NULL AUTO_INCREMENT,
    4.   `username` VARCHAR(50) DEFAULT NULL,
    5.   `password` VARCHAR(50) DEFAULT NULL,
    6.   `name` VARCHAR(50) DEFAULT NULL,
    7.   PRIMARY KEY (`id`)
    8. ) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    9.  
    10. /*Data for the table `user` */
    11. INSERT  INTO `user`(`id`,`username`,`password`,`name`) VALUES (1,'zhangsan','123','张三');
    12. INSERT  INTO `user`(`id`,`username`,`password`,`name`) VALUES (2,'lisi','123','李四');

    3）创建实体Bean

    1. package com.dfbz.entity;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6. /**
    7. * @author lscl
    8. * @version 1.0
    9. * @intro:
    10. */
    11. @Data
    12. @AllArgsConstructor
    13. @NoArgsConstructor
    14. public class User {
    15.    private Integer id;
    16.    private String username;
    17.    private String password;
    18.    private String name;
    19. }

    4）application.yml

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
    5.     username: root
    6.     password: admin
    7. #spring集成Mybatis环境
    8. mybatis:
    9.   type-aliases-package: com.dfbz.entity  #pojo别名扫描包
    10.   #加载Mybatis映射文件
    11.   mapper-locations: classpath:com/dfbz/mapper/*Mapper.xml

    5）UserMapper

    1. package com.dfbz.mapper;
    2.  
    3. import com.dfbz.entity.User;
    4. import org.apache.ibatis.annotations.Mapper;
    5.  
    6. import java.util.List;
    7.  
    8. /**
    9.  * @author lscl
    10.  * @version 1.0
    11.  * @intro:
    12.  */
    13. @Mapper
    14. public interface UserMapper {
    15.     public List findAll();
    16. }

    6）UserMapper.xml

    1. "1.0" encoding="utf-8" ?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    4. <mapper namespace="com.dfbz.mapper.UserMapper">
    5.     <select id="findAll" resultType="user">
    6.         select * from user
    7.     select>
    8. mapper>

    5.1.2 测试

    • UserController：

    1. @RestController
    2. public class UserController {
    3.     
    4.     @Autowired
    5.     private UserMapper userMapper;
    6.     
    7.     @RequestMapping("/findAll")
    8.     public List findAll(){
    9.        return userMapper.findAll();
    10.     }
    11. }

    访问：http://localhost:8080/findAll：

    5.1.3 MyBatis自动配置

    1）MybatisAutoConfiguration

    在MybatisAutoConfiguration类中帮我们配置了开启了属性配置（MybatisProperties）、扫描带有@Mapper注解的类，以及在IOC容器中注册了SqlSessionFactory、SqlSessionTemplate等Bean；

    1. package org.mybatis.spring.boot.autoconfigure;
    2.  
    3. import java.util.List;
    4.  
    5. import javax.annotation.PostConstruct;
    6. import javax.sql.DataSource;
    7.  
    8. import org.apache.commons.logging.Log;
    9. import org.apache.commons.logging.LogFactory;
    10. import org.apache.ibatis.annotations.Mapper;
    11. import org.apache.ibatis.mapping.DatabaseIdProvider;
    12. import org.apache.ibatis.plugin.Interceptor;
    13. import org.apache.ibatis.session.ExecutorType;
    14. import org.apache.ibatis.session.SqlSessionFactory;
    15. import org.mybatis.spring.SqlSessionFactoryBean;
    16. import org.mybatis.spring.SqlSessionTemplate;
    17. import org.mybatis.spring.mapper.ClassPathMapperScanner;
    18. import org.mybatis.spring.mapper.MapperFactoryBean;
    19. import org.springframework.beans.BeansException;
    20. import org.springframework.beans.factory.BeanFactory;
    21. import org.springframework.beans.factory.BeanFactoryAware;
    22. import org.springframework.beans.factory.annotation.Autowired;
    23. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    24. import org.springframework.boot.autoconfigure.AutoConfigurationPackages;
    25. import org.springframework.boot.autoconfigure.AutoConfigureAfter;
    26. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    27. import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
    28. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    29. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    30. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    31. import org.springframework.boot.context.properties.EnableConfigurationProperties;
    32. import org.springframework.context.ResourceLoaderAware;
    33. import org.springframework.context.annotation.Bean;
    34. import org.springframework.context.annotation.Configuration;
    35. import org.springframework.context.annotation.Import;
    36. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
    37. import org.springframework.core.io.DefaultResourceLoader;
    38. import org.springframework.core.io.Resource;
    39. import org.springframework.core.io.ResourceLoader;
    40. import org.springframework.core.type.AnnotationMetadata;
    41. import org.springframework.util.Assert;
    42. import org.springframework.util.ObjectUtils;
    43. import org.springframework.util.StringUtils;
    44.  
    45.  
    46. // 标注是一个配置类
    47. @Configuration			
    48.  
    49. // 当存在SqlSessionFactory和SqlSessionFactoryBean类时这个配置类才会生效
    50. @ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
    51.  
    52. // IOC容器中必须存在DataSource这个Bean
    53. @ConditionalOnBean(DataSource.class)
    54.  
    55. // 开启MybatisProperties的属性配置
    56. @EnableConfigurationProperties(MybatisProperties.class)
    57.  
    58. // 该配置类比DataSourceAutoConfiguration后生效
    59. @AutoConfigureAfter(DataSourceAutoConfiguration.class)
    60. public class MybatisAutoConfiguration {
    61.  
    62.   private static Log log = LogFactory.getLog(MybatisAutoConfiguration.class);
    63.  
    64.   @Autowired
    65.   private MybatisProperties properties;
    66.  
    67.   @Autowired(required = false)
    68.   private Interceptor[] interceptors;
    69.  
    70.   @Autowired
    71.   private ResourceLoader resourceLoader = new DefaultResourceLoader();
    72.  
    73.   @Autowired(required = false)
    74.   private DatabaseIdProvider databaseIdProvider;
    75.  
    76.   @PostConstruct
    77.   public void checkConfigFileExists() {
    78.     if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
    79.       Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
    80.       Assert.state(resource.exists(), "Cannot find config location: " + resource
    81.           + " (please add config file or check your Mybatis " + "configuration)");
    82.     }
    83.   }
    84.  
    85.   // 配置SqlSessionFactory
    86.   @Bean
    87.   @ConditionalOnMissingBean
    88.   public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    89.     SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    90.     factory.setDataSource(dataSource);
    91.     factory.setVfs(SpringBootVFS.class);
    92.     if (StringUtils.hasText(this.properties.getConfigLocation())) {
    93.       factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    94.     }
    95.     factory.setConfiguration(properties.getConfiguration());
    96.     if (!ObjectUtils.isEmpty(this.interceptors)) {
    97.       factory.setPlugins(this.interceptors);
    98.     }
    99.     if (this.databaseIdProvider != null) {
    100.       factory.setDatabaseIdProvider(this.databaseIdProvider);
    101.     }
    102.     if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
    103.       factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    104.     }
    105.     if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
    106.       factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    107.     }
    108.     if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
    109.       factory.setMapperLocations(this.properties.resolveMapperLocations());
    110.     }
    111.  
    112.     return factory.getObject();
    113.   }
    114.  
    115.   // 配置SqlSessionTemplate
    116.   @Bean
    117.   @ConditionalOnMissingBean
    118.   public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    119.     ExecutorType executorType = this.properties.getExecutorType();
    120.     if (executorType != null) {
    121.       return new SqlSessionTemplate(sqlSessionFactory, executorType);
    122.     } else {
    123.       return new SqlSessionTemplate(sqlSessionFactory);
    124.     }
    125.   }
    126.  
    127.     // Mapper自动扫描器
    128.   public static class AutoConfiguredMapperScannerRegistrar
    129.       implements BeanFactoryAware, ImportBeanDefinitionRegistrar, ResourceLoaderAware {
    130.  
    131.     private BeanFactory beanFactory;
    132.  
    133.     private ResourceLoader resourceLoader;
    134.  
    135.     @Override
    136.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    137.  
    138.       log.debug("Searching for mappers annotated with @Mapper'");
    139.  
    140.       // 扫描标注有@Mapper注解的类
    141.       ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    142.  
    143.       try {
    144.         if (this.resourceLoader != null) {
    145.           scanner.setResourceLoader(this.resourceLoader);
    146.         }
    147.  
    148.         List pkgs = AutoConfigurationPackages.get(this.beanFactory);
    149.         for (String pkg : pkgs) {
    150.           log.debug("Using auto-configuration base package '" + pkg + "'");
    151.         }
    152.  
    153.         scanner.setAnnotationClass(Mapper.class);
    154.         scanner.registerFilters();
    155.         scanner.doScan(StringUtils.toStringArray(pkgs));
    156.       } catch (IllegalStateException ex) {
    157.         log.debug("Could not determine auto-configuration " + "package, automatic mapper scanning disabled.");
    158.       }
    159.     }
    160.  
    161.     @Override
    162.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    163.       this.beanFactory = beanFactory;
    164.     }
    165.  
    166.     @Override
    167.     public void setResourceLoader(ResourceLoader resourceLoader) {
    168.       this.resourceLoader = resourceLoader;
    169.     }
    170.   }
    171.  
    172.   @Configuration
    173.   @Import({ AutoConfiguredMapperScannerRegistrar.class })
    174.   @ConditionalOnMissingBean(MapperFactoryBean.class)
    175.   public static class MapperScannerRegistrarNotFoundConfiguration {
    176.  
    177.     @PostConstruct
    178.     public void afterPropertiesSet() {
    179.       log.debug(String.format("No %s found.", MapperFactoryBean.class.getName()));
    180.     }
    181.   }
    182.  
    183. }

    2）MybatisProperties

    1. package org.mybatis.spring.boot.autoconfigure;
    2.  
    3. import java.io.IOException;
    4. import java.util.ArrayList;
    5. import java.util.Arrays;
    6. import java.util.List;
    7.  
    8. import org.apache.ibatis.session.Configuration;
    9. import org.apache.ibatis.session.ExecutorType;
    10. import org.springframework.boot.context.properties.ConfigurationProperties;
    11. import org.springframework.core.io.Resource;
    12. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    13.  
    14. /**
    15.  * Configuration properties for Mybatis.
    16.  *
    17.  * @author Eddú Meléndez
    18.  * @author Kazuki Shimizu
    19.  */
    20. // 绑定的前缀
    21. @ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
    22. public class MybatisProperties {
    23.  
    24.   public static final String MYBATIS_PREFIX = "mybatis";
    25.  
    26.     
    27.   /**
    28.    * MyBatis核心配置文件的位置
    29.    */
    30.   private String configLocation;
    31.  
    32.   /**
    33.    * Mapper.xml配置文件的位置
    34.    */
    35.   private String[] mapperLocations;
    36.  
    37.   /**
    38.    * 别名配置
    39.    */
    40.   private String typeAliasesPackage;
    41.  
    42.   /**
    43.    * 类型处理器
    44.    */
    45.   private String typeHandlersPackage;
    46.  
    47.   /**
    48.    * 检查MyBatis核心配置文件是否存在
    49.    */
    50.   private boolean checkConfigLocation = false;
    51.  
    52.   /**
    53.    * 执行器类型
    54.    */
    55.   private ExecutorType executorType;
    56.  
    57.   /**
    58.    * MyBatis核心配置文件中配置
    59.    */
    60.   private Configuration configuration;
    61.  
    62. }

    • application.yml：

    1. #spring集成Mybatis环境
    2. mybatis:
    3.   type-aliases-package: com.dfbz.entity  #pojo别名扫描包
    4.   #加载Mybatis映射文件
    5.   mapper-locations: classpath:com/dfbz/mapper/*Mapper.xml
    6.   configuration:
    7.     # 关闭二级缓存
    8.     cacheEnabled: false
    9.     # 开启驼峰命名
    10.     mapUnderscoreToCamelCase: true
    11.     # 一级缓存作用域
    12.     localCacheScope: SESSION
    13.     # 延迟加载
    14.     lazyLoadingEnabled: true 
    15. # mybatis 日志打印
    16. logging:
    17.   level:
    18.     com.dfbz.mapper: DEBUG

    5.2 SpringBoot整合Junit

    5.2.1 添加Junit的场景启动器

    1. <!--springboot集成junit起步依赖-->
    2. <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter-test</artifactId>
    5.    <scope>test</scope>
    6. </dependency>

    5.2.2 编写测试类

    1. package com.dfbz.demo;
    2.  
    3. import com.dfbz.Application;
    4. import com.dfbz.entity.User;
    5. import com.dfbz.mapper.UserMapper;
    6. import org.junit.Test;
    7. import org.junit.runner.RunWith;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.boot.test.context.SpringBootTest;
    10. import org.springframework.test.context.junit4.SpringRunner;
    11.  
    12. import java.util.List;
    13.  
    14. /**
    15.  * @author lscl
    16.  * @version 1.0
    17.  * @intro:
    18.  */
    19. @RunWith(SpringRunner.class)
    20. @SpringBootTest(classes= Application.class)
    21. public class Demo01 {
    22.  
    23.     @Autowired
    24.     private UserMapper userMapper;
    25.  
    26.     @Test
    27.     public void test1(){
    28.  
    29.         List userList = userMapper.findAll();
    30.         for (User user : userList) {
    31.             System.out.println(user);
    32.         }
    33.     }
    34. }

    5.3 SpringBoot整合Spring Data JPA

    5.3.1 添加Spring Data JPA的起步依赖

    1. <!-- springBoot JPA的起步依赖 -->
    2. <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter-data-jpa</artifactId>
    5. </dependency>

    5.3.2 jpa相关配置

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
    5.     username: root
    6.     password: admin
    7.   #JPA 配置信息:
    8.   jpa:
    9.     properties:
    10.       hibernate:
    11.         format_sql: true      # 格式化sql
    12.         show_sql: true        # 显示sql
    13.     database: mysql           # 要操作的目标数据库类型,默认情况下系统可以自动检测
    14.     generate-ddl: true        # 可以让SpringDataJPA来生成DDL
    15.     hibernate:
    16.       ddl-auto: update        # ddl的策略为update
    17.       naming:
    18.         physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl   # 允许映射 表中大写名称的字段

    5.3.3 建立映射

    1. package com.dfbz.entity;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. import javax.persistence.*;
    8.  
    9. /**
    10.  * @author lscl
    11.  * @version 1.0
    12.  * @intro:
    13.  */
    14. @AllArgsConstructor
    15. @NoArgsConstructor
    16. @Data
    17.  
    18. @Entity         //标注实体类
    19. @Table(name = "user")          //关联表
    20. public class User {
    21.     @Id
    22.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    23.     @Column
    24.     private Integer id;
    25.  
    26.     @Column
    27.     private String username;
    28.  
    29.     @Column
    30.     private String birthday;
    31.  
    32.     @Column
    33.     private String sex;
    34.  
    35.     @Column
    36.     private String address;
    37.  
    38. }

    5.3.3 编写UserDao

    1. public interface UserDao extends JpaRepository<User,Integer>{
    2. }

    5.3.4 编写测试类

    1. package com.dfbz.demo;
    2.  
    3. import com.dfbz.Application;
    4. import com.dfbz.dao.UserDao;
    5. import com.dfbz.entity.User;
    6. import org.junit.Test;
    7. import org.junit.runner.RunWith;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.boot.test.context.SpringBootTest;
    10. import org.springframework.test.context.junit4.SpringRunner;
    11.  
    12. import java.util.List;
    13.  
    14. /**
    15.  * @author lscl
    16.  * @version 1.0
    17.  * @intro:
    18.  */
    19. @RunWith(SpringRunner.class)
    20. @SpringBootTest(classes= Application.class)
    21. public class Demo02_JPA {
    22.  
    23.     @Autowired
    24.     private UserDao userDao;
    25.  
    26.     @Test
    27.     public void test1(){
    28.  
    29.         List userList = userDao.findAll();
    30.         for (User user : userList) {
    31.             System.out.println(user);
    32.         }
    33.     }
    34. }

    5.4 SpringBoot整合Redis

    Key类型操作

    ValueOperations

    Redis String/Value 操作

    ListOperations

    Redis List 操作

    SetOperations

    Redis Set 操作

    ZSetOperations

    Redis Sort Set 操作

    HashOperations

    Redis Hash 操作

    Value约束操作

    BoundValueOperations

    Redis String/Value key 约束

    BoundListOperations

    Redis List key 约束

    BoundSetOperations

    Redis Set key 约束

    BoundZSetOperations

    Redis Sort Set key 约束

    BoundHashOperations

    Redis Hash key 约束

    • GenericJackson2JsonRedisSerializer：Value序列化
    • StringRedisSerializer：Key序列化

    5.4.1 添加Redis的起步依赖

    1. <!-- 配置使用redis启动器 -->
    2. <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter-data-redis</artifactId>
    5. </dependency>

    5.4.2 Redis相关配置

    1. spring:
    2.   redis:
    3.     host: localhost
    4.     port: 6379
    5.     password: admin

    5.4.3 测试类

    1. package com.dfbz.demo;
    2.  
    3.  
    4. import com.dfbz.Application;
    5. import com.dfbz.entity.User;
    6. import com.dfbz.mapper.UserMapper;
    7. import com.fasterxml.jackson.core.JsonProcessingException;
    8. import com.fasterxml.jackson.databind.JavaType;
    9. import com.fasterxml.jackson.databind.ObjectMapper;
    10. import com.fasterxml.jackson.databind.ObjectWriter;
    11. import org.junit.Test;
    12. import org.junit.runner.RunWith;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.boot.test.context.SpringBootTest;
    15. import org.springframework.data.redis.core.BoundValueOperations;
    16. import org.springframework.data.redis.core.RedisTemplate;
    17. import org.springframework.test.context.junit4.SpringRunner;
    18.  
    19. import java.io.IOException;
    20. import java.util.List;
    21.  
    22. /**
    23.  * @author lscl
    24.  * @version 1.0
    25.  * @intro:
    26.  */
    27. @RunWith(SpringRunner.class)
    28. @SpringBootTest(classes = Application.class)
    29. public class Demo03_Redis {
    30.  
    31.     @Autowired
    32.     private UserMapper userMapper;
    33.  
    34.     @Autowired
    35.     private RedisTemplate<String, String> redisTemplate;
    36.  
    37.     @Test
    38.     public void test1() throws IOException {
    39.  
    40.         BoundValueOperations<String, String> bvo = redisTemplate.boundValueOps("userList");
    41.         String val = bvo.get();
    42.  
    43.         ObjectMapper om = new ObjectMapper();
    44.  
    45.         //第一次从数据库读取
    46.         if (val == null) {
    47.             List<User> userList = userMapper.findAll();
    48.  
    49.             val = om.writeValueAsString(userList);
    50.  
    51.             System.out.println("从数据库读出来的： " + val);
    52.             bvo.set(val);
    53.         } else {
    54.             System.out.println("从redis读取：");
    55.  
    56.             System.out.println(val);
    57.         }
    58.     }
    59. }
  • 相关阅读:
    [ 常用工具篇 ] 安装 kali 并设置 root 密码
    Kotlin高仿微信-第37篇-拍照
    基于ssm协同过滤推荐算法的电影院购票系统毕业设计源码131124
    Selenium多浏览器处理
    【WPF】Dispatcher 与消息循环
    分布式缓存架构
    一致性检验评价方法kappa
    MVC模式
    关于MongoDb查询Decimal128转BigDecimal问题
    forEach和map区别
  • 原文地址：https://blog.csdn.net/Bb15070047748/article/details/134536318