一：SpringBoot简介

　　当前互联网后端开发中，JavaEE占据了主导地位。对JavaEE开发，首选框架是Spring框架。在传统的Spring开发中，需要使用大量的与业务无关的XML配置才能使Spring框架运行起来，这点备受许多开发者诟病。随着Spring4.x发布，Spring已经完全脱离XML，只使用注解就可以运行项目。为了进一步简化Spring应用的开发，SpringBoot诞生了。它是由Pivotal团队提供的全新框架，其设计目的是简化Spring应用的搭建及开发过程，并迎合时下流行的分布式微服务设计思想，越来越多企业在使用SpringBoot

1：设计初衷

　　SpringBoot为我们开发者提供了一种更快速、体验更好的开发方式，我们可以开箱即用，无需像写Spring那样配置各种XML文件，虽然Spring3.0时引入了基于java的配置，但是编写这些配置无疑是在浪费大量时间，其实SpringBoot还内置Tomcat

2：核心功能

一：独立的运行Spring

    SpringBoot 可以以jar包形式独立运行，运行一个SpringBoot项目只需要通过java -jar xx.jar来运行

二：内置Servlet容器

    Spring Boot可以选择内嵌Tomcat、jetty或者Undertow,这样我们无须以war包形式部署项目

三：简化Maven配置

    SpringBoot提供了一系列的start pom来简化Maven的依赖加载，例如，当你使用了spring-boot-starter-web

四：自动装配

    SpringBoot会根据在类路径中的jar包，类、为jar包里面的类自动配置Bean，这样会极大地减少我们要使用的配置。
    当然，SpringBoot只考虑大多数的开发场景，并不是所有的场景，若在实际开发中我们需要配置Bean，而SpringBoot
    没有提供支持，则可以自定义自动配置

五：准生产的应用监控

    SpringBoot提供基于http ssh telnet对运行时的项目进行监控

六：无代码生产和xml配置

    SpringBoot不是借助与代码生成来实现的，而是通过条件注解来实现的，这是Spring4.x提供的新特性

Spring Boot只是Spring本身的扩展，使开发，测试和部署更加方便

3：本文开发环境需求

　　SpringBoot 2.4.1正式发行版，要求Java8并且兼容Java15；对应的Spring版本是5.3.2；而且要求Maven 3.3+ 但是最好使用3.5.4稳定版本，而Servlet容器的版本为Tomcat9.0（Servlet Version 4.0）、Jetty 9.4（Servlet Version 3.1）、Undertow 2.0（Servlet Version 4.0）

二：SpringBoot入门搭建

1：手动搭建案例

　　我们以一个简单的SpringBoot案例来突显出Spring的繁琐，我接下来将使用SpringBoot来实现一个简单的带Controller的案例

第一步：使用IDEA构建一个普通的Maven项目
第二步：在构建好的maven工程中对pom文件修改
第三步：编写启动引导类
第四步：编写Controller
第五步：访问（默认8080端口） 以本案例http://localhost:8080/index/test

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--

        在编写SpringBoot的项目时我们得继承SpringBoot的父POM文件，

        这一点和我们以前使用Spring导入的坐标不太一样，细心的会查看

        继承的父POM文件后发现SpringBoot为我们提前导入了大量的坐标，

        这就解决了我们平常导入坐标版本冲突问题

    -->

    <parent>

        <artifactId>spring-boot-starter-parent</artifactId>

        <groupId>org.springframework.boot</groupId>

        <version>2.4.1</version>

    </parent>

    <groupId>org.example</groupId>

    <artifactId>demo0023</artifactId>

    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <!--

            要编写SpringMVC相关代码我们还得导入web的starter依赖

            SpringBoot为了我们导入的方便，把一系列的关于SpringMVC的坐标打包结合到了

            这个我下面导入的坐标里面

        -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

    </dependencies>

</project>

pom.xml里面添加相应坐标

package cn.xw;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

/**

 * 启动引导类

 */

//加上此注解代表当前类就是SpringBoot启动类，否则就是普通类

@SpringBootApplication

public class SpringBoot5Application {

    //SpringBoot程序入口

    public static void main(String[] args) {

        //main函数里面的args参数是一个String数组，所以在main函数运行的

        //同时可以接收参数，接收过来的参数交给了SpringBoot，用于后期运行配置，后面介绍

        //第一个参数通过反射是告诉SpringBoot哪个是启动引导类

        //还有这个方法有个返回值，返回IOC容器

        SpringApplication.run(SpringBoot5Application.class, args);

    }

    /**

     * 注意：此类只会扫描加载当前包及其子包里面的全部类，然会把它们加载IOC容器中

     */

}

启动引导类编写

package cn.xw.controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController //结合@ResponseBody 和 @Controller 两注解

@RequestMapping("/index")

public class IndexController {

    @RequestMapping("/test")

    public String testMethod() {

        System.out.println("访问到此方法");

        return "Hello !!";

    }

}

Controller编写

2：使用Spring Initializr快速搭建

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--SpringBoot父POM坐标-->

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.4.1</version>

        <relativePath/>

    </parent>

    <groupId>cn.xw</groupId>

    <artifactId>springboot_test</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>springboot_test</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <!--WEB开发Starter-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--SpringBoot的开发者工具-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

            <scope>runtime</scope>

            <optional>true</optional>

        </dependency>

        <!--SpringBoot测试Starter-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <!--SpringBoot的Maven插件-->

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

自动创建的Maven坐标说明

三：SpringBoot基本分析

1：坐标中starters分析及依赖管理

　　starter是依赖关系的整理和封装。是一套依赖坐标的整合，可以让导入应用开发的依赖坐标更方便。利用依赖传递的特性帮我们把一些列指定功能的坐标打包成了一个starter，我们只需要导入starter即可，无需导入大量坐标；每个Starter包含了当前功能下的许多必备依赖坐标这些依赖坐标是项目开发，上线和运行必须的。同时这些依赖也支持依赖传递。如下Starter：

<!--导入WEB开发Starter-->

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

    </dependency>

<dependencies>

    <dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter</artifactId>

      <version>2.4.1</version>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-json</artifactId>

      <version>2.4.1</version>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-tomcat</artifactId>

      <version>2.4.1</version>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.springframework</groupId>

      <artifactId>spring-web</artifactId>

      <version>5.3.2</version>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>org.springframework</groupId>

      <artifactId>spring-webmvc</artifactId>

      <version>5.3.2</version>

      <scope>compile</scope>

    </dependency>

  </dependencies>

spring-boot-starter-web内部封装的一些列坐标

封装成各个Starter的好处就是让我们更加专注于业务开发，无需关心依赖导入，依赖冲突，及依赖的版本

问：为什么导入的一些Starter不需要写版本呢？

　　不指定版本是因为maven有依赖传递的特性，可推测starter在父级定义了并锁定了版本；spring-boot-dependencies.xml 文件可以给大家一个答案；继承关系为 spring-boot-starter-parent.xml ==> spring-boot-dependencies.xml 这里面锁定了我们常用的坐标及Stater

编写SpringBoot项目继承spring-boot-starter-parent的好处和特点

①：默认编译Java 1.8

②：默认编码UTF-8

③：通过spring-boot-denpendencies的pom管理所有公共Starter依赖的版本

④：spring-boot-denpendencies通过Maven的依赖传递和版本锁定特性来实现版本管理

⑤：随用随取，不用继承父类所有的starter依赖。

POM文件中的Maven插件功能

<build>

　　<plugins>

        <!-- 作用：将一个SpringBoot的工程打包成为可执行的jar包 -->

   　　 <plugin>

       　　 <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-maven-plugin</artifactId>

   　　 </plugin>

　　</plugins>

</build>

补充：可选择的启动器官网介绍，需要则查询这个手册

2：自动配置（AutoConfiguration）分析

　　所有我们要配置的项目Pivotal团队的开发人员，帮我们写好了，怎么实现的，主要是通过@Configuration实现 SpringBoot采用约定大于配置设计思想，将所有可能遇到的配置信息提前配置好，写在自动配置的jar包中。每个Starter基本都会有对应的自动配置。SpringBoot帮我们将配置信息写好，存放在一个jar包中：spring-boot-autoconfigure-2.4.1.jar；jar包里，存放的都是配置类，让配置类生效的"规则类"

接下来我来介绍一个我们常见的配置类

一：找到项目的External Libraries

二：查找Maven:org.springframework.boot:spring-autoconfigue:2.4.1

三：内部有个spring-boot-autoconfigue-2.4.1.jar

四：点击org ==> web ==> servlet ==> ServletWebServerFactoryAutoConfiguration类

@Configuration(proxyBeanMethods = false)  //代表是个配置类 SpringBoot为我们提供的每个配置类都有此注解

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)

@ConditionalOnClass(ServletRequest.class)

@ConditionalOnWebApplication(type = Type.SERVLET)

@EnableConfigurationProperties(ServerProperties.class)

@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,

        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,

        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,

        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })

public class ServletWebServerFactoryAutoConfiguration { ... }

补充：我们回到之前点击META-INF ==> spring.factories 这里面配置的是SpringBoot的全部配置类
补充：我们回到之前点击META-INF ==> spring-configuration-metadata.json 这里面配置着各种配置类的信息参数

问：SpringBoot提供这么多配置类，难道是程序运行后就全部导入吗？

　　不会全部导入，只会根据当前项目的需求选择性的装配所需的配置类，这也是SpringBoot的自动装配一大特性；我们也可以设想一下，一次性装配全部配置类，那该多慢呀；

问：SpringBoot怎么知道程序运行后就自动装配呢？

　　我们找到SpringBoot入口函数，点开 @SpringBootApplication 注解会发现里面有个 @EnableAutoConfiguration 这个注解就是开启自动配置的

问：开启自动装配后，它咋知道要加载指定配置呢？那么多配置类呢

　　我们继续看上面的 ServletWebServerFactoryAutoConfiguration 配置类

@Configuration(proxyBeanMethods = false)

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)

//配置类能否被自动装配主要看 @ConditionalOnClass注解

//此注解是否可以加载到一个叫 ServletRequest.class文件,一旦存在则自动装配

@ConditionalOnClass(ServletRequest.class)

@ConditionalOnWebApplication(type = Type.SERVLET)

@EnableConfigurationProperties(ServerProperties.class)

@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,

        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,

        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,

        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })

public class ServletWebServerFactoryAutoConfiguration { ... }

　　有了自动配置后，那么基本全部采用默认配置（这也就是为啥说约定大于配置的思想）；那么要修改默认配置也是可以的，我们只需在配置文件配置指定的参数即可 官方全部可配置属性 如下常见配置：

# 端口配置

server.port=8888

# 配置context-path项目访问根路径

server.servlet.context-path=/demo

# 开启debug模式，详细日志输出，用于开发的一种设置 默认是false

debug=true

# 配置日志  logging.level.{指定包下的日志}=debug

logging.level.cn.xw=debug

四：SpringBoot的配置文件

　　SpringBoot是约定大于配置的，配置都有默认值。如果想修改默认配置，可以使用application.properties或application.yml或application.yaml自定义配置。SpringBoot默认从Resource目录加载自定义配置文件。application.properties是键值对类型；application.yml是SpringBoot中一种新的配置文件方式，在使用自定义配置时名称一定要为application，因为是提前约定好的，而且三个后缀名的文件都写上是有个先后顺序，后面可覆盖前面

<includes>

     <include>**/application*.yml</include>

     <include>**/application*.yaml</include>

     <include>**/application*.properties</include>

</includes>

# properties类型配置文件 application.properties

server.port=8080

server.address=127.0.0.1

<!--xml类型配置文件 application.xml-->

<server>

    <port>8080</port>

    <address>127.0.0.1</address>

</server>

# yml/yaml类型配置文件 application.yml/ymal

server:

    port: 8080

    address: 127.0.0.1

三种类型文件的配置方式

1：yml/yaml配置文件语法及使用

　　YML文件格式是YAML(YAML Aint Markup Language)编写的文件格式。可以直观被电脑识别的格式。容易阅读，容易与脚本语言交互。可以支持各种编程语言(C/C++、Ruby、Python、Java、Perl、C#、PHP)。以数据为核心，比XML更简洁。扩展名为.yml或.yaml 官方网站在线properties转yml

1：大小写敏感

2：数据值前边必须有空格，作为分隔符

3：使用缩进表示层级关系

4：缩进不允许使用tab，只允许空格

5：缩进的空格数不重要，只要相同层级的元素左对齐即可

6："#"表示注释，从这个字符一直到行尾，都会被解析器忽略。

7：数组和集合使用 "-" 表示数组每个元素

# 单个值指定

name: 小周

# 单引号忽略转义字符

message1: 'hello \n world'

# 双引号识别转义字符 打印时会换行

message2: "hello \n world"

# 对象方式指定 普通写法

student:

  name: 张三

  age: 25

  address: 安徽六安

# 对象方式指定 行内写法

teacher: { name: 李老师, age: 50, address: 上海 }

# 数组方式 普通写法

hobby:

  - baseball

  - basketball

  - volleyball

# 数组方式 行内写法

likes: [ baseball, basketball, volleyball ]

# 集合方式 map等格式

peoples:

  key1: zhangsan

  key2: anhui

  key3: xiezi

# 集合方式 map等格式 行内写法

peoples1: { key1 : zhangsan, key2 : anhui , key3 : shanghai}

# 这上面的key~ 是具体的key名称

######## 其它方式扩展

# 配置引用

bookName: 零基础学Java

person:

  name: xiaowu

  likeBookName: ${bookName}

# 配置随机数 其中有int 和 long两种根据情况选择

# 随机字符串

StringA: ${random.value}

# 随机数

numberB: ${random.int}

# 随机产出小于10的数

numberC: ${random.int(10)}

# 随机产出10~100之间的数 大于10小于100

numberD: ${random.int(10,100)}

# 随机产出一个uuid字符串

uuid: ${random.uuid}

yml基本格式写法

2：配置文件与配置类属性映射

（1）：java配置获取基本的配置文件信息.properties类型

三：配置类 jdbcConfig.java

//声明此类为配置类

@Configuration

//导入外部配置文件 因为这个配置类是自定义的，不受SpringBoot帮我们管理

@PropertySource(value="classpath:application.properties")

public class JdbcConfig {

    @Value(value = "${jdbc.datasource.driver-class-name}")

    private String driver;

    @Value("${jdbc.datasource.url}")

    private String url;

    @Value("${jdbc.datasource.username}")

    private String username;

    @Value("${jdbc.datasource.password}")

    private String password;

    @Bean(value = "dataSource")

    public DataSource getDataSource() {

        System.out.println(driver);

        //创建连接池 并加入容器

        DruidDataSource dataSource = new DruidDataSource();

        dataSource.setDriverClassName(driver);

        dataSource.setUrl(url);

        dataSource.setUsername(username);

        dataSource.setPassword(password);

        return dataSource;

    }

}

四：Controller 通过访问运行程序 这里就先不写测试类

@RestController //结合@ResponseBody 和 @Controller 两注解

@RequestMapping("/index")

public class IndexController {

    @Autowired

    private DataSource dataSource;

    @RequestMapping("/test")

    public String testMethod() {

        System.out.println("访问到此方法"+dataSource);

        return "Hello !!";

    }

}

//打印

访问到此方法{

    CreateTime:"2021-01-09 15:22:49",

    ActiveCount:0,

    PoolingCount:0,

    CreateCount:0,

    DestroyCount:0,

    CloseCount:0,

    ConnectCount:0,

    Connections:[

    ]

}

基本数据获取.properties

（2）：java配置获取基本的配置文件信息并注入.yml/.yaml类型

1、使用注解@Value映射

　　@value注解将配置文件的值映射到Spring管理的Bean属性值，只能映射基本数据类型

2、使用注解@ConfigurationProperties映射

　　通过注解@ConfigurationProperties(prefix=''配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射。
　　使用@ConfigurationProperties方式必须提供Setter方法，使用@Value注解不需要Setter方法
注：使用@ConfigurationProperties要在主函数上开启@EnableConfigurationProperties

/**

 * @author: xiaofeng

 * @date: Create in $DATE

 * @description: 学生对象

 * @version: v1.0.0

 */

@Component  //一定要保证被映射注入的是个组件

@ConfigurationProperties(prefix = "student")  //可以之间映射对象

public class Student {

    private Integer id;                     //id

    private String name;                    //姓名

    private String address;                 //住宅

    private List<String> hobbys;            //爱好

    private Map<String, List<Integer>> score;//各科得分

    private Map<String,Teacher> teachers;    //各科老师

    //...省略get/set 这个一定要写 我为了代码少没复制

}

/**

 * @author: xiaofeng

 * @date: Create in $DATE

 * @description: 老师对象

 * @version: v1.0.0

 */

public class Teacher {

    private String name;

    private String message;

}

//注：在添加完@ConfigurationProperties后如果没有spring-boot-configuration-processor编译器会弹出提示

//提示信息：Spring Boot Configuration Annotation Processor.....

//pom.xml添加这个配置注解处理器

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-configuration-processor</artifactId>

    <optional>true</optional>

</dependency>

//然后去主函数类上面添加@EnableConfigurationProperties 开启配置注解处理器

POJO实体类

student:

  id: 1001

  name: 张三

  address: 安徽六安

  hobbys:

    - baseball

    - basketball

    - volleyball

  score:

    yuwen:

      - 66

      - 88

    shuxue:

      - 85

      - 99

  #简写 score: { "yuwen" : [58,99], "shuxue" : [88,96] }

  # 这里通过外界传入值 注意引号别忘了

  teachers:

    yuwenTeacher: { name: "${teacherNameA}", message: "${teacherMessageA}" }

    shuxueTecher: { name: "${teacherNameB}", message: "${teacherMessageB}" }

teacherNameA: 张老师

teacherMessageA: 教语文

teacherNameB: 李老师

teacherMessageB: 教数学

application.yml配置文件

//通过web的方式加载程序运行
@RestController //结合@ResponseBody 和 @Controller 两注解

@RequestMapping("/index")

public class IndexController {

    //注入

    @Autowired

    private Student student;

    @RequestMapping("/test")

    public String testMethod() {

        System.out.println(student.toString());

        //Student{

        // id=1001,

        // name='张三',

        // address='安徽六安',

        // hobbys=[baseball, basketball, volleyball],

        // score={yuwen=[66, 88], shuxue=[85, 99]},

        // teachers={yuwenTeacher=Teacher{name='张老师', message='教语文'},

        // shuxueTecher=Teacher{name='李老师', message='教数学'}}}

        return "Hello !!";

    }

}

五：SpringBoot与其它技术集成

1：SpringBoot集成MyBatis 建表语句

　　集成Mybatis完成查询全部

（1）：使用注解方式完成集成

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.4.1</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>cn.xw</groupId>

    <artifactId>demomybatiss</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>demomybatiss</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <!--web启动器-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--spring-boot启动器-->

        <dependency>

            <groupId>org.mybatis.spring.boot</groupId>

            <artifactId>mybatis-spring-boot-starter</artifactId>

            <version>2.1.4</version>

        </dependency>

        <!--工具-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

            <scope>runtime</scope>

            <optional>true</optional>

        </dependency>

        <!--mysql驱动-->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <scope>runtime</scope>

        </dependency>

        <!--测试 这里没用到-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

pom.xml文件

spring:

  datasource:

    driver-class-name: com.mysql.cj.jdbc.Driver

    url: jdbc:mysql://127.0.0.1:3306/demo_school?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

    username: root

    password: 123

# 加上 ?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC 是为了防止SpringBoot报时区错误

# com.mysql.jdbc.Driver 这种的已经过时了，但是不代表就剔除了 可以用

resources下的application.yml配置文件

///////////POJO

/**

 * @author: xiaofeng

 * @date: Create in $DATE

 * @description: 学生实体类

 * @version: v1.0.0

 */

public class Student implements Serializable {

    private int id;            //id

    private String name;       //姓名

    private String sex;        //性别

    private int age;           //年龄

    private double credit;      //成绩/学分

    private double money;      //零花钱

    private String address;    //住址

    private String enrol;      //入学时间

    //private int fid;    //外键 家庭

    //private int tid;    //外键 老师

    //构造器(无参构造器必须有)/set/get/toString  你们补充一下

}

/////////// Mapper

//此注解org.apache.ibatis.annotations.Mapper 是mybatis提供的加入容器

//Mapper 可以说等于 @Component、@Repository、@Server、@Controller

@Mapper

public interface StudentMapper {

    //查询全部

    @Select("select * from student")

    @Results(id = "studentMapper", value = {

            @Result(id = true, column = "sid", property = "id"),

            @Result(column = "sname", property = "name"),

            @Result(column = "ssex", property = "sex"),

            @Result(column = "sage", property = "age"),

            @Result(column = "scredit", property = "credit"),

            @Result(column = "smoney", property = "money"),

            @Result(column = "saddress", property = "address"),

            @Result(column = "senrol", property = "enrol")

    })

    List<Student> findAll();

}

///////////Service

/**

 * @author: xiaofeng

 * @date: Create in $DATE

 * @description: 学生业务接口

 * @version: v1.0.0

 */

public interface StudentService {

    //查询全部

    List<Student> findAll();

}

/**

 * @author: xiaofeng

 * @date: Create in $DATE

 * @description: 学生业务实现

 * @version: v1.0.0

 */

@Service    //注入到容器

public class StudentServiceImpl implements StudentService {

    //注入对象  如果是IDEA编译器这边会有个红线错误，不影响

    @Autowired

    private StudentMapper studentMapper;

    //查询全部

    @Override

    public List<Student> findAll() {

        return studentMapper.findAll();

    }

}

//////////Controller

@RestController

@RequestMapping("/student")

public class StudentController {

    @Autowired

    private StudentService studentService;

    @RequestMapping("/findAll")

    public List<Student> findAll() {

        System.out.println("访问成功");

        //这里通过json把对象写到浏览器，要序列化对象

        return studentService.findAll();

    }

}

POJO、Mapper、Service、Controller文件

注：使用http://localhost:8080/student/findAll访问，还有就是Mapper文件夹里面的代码一定要写在主函数类当前包及其子包下，如果不在则需要在入口类添加@MapperScan或者@MapperScans注解扫描一下，这个是mybatis提供的

（2）：使用Mapper.xml映射完成集成

spring:

  datasource:

    driver-class-name: com.mysql.cj.jdbc.Driver

    url: jdbc:mysql://127.0.0.1:3306/demo_school?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

    username: root

    password: 123

# spring继承mybatis环境

# type-aliases-package:pojo别名扫描包

# mapper-locations:加载mybatis映射文件

mybatis:

  type-aliases-package: cn.xw.pojo

  mapper-locations: classpath:mapper/*Mapper.xml

# 加上 ?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC 是为了防止SpringBoot报时区错误

# com.mysql.jdbc.Driver 这种的已经过时了，但是不代表就剔除了 可以用

更改application.yml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper

        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.xw.mapper.StudentMapper">

    <!--名称字段不一样可以使用这个映射名称对应-->

    <resultMap id="studentMapper" type="student">

        <id column="sid" property="id"/>

        <result column="sname" property="name"/>

        <result column="ssex" property="sex"/>

        <result column="sage" property="age"/>

        <result column="sscore" property="credit"/>

        <result column="smoney" property="money"/>

        <result column="saddress" property="address"/>

        <result column="senrol" property="enrol"/>

    </resultMap>

    <!--查询全部学生    要使用上面的resultMap才可以-->

    <select id="findAll" resultMap="studentMapper">

        select * from student;

    </select>

</mapper>

在resources下创建mapper/StudentMapper.xml

删除之前在Mapper使用注解的SQL语句删除，只留方法

2：Spring Boot 集成 Redis

　　springBoot集成Redis后，以上个案例的基础上做个查询学生缓存，如果第一次查询则缓存到redis服务器里，然后从redis读取数据返回到客户端

 <!--导入redis启动器-->

<dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>

@RestController

@RequestMapping("/student")

public class StudentController {

    @Autowired

    private StudentService studentService;

    //注入redis模板对象

    @Autowired

    private RedisTemplate redisTemplate;

    @RequestMapping("/findAll")

    public List<Student> findAll() {

        System.out.println("访问成功");

        //获取类名

        String className = studentService.getClass().getName();

        //以类名+方法名的方式作为key来查询redis缓存数据

        List<Student> studentList = (List<Student>) redisTemplate.boundValueOps(className + "findAll").get();

        //redis没有数据 查询数据库放入到redis

        if (studentList == null) {

            System.out.println("从数据库查询数据放入到redis");

            //查询数据库

            studentList = studentService.findAll();

            //把查询到的数据放入redis中 key为类名加findAll

            redisTemplate.boundValueOps(className + "findAll").set(studentList);

        } else {

            System.out.println("从redis读取数据缓存");

        }

        //这里通过json把对象写到浏览器，要序列化对象

        return studentList;

    }

}

更改StudentController

3：Spring Boot 集成定时器

　使用SpringBoot完成一个简易的定时器，每5秒输出一下当前的时间到控制台；

　　首先在入口函数类上面加@EnableScheduling注解，代表开启定时器

@Component

public class TimerUtil {

    /**

     * @Scheduled 设置方法执行规则  就是定时任务设置

     * cron: 设置一个String类型的cron表达式  这个属性和下面6个不要混用

     * fixedDelay       以一个固定的延迟时间，上个任务完成后多久执行下一个任务

     * fixedDelayString 和上面一样字符串形式传值

     * fixedRate        以一个固定的频率运行，不管上一个任务执行时间

     * fixedRateString  和上面一样字符串形式传值

     * initialDelay         当项目初始化后多久触发事务的执行

     * initialDelayString   和上面一样字符串形式传值

     */

    //使用cron表达式

    @Scheduled(initialDelay=10000,fixedDelay = 5000)

    public void myTask(){

        System.out.println("当前时间："+new Date());

    }

}

//注：写在入口函数类可扫描的范围包下

编写定时器类

4：Spring Boot 集成Test单元测试

<!--测试启动start-->

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-test</artifactId>

    <scope>test</scope>

</dependency>

//@RunWith(SpringRunner.class) 在老版的SpringBoot项目需要这个
//2.2.0.RELEASE以后，springboot测试类不再需要@Runwith的注解


@SpringBootTest //注明为SpringBoot测试类

class DemomybatissApplicationTests {

    //注入StudentService对象

    @Autowired

    private StudentService studentService;

    @Test

    void contextLoads() {

        System.out.println(studentService.findAll());

    }

}

5：Spring Boot 发送HTTP请求

　　要在SpringBoot内部发送HTTP请求就得用到RestTemplate模板，它是Rest的HTTP客户端模板工具类；对基于HTTP客户端进行了封装；还实现了对象与JSON的序列化与反序列化；不限定客户端类型，目前常用的3种客户端都支持：HttpClient、OKHttp、JDK原生URLConnection(默认方式)

@SpringBootApplication

@EnableScheduling //开启定时器注解

public class DemomybatissApplication {

    public static void main(String[] args) {

        SpringApplication.run(DemomybatissApplication.class, args);

    }

    //注册RestTemplate对象放入IOC容器

    @Bean

    public RestTemplate restTemplate(){

        return new RestTemplate();

    }

}

入口函数类更改

//@RunWith(SpringRunner.class) 在老版的SpringBoot项目需要这个

@SpringBootTest //注明为SpringBoot测试类

class DemomybatissApplicationTests {

    //注入RestTemplate对象

    @Autowired

    private RestTemplate restTemplate;

    @Test

    void contextLoads() {

        //String.class代表以字符串形式接收结果

        String forObject = restTemplate.getForObject("http://baidu.com", String.class);

        System.out.println(forObject);

        //打印

        //<html>

        //<meta http-equiv="refresh" content="0;url=http://www.baidu.com/">

        //</html>

    }

}

编写RestTemplate发送Http请求测试类

6：扩展

　　SpringBoot除了上面几个集成外还集成 MongoDB、ElasticSearch、Memcached、邮件服务：普通邮件、模板邮件、验证码、带Html的邮件、RabbitMQ消息中间件、Freemarker或者Thymeleaf等等

六：SpringBoot打包部署

　　启动方式有两种，一种是打成jar直接执行，另一种是打包成war包放到Tomcat服务下，启动Tomcat

1：打成Jar包部署运行

　　注：pom文件里的<packaging>jar</packaging>必须为jar，默认就是jar

/**

 * 第一步：使用IDEA工具把写的代码通过maven的package打包

 * 第二步：找到打包后的target文件夹里面，把xxx.jar包扔给测试

 * 第三步：自己测试的话使用cmd执行下面命令，前提得检查自己的pom.xml文件中是否有springboot的maven插件

 * java -jar  xxxx.jar

 * 补充：在运行的时候传递参数 通过main函数的args接收

 * java -jar  xxxx.jar --server.port=8888

 * 补充：在运行的时候配置jvm参数，使占用更少的内存

 * java -Xmx80m -Xms20m -jar xxxx.jar

 */

2：打成War包部署运行

　　注：pom文件里的<packaging>war</packaging>必须为jar，默认就是war

创建一个类如：ServletInitializer.java，继承 SpringBootServletInitializer ，覆盖 configure()，

把启动类 Application 注册进去。外部 Web 应用服务器构建 Web Application Context 的时候，

会把启动类添加进去。

//如下代码创建的类 除了类名和注册的启动类不一样，其它是固定写法

//WEB-INF/web.xml

public class ServletInitializer extends SpringBootServletInitializer {

    @Override

    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

        //DemoApplication是自己当前项目的主函数

        return builder.sources(DemoApplication.class);

    }

}

七：SpringBoot热部署

　　我们在之前每次写完代码之后都要重新部署运行，这样特别浪费时间，其实SpringBoot是支持热部署的，但是我们得有相对应的参数配置，导入坐标

检查当前的pom.xml必须有此配置才可以，然后正常启动运行即可
<!--工具 用于设置热部署，optional必须为true-->

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-devtools</artifactId>

    <scope>runtime</scope>

    <optional>true</optional>

</dependency>

当我们的代码写文运行后，后期更改了代码无需重写部署，只需要按CTRL+F9(Build Project)，这是快速构建项目，或点击有上角的锤子；

如果还觉得麻烦，那就设置，一旦更改代码，IDEA失去焦点就自动构建代码，我们要设置一下IDEA配置

八：SpringBoot配置文件深入

1：多环境配置文件

　　我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发dev、测试test、生产pro等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。

（1）：单文件的多环境配置

# 在只有application.yml一个文件下配置多个配置环境就需要使用 " --- " 分隔界限

# 为了规范 Dev为开发  Test为测试  Pro为生产

# 配置完以后在这里选择要使用的配置环境

spring:

  profiles:

    # 开启哪个环境下的配置文件

    active: oo

    # 引用包含哪个配置文件

    include: global

# 开发环境配置  Dev

---

server.port: 8881

# 设置当前的配置界限为 dev开发环境

spring.profiles: dev

# 测试环境配置  Test

---

server.port: 8882

spring.profiles: test

# 生产上线环境配置  Pro

---

server.port: 80

spring.profiles: pro

# 全局的配置供include包含使用

---

server.servlet.context-path: /littleBird

spring.profiles: global

单个application.yml配置文件完成多环境配置 不推荐

（2）：多文件的多环境配置

：application.yml 主配置文件（必须有）

# 为了规范 Dev为开发  Test为测试  Pro为生产

# 配置完以后在这里选择要使用的配置环境

spring:

  profiles:

    # 开启哪个环境下的配置文件

    active: dev

    # 引入包含共有配置

    include: common

：application-dev.yml/properties 开发环境配置

# 开发环境

server.port: 8881

：application-test.yml/properties 测试环境配置

# 测试环境

server.port: 8882

：application-pro.yml/properties 生产环境配置

# 上线环境

server.port: 80

：application-common.yml/properties 公共环境配置

# 公共配置 供其包含导入

server.servlet.context-path: /littleBird

多文件配置多环境推荐

（3）：profile激活方式

　　在上面我介绍了使用配置文件来指定配置环境：spring.profiles.active=xx；可是这个是有局限性的，除了这种方式激活还要另外2种

配置文件：  再配置文件中配置：spring.profiles.active=dev

虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev

命令行参数：java –jar xxx.jar --spring.profiles.active=dev
优先级：命令行参数 > 虚拟机参数 > 配置文件

2：松散绑定

　　不论配置文件中的属性值是短横线、驼峰式还是下换线分隔配置方式，在注入配置时都可以通过短横线方式取出值；使用范围：properties文件、YAML文件、系统属性

命名各种方式的名称 application.yml文件下定义方式

# 短横线分隔

parameter1:

  spring-boot:

    student-name: zhangsan

# 驼峰式

parameter2:

  springBoot:

    studentName: lisi

# 下划线分隔

parameter3:

  spring_boot:

    student_name: wangwu

命名各种方式的名称 application.properties文件下定义方式

# 短横线分隔

parameter1.spring-boot.student-name=zhangsan

# 驼峰式

parameter2.springBoot.studentName=lisi

# 下划线分隔

parameter3.spring_boot.student_name: wangwu

取出方式：使用短横线分隔可以取出上面的任意一直格式

注：在@Value获取上面的3种方式命名的配置只能使用短横线分隔通配

否则配置文件写啥名，获取就写啥名，一一对应

@Value(value="${parameter1.spring-boot.student-name}")

@Value(value="${parameter2.spring-boot.student-name}")

@Value(value="${parameter3.spring-boot.student-name}")

松散绑定配置文件介绍

3：配置路径及其加载顺序

4：外部配置加载顺序官方文档

　　外部加载顺序就是说在程序运行时加载外部的配置信息的顺序，如我们常用的命令行下指定额外信息 java -jar xxx.jar --server.port=8888

# 这个是2.1.11版本的springboot之前的信息，中文的看的清楚，以具体版本为准

1：开启 DevTools 时， ~/.spring-boot-devtools.properties

2：测试类上的 @TestPropertySource 注解

3：@SpringBootTest#properties 属性

4：==命令?参数（--server.port=9000 ）==

5：SPRING_APPLICATION_JSON 中的属性

6：ServletConfig 初始化参数

7：ServletContext 初始化参数

8：java:comp/env 中的 JNDI 属性

9：System.getProperties()

10：操作系统环境变量

11：random.* 涉及到的 RandomValuePropertySource

12：jar 包外部的 application-{profile}.properties 或 .yml

13：jar 包内部的 application-{profile}.properties 或 .yml

14：jar 包外部的 application.properties 或 .yml

15：jar 包内部的 application.properties 或 .yml

16：@Configuration 类上的 @PropertySource

17：SpringApplication.setDefaultProperties() 设置的默认属性

中文介绍

5：修改配置文件位置及默认名称

　　我们知道配置文件只能以application.yml/properties来定义，但是名称不一样是可以指定具体文件名，也可以把配置文件放入其它位置并指定都是可以的；指定的方式我以cmd下指定参数 java -jar xxx.jar --xxx -xxx 方式指定，或在IDEA里面指定-xxx参数

# 自定义配置文件名称

--spring.config.name=myApplication

# 指定配置文件存储位置 或 指定配置文件存储位置及配置文件名称
--spring.config.location=classpath:/myconfig/myApplication.yml
注：多个配置参数以空格隔开 --xxx -xxx

九：SpringBoot监听器

　　我们知道JavaEE包括13门规范，其中Servlet规范包括三个技术点：Servlet、Listener、Filter；而本章介绍的是监听器，监听器就是监听某个对象的状态变化；SpringBoot中的监听器有很多种：如下

①：CommandLineRunner 应用程序启动完成后

②：ApplicationRunner 应用程序启动完成后

③：ApplicationContextInitializer 程序运行初始化前

④：SpringApplicationRunListener 多功能监听器

1：对开发者有益的监听器

@Component  //实现CommandLineRunner接口的监听器必须要加入IOC容器

public class MyCommandLineRunner implements CommandLineRunner {

    //注 参数args是主函数入口的args传来的

    @Override

    public void run(String... args) throws Exception {

        System.out.println("应用程序启动完成后 打印：CommandLineRunner");

    }

}

CommandLineRunner 监听器使用

@Component  //实现ApplicationRunner接口的监听器必须要加入IOC容器

public class MyApplicationRunner implements ApplicationRunner {

    //注 参数args是主函数入口的args传来的

    @Override

    public void run(ApplicationArguments args) throws Exception {

        System.out.println("应用程序启动完成后 打印：ApplicationRunner");

    }

}

ApplicationRunner 监听器使用

2：对框架开发者有意义的监听器功能多

public class MyApplicationContextInitializer implements ApplicationContextInitializer {

    @Override

    public void initialize(ConfigurableApplicationContext applicationContext) {

        System.out.println("程序运行初始化前 打印：ApplicationContextInitializer");

    }

}

ApplicationContextInitializer 监听器使用

public class MySpringApplicationRunListener implements SpringApplicationRunListener {

    //注意：此构造方法必须要写 不写就给你报个错误

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

    @Override

    public void starting(ConfigurableBootstrapContext bootstrapContext) {

        System.out.println("应用程序开始启动==>starting");

    }

    @Override

    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {

        System.out.println("环境准备完成==>environmentPrepared");

    }

    @Override

    public void contextPrepared(ConfigurableApplicationContext context) {

        System.out.println("Spring容器准备完成==>contextPrepared");

    }

    @Override

    public void contextLoaded(ConfigurableApplicationContext context) {

        System.out.println("Spring容器加载完成==>contextLoaded");

    }

    @Override

    public void started(ConfigurableApplicationContext context) {

        System.out.println("应用程序启动完成==>started");

    }

    //注：running成功与failed异常只会存在一个

    @Override

    public void running(ConfigurableApplicationContext context) {

        System.out.println("应用程序开始运行==>running");

    }

    @Override

    public void failed(ConfigurableApplicationContext context, Throwable exception) {

        System.out.println("应用程序运行时抛出异常==>failed");

    }

}

SpringApplicationRunListener 监听器使用

# 说明 在resources目录下创建META-INF文件夹 并在里面创建一个spring.factories

# 主要目的是解耦：将监听器的配置权交给第三方厂商、插件开发者

# 框架提供接口，实现类由你自己来写，释放原生API能力，增加可定制性

# META-INF/spring.factories文件中配置接口的实现类名称

# 配置ApplicationContextInitializer监听器的配置

# 左边监听器的全路径名称=右边实现此监听器的全路径名

org.springframework.context.ApplicationContextInitializer=cn.xw.lintener.MyApplicationContextInitializer

# 配置SpringApplicationRunListener监听器的配置

# 左边监听器的全路径名称=右边实现此监听器的全路径名

org.springframework.boot.SpringApplicationRunListener=cn.xw.lintener.MySpringApplicationRunListener

使用ApplicationContextInitializer/SpringApplicationRunListener监听器必看配置一些信息才可使用

十：自动配置实现分析

　　我们在导入spring-boot-starter-web启动器无需其它配置就可以之间用，还有我们导入spring-boot-starter-data-redis启动器后可以直接使用@Autowired直接注入RedisTemplate对象，很奇怪吧，这就是SpringBoot自动配置特性，在下几节我慢慢引入

1：@Import注解进阶

　　当我们需要导入某个类到spring容器中去，但spring恰好无法扫描到这个类，而我们又无法修改这个类（jar包形式）。我们就可以通过@import(xxx.class)是将这个类导入到spring容器中

（1）：直接导入

//配置类  springConfig

@Configuration

@Import(value={DateConfig.class})  //直接导入

public class SpringConfig { }

//普通类，里面有个@Bean注入方法  DateConfig

//被任何一个配置类引用，当前自己类也变为子配置类

public class DateConfig {

    //创建时间对象放入容器

    @Bean

    public Date createDate() { return new Date(); }

}

（2）：通过配置类导入

@Configuration

public class SpringConfig {

    //创建时间对象放入容器

    @Bean

    public Date createDate() { return new Date(); }

}

@SpringBootApplication

@Import(value={SpringConfig.class}) //导入配置类

public class LintenerDemoApplication {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(LintenerDemoApplication.class, args);

        //打印时间对象

        System.out.println(run.getBean(Date.class));

    }

}

（3）：通过ImportSelector接口实现类导入高级方式

//普通类 里面有个@Bean注入对象

public class DateConfig {

    //创建时间对象放入容器

    @Bean

    public Date createDate() { return new Date(); }

}

//创建一个类实现ImportSelector

public class MyImportSelector implements ImportSelector {

    //这个方法是返回配置类的全类名，导入多少都行，最后通过@Import导入

    @Override

    public String[] selectImports(AnnotationMetadata importingClassMetadata) {

        //返回一个数组

        return new String[]{"cn.xw.config.DateConfig"};

    }

}

@SpringBootApplication

@Import(value={MyImportSelector.class}) //导入配置类

public class LintenerDemoApplication {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(LintenerDemoApplication.class, args);

        //打印时间对象

        System.out.println(run.getBean(Date.class));

    }

}

使用ImportSelector接口

2：@Configuration注解进阶

　　相对这个注解大家肯定不陌生，只要是Spring注解配置类都有这玩意；其实只要添加@Configuration注解的类里面可以衍生出各种条件注解供我们使用，前提只能在注解类下使用，它就是@Conditional条件注解，这个条件注解又衍生出各种详细的条件注解

注：@EnableAutoConfiguration 其本质是 @Import 和 @Configuration的组合

一：class类条件

    @ConditionalOnClass == 存在指定类条件

    @ConditionalOnMissingClass == 不存在指定类条件

二：属性条件

    @ConditionalOnProperty == 属性条件，还可以为属性设置默认值

三：Bean条件

    @ConditionalOnBean == 存在Bean条件

    @ConditionalOnMissingBean == 不存在Bean条件

    @ConditionalOnSingleCondidate == 只有一个Bean条件

四：资源条件

    @ConditionalResource == 资源条件

五：Web应用条件

    @ConditionalOnWebApplication == web应用程序条件

    @ConditionalOnNotWebApplication == 不是web应用程序条件

六：其他条件

    @ConditionalOneExpression == EL表达式条件

    @ConditionalOnJava == 在特定的Java版本条件

　　@Configuration还有一些加载顺序的方式

1：@AutoConfigureBefore==在那些自动配置之前执行

2：@AutoConfigureAfter==在那些自动配置之后执行

3：@AutoConfigureOrder==自动配置顺序

（1）：@ConditionalOnClass 与 @ConditionalOnProperty 介绍

@ConditionalOnClass注解属性介绍

    Class<?>[] value()：以类的class形式的数组

    String[] name()：以类的全路径名的字符串数组

@ConditionalOnProperty注解属性介绍

    value 和 name：数组，获取对应property名称的值，它们只能存在其中一个

    prefix：配置属性名称的前缀，比如spring.http.encoding

    havingValue：可与name组合使用，比较获取到的属性值与havingValue给定的值是否相同，相同才加载配置

    matchIfMissing：缺少该配置属性时是否可以加载。如果为true，没有该配置属性时也会正常加载；反之则不会生效

//学生类

public class Student {

    private String name;

    private String identity;

    //省略了get/set，

}

//老师类

public class Teacher {

    private String name;

    private String identity;

    //省略了get/set，

}

//需求，当创建Teacher加入容器时得判断当前是否存在Student这个类

@Configuration

@ConditionalOnClass(name = "cn.xw.pojo.Student")

public class SpringConfig {

    //可以通过spring.myconfig.enable=true开启 或者false 关闭容器注册

    @Bean(value = "teacher")

    @ConditionalOnProperty(prefix = "spring.myconfig", name = "enable", havingValue ="true", matchIfMissing = true)

    public Teacher createTeacher() {

        Teacher teacher = new Teacher();

        teacher.setName("张老师");

        teacher.setIdentity("老师");

        return teacher;

    }

}

@SpringBootApplication

//导入配置类

@Import(value={SpringConfig.class})

public class LintenerDemoApplication {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(LintenerDemoApplication.class, args);

        //打印时间对象

        System.out.println(run.getBean(Teacher.class).getName());

    }

}

//application.properties

# 关闭容器注册

spring.myconfig.enable=false

案例讲解注解

//注解类

@Configuration(proxyBeanMethods = false)

//条件注解 确保存在RedisOperations类

@ConditionalOnClass(RedisOperations.class)

//@Import 和  @ConfigurationProperties结合  RedisProperties类就是我们配置额外变量的spring.redis

@EnableConfigurationProperties(RedisProperties.class)

//导入配置类

@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })

public class RedisAutoConfiguration {

    @Bean

    //判断不存在redisTemplate的Bean条件

    @ConditionalOnMissingBean(name = "redisTemplate")

    //判断只有一个RedisConnectionFactory的Bean条件

    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)

    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<Object, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(redisConnectionFactory);

        return template;

    }

    //下面差不多

    @Bean

    @ConditionalOnMissingBean

    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)

    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

        StringRedisTemplate template = new StringRedisTemplate();

        template.setConnectionFactory(redisConnectionFactory);

        return template;

    }

}

RedisTemplate自动注入分析

十一：自定义auto-Configuration及starter

　　我们平常导入是第三方mybatis-spring-boot-starter启动器都是由第三方提供给，特点就是以mybatis开头，那下面我们自定义starter也得是自定义名称开头，我们要自定义auto-Configuraction并使用必备的四个角色：功能主体框架、自动配置模块、starter模块、开发者引用

1：定制自动配置必要内容

    autoconfiguration模块，包含自动配置代码。自定义 *-spring-boot-autoconfigure。

    starter模块。自定义 *-spring-boot-starter

2：自动配置命名方式

    官方的Starters

        spring-boot-starter-*  如：spring-boot-starter-web

    非官方的starters

        *-spring-boot-starter  如：mybatis-spring-boot-starter

3：SpringBoot起步依赖，Starter Dependencies

　　接下来我要创建一个第三方模块，功能主体模块是一个图形打印模块，根据配置文件的不同打印出不同的图案，还要就是一个自动配置模块和starter模块咯，最后由我来在普通的springboot应用中调用这个自定义的自动配置

（1）：功能主体模块

主体功能模块maven坐标

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.tx</groupId>

    <artifactId>graphic-printing</artifactId>

    <version>1.0-SNAPSHOT</version>

    <!--设置maven使用什么版本的jdk解析编译-->

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <maven.compiler.source>1.8</maven.compiler.source>

        <maven.compiler.target>1.8</maven.compiler.target>

    </properties>

</project>

主体功能模块具体类方法

//图形打印对象

public class GraphicPrintingUtil {

    private Integer width = 4;

    private Integer height = 3;

    //别忘了添加get/set方法，后面会参数注入

    //打印图形 方法

    public void graphicPrinting() {

        System.out.println(">图形开始打印<");

        for (int i = 1; i <= height; i++) {

            for (int j = 1; j <= width; j++) {

                System.out.print(" * ");

            }

            System.out.println();

        }

    }

}

功能主体代码 模块名：graphic-printing

（2）：自动配置模块

自动配置模块maven坐标

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--导入Springboot父坐标-->

    <parent>

        <artifactId>spring-boot-starter-parent</artifactId>

        <groupId>org.springframework.boot</groupId>

        <version>2.4.1</version>

    </parent>

    <!--当前本项目的一些信息-->

    <groupId>cn.tx</groupId>

    <artifactId>graphic-spring-boot-autoconfigure</artifactId>

    <version>1.0-SNAPSHOT</version>

    <!--坐标-->

    <dependencies>

        <!--导入SpringBoot的自动配置坐标 因为代码中要写配置注解-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-autoconfigure</artifactId>

        </dependency>

        <!--导入我们之前创建的主体模块graphic-printing-->

        <dependency>

            <groupId>cn.tx</groupId>

            <artifactId>graphic-printing</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

    </dependencies>

</project>

自动配置模块具体类方法

## GraphicConfiguration类

@Configuration  //注解类

@Import(value = {GraphicProperties.class})  //导入配置类

@ConditionalOnClass(GraphicPrintingUtil.class)//判断当前项目是否存在GraphicPrintingUtil类

public class GraphicConfiguration {

    @Bean

    @ConditionalOnProperty(prefix = "graphic.printing", name = "enable", havingValue = "true", matchIfMissing = true)

    //@ConfigurationProperties(prefix = "graphic.config") 可以使用此注解直接注入 注入时值可有可无

    public GraphicPrintingUtil createGraphicPrintingUtil(GraphicProperties g) {

        //创建图形打印对象，主体模块上的对象

        GraphicPrintingUtil printingUtil = new GraphicPrintingUtil();

        //设置宽高

        printingUtil.setHeight(g.getHeight());

        printingUtil.setWidth(g.getWidth());

        return printingUtil;

    }

}

##  GraphicProperties 配置类

//这里报红不管他，后面使用者导入<artifactId>spring-boot-configuration-processor</artifactId>

@ConfigurationProperties(prefix = "graphic.config")

public class GraphicProperties {

    private Integer width;

    private Integer height;

    //别忘了写get/set

}

自动配置代码 模块名：graphic-spring-boot-autoconfigure

# 注册自定义自动配置

# 前面是固定的，后面是自定义配置类

org.springframework.boot.autoconfigure.EnableAutoConfiguration=cn.tx.config.GraphicConfiguration

在resources下创建META-INF文件夹，并在下面创建spring.factories配置

（3）：stater模块

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--自己项目坐标-->

    <groupId>cn.tx</groupId>

    <artifactId>graphic-spring-boot-starter</artifactId>

    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <!--主体功能模块-->

        <dependency>

            <groupId>cn.tx</groupId>

            <artifactId>graphic-printing</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

        <!--自动配置类autoconfigure-->

        <dependency>

            <groupId>cn.tx</groupId>

            <artifactId>graphic-spring-boot-autoconfigure</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

    </dependencies>

</project>

stater模块模块名：graphic-spring-boot-starter

　　注：此模块啥都不用，只要pom.xml文件即可

（3）：开发者引用

注：此模块和正常SpringBoot一样，可以使用脚手架构建

使用者maven坐标

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--springboot父坐标-->

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.4.1</version>

        <relativePath/>

    </parent>

    <!--本项目的坐标信息-->

    <groupId>cn.xw</groupId>

    <artifactId>test001</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>test001</name>

    <description>Demo project for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter</artifactId>

        </dependency>

        <!--导入我们自定义的stater启动器-->

        <dependency>

            <groupId>cn.tx</groupId>

            <artifactId>graphic-spring-boot-starter</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

        <!--一定要导入，是为了注入配置文件里面的数值-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-configuration-processor</artifactId>

            <optional>true</optional>

        </dependency>

    </dependencies>

    <!--maven插件-->

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

使用者具体类方法

@SpringBootApplication

public class Test001Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext run = SpringApplication.run(Test001Application.class, args);

        //ConfigurableApplicationContext是ClassPathXmlApplicationContext子类

        run.getBean(GraphicPrintingUtil.class).graphicPrinting();

    }

}

配置文件application.properties

graphic.printing.enable=true

graphic.config.width=10

graphic.config.height=15

开发者模块模块名：test001

十二：切换内置web应用服务器

SpringBoot的web环境中默认使用tomcat作为内置服务器，其实还提供了另外2种内置服务器供我们选择，我们可以很方便的进行切换。

1：Tomcat：这个是使用最广泛但性能不太好的web应用服务器  默认

2：Jetty：Jetty 是一个开源的servlet容器，它为基于Java的web容器，例如JSP和servlet提供运行环境。

3：Undertow： 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器

　　Tomcat方式：Tomcat started on port(s): 8080 (http) with context path ''
　　Jetty方式：Jetty started on port(s) 8080 (http/1.1) with context path '/'
　　Undertow方式：Undertow started on port(s) 8080 (http)

<!--导入web的starter启动器-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

            <!--一定要排除tomcat的starter   因为默认就是tomcat-->

            <exclusions>

                <exclusion>

                    <groupId>org.springframework.boot</groupId>

                    <artifactId>spring-boot-starter-tomcat</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

        <!--导入jetty容器依赖-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-jetty</artifactId>

        </dependency>

切换为Jetty

 <!--导入web的starter启动器-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

            <!--一定要排除tomcat的starter   因为默认就是tomcat-->

            <exclusions>

                <exclusion>

                    <groupId>org.springframework.boot</groupId>

                    <artifactId>spring-boot-starter-tomcat</artifactId>

                </exclusion>

            </exclusions>

        </dependency>

        <!--导入undertow容器依赖-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-undertow</artifactId>

        </dependency>

切换Undertow

十三：SpringBoot生产级监控

　　SpringBoot自带监控功能Actuator，可以帮助实现对程序内部运行情况监控，比如监控状况、Bean加载情况、配置属性、日志信息等

1：项目集成Actuator监控服务

　　其实导入健康服务特别简单，任何一个SpringBoot只需要加入一个监控启动器则可开启监控服务，然后项目正常运行即可

<!--监控服务Actuator启动器-->
<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

　　保存SpringBoot导入监控坐标后启动程序，在程序运行的情况下访问 http://localhost:8080/actuator 则可监控程序

补充：默认只可以监控这几项，其实可以监测很多模块

 路径                描述                                默认开启

/beans            显示容器的全部的Bean，以及它们的关系        N

/env            获取全部环境属性                           N

/env/{name}        根据名称获取特定的环境属性值                N

/health            显示健康检查信息                           Y

/info            显示设置好的应用信息                       Y

/mappings        显示所有的@RequestMapping信息               N

/metrics        显示应用的度量信息                           N

/scheduledtasks    显示任务调度信息                           N

/httptrace        显示Http Trace信息                          N

/caches            显示应用中的缓存                           N

/conditions        显示配置条件的匹配情况                        N

/configprops    显示@ConfigurationProperties的信息           N

/loggers        显示并更新日志配置                            N

/shutdown        关闭应用程序                               N

/threaddump        执行ThreadDump                              N

/headdump        返回HeadDump文件，格式为HPROF               N

/prometheus        返回可供Prometheus抓取的信息               N

监控应用endpoint

常用application.properties配置

# 暴露所有的监控点

management.endpoints.web.exposure.include=*

# 定义Actuator访问路径

management.endpoints.web.base-path=/act

# 开启endpoint 关闭服务功能  访问关闭路径只能发送post请求才可关闭

management.endpoint.shutdown.enabled=true

33333333333

配置文件：再配置文件中配置：spring.profiles.active=dev
虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
命令行参数：java –jar xxx.jar --spring.profiles.active=dev

巴特西

SpringBoot入门及深入