• SpringBoot【基础篇】

    一、快速上手

    按照要求，左侧选择web，然后在中间选择Spring Web即可，选完右侧就出现了新的内容项，这就表示勾选成功了

    关注：此处选择的SpringBoot的版本使用默认的就可以了，需要说一点，SpringBoot的版本升级速度很快，可能昨天创建工程的时候默认版本是2.5.4，今天再创建工程默认版本就变成2.5.5了，差别不大，无需过于纠结，回头可以到配置文件中修改对应的版本

    开发控制器类

    1. //Rest模式
    2. @RestController
    3. @RequestMapping("/books")
    4. public class BookController {
    5.     @GetMapping
    6.     public String getById(){
    7.         System.out.println("springboot is running...");
    8.         return "springboot is running...";
    9.     }
    10. }

     入门案例制作的SpringMVC的控制器基于Rest风格开发，当然此处使用原始格式制作SpringMVC的程序也是没有问题的，上例中的@RestController与@GetMapping注解是基于Restful开发的典型注解

     关注：做到这里SpringBoot程序的最基础的开发已经做完了，现在就可以正常的运行Spring程序了。可能有些小伙伴会有疑惑，Tomcat服务器没有配置，=-Spring也没有配置，什么都没有配置这就能用吗？这就是SpringBoot技术的强大之处。关于内部工作流程后面再说，先专心学习开发过程

    二、SpringBoot简介

    SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

    都简化了了哪些东西呢？其实就是针对原始的Spring程序制作的两个方面进行了简化：

    • Spring程序缺点

      • 依赖设置繁琐

        • 以前写Spring程序，使用的技术都要自己一个一个的写，现在不需要了，如果做过原始SpringMVC程序的小伙伴应该知道，写SpringMVC程序，最基础的spring-web和spring-webmvc这两个坐标时必须的，就这还不包含你用json啊等等这些坐标，现在呢？一个坐标搞定面

      • 配置繁琐

        • 以前写配置类或者配置文件，然后用什么东西就要自己写加载bean这些东西，现在呢？什么都没写，照样能用

    SpringBoot的优点:

    再来看看前面提出的两个问题，已经有答案了，都简化了，都不用写了，这就是SpringBoot给我们带来的好处。这些简化操作在SpringBoot中有专业的用语，也是SpringBoot程序的核心功能及优点：

    • 起步依赖（简化依赖配置）

      • 依赖配置的书写简化就是靠这个起步依赖达成的

    • 自动配置（简化常用工程相关配置）

      • 配置过于繁琐，使用自动配置就可以做响应的简化，但是内部还是很复杂的，后面具体展开说

    • 辅助功能（内置服务器，……）

      • 除了上面的功能，其实SpringBoot程序还有其他的一些优势，比如我们没有配置Tomcat服务器，但是能正常运行，这是SpringBoot程序的一个可以感知到的功能，也是SpringBoot的辅助功能之一。一个辅助功能都能做的这么6，太牛了

    1.parent：减少依赖冲突【控制版本】

    其实很多开发者都一直想做一件事情，就是将各种各样的技术配合使用的常见依赖版本进行收集整理，制作出了最合理的依赖版本配置方案，这样使用起来就方便多了。

    将所有的技术版本的常见使用方案都给开发者整理了出来，以后开发者使用时直接用它提供的版本方案，就不用担心冲突问题了，相当于SpringBoot做了无数个技术版本搭配的列表，这个技术搭配列表的名字叫做parent。

    parent自身具有很多个版本，每个parent版本中包含有几百个其他技术的版本号，不同的parent间使用的各种技术的版本号有可能会发生变化。当开发者使用某些技术时，直接使用SpringBoot提供的parent就行了，由parent帮助开发者统一的进行各种技术的版本管理

    注意点：

    parent仅仅帮我们进行版本管理，它不负责帮你导入坐标，说白了用什么还是你自己定，只不过版本不需要你管理了。整体上来说，使用parent可以帮助开发者进行版本的统一管理

    源码查看：

    • 项目中的pom.xml中继承了一个坐标

    1. <parent>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starter-parentartifactId>
    4.     <version>2.5.4version>
    5. parent>

    • 打开后可以查阅到其中又继承了一个坐标

    1. <parent>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-dependenciesartifactId>
    4.     <version>2.5.4version>
    5. parent>

    • 这个坐标中定义了两组信息，第一组是各式各样的依赖版本号属性，下面列出依赖版本属性的局部，可以看的出来，定义了若干个技术的依赖版本号

    1. <properties>
    2.     <activemq.version>5.16.3activemq.version>
    3.     <aspectj.version>1.9.7aspectj.version>
    4.     <assertj.version>3.19.0assertj.version>
    5.     <commons-codec.version>1.15commons-codec.version>
    6.     <commons-dbcp2.version>2.8.0commons-dbcp2.version>
    7.     <commons-lang3.version>3.12.0commons-lang3.version>
    8.     <commons-pool.version>1.6commons-pool.version>
    9.     <commons-pool2.version>2.9.0commons-pool2.version>
    10.     <h2.version>1.4.200h2.version>
    11.     <hibernate.version>5.4.32.Finalhibernate.version>
    12.     <hibernate-validator.version>6.2.0.Finalhibernate-validator.version>
    13.     <httpclient.version>4.5.13httpclient.version>
    14.     <jackson-bom.version>2.12.4jackson-bom.version>
    15.     <javax-jms.version>2.0.1javax-jms.version>
    16.     <javax-json.version>1.1.4javax-json.version>
    17.     <javax-websocket.version>1.1javax-websocket.version>
    18.     <jetty-el.version>9.0.48jetty-el.version>
    19.     <junit.version>4.13.2junit.version>
    20. properties>

    第二组是各式各样的的依赖坐标信息，可以看出依赖坐标定义中没有具体的依赖版本号，而是引用了第一组信息中定义的依赖版本属性值

    1. <dependencyManagement>
    2.     <dependencies>
    3.         <dependency>
    4.             <groupId>org.hibernategroupId>
    5.             <artifactId>hibernate-coreartifactId>
    6.             <version>${hibernate.version}version>
    7.         dependency>
    8.         <dependency>
    9.             <groupId>junitgroupId>
    10.             <artifactId>junitartifactId>
    11.             <version>${junit.version}version>
    12.         dependency>
    13.     dependencies>
    14. dependencyManagement>
    注意点：

    上面的依赖坐标定义是出现在标签中的，其实是对引用坐标的依赖管理，并不是实际使用的坐标。因此当你的项目中继承了这组parent信息后，在不使用对应坐标的情况下，前面的这组定义是不会具体导入某个依赖的

    总结：

    1. 开发SpringBoot程序要继承spring-boot-starter-parent

    2. spring-boot-starter-parent中定义了若干个依赖管理

    3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突

    4. 继承parent的形式也可以采用引入依赖的形式实现效果

    2.starter：减少依赖配置

    使用starter可以帮助开发者减少依赖配置

    SpringMVC的使用

    • 项目中的pom.xml定义了使用SpringMVC技术，但是并没有写SpringMVC的坐标，而是添加了一个名字中包含starter的依赖

    1. <dependency>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starter-webartifactId>
    4. dependency>

    • 在spring-boot-starter-web中又定义了若干个具体依赖的坐标

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.bootgroupId>
    4.         <artifactId>spring-boot-starterartifactId>
    5.         <version>2.5.4version>
    6.         <scope>compilescope>
    7.     dependency>
    8.     <dependency>
    9.         <groupId>org.springframework.bootgroupId>
    10.         <artifactId>spring-boot-starter-jsonartifactId>
    11.         <version>2.5.4version>
    12.         <scope>compilescope>
    13.     dependency>
    14.     <dependency>
    15.         <groupId>org.springframework.bootgroupId>
    16.         <artifactId>spring-boot-starter-tomcatartifactId>
    17.         <version>2.5.4version>
    18.         <scope>compilescope>
    19.     dependency>
    20.     <dependency>
    21.         <groupId>org.springframeworkgroupId>
    22.         <artifactId>spring-webartifactId>
    23.         <version>5.3.9version>
    24.         <scope>compilescope>
    25.     dependency>
    26.     <dependency>
    27.         <groupId>org.springframeworkgroupId>
    28.         <artifactId>spring-webmvcartifactId>
    29.         <version>5.3.9version>
    30.         <scope>compilescope>
    31.     dependency>
    32. dependencies>

    之前提到过开发SpringMVC程序需要导入spring-webmvc的坐标和spring整合web开发的坐标，就是上面这组坐标中的最后两个了。

    但是我们发现除了这两个还有其他的，比如第二个，叫做spring-boot-starter-json。看名称就知道，这个是与json有关的坐标了，但是看名字发现和最后两个又不太一样，它的名字中也有starter，打开看看里面有什么？

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.bootgroupId>
    4.         <artifactId>spring-boot-starterartifactId>
    5.         <version>2.5.4version>
    6.         <scope>compilescope>
    7.     dependency>
    8.     <dependency>
    9.         <groupId>org.springframeworkgroupId>
    10.         <artifactId>spring-webartifactId>
    11.         <version>5.3.9version>
    12.         <scope>compilescope>
    13.     dependency>
    14.     <dependency>
    15.         <groupId>com.fasterxml.jackson.coregroupId>
    16.         <artifactId>jackson-databindartifactId>
    17.         <version>2.12.4version>
    18.         <scope>compilescope>
    19.     dependency>
    20.     <dependency>
    21.         <groupId>com.fasterxml.jackson.datatypegroupId>
    22.         <artifactId>jackson-datatype-jdk8artifactId>
    23.         <version>2.12.4version>
    24.         <scope>compilescope>
    25.     dependency>
    26.     <dependency>
    27.         <groupId>com.fasterxml.jackson.datatypegroupId>
    28.         <artifactId>jackson-datatype-jsr310artifactId>
    29.         <version>2.12.4version>
    30.         <scope>compilescope>
    31.     dependency>
    32.     <dependency>
    33.         <groupId>com.fasterxml.jackson.modulegroupId>
    34.         <artifactId>jackson-module-parameter-namesartifactId>
    35.         <version>2.12.4version>
    36.         <scope>compilescope>
    37.     dependency>
    38. dependencies>

    SpringBoot把我们开发中使用的东西能用到的都给提前做好了。你仔细看完会发现，里面有一些你没用过的。的确会出现这种过量导入的可能性，没关系，可以通过maven中的排除依赖剔除掉一部分。不过你不管它也没事，大不了就是过量导入呗。

    starter与parent的区别

    starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的

    parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的

    实际开发应用方式

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

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

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

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

      • 方式一：直接写坐标

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

    1. <properties>
    2.     <activemq.version>5.16.3activemq.version>
    3.     <aspectj.version>1.9.7aspectj.version>
    4.     <assertj.version>3.19.0assertj.version>
    5.     <commons-codec.version>1.15commons-codec.version>
    6.     <commons-dbcp2.version>2.8.0commons-dbcp2.version>
    7.     <commons-lang3.version>3.12.0commons-lang3.version>
    8.     <commons-pool.version>1.6commons-pool.version>
    9.     <commons-pool2.version>2.9.0commons-pool2.version>
    10.     <h2.version>1.4.200h2.version>
    11.     <hibernate.version>5.4.32.Finalhibernate.version>
    12.     <hibernate-validator.version>6.2.0.Finalhibernate-validator.version>
    13.     <httpclient.version>4.5.13httpclient.version>
    14.     <jackson-bom.version>2.12.4jackson-bom.version>
    15.     <javax-jms.version>2.0.1javax-jms.version>
    16.     <javax-json.version>1.1.4javax-json.version>
    17.     <javax-websocket.version>1.1javax-websocket.version>
    18.     <jetty-el.version>9.0.48jetty-el.version>
    19.     <junit.version>4.13.2junit.version>
    20. properties>

    温馨提示

    SpringBoot官方给出了好多个starter的定义，方便我们使用，而且名称都是如下格式

    命名规则：spring-boot-starter-技术名称

    总结

    1. 开发SpringBoot程序需要导入坐标时通常导入对应的starter

    2. 每个不同的starter根据功能不同，通常包含多个依赖坐标

    3. 使用starter可以实现快速配置的效果，达到简化配置的目的

    3.引导类

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

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

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

    1. @SpringBootApplication
    2. public class Springboot0101QuickstartApplication {
    3.     public static void main(String[] args) {
    4.         ConfigurableApplicationContext ctx = SpringApplication.run(Springboot0101QuickstartApplication.class, args);
    5.         BookController bean = ctx.getBean(BookController.class);
    6.         System.out.println("bean======>" + bean);
    7.     }
    8. }

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

    作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication

    总结

    1. SpringBoot工程提供引导类用来启动程序

    2. SpringBoot工程启动后创建并初始化Spring容器

    思考

    程序现在已经运行了，通过引导类的main方法运行了起来。但是运行java程序不应该是执行完就结束了吗？但是我们现在明显是启动了一个web服务器啊，不然网页怎么能正常访问呢？这个服务器是在哪里写的呢？

    4.内嵌tomcat

    当前我们做的SpringBoot入门案例勾选了Spirng-web的功能，并且导入了对应的starter。

    1. <dependency>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starter-webartifactId>
    4. dependency>

    Spring提供了一个Web服务器

    内嵌Tomcat定义位置

    说到定义的位置，我们就想，如果我们不开发web程序，用的着web服务器吗？肯定用不着啊。那如果这个东西被加入到你的程序中，伴随着什么技术进来的呢？肯定是web相关的功能啊，没错，就是前面导入的web相关的starter做的这件事。

    2.     org.springframework.boot
    3.     spring-boot-starter-web

    打开查看web的starter导入了哪些东西

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.bootgroupId>
    4.         <artifactId>spring-boot-starterartifactId>
    5.         <version>2.5.4version>
    6.         <scope>compilescope>
    7.     dependency>
    8.     <dependency>
    9.         <groupId>org.springframework.bootgroupId>
    10.         <artifactId>spring-boot-starter-jsonartifactId>
    11.         <version>2.5.4version>
    12.         <scope>compilescope>
    13.     dependency>
    14.     <dependency>
    15.         <groupId>org.springframework.bootgroupId>
    16.         <artifactId>spring-boot-starter-tomcatartifactId>
    17.         <version>2.5.4version>
    18.         <scope>compilescope>
    19.     dependency>
    20.     <dependency>
    21.         <groupId>org.springframeworkgroupId>
    22.         <artifactId>spring-webartifactId>
    23.         <version>5.3.9version>
    24.         <scope>compilescope>
    25.     dependency>
    26.     <dependency>
    27.         <groupId>org.springframeworkgroupId>
    28.         <artifactId>spring-webmvcartifactId>
    29.         <version>5.3.9version>
    30.         <scope>compilescope>
    31.     dependency>
    32. dependencies>

    第三个依赖就是这个tomcat对应的东西了，居然也是一个starter，再打开看看

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>jakarta.annotationgroupId>
    4.         <artifactId>jakarta.annotation-apiartifactId>
    5.         <version>1.3.5version>
    6.         <scope>compilescope>
    7.     dependency>
    8.     <dependency>
    9.         <groupId>org.apache.tomcat.embedgroupId>
    10.         <artifactId>tomcat-embed-coreartifactId>
    11.         <version>9.0.52version>
    12.         <scope>compilescope>
    13.         <exclusions>
    14.             <exclusion>
    15.                 <artifactId>tomcat-annotations-apiartifactId>
    16.                 <groupId>org.apache.tomcatgroupId>
    17.             exclusion>
    18.         exclusions>
    19.     dependency>
    20.     <dependency>
    21.         <groupId>org.apache.tomcat.embedgroupId>
    22.         <artifactId>tomcat-embed-elartifactId>
    23.         <version>9.0.52version>
    24.         <scope>compilescope>
    25.     dependency>
    26.     <dependency>
    27.         <groupId>org.apache.tomcat.embedgroupId>
    28.         <artifactId>tomcat-embed-websocketartifactId>
    29.         <version>9.0.52version>
    30.         <scope>compilescope>
    31.         <exclusions>
    32.             <exclusion>
    33.                 <artifactId>tomcat-annotations-apiartifactId>
    34.                 <groupId>org.apache.tomcatgroupId>
    35.             exclusion>
    36.         exclusions>
    37.     dependency>
    38. dependencies>

    tomcat-embed-core，叫做tomcat内嵌核心。就是这个东西把tomcat功能引入到了我们的程序中。

    内嵌Tomcat运行原理

    对象都可以交给Spring容器管理，tomcat服务器运行其实是以对象的形式在Spring容器中运行的

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.apache.tomcat.embedgroupId>
    4.         <artifactId>tomcat-embed-coreartifactId>
    5.         <version>9.0.52version>
    6.         <scope>compilescope>
    7.     dependency>
    8. dependencies>

    如果将这个Tomcat注释掉，则程序无法运行

    更换内嵌Tomcat

    SpringBoot提供了3款内置的服务器

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

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

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

    前提是把tomcat排除掉，因为tomcat是默认加载的。

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.springframework.bootgroupId>
    4.         <artifactId>spring-boot-starter-webartifactId>
    5.         <exclusions>
    6.             <exclusion>
    7.                 <groupId>org.springframework.bootgroupId>
    8.                 <artifactId>spring-boot-starter-tomcatartifactId>
    9.             exclusion>
    10.         exclusions>
    11.     dependency>
    12.     <dependency>
    13.         <groupId>org.springframework.bootgroupId>
    14.         <artifactId>spring-boot-starter-jettyartifactId>
    15.     dependency>
    16. dependencies>

    总结

    1. 内嵌Tomcat服务器是SpringBoot辅助功能之一

    2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理

    3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器

    三、SpringBoot基础配置

    1.属性配置

    SpringBoot通过配置文件application.properties就可以修改默认的配置

    SpringBoot官方文档，打开查看附录中的Application Properties就可以获取到对应的配置项了

    地址：Common Application Properties

    注意点：

    所有的starter中都会依赖下面这个starter，叫做spring-boot-starter。这个starter是所有的SpringBoot的starter的基础依赖，里面定义了SpringBoot相关的基础配置，关于这个starter我们到开发应用篇和原理篇中再深入讲解。

    starter-web中包括starter 

    1. <dependency>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starterartifactId>
    4.     <version>2.5.4version>
    5.     <scope>compilescope>
    6. dependency>

    总结

    1. SpringBoot中导入对应starter后，提供对应配置属性

    2. 书写SpringBoot配置采用关键字+提示形式书写

    2.配置文件分类

    SpringBoot除了支持properties格式的配置文件，还支持另外两种格式的配置文件。分别如下:

    • properties格式

    • yml格式

    • yaml格式

    yml格式和yaml格式除了文件名后缀不一样，格式完全一样

    3.配置文件优先级

    application.properties  >  application.yml  >  application.yaml

    如果多个配置文件中有相同类型的配置会优先级高的文件覆盖优先级的文件中的配置。如果配置项不同的话，那所有的配置项都会生效。

    总结

    1. 配置文件间的加载优先级 properties（最高）> yml > yaml（最低）

    2. 不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留

    4.yaml文件

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

    • .yml格式（主流）

    • .yaml格式

    要求：

    1. 大小写敏感

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

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

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

    5. #号 表示注释

    数据前面要加空格与冒号隔开 

    1. boolean: TRUE  						#TRUE,true,True,FALSE,false，False均可
    2. float: 3.14    						#6.8523015e+5  #支持科学计数法
    3. int: 123       						#0b1010_0111_0100_1010_1110    #支持二进制、八进制、十六进制
    4. null: ~        						#使用~表示null
    5. string: HelloWorld      			#字符串可以直接书写
    6. string2: "Hello World"  			#可以使用双引号包裹特殊字符
    7. date: 2018-02-17        			#日期必须使用yyyy-MM-dd格式
    8. datetime: 2018-02-17T15:02:31+08:00  #时间和日期之间使用T连接，最后使用+代表时区

    yaml格式中也可以表示数组，在属性名书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

    数组和对象的写法：

    1. subject:
    2. 	- Java
    3. 	- 前端
    4. 	- 大数据
    5. enterprise:
    6. 	name: itcast
    7.     age: 16
    8.     subject:
    9.     	- Java
    10.         - 前端
    11.         - 大数据
    12. likes: [王者荣耀,刺激战场]			#数组书写缩略格式
    13. users:							 #对象数组格式一
    14.   - name: Tom
    15.    	age: 4
    16.   - name: Jerry
    17.     age: 5
    18. users:							 #对象数组格式二
    19.   -  
    20.     name: Tom
    21.     age: 4
    22.   -   
    23.     name: Jerry
    24.     age: 5			    
    25. users2: [ { name:Tom , age:4 } , { name:Jerry , age:5 } ]	#对象数组缩略格式

    总结

    1. yaml语法规则

      • 大小写敏感

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

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

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

      • #号 表示注释

    2. 注意属性名冒号后面与数据之间有一个空格

    3. 字面值、对象数据格式、数组数据格式

    5.yaml数据读取

    yaml当作是一个小型的数据库，里面保存有若干数据，每个数据都有一个独立的名字，如果你想读取里面的数据，肯定是支持的

    5.1 读取单一数据

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

    总结

    1. 使用@Value配合SpEL读取单个数据

    2. 如果数据存在多层级，依次书写层级名称即可

    5.2 读取全部数据：Environment.getProperty

    SpringBoot提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中

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

    总结

    1. 使用Environment对象封装全部配置信息

    2. 使用@Autowired自动装配数据到Environment对象中

    3. env.getProperty("lesson")

    5.3 读取对象数据:@ConfigurationProperties

    SpringBoot也提供了可以将一组yaml对象数据封装一个Java对象的操作

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

    步骤
    1.创建类，用于封装下面的数据
    2.由Spring帮我们去加载数据到对象中，一定要告诉spring加载这信息
    3.使用的时候从spring中直接获取信息使

    总结

    1. 使用@ConfigurationProperties注解绑定配置信息到封装类中

    2. 封装类需要定义为Spring管理的bean，否则无法进行属性注入

    6.yaml文件的数据引用

    如果你在书写yaml数据时，经常出现如下现象，比如很多个文件都具有相同的目录前缀

    1. center:
    2. 	dataDir: /usr/local/fire/data
    3.     tmpDir: /usr/local/fire/tmp
    4.     logDir: /usr/local/fire/log
    5.     msgDir: /usr/local/fire/msgDir

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

    1. baseDir: /usr/local/fire
    2. 	center:
    3.     dataDir: ${baseDir}/data
    4.     tmpDir: ${baseDir}/tmp
    5.     logDir: ${baseDir}/log
    6.     msgDir: ${baseDir}/msgDir

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

    lesson: "Spring\tboot\nlesson"

    总结

    1. 在配置文件中可以使用${属性名}方式引用属性值

    2. 如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析

    四、基于SpringBoot实现SSMP整合

    1.整合JUnit

    不使用SpringBoot技术时，Spring整合JUnit的制作方式

    1. //加载spring整合junit专用的类运行器
    2. @RunWith(SpringJUnit4ClassRunner.class)
    3. //指定对应的配置信息
    4. @ContextConfiguration(classes = SpringConfig.class)
    5. public class AccountServiceTestCase {
    6.     //注入你要测试的对象
    7.     @Autowired
    8.     private AccountService accountService;
    9.     @Test
    10.     public void testGetById(){
    11.         //执行要测试的对象对应的方法
    12.         System.out.println(accountService.findById(2));
    13.     }
    14. }

    其中核心代码是前两个注解，第一个注解@RunWith是设置Spring专用于测试的类运行器，简单说就是Spring程序执行程序有自己的一套独立的运行程序的方式，不能使用JUnit提供的类运行方式了，必须指定一下，但是格式是固定的，琢磨一下，每次都指定一样的东西，这个东西写起来没有技术含量啊，第二个注解@ContextConfiguration是用来设置Spring核心配置文件或配置类的，简单说就是加载Spring的环境你要告诉Spring具体的环境配置是在哪里写的，虽然每次加载的文件都有可能不同，但是仔细想想，如果文件名是固定的，这个貌似也是一个固定格式。似然有可能是固定格式，那就有可能每次都写一样的东西，也是一个没有技术含量的内容书写

    使用SpringBoot的写法

    1. @SpringBootTest
    2. class Springboot04JunitApplicationTests {
    3.     //注入你要测试的对象
    4.     @Autowired
    5.     private BookDao bookDao;
    6.     @Test
    7.     void contextLoads() {
    8.         //执行要测试的对象对应的方法
    9.         bookDao.save();
    10.         System.out.println("two...");
    11.     }
    12. }

    @SpringBootTest替换了前面两个注解

    手动进行指定引导类

    方法一：使用属性的形式进行

    1. @SpringBootTest(classes = Springboot04JunitApplication.class)
    2. class Springboot04JunitApplicationTests {
    3.     //注入你要测试的对象
    4.     @Autowired
    5.     private BookDao bookDao;
    6.     @Test
    7.     void contextLoads() {
    8.         //执行要测试的对象对应的方法
    9.         bookDao.save();
    10.         System.out.println("two...");
    11.     }
    12. }

    方法二：使用@ContextConfiguration

    1. @SpringBootTest
    2. @ContextConfiguration(classes = Springboot04JunitApplication.class)
    3. class Springboot04JunitApplicationTests {
    4.     //注入你要测试的对象
    5.     @Autowired
    6.     private BookDao bookDao;
    7.     @Test
    8.     void contextLoads() {
    9.         //执行要测试的对象对应的方法
    10.         bookDao.save();
    11.         System.out.println("two...");
    12.     }
    13. }

    温馨提示

    使用SpringBoot整合JUnit需要保障导入test对应的starter，由于初始化项目时此项是默认导入的，所以此处没有提及，其实和之前学习的内容一样，用什么技术导入对应的starter即可。

    总结

    1. 导入测试对应的starter

    2. 测试类使用@SpringBootTest修饰

    3. 使用自动装配的形式添加要测试的对象

    4. 测试类如果存在于引导类所在包或子包中无需指定引导类

    5. 测试类如果不存在于引导类所在的包或子包中需要通过classes属性指定引导类

    2.整合Mybatis

    1.创建模块时勾选要使用的技术，MyBatis，由于要操作数据库，还要勾选对应数据库

    或者手工导入对应技术的starter，和对应数据库的坐标

    1. <dependencies>
    2.     
    3.     <dependency>
    4.         <groupId>org.mybatis.spring.bootgroupId>
    5.         <artifactId>mybatis-spring-boot-starterartifactId>
    6.         <version>2.2.0version>
    7.     dependency>
    8.  
    9.     <dependency>        
    10.         <dependency>
    11.             <groupId>org.mybatis.spring.bootgroupId>
    12.             <artifactId>mybatis-spring-boot-starterartifactId>
    13.             <version>2.2.0version>
    14.         dependency>
    15.  
    16.         <dependency>
    17.             <groupId>mysqlgroupId>
    18.             <artifactId>mysql-connector-javaartifactId>
    19.             <scope>runtimescope>
    20.         dependency>
    21.  
    22.         <dependency>
    23.             <groupId>org.springframework.bootgroupId>
    24.             <artifactId>spring-boot-starter-testartifactId>
    25.             <scope>testscope>
    26.         dependency>
    27.         <groupId>mysqlgroupId>
    28.         <artifactId>mysql-connector-javaartifactId>
    29.         <scope>runtimescope>
    30.     dependency>
    31. dependencies>

    2.配置数据源相关信息，没有这个信息你连接哪个数据库都不知道

    1. #2.配置相关信息
    2. spring:
    3.   datasource:
    4.     driver-class-name: com.mysql.cj.jdbc.Driver
    5.     url: jdbc:mysql://localhost:3306/ssm_db
    6.     username: root
    7.     password: root

    3.测试

    实体类

    1. public class Book {
    2.     private Integer id;
    3.     private String type;
    4.     private String name;
    5.     private String description;
    6. }

    映射接口（Dao）

    1. @Mapper
    2. public interface BookDao {
    3.     @Select("select * from tbl_book where id = #{id}")
    4.     public Book getById(Integer id);
    5. }

    测试类

    1. @SpringBootTest
    2. class Springboot05MybatisApplicationTests {
    3.     @Autowired
    4.     private BookDao bookDao;
    5.     @Test
    6.     void contextLoads() {
    7.         System.out.println(bookDao.getById(1));
    8.     }
    9. }
    注意点：

    当前使用的SpringBoot版本是2.5.4，对应的坐标设置中Mysql驱动使用的是8x版本。当SpringBoot2.4.3（不含）版本之前会出现一个小BUG，就是MySQL驱动升级到8以后要求强制配置时区，如果不设置会出问题。解决方案很简单，驱动url上面添加上对应设置就行了

    1. #2.配置相关信息
    2. spring:
    3.   datasource:
    4.     driver-class-name: com.mysql.cj.jdbc.Driver
    5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    6.     username: root
    7.     password: root

    此外在运行程序时还会给出一个提示，说数据库驱动过时的警告，根据提示修改配置即可，弃用com.mysql.jdbc.Driver，换用com.mysql.cj.jdbc.Driver。前面的例子中已经更换了驱动了，在此说明一下。

    总结

    1. 整合操作需要勾选MyBatis技术，也就是导入MyBatis对应的starter

    2. 数据库连接相关信息转换成配置

    3. 数据库SQL映射需要添加@Mapper被容器识别到

    4. MySQL 8.X驱动强制要求设置时区

      • 修改url，添加serverTimezone设定

      • 修改MySQL数据库配置

    5. 驱动类过时，提醒更换为com.mysql.cj.jdbc.Driver

    3.整合Mybatis-plus

    步骤①：导入对应的starter

    1. <dependency>
    2.     <groupId>com.baomidougroupId>
    3.     <artifactId>mybatis-plus-boot-starterartifactId>
    4.     <version>3.4.3version>
    5. dependency>

    步骤②：配置数据源相关信息

    1. #2.配置相关信息
    2. spring:
    3.   datasource:
    4.     driver-class-name: com.mysql.cj.jdbc.Driver
    5.     url: jdbc:mysql://localhost:3306/ssm_db
    6.     username: root
    7.     password: root

    映射接口（Dao）:继承BaseMapper

    1. @Mapper
    2. public interface BookDao extends BaseMapper {
    3. }

    核心在于Dao接口继承了一个BaseMapper的接口，这个接口中帮助开发者预定了若干个常用的API接口，简化了通用API接口的开发工作。

    ServiceImpl要实现IService和继承UserService

    温馨提示

    目前数据库的表名定义规则是tbl_模块名称，为了能和实体类相对应，需要做一个配置，相关知识各位小伙伴可以到MyBatisPlus课程中去学习，此处仅给出解决方案。配置application.yml文件，添加如下配置即可，设置所有表名的通用前缀名

    1. mybatis-plus:
    2.   global-config:
    3.     db-config:
    4.       table-prefix: tbl_		#设置所有表的通用前缀名称为tbl_

    总结

    1. 手工添加MyBatis-Plus对应的starter

    2. 数据层接口使用BaseMapper简化开发

    3. 需要使用的第三方技术无法通过勾选确定时，需要手工添加坐标

    4.整合Druid

    1.导入对应的坐标

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>com.alibabagroupId>
    4.         <artifactId>druid-spring-boot-starterartifactId>
    5.         <version>1.2.6version>
    6.     dependency>
    7. dependencies>

    2.配置数据源

    1. spring:
    2.   datasource:
    3.     druid:
    4.       driver-class-name: com.mysql.cj.jdbc.Driver
    5.       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    6.       username: root
    7.       password: root

    注意观察，配置项中，在datasource下面并不是直接配置url这些属性的，而是先配置了一个druid节点，然后再配置的url这些东西。言外之意，url这个属性时druid下面的属性，那你能想到吗？除了这4个常规配置外，还有druid专用的其他配置。通过提示功能可以打开druid相关的配置查阅

    总结

    1. 整合Druid需要导入Druid对应的starter

    2. 根据Druid提供的配置方式进行配置

    3. 整合第三方技术通用方式

      • 导入对应的starter

      • 根据提供的配置格式，配置非默认值对应的配置项

    五、SSMP整合综合案例：CRUD

    SSMP整合综合案例【SpringBoot的基本增删改查】-CSDN博客

  • 相关阅读:
    MySQL数据库、表的基本操作和常用数据类型
    实用又好用，4款高质量办公软件，助你工作效率，节节攀升
    聊聊jedis连接池参数配置
    IPTABLES问题：DNAT下如何解决内网访问内部服务器问题
    Maven学习笔记
    Google Earth Engine ——利用降水数据来实现
    数据库名词解析
    什么是正向代理和反向代理
    股票推荐系统，并查集
    leetcode 692. 前K个高频单词
  • 原文地址：https://blog.csdn.net/m0_63077733/article/details/132763421