1.SpringBoot简介

1.1 原有Spring优缺点分析

1.1.1 Spring的优点分析

Spring是Java企业版（Java Enterprise Edition，javeEE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

1.1.2 Spring的缺点分析

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。
不论是一开始的基于XML的配置，还是Spring2.5引入的基于注解的组件扫描，还是Spring 3.0引入的基于Java的配置，这些都代表了开发时的额外损耗。
因为在思考Spring配置和解决业务问题之间需要进行思维切换，甚至还带来了何种方式配置更好的无谓争论，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

1.2 SpringBoot的概述

SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

1.2.1 SpringBoot的特点

  • SpringBoot不是对Spring功能上的增强，而是提供了一种快速构建Spring的方式
  • 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求

  • 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器（嵌入Tomcat，无需部署WAR文件）、安全、指标，健康检测、外部配置等

    1.2.2 SpringBoot的核心功能

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

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

后面会详细说明起步依赖与自动配置的原理解析。

2.SpringBoot实例

2.1.创建SpringBoot简单实例

下面使用Maven创建一个基于SpringBoot的Web工程的简单实例。

2.1.1.创建工程

SpringBoot框架 - 图1

注意：虽然是创建Web工程，但由于SpringBoot内嵌了Tomcat，所以这里选择jar包形式的工程。

2.1.2.添加依赖

在pom.xml文件中添加SpringBoot的相关依赖

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.neusoft</groupId>
  6.     <artifactId>boot</artifactId>
  7.     <version>0.0.1-SNAPSHOT</version>
  8.     <!-- 
  9.         继承Spring Boot父级依赖，也就是：spring-boot-dependencies。
  10.         父级依赖管理了Spring Boot项目中的所有依赖版本，以后导入依赖默认不需要写版本号了。
  11.        （当前没有在dependencies里面管理的依赖自然需要声明版本号）
  12.     -->
  13.     <parent>
  14.         <groupId>org.springframework.boot</groupId>
  15.         <artifactId>spring-boot-starter-parent</artifactId>
  16.         <version>2.3.3.RELEASE</version>
  17.     </parent>
  18.     <dependencies>
  19.         <!-- 
  20.             spring-boot-starter是Spring Boot的核心启动器。
  21.             只要引入官方提供的starter，就可以将此模块中的相关jar都导入进来。
  22.             官方的starter命名规范是：spring-boot-starter-模块名
  23.             所以，下面配置会将web开发相关jar都导入进来，并自动管理版本信息。
  24.         -->
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-web</artifactId>
  28.         </dependency>
  29.     </dependencies>
  30. </project>

2.1.3.添加工程主启动类

在类路径下创建HelloApplication.java文件

  1. package com.neusoft.boot;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class HelloApplication {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(HelloApplication.class, args);
  8.     }
  9. }

注意：

  1. @SpringBootApplication注解指定该类为SpringBoot的程序入口类。
  2. SpringBoot项目的Bean默认装配规则是：根据入口类所在包位置从上往下扫描。
    例如：如果DemoApplication类所在的包为：com.neusoft.demo；那么就会自动扫描com.neusoft.demo 包及其所有子包，否则不会被扫描！
    所以，应将SpringBoot的程序入口类放到mapper、service所在包的上级。
  3. SpringApplication类中的run方法会对当前SpringBoot工程进程初始化创建。

2.1.4.创建Controller

在 HelloApplication.java 所在包下创建controller包，然后创建Controller。

  1. package com.neusoft.boot.controller;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4. @RestController
  5. public class HelloController {
  6.     @RequestMapping("/hello")
  7.     public String say(){          //可以直接返回对象或集合，客户端将接收到json数据
  8.         return "hello...";
  9.     }
  10. }

@RestController 注解标识当前类为Controller组件，并且直接响应json数据。

2.1.5.测试

执行HelloApplication类的入口方法，SpringApplication类中的run方法就会启动当前的SpringBoot工程。

  1. Tomcat started on port(s): 8080 (http) with context path ''
  2. Started DemoApplication in 4.292 seconds (JVM running for 5.15)

当控制台输出上述内容时，表示SpringBoot工程启动成功。 在地址栏中输入url进行访问测试：
SpringBoot框架 - 图2

注意：SpringBoot内嵌了Tomcat，所以只需要运行SpringBoot工程的主启动类即可。

2.1.6.工程目录结构

SpringBoot框架 - 图3

2.2.使用Spring Initializr创建工程

上面案例中，我们自己手动搭建了一个SpringBoot框架。实际上，为了实现快速开发，SpringBoot官方给我们提供了一个初始化器，可以引导我们快速构建一个SpringBoot工程。

2.2.1.使用官方工具生成工程

打开 SpringBoot 官网：https://spring.io/projects/spring-boot/； 在网站的下部有 Spring Initializr 的链接。
SpringBoot框架 - 图4
点击此链接，进入到工程引导页面：
SpringBoot框架 - 图5

注意：

  1. 引导页面的左部，设置工程属性及版本信息等内容。右部设置工程所添加的依赖jar包。
  2. Packaging 处选择 Jar 形式。（因为SpringBoot 内置服务器，不需要打成 war 包）
  3. 因为我们想要创建web工程，所以添加 Spring Web 依赖模块。
  4. 最后，点击 “GENERATE” 按钮，生成整个工程。

2.2.2.工程目录结构

先使用IDE导入工程（这里使用STS导入此Maven工程）。
SpringBoot框架 - 图6

注意： mvnw是一个maven wrapper script（Maven包装脚本），它可以让你在没有安装maven或者maven版本不兼容的条件下运行maven的命令。

2.2.3.pom.xml文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <!-- pom模型版本 -->
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <parent>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-parent</artifactId>
  9.         <version>2.3.3.RELEASE</version>
  10.         <relativePath/> <!-- lookup parent from repository -->
  11.     </parent>
  12.     <!-- 项目信息 -->
  13.     <groupId>com.neusoft</groupId>
  14.     <artifactId>demo</artifactId>
  15.     <version>0.0.1-SNAPSHOT</version>
  16.     <name>demo</name>
  17.     <description>Demo project for Spring Boot</description>
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.         <!-- 配置工程字符编码集 -->
  21.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  22.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  23.     </properties>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-web</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-test</artifactId>
  32.             <scope>test</scope>
  33.             <exclusions>
  34.                 <exclusion>
  35.                     <groupId>org.junit.vintage</groupId>
  36.                     <artifactId>junit-vintage-engine</artifactId>
  37.                 </exclusion>
  38.             </exclusions>
  39.         </dependency>
  40.     </dependencies>
  41.     <!-- 配置SpringBoot的Maven插件 -->
  42.     <build>
  43.         <plugins>
  44.             <plugin>
  45.                 <groupId>org.springframework.boot</groupId>
  46.                 <artifactId>spring-boot-maven-plugin</artifactId>
  47.             </plugin>
  48.         </plugins>
  49.     </build>
  50. </project>

2.2.4.工程主启动类

  1. package com.neusoft.demo;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class DemoApplication {
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(DemoApplication.class, args);
  8.     }
  9. }

2.2.5.创建Controller

在 DemoApplication.java 所在包下创建controller包，然后创建Controller。

  1. package com.neusoft.demo.controller;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4. @RestController
  5. public class UserController {
  6.     @RequestMapping("/hello")
  7.     public String say() {
  8.         return "hello...";
  9.     }
  10. }

2.2.6.测试

执行 DemoApplication类的入口方法，然后在地址栏中输入url进行访问测试。

2.3.使用STS创建工程

2.3.1.创建Spring Starter Project工程

SpringBoot框架 - 图7

2.3.2.添加工程信息

SpringBoot框架 - 图8

注意：这里添加Maven工程需要的一些信息

2.3.3.添加版本及依赖信息

SpringBoot框架 - 图9

注意：这里添加SpringBoot版本信息、添加的依赖信息。然后点击 “Finish” 。

2.3.4.生成SpringBoot工程

工程创建完成后，我们会发现：创建的工程与使用 Spring Initializr 创建的工程是完全一样的。

2.4.SpringBoot热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间，我们可以在修改代码后不重启就能生效，在 pom.xml 中添加如下配置就可以实现这样的功能，我们称之为热部署。

  1. <!--热部署配置-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5. </dependency>

2.5.SpringBoot的跨域处理

除了使用传统的过滤器来设置跨域处理配置之外，SpringBoot还给我们提供了两种跨域处理方式：

  1. 使用 @CrossOrigin 注解配置某一个 Controller 允许跨域。

    1. //只要在此Controller上使用@CrossOrigin注解就可实现跨域访问，并可配置允许跨域的url
    2. @CrossOrigin("*") 
    3. @RestController
    4. public class DeptController { //... }

  2. 实现 WebMvcConfigurer 接口中的 addCorsMappings 方法，在此方法中配置全局跨域处理。
    在工程中添加 WebMvcConfig 类。此类配置了 @Configuration 注解，就成为一个 Spring 容器类，工程启动时会自动加载此类中的配置。

    1. package com.neusoft.demo;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.web.servlet.config.annotation.CorsRegistry;
    4. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    5. @Configuration
    6. public class WebMvcConfig implements WebMvcConfigurer {
    7.  @Override
    8.  public void addCorsMappings(CorsRegistry registry) {
    9.      /*
    10.       * addMapping：配置可以被跨域的路径，可以任意配置，可以具体到直接请求路径。 
    11.       * allowCredentials：是否开启Cookie
    12.       * allowedMethods：允许的请求方式，如：POST、GET、PUT、DELETE等。
    13.       * allowedOrigins：允许访问的url，可以固定单条或者多条内容
    14.       * allowedHeaders：允许的请求header，可以自定义设置任意请求头信息。 
    15.       * maxAge：配置预检请求的有效时间
    16.       */
    17.      registry.addMapping("/**")
    18.              .allowedOrigins("*")
    19.              .allowCredentials(true)
    20.              .allowedMethods("*")
    21.              .allowedHeaders("*")
    22.              .maxAge(36000);
    23.  }
    24. }

    2.6.@RequestBody实现参数序列化

    前端使用 AJAX 的 post 方式请求时，需要对请求参数做序列化处理，否则 SpringMVC 无法接收提交参数。

    1. //使用qs模块中的stringify方法实现post提交时的参数序列化
    2. this.$axios.post('http://localhost:8080/hello', this.$qs.stringify(user))...

    在 SpringBoot 中，可以使用 @RequestBody 注解，在服务器端实现 post 提交时的参数序列化处理。这样，前端的 post 请求就可以直接提交 json 对象了。

    1. @RequestMapping("/hello")
    2. //在参数前使用@RequestBody注解
    3. public String say(@RequestBody User user) {
    4.  System.out.println(user);
    5.  return "hello...";
    6. }
    1. let user = {
    2.  userId: 1,
    3.  userName: 'zhangsan',
    4.  password: '123'
    5. };
    6. axios.post('http://localhost:8080/elm/hello',user)
    7.  .then(response => {
    8.      console.log(response.data);
    9.  }).catch(error => {
    10.      console.log(error);
    11.  });

    @RequestBody 注解很强大，它甚至于可以直接接收 json 数组。

    1. @RequestMapping("/hello")
    2. //使用集合接收json数组
    3. public String say(@RequestBody List<User> list) {
    4.  for(User user : list) {
    5.      System.out.println(user);
    6.  }
    7.  return "hello...";
    8. }
    1. let userArr = [{
    2.  userId: 1,
    3.  userName: '张三',
    4.  password: '123'
    5. }, {
    6.  userId: 2,
    7.  userName: '李四',
    8.  password: '888'
    9. }, {
    10.  userId: 3,
    11.  userName: '王五',
    12.  password: '999'
    13. }]
    14. axios.post('http://localhost:8080/elm/hello', userArr)
    15.  .then(response => {
    16.      console.log(response.data);
    17.  }).catch(error => {
    18.      console.log(error);
    19.  });

    注意：@RequestBody 注解不支持get方式请求

3.SpringBoot原理分析

3.1.起步依赖原理解析

3.1.1.分析spring-boot-starter-parent

按住Ctrl键，然后点击pom.xml中的spring-boot-starter-parent，跳转到了spring-boot-starter-parent的pom.xml，xml配置如下（只摘抄了部分重点配置）：

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-dependencies</artifactId>
  4.     <version>2.3.3.RELEASE</version>
  5.     <relativePath>../../spring-boot-dependencies</relativePath>
  6. </parent>

按住Ctrll键，然后点击pom.xml中的spring-boot-starter-dependencies，跳转到了spring-boot-starter-dependencies的pom.xml，xml配置如下（只摘抄了部分重点配置）：

  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.       <build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
  11.       <byte-buddy.version>1.7.11</byte-buddy.version>
  12.       ... ... ...
  13. </properties>
  14. <dependencyManagement>
  15.       <dependencies>
  16.           <dependency>
  17.             <groupId>org.springframework.boot</groupId>
  18.             <artifactId>spring-boot</artifactId>
  19.             <version>2.3.1.RELEASE</version>
  20.           </dependency>
  21.           <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-test</artifactId>
  24.             <version>2.3.3.RELEASE</version>
  25.           </dependency>
  26.           ... ... ...
  27.     </dependencies>
  28. </dependencyManagement>
  29. <build>
  30.       <pluginManagement>
  31.         <plugins>
  32.               <plugin>
  33.                 <groupId>org.jetbrains.kotlin</groupId>
  34.                 <artifactId>kotlin-maven-plugin</artifactId>
  35.                 <version>${kotlin.version}</version>
  36.               </plugin>
  37.               <plugin>
  38.                 <groupId>org.jooq</groupId>
  39.                 <artifactId>jooq-codegen-maven</artifactId>
  40.                 <version>${jooq.version}</version>
  41.               </plugin>
  42.               <plugin>
  43.                 <groupId>org.springframework.boot</groupId>
  44.                 <artifactId>spring-boot-maven-plugin</artifactId>
  45.                 <version>2.3.3.RELEASE</version>
  46.               </plugin>
  47.               ... ... ...
  48.         </plugins>
  49.       </pluginManagement>
  50. </build>

从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、> > 依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后> > 已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。

3.1.2.分析spring-boot-starter-web

按住Ctrll键，然后点击pom.xml中的spring-boot-starter-web，跳转到了spring-boot-starter-web的pom.xml，xml配置如下（只摘抄了部分重点配置）：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  4.       <modelVersion>4.0.0</modelVersion>
  5.       <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starters</artifactId>
  8.         <version>2.3.3.RELEASE</version>
  9.       </parent>
  10.       <groupId>org.springframework.boot</groupId>
  11.       <artifactId>spring-boot-starter-web</artifactId>
  12.       <version>2.3.3.RELEASE</version>
  13.       <name>Spring Boot Web Starter</name>
  14.       <dependencies>
  15.         <dependency>
  16.               <groupId>org.springframework.boot</groupId>
  17.               <artifactId>spring-boot-starter</artifactId>
  18.               <version>2.3.3.RELEASE</version>
  19.               <scope>compile</scope>
  20.         </dependency>
  21.         <dependency>
  22.               <groupId>org.springframework.boot</groupId>
  23.               <artifactId>spring-boot-starter-json</artifactId>
  24.               <version>2.3.3.RELEASE</version>
  25.               <scope>compile</scope>
  26.         </dependency>
  27.         <dependency>
  28.               <groupId>org.springframework.boot</groupId>
  29.               <artifactId>spring-boot-starter-tomcat</artifactId>
  30.               <version>2.3.3.RELEASE</version>
  31.               <scope>compile</scope>
  32.         </dependency>
  33.         <dependency>
  34.               <groupId>org.hibernate.validator</groupId>
  35.               <artifactId>hibernate-validator</artifactId>
  36.               <version>6.0.9.Final</version>
  37.               <scope>compile</scope>
  38.         </dependency>
  39.         <dependency>
  40.               <groupId>org.springframework</groupId>
  41.               <artifactId>spring-web</artifactId>
  42.               <version>5.2.8.RELEASE</version>
  43.               <scope>compile</scope>
  44.         </dependency>
  45.         <dependency>
  46.               <groupId>org.springframework</groupId>
  47.               <artifactId>spring-webmvc</artifactId>
  48.               <version>5.2.8.RELEASE</version>
  49.               <scope>compile</scope>
  50.         </dependency>
  51.       </dependencies>
  52. </project>

从上面的spring-boot-starter-web的pom.xml中我们可以发现，spring-boot-starter-web就是将> web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”，这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的作用。

3.2.自动配置原理解析

按住Ctrll键，然后点击查看启动类DemoApplication上的注解@SpringBootApplication

  1. @SpringBootApplication
  2. public class DemoApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(DemoApplication.class, args);
  5.     }
  6. }

注解@SpringBootApplication的源码

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Inherited
  5. @SpringBootConfiguration
  6. @EnableAutoConfiguration
  7. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  8.         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
  9. public @interface SpringBootApplication {  //...  }

@SpringBootConfiguration：等同与@Configuration，既标注该类是Spring的一个配置类@EnableAutoConfiguration：SpringBoot自动配置功能开启 @ComponentScan：定义扫描路径，从中找出标识了需要装配的类，并自动装配到spring容器中

3.3.处理器配置原理解析

按住Ctrll键，然后点击查看处理器类 UserController上的注解@RestController

  1. @RestController
  2. public class UserController { }

注解@RestController的源码

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Controller
  5. @ResponseBody
  6. public @interface RestController { //... }

可以看到：@RestController注解就相当于：@Controller+@ResponseBody

4.SpringBoot工程配置文件

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用SpringBoot配置文件进行配置。
SpringBoot配置文件有两种：properties文件形式、yml文件形式。SpringBoot默认会从Resources目录下加载application.properties或application.yml文件。

4.1.application.properties配置文件

下面是一个 application.properties 配置文件实例：

  1. ## 修改服务器启动端口
  2. server.port=8080
  3. ## 设置应用程序访问上下文路径
  4. server.servlet.context-path=/elm
  5. ## 设置SpringBoot日志输出级别（error、warn、info、debug）
  6. logging.level.org.springframework=debug

4.2.application.yml配置文件

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

  1. server:
  2.     port: 8080
  3.     servlet:
  4.         context-path: /elm
  5. logging:
  6.     level:
  7.         org.springframework: debug

yml文件基本语法：

  1. 大小写敏感
  2. 使用缩进表示层级关系（缩进的空格数并不重要，只要相同层级的元素左对齐即可）
  3. 缩进不允许使用tab，只允许空格
  4. 冒号后必须要有一个空格
  5. 使用 # 作为注释

4.3.SpringBoot配置信息的查询

上面提及过，SpringBoot的配置文件，主要的目的就是对配置信息进行修改的，但在配置时的key从哪里去查询呢？我们可以查阅SpringBoot的官方文档文档URL： https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/#common-application-properties 常用的配置摘抄如下：

  1. # QUARTZ SCHEDULER (QuartzProperties)
  2. spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
  3. spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql # Path to the SQL file to use to initialize the database schema.
  4. spring.quartz.job-store-type=memory # Quartz job store type.
  5. spring.quartz.properties.*= # Additional Quartz Scheduler properties.
  6. # ----------------------------------------
  7. # WEB PROPERTIES
  8. # ----------------------------------------
  9. # EMBEDDED SERVER CONFIGURATION (ServerProperties)
  10. server.port=8080 # Server HTTP port.
  11. server.servlet.context-path= # Context path of the application.
  12. server.servlet.path=/ # Path of the main dispatcher servlet.
  13. # HTTP encoding (HttpEncodingProperties)
  14. spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to the "Content-Type" header if not set explicitly.
  15. # JACKSON (JacksonProperties)
  16. spring.jackson.date-format= # Date format string or a fully-qualified date format class name. For instance, `yyyy-MM-dd HH:mm:ss`.
  17. # SPRING MVC (WebMvcProperties)
  18. spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher servlet.
  19. spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
  20. spring.mvc.view.prefix= # Spring MVC view prefix.
  21. spring.mvc.view.suffix= # Spring MVC view suffix.
  22. # DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
  23. spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
  24. spring.datasource.password= # Login password of the database.
  25. spring.datasource.url= # JDBC URL of the database.
  26. spring.datasource.username= # Login username of the database.

4.4.@Value注解

我们可以通过@Value注解，将配置文件中的值映射到一个Spring管理的Bean的属性上。

  1. @RestController
  2. public class DeptController {
  3.     //server.port 就是SpringBoot配置文件中的一个值
  4.     @Value("${server.port}")
  5.     private int port;
  6.     @Autowired
  7.     private DeptService deptService;
  8.     @RequestMapping("/listDept")
  9.     public List<Dept> listDept(){
  10.         System.out.println("端口："+port);
  11.         return deptService.listDept();
  12.     }
  13. }

将@Value注解放置在一个属性上，就可以使用它获取SpringBoot配置文件中的值。

5.SpringBoot整合MyBatis

5.1.添加MyBatis相关依赖

  1. <dependency>
  2.     <groupId>org.mybatis.spring.boot</groupId>
  3.     <artifactId>mybatis-spring-boot-starter</artifactId>
  4.     <version>2.0.1</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>mysql</groupId>
  8.     <artifactId>mysql-connector-java</artifactId>
  9.     <version>5.1.6</version>
  10.     <scope>runtime</scope>
  11. </dependency>

5.2.添加MyBatis相关配置

在application.properties配置文件中配置MyBatis相关信息

  1. server.port=8080
  2. server.servlet.context-path=/elm
  3. logging.level.org.springframework=debug
  4. ## 配置mapper输出日志级别
  5. logging.level.com.neusoft.demo.mapper=debug
  6. ## 配置数据源信息
  7. spring.datasource.username=root
  8. spring.datasource.password=123
  9. spring.datasource.url=jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  10. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  11. ## 配置mapper映射文件路径
  12. mybatis.mapper-locations=classpath:mapper/*.xml
  13. ## 配置扫描实体包，给实体类设置别名
  14. mybatis.type-aliases-package=com.neusoft.demo.po

也可以使用application.yml形式配置文件进行MyBatis相关配置：

  1. server:
  2.     port: 8080
  3.     servlet:
  4.         context-path: /elm
  5. logging:
  6.     level:
  7.         org.springframework: debug
  8.         com.neusoft.demo.mapper: debug
  9. spring:
  10.     datasource:
  11.         driver-class-name: com.mysql.jdbc.Driver
  12.         url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
  13.         username: root
  14.         password: 123
  15. mybatis:
  16.     mapper-locations: classpath:mapper/*.xml
  17.     type-aliases-package: com.neusoft.demo.po

5.3.创建mapper接口

  1. @Mapper
  2. public interface DeptMapper {
  3.     @Select("select * from dept order by deptno")
  4.     public List<Dept> listDept();
  5. }

注意：必须要使用 @Mapper 标识此mapper接口

5.4.创建service接口与实现类

  1. public interface DeptService {
  2.     public List<Dept> listDept();
  3. }
  1. @Service
  2. public class DeptServiceImpl implements DeptService{
  3.     @Autowired
  4.     private DeptMapper deptMapper;
  5.     @Override
  6.     public List<Dept> listDept() {
  7.         return deptMapper.listDept();
  8.     }
  9. }

5.5.创建controller

  1. @RestController
  2. public class DeptController {
  3.     @Autowired
  4.     private DeptService deptService;
  5.     @RequestMapping("/listDept")
  6.     public List<Dept> listDept(){
  7.         return deptService.listDept();
  8.     }
  9. }

5.6.测试

  1. <script src="https://unpkg.com/axios/dist/axios.js"></script>
  2. <script>
  3.     axios.post('http://localhost:8080/elm/listDept')
  4.         .then(response => {
  5.             console.log(response.data);
  6.         }).catch(error => {
  7.             console.log(error);
  8.         });    
  9. </script>


本章作业

  1. SpringBoot与SpringMVC的区别?
  2. 简述SpringBoot的特点？
  3. 简述SpringBoot的核心功能？
  4. 简述@RequestBody 注解的功能？
  5. 简述yml文件的基本语法？
  6. 什么是 Spring Boot Stater？
  7. 什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?
  8. 编程题：
    1. 使用SpringBoot+MyBatis集成框架实现一个登录案例。
    2. 使用前后端分离的模式实现。
    3. 服务器端要有数据层组件、业务层组件、控制层组件。
    4. 数据层组件使用MyBatis框架完成对数据库的操作。
    5. 控制层组件要向前端返回json数据。
    6. 前端使用ajax请求，并通过服务器端返回的json数据来判断是否登录成功。