Spring Boot(一)

       Spring Boot是一个开源的Java框架，旨在简化基于Java的应用程序的开发和部署过程。它提供了许多开箱即用的功能和工具，使开发者能够快速构建独立、可执行的、生产级别的应用程序。

以下是Spring Boot的一些主要特点和优势：

• 简化的配置：Spring Boot采用了约定优于配置的原则，通过自动配置和默认值减少了开发者在配置方面的工作量。它提供了内置的默认配置，可以根据需要进行覆盖，同时还支持外部化配置，使得应用程序的配置变得非常灵活。

• 内嵌式容器：Spring Boot可以将应用程序打包成一个可执行的JAR文件，其中包含了一个内嵌的Servlet容器（如Tomcat、Jetty或Undertow）。这意味着开发者不需要部署WAR文件到独立的Servlet容器中，而可以直接运行JAR文件，使得应用程序的部署变得非常简单。

• 自动化依赖管理：Spring Boot使用了“起步依赖”（Starter Dependency）的概念，它是一种预定义的依赖关系集合，可快速获取常用的库和框架。通过引入适当的起步依赖，开发者不需要手动管理依赖关系和版本冲突，Spring Boot会自动根据项目的需求解析和配置依赖项。

• 简化的错误处理：Spring Boot提供了一种简化的方式来处理错误，通过自动配置的全局异常处理器，开发者可以捕获和处理应用程序中的异常。此外，Spring Boot还提供了友好的错误页面和统一的错误消息格式，方便开发者在出现错误时进行调试和排查。

• 健康检查和指标监控：Spring Boot内置了健康检查和指标监控的功能，通过使用Actuator模块，开发者可以方便地暴露应用程序的健康状态、性能指标和管理端点，实现对应用程序的监控和管理。

        总之，Spring Boot通过简化配置、内嵌式容器、自动化依赖管理、简化的错误处理以及健康检查和指标监控等特性，提供了一种快速、便捷和高效的方式来构建Java应用程序。它成为了Java开发者非常受欢迎的框架之一，被广泛应用于各种类型的项目和企业级应用开发中。

1、自动化依赖管理

1.1、parent：

        在项目开发中，我们很多的时候出现的问题都是jar包版本，依赖之间的版本兼容问题。parent自身具有很多个版本，每个parent版本中包含有几百个其他技术的版本号，不同的parent间使用的各种技术的版本号有可能会发生变化。当开发者使用某些技术时，直接使用SpringBoot提供的parent就行了，由parent帮助开发者统一的进行各种技术的版本管理。

        这里讲一下，在声明的依赖中的版本是固定的，是经过测试后这写版本组合在一起使用是没有问题的，然后spingboot只是声明啦，并不是一股脑的把依赖一股脑的都引入到我们的项目，我们只需要在开发的时候选择我们想要的依赖引入就可以，而且不用指定版本号，因为springboot给我们管理这些依赖。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
</parent>

        我们只需要在创建完项目的时候引入就可以啦！然后查看内部的结构其实际上是依赖啦下面的依赖管理。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.4</version>
</parent>

1.2、starter：

        SpringBoot关注到实际开发时，开发者对于依赖坐标的使用往往都有一些固定的组合方式，比如使用spring-webmvc就一定要使用spring-web。每次都要固定搭配着写，非常繁琐，而且格式固定，没有任何技术含量。starter定义了使用某种技术时对于依赖的固定搭配格式，也是一种最佳解决方案，使用starter可以帮助开发者减少依赖配置。

        实际上就是如果你使用的某一个技术，然后这个技术使用的所有的依赖进行一个打包，然后我们只需要引入这个打包好的依赖就可以啦。

开发web项目：导入

<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.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-json</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

1.3、starter与parent的区别

        starter与parent好像都是帮助我们简化配置的，starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的。parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的。

实际开发应用方式

• 实际开发中如果需要用什么技术，先去找有没有这个技术对应的starter

  • 如果有对应的starter，直接写starter，而且无需指定版本，版本由parent提供

  • 如果没有对应的starter，手写坐标即可

• 实际开发中如果发现坐标出现了冲突现象，确认你要使用的可行的版本号，使用手工书写的方式添加对应依赖，覆盖SpringBoot提供给我们的配置管理

  • 方式一：直接写坐标

  • 方式二：覆盖<properties>中定义的版本号，就是下面这堆东西了，哪个冲突了覆盖哪个就OK了

2、引导类

        配置说完了，我们发现SpringBoot确实帮助我们减少了很多配置工作，下面说一下程序是如何运行的。目前程序运行的入口就是SpringBoot工程创建时自带的那个类，也就是带有main方法的那个类，运行这个类就可以启动SpringBoot工程的运行。

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

        SpringBoot本身是为了加速Spring程序的开发的，而Spring程序运行的基础是需要创建Spring容器对象（IoC容器）并将所有的对象放置到Spring容器中管理，也就是一个一个的Bean。现在改用SpringBoot加速开发Spring程序，这个容器还在吗？这个疑问不用说，一定在。其实当前这个类运行后就会产生一个Spring容器对象，并且可以将这个对象保存起来，通过容器对象直接操作Bean。

@SpringBootApplication
public class QuickstartApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext IOC = SpringApplication.run(QuickstartApplication.class, args);
        BookController bean = IOC.getBean(BookController.class);
        System.out.println(bean);
    }
}

        通过上述操作不难看出，其实SpringBoot程序启动还是创建了一个Spring容器对象。当前运行的这个类在SpringBoot程序中是所有功能的入口，称为引导类。

        作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication。SpringBoot工程提供引导类用来启动程序，工程启动后创建并初始化Spring容器。

3、内置tomcat

        我们创建一个web项目引入spring-boot-starter-web依赖，然后这个依赖有包含啦spring-boot-starter-tomcat，然后这个依赖中包含啦有关tomcat的依赖。

<dependencies>
    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>1.3.5</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-annotations-api</artifactId>
                <groupId>org.apache.tomcat</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-el</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-websocket</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-annotations-api</artifactId>
                <groupId>org.apache.tomcat</groupId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

        当然也可以更换内置的服务器，只需要排除依赖，然后引入对用的服务器依赖SpringBoot提供了3款内置的服务器：

• tomcat(默认)：apache出品，粉丝多，应用面广，负载了若干较重的组件

• jetty：更轻量级，负载性能远不及tomcat

• undertow：负载性能勉强跑赢tomcat

4、基础配置

        其实在SpringBoot中的配置基本上也不用修改什么，除非你想个人定制一些特别的，然后你才要修改默认配置，按照自己的需求修改就好啦。总之需要什么配什么

1. SpringBoot程序可以在配置文件中进行属性配置

2. application.properties文件中只要输入要配置的属性关键字就可以根据提示进行设置

3. SpringBoot将配置信息集中在一个文件中写，不管你是服务器的配置，还是数据库的配置，总之都写在一起，逃离一个项目十几种配置文件格式的尴尬局面

4.1、配置文件

        现在已经能够进行SpringBoot相关的配置了，但是properties格式的配置写起来总是觉得看着不舒服，所以就期望存在一种书写起来更简便的配置格式提供给开发者使用。有吗？还真有，SpringBoot除了支持properties格式的配置文件，还支持另外两种格式的配置文件。三种配置文件格式分别如下:

• properties格式

• yml格式

• yaml格式

        其中properties的没有层级的格式，然后写配置文件比较多的时候不是很好看，读起来不是很方便，然后yml和yaml的格式是一致的，就一个文件后缀不一样而已。

配置文件优先级

application.properties > application.yml > application.yaml

        虽然是这样的，但是我们其实没有必要去写三个配置文件，这不是没事找事嘛！然后不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

4.2、yaml语法

        YAML（YAML Ain't Markup Language），一种数据序列化格式。具有容易阅读、容易与脚本语言交互、以数据为核心，重数据轻格式的特点。常见的文件扩展名有两种：

• .yml格式（主流）

• .yaml格式

  具体的语法格式要求如下：

1. 大小写敏感

2. 属性层级关系使用多行描述，每行结尾使用冒号结束

3. 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）

4. 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）

5. #号 表示注释

users:							 #对象数组格式一
  - name: Tom
   	age: 4
  - name: Jerry
    age: 5
users:							 #对象数组格式二
  -  
    name: Tom
    age: 4
  -   
    name: Jerry
    age: 5			    
users2: [ { name:Tom , age:4 } , { name:Jerry , age:5 } ]	#对象数组缩略格式

4.3、yaml数据读取

yaml文件中对于数字的定义支持进制书写格式，如需使用字符串请使用引号明确标注

4.3.1、读取单一数据

        yaml中保存的单个数据，可以使用Spring中的注解@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

4.3.2、读取全部数据

        读取单一数据可以解决读取数据的问题，但是如果定义的数据量过大，这么一个一个书写肯定会累死人的，SpringBoot提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中。

        数据封装到了Environment对象中，获取属性时，通过Environment的接口操作进行，具体方法是getProperties（String），参数填写属性名即可

4.3.3、读取对象数据

        单一数据读取书写比较繁琐，全数据读取封装的太厉害了，每次拿数据还要一个一个的getProperties（）,总之用起来都不是很舒服。由于Java是一个面向对象的语言，很多情况下，我们会将一组数据封装成一个对象。SpringBoot也提供了可以将一组yaml对象数据封装一个Java对象的操作

        首先定义一个对象，并将该对象纳入Spring管控的范围，也就是定义成一个bean，然后使用注解@ConfigurationProperties指定该对象加载哪一组yaml中配置的信息。

        这个@ConfigurationProperties必须告诉他加载的数据前缀是什么，这样指定前缀下的所有属性就封装到这个对象中。记得数据属性名要与对象的变量名一一对应啊，不然没法封装。其实以后如果你要定义一组数据自己使用，就可以先写一个对象，然后定义好属性，下面到配置中根据这个格式书写即可。

        但是有时候没有提示，没提示就算啦而且还会报错，我刚开始以为是我有两个配置文件，一个是properties一个是yml，两个冲突啦，然后删掉一个也没有用。

4.3.4、yaml文件中的数据引用

        在文件中如果有大量的重复的字段，然后其他的字段又使用啦这个字段，就比如

center:
	dataDir: D:/usr/local/fire/data
    tmpDir: D:/usr/local/fire/tmp
    logDir: D:/usr/local/fire/log
    msgDir: D:/usr/local/fire/msgDir

这个时候你可以使用引用格式来定义数据，其实就是搞了个变量名，然后引用变量了，格式如下：

baseDir: D:/usr/local/fire
center:
    dataDir: ${baseDir}/data
    tmpDir: ${baseDir}/tmp
    logDir: ${baseDir}/log
    msgDir: ${baseDir}/msgDir

         还有一个注意事项，在书写字符串时，如果需要使用转义字符，需要将数据字符串使用双引号包裹起来。

lesson: "Spring\tboot\nlesson"

5、整合第三方技术：

5.1、整合JUnit：

        在Spring阶段就又关于Spring6整合Junit4、以及整合Junit5的方式，引入不同的jar包，测试类使用不同的注解。

spring整合junit4

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class TestJunit4 {
    @Autowired
    private User user;
    @Test
    public void  test1(){
        System.out.println(user.getName());
    }
}

spring整合junit5

/*@ContextConfiguration("classpath:spring.xml")
@ExtendWith(SpringExtension.class)*/
//写法二
@SpringJUnitConfig(locations = "classpath:spring.xml")
public class TestJunit5 {
    @Autowired
    private User user;
    @Test
    public void  test1(){
        System.out.println(user.getName());
    }
}

        第一个注解@RunWith是设置Spring专用的测试类运行器，简单说就是Spring程序执行程序有自己的一套独立的运行程序的方式，不能使用JUnit提供的类运行方式了，必须指定一下，但是格式是固定的，琢磨一下，每次都指定一样的东西，这个东西写起来没有技术含量啊，第二个注解@ContextConfiguration是用来设置Spring核心配置文件或配置类的，简单说就是加载Spring的环境你要告诉Spring具体的环境配置是在哪里写的。

        然后经过springboot的简化后，只需要一个注解@springBootTest

@SpringBootTest
class SpringBootDemo1ApplicationTests {
    @Test
    void contextLoads() {
    }
}

        如果测试类和引导类在同一个路径下，使用一个注解就可以，但是如果不在同一个路径下，那么就需要指定引导类，可以这样写：

@SpringBootTest(classes = Springboot04JunitApplication.class)

或者使用

@ContextConfiguration(classes = Springboot04JunitApplication.class)
@SpringBootTest

都可以实现整合junit测试。

5.2、整合MyBatis

5.2.1、导入依赖：

<!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        <!--数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>3.0.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
    </dependencies>

5.2.2、核心配置文件

#配置数据库连接
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?&useSSL=false&serverTimezone=UTC
    username: root
    password: 10100109
#mybtis
mybatis:
  mapper-locations: classpath:/mapper/**.xml

        确实是不用配置什么，但是如果使用的是映射文件的话那么会出现找不到映射文件的请情况，确实很让人不解，mybatis-plus使用的时候还没有这些要指定映射文件。如果不指定的话就会报错！！！！，其他的倒没有什么特别的地方，我们也不需要特别的配置其他的东西。

5.3、整合MyBatis-Plus

5.3.1、导入依赖： 

     <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.4</version>
        </dependency>

MyBatis与MyBatisPlus这两个坐标的名字书写比较特殊，是第三方技术名称在前，boot和starter在后。

starter所属	命名规则	示例
官方提供	spring-boot-starter-技术名称	spring-boot-starter-web spring-boot-starter-test
第三方提供	第三方技术名称-spring-boot-starter	mybatis-spring-boot-starter druid-spring-boot-starter
第三方提供	第三方技术名称-boot-starter（第三方技术名称过长，简化命名）	mybatis-plus-boot-starter

5.3.2、核心配置：

#mybatis_plus 没什么要配置的 预定大于配置

5.4、配置数据源

5.4.1、方式一：

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

5.4.2、方式二:

导入依赖

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.6</version>
    </dependency>
</dependencies>

配置文件: 

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root