• [黑马程序员SpringBoot2]——基础篇1

     目录：

    1.  SpringBoot入门案例（Idea联网版）
    2. SpringBoot入门案例（官网创建版）
    3. SpringBoot入门案例（阿里云版）
    4. SpringBoot入门案例（手工制作版）
    5. 教你一招，隐藏文件或文件夹
    6. 入门案例解析:parent
    7. 入门案例解析:starter
    8. 入门案例解析:引导类
    9. 入门案例解析:辅助功能
    10. REST风格简介
    11. RESTfuI入门案例
    12. RESTful快速开发
    13. 复制模块
    14. 属性配置方式
    15. 基础配置
    16. 3种配置文件类型
    17. 配置文件加载优先级
    18. 属性提示消失解决方案
    19. yaml数据格式
    20. 读取yaml单一属性数据
    21. yaml文件中的变量引用
    22. 读取yaml全部属性数据
    23. 读取yaml引用类型属性数据
    24. SpringBoot整合JUnit
    25. 整合JUnit--classes属性
    26. SpringBoot整合MyBatis
    27. SpringBoot整合MyBatis常见问题处理
    28. SpringBoot整合MyBatisPlus
    29. SpringBoot整合Druid
    30. SSMP整合案例制作分析 

    1.SpringBoot入门案例（Idea联网版）

    SpringBoot入门程序开发

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


    SpringBoot基础配置

    1.创建新模块，选择Spring Initializr，并配置模块相关基础信息

    2.选择当前模块需要使用的技术集

    3.开发控制器类

    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. }

    4.运行自动生成的Application类

    5.运行结果：

    入门案例

    最简SpringBoot程序所包含的基础文件

    • pom.xml文件

    • Application类

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

    Spring程序与SpringBoot程序对比


    注意：基于idea开发SpringBoot程序需要确保联网且能够加载到程序框架结构
     

    小结：

    1. 开发SpringBoot程序可以根据向导进行联网快速制作
    2. SpringBoot程序需要基于JDK8进行制作
    3. SpringBoot程序中需要使用何种功能通过勾选选择技术
    4. 运行SpringBoot程序通过运行Application程序入口进行
       

    2.SpringBoot入门案例（官网创建版）

    • 基于SpringBoot官网创建项目，地址： https://start.spring.io/

    步骤： 

    1. 打开SpringBoot官网，选择Quickstart Your Project
    2. 创建工程，并保存项目
    3. 解压项目，通过IDE导入项目
       

    3.SpringBoot入门案例（阿里云版） 

    • 基于SpringBoot官网创建项目，地址： https://start.spring.io/

    • 基于阿里云创建项目，地址： https://start.aliyun.com

    • 阿里云提供的坐标版本较低，如果需要使用高版本，进入工程后手工切换SpringBoot版本
    • 阿里云提供的工程模板与Spring官网提供的工程模板略有不同

    步骤： 

    1. 选择start来源为自定义URL
    2. 输入阿里云start地址
    3.  创建项目

    4.SpringBoot入门案例（手工制作版） 

    手工创建项目（手工导入坐标）

    手工创建项目（手工制作引导类）

    步骤： 

    1. 创建普通Maven工程
    2. 继承spring-boot-starter-parent
    3. 添加依赖spring-boot-starter-web
    4. 制作引导类Application

     5.教你一招，隐藏文件或文件夹

    隐藏指定文件/文件夹


     

    Idea中隐藏指定文件或指定类型文件 Setting → File Types → Ignored Files and Folders

    • 输入要隐藏的文件名，支持*号通配符
    • 回车确认添加

     6.入门案例解析:parent

    SpringBoot简介

    • SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
    • Spring程序缺点
      • 依赖设置繁琐
      • 配置繁琐
    • SpringBoot程序优点
      • 起步依赖（简化依赖配置）
      • 自动配置（简化常用工程相关配置）
      •  辅助功能（内置服务器， ……）
         
    1. 开发springBoot程序要继承spring-boot-starter-parent
    2. spring-boot-starter-parent中定义了若干个依赖管理
    3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突
    4. 继承parent的形式也可以采用引入依赖的形式实现效果

     7.入门案例解析:starter

    • starter
      • SpringBoot中常见项目名称，定义了当前项目使用的所有依赖坐标，以达到减少依赖配置的目的
    • parent
      • 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖）， 以达到减少依赖冲突的目的
      • spring-boot-starter-parent各版本间存在着诸多坐标版本不同
    • 实际开发
      • 使用任意坐标时，仅书写GAV中的G和A， V由SpringBoot提供，除非SpringBoot未提供对应版本V
      • 如发生坐标错误，再指定Version（要小心版本冲突）

    总结： 

    1. 开发springBoot程序需要导入坐标时通常导入对应的starter
    2. 每个不同的starter根据功能不同，通常包含多个依赖坐标
    3. 使用starter可以实现快速配置的效果，达到简化配置的目的 

    8.入门案例解析:引导类

    Application.class

    1. package com.example._20231018;
    2.  
    3. import com.example._20231018.controller.BookController;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.springframework.context.ConfigurableApplicationContext;
    7.  
    8. @SpringBootApplication
    9. public class Application {
    10.  
    11.     public static void main(String[] args) {
    12.         ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);
    13.         BookController bean = ctx.getBean(BookController.class);
    14.         System.out.println(bean);
    15.         User user = ctx.getBean(User.class);
    16.         System.out.println(user);
    17.     }
    18.  
    19. }

    运行结果：

     启动方式

    • SpringBoot的引导类是Boot工程的执行入口，运行main方法就可以启动项目
    • SpringBoot工程运行后初始化Spring容器，扫描引导类所在包加载bean
       

     9.入门案例解析:辅助功能

    内置服务器

    • tomcat(默认)        apache出品，粉丝多， 应用面广，负载了若干较重的组件
    • jetty                      更轻量级， 负载性能远不及tomcat
    • undertow              undertow，负载性能勉强跑赢tomcat

    总结：

    1. 内嵌Tomcat服务器是SpringBoot辅助功能之一
    2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理
    3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器

    10.REST风格简介

    REST简介

    • REST (Representational State Transfer)，表现形式状态转换

    传统风格资源描述形式

    • http: / /localhost/user/getById?id=1
    • http: / /localhost/user/ saveUser 

    REST风格描述形式

    • http: / / localhost/user/1
    • http: / / localhost/user 

    REST风格优点:

    • 隐藏资源的访问行为，无法通过地址得知对资源是何种操作书写简化 

    按照REST风格访问资源时使用行为动作区分对资源进行了何种操作

    • http: / / localhost/users       查询全部用户信息     GET(查询)
    • http: / / localhost/users/1    查询指定用户信息     GET(查询)
    • http: / / localhost/users       添加用户信息            POST(新增/保存)
    • http: / / localhost/users       修改用户信息            PUT（修改/更新)
    • http:// localhost/users/1      删除用户信息            DELETE （删除)

    根据REST风格对资源进行访问称为RESTful 

    • 上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范
    • 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如:users、books、account.…..

    11.RESTfuI入门案例 

    UserController.class

    1. package com.example._20231018.controller;
    2.  
    3. import com.example._20231018.User;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.*;
    6.  
    7. @Controller
    8. public class UserController {
    9.     @RequestMapping(value = "/users", method = RequestMethod.POST)
    10.     @ResponseBody
    11.     public String save(@RequestBody User user) {
    12.         System.out.println("user save..." + user);
    13.         return "{'moudle':'user save'}";
    14.     }
    15.  
    16.     @RequestMapping(value = "/users/{id}", method = RequestMethod.DELETE)
    17.     @ResponseBody
    18.     public String delete(@PathVariable Integer id) {
    19.         System.out.println("user delete..." + id);
    20.         return "{'moudle':'user delete'}";
    21.     }
    22.  
    23.     @RequestMapping(value = "/users", method = RequestMethod.PUT)
    24.     @ResponseBody
    25.     public String update(@RequestBody User user) {
    26.         System.out.println("user update..." + user);
    27.         return "{'moudle':'user update'}";
    28.     }
    29.  
    30.  
    31.     @RequestMapping(value = "/users/{id}", method = RequestMethod.GET)
    32.     @ResponseBody
    33.     public String getById(@PathVariable Integer id) {
    34.         System.out.println("user getById..." + id);
    35.         return "{'moudle':'user getById'}";
    36.     }
    37.  
    38.     @RequestMapping(value = "/users", method = RequestMethod.GET)
    39.     @ResponseBody
    40.     public String getAll() {
    41.         System.out.println("user getAll...");
    42.         return "{'moudle':'user getAll'}";
    43.     }
    44. }

    User.class

    1. package com.example._20231018;
    2. import org.springframework.stereotype.Component;
    3.  
    4. @Component
    5. public class User {
    6.     public String name;
    7.     public Integer age;
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "User{" +
    12.                 "name='" + name + '\'' +
    13.                 ", age=" + age +
    14.                 '}';
    15.     }
    16. }

    项目结构：

    postman验证接口：

    新增操作

    删除操作：

    修改操作：

    查询单个操作：

    查询全部操作：

    运行结果：

     

    @RequestBody @RequestParam @PathVariable


    区别

    • @RequestParam用于接收url地址传参或表单传参
    • @RequestBody用于接收json数据
    • @PathVariable用于接收路径参数，使用{参数名称}描述路径参数

    应用

    • 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
    • 如果发送非json格式数据，选用@RequestParam接收请求参数
    • 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值 

     12.RESTful快速开发

    BookController.class

    1. package com.example._20231018.controller;
    2.  
    3. import com.example._20231018.Book;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.*;
    6.  
    7. //@Controller
    8. //@ResponseBody
    9. @RestController
    10. @RequestMapping("/books")
    11. public class BookController {
    12.     //    @RequestMapping(method = RequestMethod.POST)
    13.     //    @ResponseBody
    14.     @PostMapping
    15.     public String save(@RequestBody Book book) {
    16.         System.out.println("book save..." + book);
    17.         return "{'moudle':'book save'}";
    18.     }
    19.  
    20.     //    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    21.     //    @ResponseBody
    22.     @DeleteMapping("/{id}")
    23.     public String delete(@PathVariable Integer id) {
    24.         System.out.println("book delete..." + id);
    25.         return "{'moudle':'book delete'}";
    26.     }
    27.  
    28.     //    @RequestMapping(method = RequestMethod.PUT)
    29.     //    @ResponseBody
    30.     @PutMapping
    31.     public String update(@RequestBody Book book) {
    32.         System.out.println("book update..." + book);
    33.         return "{'moudle':'book update'}";
    34.     }
    35.  
    36.     //    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    37.     //    @ResponseBody
    38.     @GetMapping("/{id}")
    39.     public String getById(@PathVariable Integer id) {
    40.         System.out.println("book getById..." + id);
    41.         return "{'moudle':'book getById'}";
    42.     }
    43.  
    44.     //    @RequestMapping(method = RequestMethod.GET)
    45.     //    @ResponseBody
    46.     @GetMapping
    47.     public String getAll() {
    48.         System.out.println("book getAll...");
    49.         return "{'moudle':'book getAll'}";
    50.     }
    51. }

    Book.class

    1. package com.example._20231018;
    2.  
    3. import org.springframework.stereotype.Component;
    4.  
    5. @Component
    6. public class Book {
    7.     public String name;
    8.     public int price;
    9.  
    10.     @Override
    11.     public String toString() {
    12.         return "Book{" +
    13.                 "name='" + name + '\'' +
    14.                 ", price=" + price +
    15.                 '}';
    16.     }
    17. }

    postman测试接口：

    新增操作：

    删除操作：

     修改操作：

    查询单个操作：

    查询全部操作：

    运行结果：

    总结：

     

    13.复制模块 

    原则

    • 保留工程基础结构
    •  抹掉原始工程痕迹
       

    总结： 

    1. 在工作空间中复制对应工程，并修改工程名称
    2. 删除与Idea相关配置文件，仅保留src目录与pom.xml文件
    3. 修改pom.xml文件中的artifactId与新工程/模块名相同
    4. 删除name标签（可选)
    5. 保留备份工程供后期使用 

    14.属性配置方式 

     

    修改配置

    • 修改服务器端口 
      • server.prot=80
    • 关闭运行日志图标（banner）
      • spring.main.banner-mode=off
    • 设置日志相关
      • logging.level.root=debug

     springbooot内置属性查询

     15.基础配置

    1. SpringBoot中导入对应starter后，提供对应配置属性
    2. 书写SpringBoot配置采用关键字+提示形式书写 

    16.3种配置文件类型

    • 配置文件格式

    • SpringBoot提供了多种属性配置方式
       

    总结：

    • SpringBoot提供了3种配置文件的格式
      • properties (传统格式 /默认格式）
      • yml（主流格式）
      • yaml

     17.配置文件加载优先级

    • SpringBoot配置文件加载顺序
      • application.properties > application.yml > application.yaml
    • 常用配置文件种类
      • application.yml

    小结：

    1.配置文件间的加载优先级

    • properties（最高）
    • yml
    • yaml（最低）

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

    18.属性提示消失解决方案

     

    小结：

    • 指定SpringBoot配置文件
      • setting →Project Structure Facets
      • 选中对应项目/工程·
      • customize Spring Boot
      • 选择配置文件 

    19.yaml数据格式 

     

    小结：

    1. yaml语法规则

    • 大小写敏感
    • 属性层级关系使用多行描述，每行结尾使用冒号结束
    • 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格(不允许使用Tab键)
    • 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔)
    • #表示注释

    2.注意属性名冒号后面与数据之间有一个空格
    3.字面值、对象数据格式、数组数据格式

    20.读取yaml单一属性数据

     yaml与yml文件有啥不同？

    • YAML（Yet Another Markup Language）和YML（YAML）没有区别，它们是同一种文件格式的不同文件扩展名。
    • YAML 是一种可读性高、用途广泛的数据序列化格式。它参考了其他多种语言，包括C语言、Python、Perl，并从XML、电子邮件的数据格式（RFC 2822）中获得灵感。YAML 文件使用缩进和换行等符号来表示层次结构和序列关系，从而达到编写简单易读的数据文档的目的。
    • 由于历史原因，许多 Windows 程序员仍然不敢使用具有三个以上字符的扩展名，因此选择使用 yml 代替。但这只是一种习惯，并不影响文件的解析或者使用。
    • 因此，YAML 和 YML 是同一个文件格式的不同文件扩展名，只是习惯上大家更常使用 YAML 这个名称。

     示例：读取application.yml文件

    1. country: china
    2.  
    3. user:
    4.   name_1: itcast
    5.   age: 16
    6.  
    7. a:
    8.   b:
    9.     c:
    10.       d:
    11.         e: 123
    12.  
    13. likes:
    14.   - game
    15.   - music
    16.   - sleep
    17.  
    18. likes2: [ game,music,sleep ]
    19.  
    20.  
    21. users3:
    22.   - name: zhangsan
    23.     age: 45
    24.  
    25.   - name: lisi
    26.     age: 23

    ReadYmlController.class

    1. package com.example.demo_01.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7.  
    8. @RestController
    9. @RequestMapping("/read")
    10. public class ReadYmlController {
    11.     @Value("${country}")
    12.     private String country_variable;
    13.  
    14.     @Value("${user.name_1}")
    15.     private String name_variable;
    16.  
    17.     @Value("${user.age}")
    18.     private Integer age_variable;
    19.  
    20.     @Value("${a.b.c.d.e}")
    21.     private Integer e_variable;
    22.  
    23.     @Value("${likes[1]}")
    24.     private String music_variable;
    25.  
    26.     @Value("${likes2[0]}")
    27.     private String game_variable;
    28.  
    29.     @Value("${users3[0].name}")
    30.     private String name111_variable;
    31.  
    32.     @GetMapping
    33.     public String showVariable() {
    34.         System.out.println(country_variable);
    35.         System.out.println(name_variable);
    36.         System.out.println(age_variable);
    37.         System.out.println(e_variable);
    38.         System.out.println(music_variable);
    39.         System.out.println(game_variable);
    40.         System.out.println(name111_variable);
    41.  
    42.         return country_variable + name_variable + age_variable + e_variable + music_variable + game_variable + name111_variable;
    43.     }
    44. }

     运行结果：

     

    1. 使用@Value配合SpEL读取单个数据
    2. 如果数据存在多层级，依次书写层级名称即可 

    21.yaml文件中的变量引用

    application.yml

    1. country: china
    2.  
    3. user:
    4.   name_1: itcast
    5.   age: 16
    6.  
    7. a:
    8.   b:
    9.     c:
    10.       d:
    11.         e: 123
    12.  
    13. likes:
    14.   - game
    15.   - music
    16.   - sleep
    17.  
    18. likes2: [ game,music,sleep ]
    19.  
    20.  
    21. users3:
    22.   - name: zhangsan
    23.     age: 45
    24.  
    25.   - name: lisi
    26.     age: 23
    27.  
    28. baseDir: c\windows
    29.  
    30. #tempDir: c\windows\temp
    31. tempDir: ${baseDir}\temp
    32. #使用引号包裹的字符串，其中的转义字符可以生效
    33. tempDir1: "${baseDir}\temp \t1 \t2 \t3"

    ReadYmlController.class

    1. package com.example.demo_01.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7.  
    8. @RestController
    9. @RequestMapping("/read")
    10. public class ReadYmlController {
    11.     @Value("${country}")
    12.     private String country_variable;
    13.  
    14.     @Value("${user.name_1}")
    15.     private String name_variable;
    16.  
    17.     @Value("${user.age}")
    18.     private Integer age_variable;
    19.  
    20.     @Value("${a.b.c.d.e}")
    21.     private Integer e_variable;
    22.  
    23.     @Value("${likes[1]}")
    24.     private String music_variable;
    25.  
    26.     @Value("${likes2[0]}")
    27.     private String game_variable;
    28.  
    29.     @Value("${users3[0].name}")
    30.     private String name111_variable;
    31.  
    32.     @Value("${tempDir}")
    33.     private String temp_dir_variable;
    34.  
    35.     @Value("${tempDir1}")
    36.     private String temp_dir1_variable;
    37.  
    38.     @GetMapping
    39.     public String showVariable() {
    40.         System.out.println(country_variable);
    41.         System.out.println(name_variable);
    42.         System.out.println(age_variable);
    43.         System.out.println(e_variable);
    44.         System.out.println(music_variable);
    45.         System.out.println(game_variable);
    46.         System.out.println(name111_variable);
    47.         System.out.println(temp_dir_variable);
    48.         System.out.println(temp_dir1_variable);
    49.  
    50.         return country_variable +
    51.                 name_variable +
    52.                 age_variable +
    53.                 e_variable +
    54.                 music_variable +
    55.                 game_variable +
    56.                 name111_variable +
    57.                 temp_dir_variable +
    58.                 temp_dir1_variable
    59.                 ;
    60.     }
    61. }

    运行结果：

     

    小结：

    1. 在配置文件中可以使用${属性名}方式引用属性值
    2. 如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析 

    22.读取yaml全部属性数据

    1. 使用Environment对象封装全部配置信息
    2. 使用@Autowired自动装配数据到Environment对象中 

     示例：

    ReadYmlController.class

    1. package com.example.demo_01.controller;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.beans.factory.annotation.Value;
    5. import org.springframework.core.env.Environment;
    6. import org.springframework.web.bind.annotation.GetMapping;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RestController;
    9.  
    10. @RestController
    11. @RequestMapping("/read")
    12. public class ReadYmlController {
    13.     @Value("${country}")
    14.     private String country_variable;
    15.  
    16.     @Value("${user.name_1}")
    17.     private String name_variable;
    18.  
    19.     @Value("${user.age}")
    20.     private Integer age_variable;
    21.  
    22.     @Value("${a.b.c.d.e}")
    23.     private Integer e_variable;
    24.  
    25.     @Value("${likes[1]}")
    26.     private String music_variable;
    27.  
    28.     @Value("${likes2[0]}")
    29.     private String game_variable;
    30.  
    31.     @Value("${users3[0].name}")
    32.     private String name111_variable;
    33.  
    34.     @Value("${tempDir}")
    35.     private String temp_dir_variable;
    36.  
    37.     @Value("${tempDir1}")
    38.     private String temp_dir1_variable;
    39.  
    40.     //使用自动装配将所有的数据封装到一个对象Environment中
    41.     @Autowired
    42.     private Environment environment;
    43.  
    44.     @GetMapping
    45.     public String showVariable() {
    46.         System.out.println(country_variable);
    47.         System.out.println(name_variable);
    48.         System.out.println(age_variable);
    49.         System.out.println(e_variable);
    50.         System.out.println(music_variable);
    51.         System.out.println(game_variable);
    52.         System.out.println(name111_variable);
    53.         System.out.println(temp_dir_variable);
    54.         System.out.println(temp_dir1_variable);
    55.         System.out.println("---------------------------------");
    56.         System.out.println(environment.getProperty("country"));
    57.         System.out.println(environment.getProperty("user.age"));
    58.  
    59.         return country_variable +
    60.                 name_variable +
    61.                 age_variable +
    62.                 e_variable +
    63.                 music_variable +
    64.                 game_variable +
    65.                 name111_variable +
    66.                 temp_dir_variable +
    67.                 temp_dir1_variable
    68.                 ;
    69.     }
    70. }

    运行结果：

    23.读取yaml引用类型属性数据

     

     

    1. 使用@ConfigurationProperties注解绑定配置信息到封装类中
    2. 封装类需要定义为Spring管理的bean，否则无法进行属性注入 

    代码示例：

    application.yml

    1. country: china
    2.  
    3. user:
    4.   name_1: itcast
    5.   age: 16
    6.  
    7. a:
    8.   b:
    9.     c:
    10.       d:
    11.         e: 123
    12.  
    13. likes:
    14.   - game
    15.   - music
    16.   - sleep
    17.  
    18. likes2: [ game,music,sleep ]
    19.  
    20.  
    21. users3:
    22.   - name: zhangsan
    23.     age: 45
    24.  
    25.   - name: lisi
    26.     age: 23
    27.  
    28. baseDir: c\windows
    29.  
    30. #tempDir: c\windows\temp
    31. tempDir: ${baseDir}\temp
    32. #使用引号包裹的字符串，其中的转义字符可以生效
    33. tempDir1: "${baseDir}\temp \t1 \t2 \t3"
    34.  
    35.  
    36.  
    37. datasource:
    38.   driver: com.mysql.jdbc.Driver
    39.   url: jdbc:mysql://localhost/springboot_db
    40.   username: root
    41.   password: 666666

     MyDataSource.class

    1. package com.example.demo_01.entity;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.stereotype.Component;
    6.  
    7. //1.定义数据模型封装yamL文件中对应的数据
    8. //2.定义为spring管控的bean
    9. //3.指定加载的数据
    10. @Component
    11. @ConfigurationProperties("datasource")
    12. public class MyDataSource {
    13.     private String driver;
    14.     private String url;
    15.     private String username;
    16.     private String password;
    17.  
    18.     public String getDriver() {
    19.         return driver;
    20.     }
    21.  
    22.     public void setDriver(String driver) {
    23.         this.driver = driver;
    24.     }
    25.  
    26.     public String getUrl() {
    27.         return url;
    28.     }
    29.  
    30.     public void setUrl(String url) {
    31.         this.url = url;
    32.     }
    33.  
    34.     public String getUsername() {
    35.         return username;
    36.     }
    37.  
    38.     public void setUsername(String username) {
    39.         this.username = username;
    40.     }
    41.  
    42.     public String getPassword() {
    43.         return password;
    44.     }
    45.  
    46.     public void setPassword(String password) {
    47.         this.password = password;
    48.     }
    49.  
    50.     @Override
    51.     public String toString() {
    52.         return "MyDataSource{" +
    53.                 "driver='" + driver + '\'' +
    54.                 ", url='" + url + '\'' +
    55.                 ", username='" + username + '\'' +
    56.                 ", password='" + password + '\'' +
    57.                 '}';
    58.     }
    59. }

    ReadYmlController.class

    1. package com.example.demo_01.controller;
    2.  
    3. import com.example.demo_01.entity.MyDataSource;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.beans.factory.annotation.Value;
    6. import org.springframework.core.env.Environment;
    7. import org.springframework.web.bind.annotation.GetMapping;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.RestController;
    10.  
    11. @RestController
    12. @RequestMapping("/read")
    13. public class ReadYmlController {
    14.     @Value("${country}")
    15.     private String country_variable;
    16.  
    17.     @Value("${user.name_1}")
    18.     private String name_variable;
    19.  
    20.     @Value("${user.age}")
    21.     private Integer age_variable;
    22.  
    23.     @Value("${a.b.c.d.e}")
    24.     private Integer e_variable;
    25.  
    26.     @Value("${likes[1]}")
    27.     private String music_variable;
    28.  
    29.     @Value("${likes2[0]}")
    30.     private String game_variable;
    31.  
    32.     @Value("${users3[0].name}")
    33.     private String name111_variable;
    34.  
    35.     @Value("${tempDir}")
    36.     private String temp_dir_variable;
    37.  
    38.     @Value("${tempDir1}")
    39.     private String temp_dir1_variable;
    40.  
    41.     //使用自动装配将所有的数据封装到一个对象Environment中
    42.     @Autowired
    43.     private Environment environment;
    44.  
    45.     @Autowired
    46.     private MyDataSource myDataSource;
    47.  
    48.     @GetMapping
    49.     public String showVariable() {
    50.         System.out.println(country_variable);
    51.         System.out.println(name_variable);
    52.         System.out.println(age_variable);
    53.         System.out.println(e_variable);
    54.         System.out.println(music_variable);
    55.         System.out.println(game_variable);
    56.         System.out.println(name111_variable);
    57.         System.out.println(temp_dir_variable);
    58.         System.out.println(temp_dir1_variable);
    59.         System.out.println("---------------------------------");
    60.         System.out.println(environment.getProperty("country"));
    61.         System.out.println(environment.getProperty("user.age"));
    62.         System.out.println("---------------------------------");
    63.         System.out.println(myDataSource);
    64.  
    65.         return country_variable +
    66.                 name_variable +
    67.                 age_variable +
    68.                 e_variable +
    69.                 music_variable +
    70.                 game_variable +
    71.                 name111_variable +
    72.                 temp_dir_variable +
    73.                 temp_dir1_variable
    74.                 ;
    75.     }
    76. }

    运行结果：

     

    24.SpringBoot整合JUnit

    • 名称: @SpringBootTest
    • 类型:测试类注解
    • 位置:测试类定义上方
    • 作用:设置JUnit加载的SpringBoot启动类
    • 范例: 

    代码示例：

    BookDao.interface

    1. package com.example.junit.Dao;
    2.  
    3. public interface BookDao {
    4.     public void save();
    5. }

     BookDaoImpl.class

    1. package com.example.junit.Dao.impl;
    2.  
    3. import com.example.junit.Dao.BookDao;
    4. import org.springframework.stereotype.Repository;
    5.  
    6. @Repository
    7. public class BookDaoImpl implements BookDao {
    8.     @Override
    9.     public void save() {
    10.         System.out.println("book dao is running ...");
    11.     }
    12. }

    JunitApplicationTests.class

    1. package com.example.junit;
    2.  
    3. import com.example.junit.Dao.BookDao;
    4. import org.junit.jupiter.api.Test;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.boot.test.context.SpringBootTest;
    7.  
    8. @SpringBootTest
    9. class JunitApplicationTests {
    10.     //1.注入你要测试的对象
    11.     @Autowired
    12.     private BookDao bookDao;
    13.  
    14.  
    15.     @Test
    16.     void contextLoads() {
    17.         //2.执行要测试的对象对应的方法
    18.         bookDao.save();
    19.     }
    20. }

    项目结构：

    运行结果：

    小结：

    1. 导入测试对应的starter
    2. 测试类使用@SpringBootTest修饰
    3. 使用自动装配的形式添加要测试的对象

     25.整合JUnit--classes属性

    小结：

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

    26.SpringBoot整合MyBatis

    整合MyBatis

    • 核心配置:数据库连接相关信息(连什么?连谁?什么权限)
    • 映射配置:SQL映射(XML/注解)

     

     

    代码示例：

    BookDao.interface

    1. package com.example._20231023.dao;
    2.  
    3.  
    4. import com.example._20231023.domain.Book;
    5. import org.apache.ibatis.annotations.Mapper;
    6. import org.apache.ibatis.annotations.Select;
    7.  
    8. @Mapper
    9. public interface BookDao {
    10.     @Select("select * from tbl_book where id = #{id}")
    11.     public Book getById(Integer id);
    12. }

    Book.class

    1. package com.example._20231023.domain;
    2.  
    3. public class Book {
    4.     private Integer id;
    5.     private String type;
    6.     private String name;
    7.     private String description;
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "Book{" +
    12.                 "id=" + id +
    13.                 ", type='" + type + '\'' +
    14.                 ", name='" + name + '\'' +
    15.                 ", description='" + description + '\'' +
    16.                 '}';
    17.     }
    18.  
    19.     public Integer getId() {
    20.         return id;
    21.     }
    22.  
    23.     public void setId(Integer id) {
    24.         this.id = id;
    25.     }
    26.  
    27.     public String getType() {
    28.         return type;
    29.     }
    30.  
    31.     public void setType(String type) {
    32.         this.type = type;
    33.     }
    34.  
    35.     public String getName() {
    36.         return name;
    37.     }
    38.  
    39.     public void setName(String name) {
    40.         this.name = name;
    41.     }
    42.  
    43.     public String getDescription() {
    44.         return description;
    45.     }
    46.  
    47.     public void setDescription(String description) {
    48.         this.description = description;
    49.     }
    50. }

    Application.Tests

    1. package com.example._20231023;
    2.  
    3. import com.example._20231023.dao.BookDao;
    4. import org.junit.jupiter.api.Test;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.boot.test.context.SpringBootTest;
    7.  
    8. @SpringBootTest
    9. class ApplicationTests {
    10.  
    11.     @Autowired
    12.     private BookDao bookDao;
    13.  
    14.     @Test
    15.     void contextLoads() {
    16.         System.out.println(bookDao.getById(11));
    17.     }
    18.  
    19. }

    application.yml

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.cj.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3308/test_db
    5.     username: root
    6.     password: 666666

    运行结果：

    小结：

    1. 勾选MyBatis技术，也就是导入MyBatis对应的starter
    2. 数据库连接相关信息转换成配置
    3. 数据库SQL映射需要添加@Mapper被容器识别到 

     27.SpringBoot整合MyBatis常见问题处理

    • MySQL 8.X驱动强制要求设置时区
      • 修改url，添加serverTimezone设定
      • 修改MySQL数据库配置(略)
    • 驱动类过时，提醒更换为com.mysql.cj.jdbc.Driver 

    28.SpringBoot整合MyBatisPlus 

    BookDao.interface

    1. package com.example._20231024.dao;
    2.  
    3.  
    4. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    5. import com.example._20231024.domain.Book;
    6. import org.apache.ibatis.annotations.Mapper;
    7.  
    8. @Mapper
    9. public interface BookDao extends BaseMapper {
    10.  
    11. }

     Book.class

    1. package com.example._20231024.domain;
    2.  
    3. public class Book {
    4.     private Integer id;
    5.     private String type;
    6.     private String name;
    7.     private String description;
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "Book{" +
    12.                 "id=" + id +
    13.                 ", type='" + type + '\'' +
    14.                 ", name='" + name + '\'' +
    15.                 ", description='" + description + '\'' +
    16.                 '}';
    17.     }
    18.  
    19.     public Integer getId() {
    20.         return id;
    21.     }
    22.  
    23.     public void setId(Integer id) {
    24.         this.id = id;
    25.     }
    26.  
    27.     public String getType() {
    28.         return type;
    29.     }
    30.  
    31.     public void setType(String type) {
    32.         this.type = type;
    33.     }
    34.  
    35.     public String getName() {
    36.         return name;
    37.     }
    38.  
    39.     public void setName(String name) {
    40.         this.name = name;
    41.     }
    42.  
    43.     public String getDescription() {
    44.         return description;
    45.     }
    46.  
    47.     public void setDescription(String description) {
    48.         this.description = description;
    49.     }
    50. }

    application.yml

    1. spring:
    2.   datasource:
    3.     driver-class-name: com.mysql.cj.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3308/test_db
    5.     username: root
    6.     password: 666666
    7.  
    8. mybatis-plus:
    9.   global-config:
    10.     db-config:
    11.       table-prefix: tbl_

    ApplicationTests

    1. package com.example._20231024;
    2.  
    3. import com.example._20231024.dao.BookDao;
    4. import org.junit.jupiter.api.Test;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.boot.test.context.SpringBootTest;
    7.  
    8. @SpringBootTest
    9. class ApplicationTests {
    10.  
    11.     @Autowired
    12.     private BookDao bookDao;
    13.  
    14.     @Test
    15.     void contextLoads() {
    16.         System.out.println(bookDao.selectById(2));
    17.     }
    18.  
    19.     @Test
    20.     void testGetAll() {
    21.         System.out.println(bookDao.selectList(null));
    22.     }
    23. }

    运行结果：

    MyBatis-Plus与MyBatis区别

    • 导入坐标不同
    • 数据层实现简化 

     

    小结：

    1. 手工添加MyBatis-Plus对应的starter
    2. 数据层接口使用BaseMapper简化开发
    3. 需要使用的第三方技术无法通过勾选确定时，需要手工添加坐标

    29.SpringBoot整合Druid

    整合任意第三方技术

    • 导入对应的starter
    • 配置对应的设置或采用默认配置

    代码示例：

    BookDao.interface

    1. package com.example.dao;
    2.  
    3. import com.example.domain.Book;
    4. import org.apache.ibatis.annotations.Mapper;
    5. import org.apache.ibatis.annotations.Select;
    6.  
    7. @Mapper
    8. public interface BookDao {
    9.     @Select("select * from tbl_book where id = #{id}")
    10.     public Book getById(Integer id);
    11. }

     Book.class

    1. package com.example.domain;
    2.  
    3. public class Book {
    4.     private Integer id;
    5.     private String type;
    6.     private String name;
    7.     private String description;
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "Book{" +
    12.                 "id=" + id +
    13.                 ", type='" + type + '\'' +
    14.                 ", name='" + name + '\'' +
    15.                 ", description='" + description + '\'' +
    16.                 '}';
    17.     }
    18.  
    19.     public Integer getId() {
    20.         return id;
    21.     }
    22.  
    23.     public void setId(Integer id) {
    24.         this.id = id;
    25.     }
    26.  
    27.     public String getType() {
    28.         return type;
    29.     }
    30.  
    31.     public void setType(String type) {
    32.         this.type = type;
    33.     }
    34.  
    35.     public String getName() {
    36.         return name;
    37.     }
    38.  
    39.     public void setName(String name) {
    40.         this.name = name;
    41.     }
    42.  
    43.     public String getDescription() {
    44.         return description;
    45.     }
    46.  
    47.     public void setDescription(String description) {
    48.         this.description = description;
    49.     }
    50. }

    application.yml

    1. #spring:
    2. #  datasource:
    3. #    driver-class-name: com.mysql.cj.jdbc.Driver
    4. #    url: jdbc:mysql://localhost:3308/test_db
    5. #    username: root
    6. #    password: 666666
    7. #    type: com.alibaba.druid.pool.DruidDataSource
    8.  
    9. spring:
    10.   datasource:
    11.     druid:
    12.       driver-class-name: com.mysql.cj.jdbc.Driver
    13.       url: jdbc:mysql://localhost:3308/test_db
    14.       username: root
    15.       password: 666666

     ApplicationTests

    1. package com.example;
    2.  
    3. import com.example.dao.BookDao;
    4. import org.junit.jupiter.api.Test;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.boot.test.context.SpringBootTest;
    7.  
    8. @SpringBootTest
    9. class ApplicationTests {
    10.  
    11.     @Autowired
    12.     private BookDao bookDao;
    13.  
    14.     @Test
    15.     void contextLoads() {
    16.         System.out.println(bookDao.getById(3));
    17.     }
    18.  
    19. }

    运行结果：

    小结：

    • 整合Druid需要导入Druid对应的starter
    • 根据Druid提供的配置方式进行配置
    • 整合第三方技术通用方式
      • 导入对应的starter
      • 根据提供的配置格式，配置非默认值对应的配置项

    30.SSMP整合案例制作分析

    SSMP整合案例

    • 案例效果演示
    • 案例实现方案分析
      • 实体类开发---使用Lombok快速制作实体类
      • Dao开发----整合MyBatisPlus，制作数据层测试类
      • Service开发----基于MyBatisPlus进行增量开发，制作业务层测试类
      • Controller开发----基于Restful开发，使用PostMan测试接口功能
      • Controller开发----前后端开发协议制作
      • 页面开发--基于VUE+ElementuI制作，前后端联调，页面数据处理，页面消息处理
        • 列表、新增、修改、删除、分页、查询
      • 项目异常处理
      • 按条件查询--—页面功能调整、controller修正功能、Service修正功能

    小结：

    • SSMP案例效果演示
    • SSMP案例制作流程解析
      • 先开发基础CRUD功能，做一层测一层
      • 调通页面，确认异步提交成功后，制作所有功能
      • 添加分页功能与查询功能 
  • 相关阅读:
    JavaScript 循环遍历对象案例
    【CSS】自定义下拉框
    安全狗云原生安全能力守护中国联通安全发展
    安装OCP集群
    连接虚拟机报错 Could not connect to ‘192.168.xxx.xxx‘ (port 22): Connection failed.
    1027 打印沙漏
    6.28日刷题题解
    centos7基础操作
    SpringBoot（一、快速入门）
    400电话-400电话申请-400电话办理开通服务中心
  • 原文地址：https://blog.csdn.net/qq_56444564/article/details/134003809