本文最后更新于 2024-03-03，文章内容可能已经过时。

Springboot基础篇

1、springboot项目的创建方式

方式一：基于idea创建的联网版项目：

①：创建新模块，选择spring Initializr ,并配置模块相关基础信息。

②：选择当前需要集成的技术，以javaweb为例

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

③：创建控制器类

//Rest模式
@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping
    public String getById(){
        System.out.println("springboot is running...");
        return "springboot is running...";
    }
}

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

④：运行自动生成的Application类

方式二：官网上创建springboot项目，下载工程导入至idea

​ 如果Idea不能正常联网，这个SpringBoot程序就无法制作了吗？开什么玩笑，世上IDE工具千千万，难道SpringBoot技术还必须基于Idea来做了？这是不可能的。开发SpringBoot程序，可以不基于任意的IDE工具进行，其实在SpringBoot的官网里面就可以直接创建SpringBoot程序。

官网地址

步骤①：点击Spring Initializr后进入到创建SpringBoot程序的界面上，下面是输入信息的过程，和前面的一样，只是界面变了而已，根据自己的要求，在左侧选择对应信息和输入对应的信息即可

步骤②：右侧的ADD DEPENDENCIES用于选择使用何种技术，和之前勾选的Spring WEB是在做同一件事，仅仅是界面不同而已，点击后打开网页版的技术选择界面

步骤③：所有信息设置完毕后，点击下面左侧按钮，生成一个文件包

步骤④：保存后得到一个压缩文件，这个文件打开后就是创建的SpringBoot工程文件夹了

步骤⑤：解压缩此文件后，得到工程目录，在Idea中导入即可使用，和之前创建的东西完全一样。下面就可以自己创建一个Controller测试一下是否能用了。

温馨提示

​ 做到这里其实可以透漏一个小秘密，Idea工具中创建SpringBoot工程其实连接的就是SpringBoot的官网，走的就是这个过程，只不过Idea把界面给整合了一下，读取到了Spring官网给的信息，然后展示到了Idea的界面中而已，不信你可以看看下面这个步骤

方式三：使用aliyun提供的官网来创建

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

方式四：手动创建

  1. 创建一个普通的maven项目。

  2. 参照标准的springboot工程pom文件，书写自己的pom文件即可。

    1. 主要继承 spring-boot-starter-parent
    2. 添加依赖spring-boot-starter-web

  3. 添加引导类Application

  4. 访问些的控制层程序

如何在idea中隐藏不想看到的文件/文件夹

​ 创建SpringBoot工程时，使用SpringBoot向导也好，阿里云也罢，其实都是为了一个目的，得到一个标准的SpringBoot工程文件结构。这个时候就有新的问题出现了，标准的工程结构中包含了一些未知的文件夹，在开发的时候看起来特别别扭，这一节就来说说这些文件怎么处理。

​ 处理方案无外乎两种，如果你对每一个文件/目录足够了解，没有用的完全可以删除掉，或者不删除，但是看着别扭，就设置文件为看不到就行了。删除不说了，直接Delete掉就好了，这一节说说如何隐藏指定的文件或文件夹信息。

​ 既然是在Idea下做隐藏功能，肯定隶属于Idea的设置，设置方式如下。

步骤①：打开设置，【Files】→【Settings】

步骤②：打开文件类型设置界面，【Editor】→【File Types】→【Ignored Files and Folders】，忽略文件或文件夹显示

步骤③：添加你要隐藏的文件名称或文件夹名称，可以使用*号通配符，表示任意，设置完毕即可

2、springboot 概述

2.1、简介

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

Spring程序缺点

  • 依赖设置繁琐
    • 以前写Spring程序，使用的技术都要自己一个一个的写，现在不需要了，如果做过原始SpringMVC程序的小伙伴应该知道，写SpringMVC程序，最基础的spring-web和spring-webmvc这两个坐标时必须的，就这还不包含你用json啊等等这些坐标，现在呢？一个坐标搞定面
  • 配置繁琐
    • 以前写配置类或者配置文件，然后用什么东西就要自己写加载bean这些东西，现在呢？什么都没写，照样能用。

springboot程序的有点：

  • 起步依赖（简化依赖配置）依赖配置的书写简化就是靠这个起步依赖达成的
  • 自动配置（简化常用工程相关配置）
    • 配置过于繁琐，使用自动配置就可以做响应的简化，但是内部还是很复杂的。
  • 辅助功能（内置服务器，……）
    • 除了上面的功能，其实SpringBoot程序还有其他的一些优势，比如我们没有配置Tomcat服务器，但是能正常运行，这是SpringBoot程序的一个可以感知到的功能，也是SpringBoot的辅助功能之一。

2.2、parent

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

parent 并没有将所有的坐标导入给我们，它仅仅帮助我们进行版本管理，我们在使用还是自己需要用什么依赖就导入什么依赖。

springboot是如何实现这一点的：

  • 项目中的pom.xml文件中继承了一个坐标
<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>
  • 这个坐标中定义了两组属性，第一组是各种各样的依赖版本号属性，第二组是各种各样的依赖坐标信息，它们的版本号是依赖于版本属性值的。
<!-- 版本属性值 -->
<properties>
    <activemq.version>5.16.3</activemq.version>
    <aspectj.version>1.9.7</aspectj.version>
    <assertj.version>3.19.0</assertj.version>
    <commons-codec.version>1.15</commons-codec.version>
    <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
    <commons-lang3.version>3.12.0</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.9.0</commons-pool2.version>
    <h2.version>1.4.200</h2.version>
    <hibernate.version>5.4.32.Final</hibernate.version>
    <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
    <httpclient.version>4.5.13</httpclient.version>
    <jackson-bom.version>2.12.4</jackson-bom.version>
    <javax-jms.version>2.0.1</javax-jms.version>
    <javax-json.version>1.1.4</javax-json.version>
    <javax-websocket.version>1.1</javax-websocket.version>
    <jetty-el.version>9.0.48</jetty-el.version>
    <junit.version>4.13.2</junit.version>
</properties>

<!-- 版本配置信息 -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

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

2.3、starter：使用这些定义的依赖班本管理

SpringBoot一看这种情况，看来需要给开发者带来一些帮助了。安排，把所有的技术使用的固定搭配格式都给开发出来，以后你用某个技术，就不用一次写一堆依赖了，还容易写错，我给你做一个东西，代表一堆东西，开发者使用的时候，直接用我做好的这个东西就好了，对于这样的固定技术搭配，SpringBoot给它起了个名字叫做starter。

​ starter定义了使用某种技术时对于依赖的固定搭配格式，也是一种最佳解决方案，使用starter可以帮助开发者减少依赖配置

示例：

  • 项目中的pom.xml定义了使用SpringMVC技术，但是并没有写SpringMVC的坐标，而是添加了一个名字中包含starter的依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
  • 这个坐标内部其实定义了若干个具体依赖的坐标
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.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>

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

2.4、parent和starter的区别

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

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

2.5、实际开发应用方式

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

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

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

    • 方式一：直接写坐标
    • 方式二：覆盖中定义的版本号，就是下面这堆东西了，哪个冲突了覆盖哪个就OK了
    <properties>
    <activemq.version>5.16.3</activemq.version>
    <aspectj.version>1.9.7</aspectj.version>
    <assertj.version>3.19.0</assertj.version>
    <commons-codec.version>1.15</commons-codec.version>
    <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
    <commons-lang3.version>3.12.0</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.9.0</commons-pool2.version>
    <h2.version>1.4.200</h2.version>
    <hibernate.version>5.4.32.Final</hibernate.version>
    <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
    <httpclient.version>4.5.13</httpclient.version>
    <jackson-bom.version>2.12.4</jackson-bom.version>
    <javax-jms.version>2.0.1</javax-jms.version>
    <javax-json.version>1.1.4</javax-json.version>
    <javax-websocket.version>1.1</javax-websocket.version>
    <jetty-el.version>9.0.48</jetty-el.version>
    <junit.version>4.13.2</junit.version>
</properties>

温馨提示

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

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

所以以后见了spring-boot-starter-aaa这样的名字，这就是SpringBoot官方给出的starter定义。那非官方定义的也有吗？有的，具体命名方式到整合章节再说。

2.6、引导类

目前程序运行的入口就是SpringBoot工程创建时自带的那个类了，带有main方法的那个类，运行这个类就可以启动SpringBoot工程的运行。

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

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

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

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

2.7、内嵌tomcat

定义位置：在我们之前定义的 starter-web中有内嵌的tomcat核心

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

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

<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>
    <!-- 第三个依赖就是我们对应的tomcat东西了 -->
    <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>

打开第三个依赖里边的依赖配置如下：

<dependencies>
    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>1.3.5</version>
        <scope>compile</scope>
    </dependency>
    <!-- tomcat的内嵌核心 -->
    <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>

内嵌tomcat运行的原理：

​ Tomcat服务器是一款软件，而且是一款使用java语言开发的软件，熟悉的小伙伴可能有印象，tomcat安装目录中保存有jar，好多个jar。

​ 下面的问题来了，既然是使用java语言开发的，运行的时候肯定符合java程序运行的原理，java程序运行靠的是什么？对象呀，一切皆对象，万物皆对象。那tomcat运行起来呢？也是对象。

​ 如果是对象，那Spring容器是用来管理对象的，这个对象能不能交给Spring容器管理呢？把吗去掉，是个对象都可以交给Spring容器管理，行了，这下通了。tomcat服务器运行其实是以对象的形式在Spring容器中运行的，怪不得我们没有安装这个tomcat，而且还能用。闹了白天这东西最后是以一个对象的形式存在，保存在Spring容器中悄悄运行的。具体运行的是什么呢？其实就是上前面提到的那个tomcat内嵌核心。

那既然是个对象，如果把这个对象从Spring容器中去掉是不是就没有web服务器的功能呢？是这样的，通过依赖排除可以去掉这个web服务器功能

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

​ 上面对web-starter做了一个操作，使用maven的排除依赖去掉了使用tomcat的starter。这下好了，容器中肯定没有这个对象了，重新启动程序可以观察到程序运行了，但是并没有像之前那样运行后会等着用户发请求，而是直接停掉了，就是这个原因了。

2.8、更换内嵌Tomcat

那根据上面的操作我们思考是否可以换个服务器呢？必须的嘛。根据SpringBoot的工作机制，用什么技术，加入什么依赖就行了。SpringBoot提供了3款内置的服务器

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

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

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

    想用哪个，加个坐标就OK。前提是把tomcat排除掉，因为tomcat是默认加载的。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
</dependencies>

现在就已经成功替换了web服务器，核心思想就是用什么加入对应坐标就可以了。如果有starter，优先使用starter。

3、基础配置

3.1、复制工程

3.2、基础配置

服务器端口配置（application.properties）

server.port = 80

关闭运行日志图标

spring.main.banner-mode=off

设置日志相关

logging.level.root=debug

springboot内置属性查询网址

3.3、springboot提供的多种属性配置

  • properties 传统的默认格式

  • yml 主流格式

  • yaml

配置文件的优先级：

  • properties 最高
  • yml
  • yaml 最低

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

3.4、如何解决配置文件提示消失的问题

3.5、yaml

一种数据序列化格式，其优点主要如下：

  • 容易阅读
  • 容易与脚本语言交互
  • 以数据为核心，重数据轻格式

yaml有两种文件扩展名：yaml、yml，yml是目前最主流的格式。

3.6、yaml的语法规则

  • 大小写敏感

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

  • 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格，不允许使用tab键，因为不同操作系统的Tab键所缩进量是不一致的。

  • 属性值前边加空格

  • #表示注释

  • 核心规则：数据前面必须加空格与冒号隔开

演示：

  1. 字面值方式
boolean: TRUE   # true,false,TRUE,FALSE均可
float: 3.14     # 支持科学计数法
int: 123       # 支持二进制 八进制 十六进制
null: ~        # 使用 ~ 表示 null
string: Helloworld   # 字符串可以直接书写 也可以支持字符串的书写
date: 2018-02-17      # 日期必须使用 yyyy-MM-dd格式
datetime: 2018-02-17T15:02:31+08:00  # 时间和日期之间使用 T 链接 最后使用 + 代表时区
  1. 数组表示方式
# 普通数组表示方法
subject:
  - java
  - web
  - python
enterprise:
  name: itcast
  age: 18
  subject:
    - java
    - web
    - python
    
likes: [wang,wei]

对象数组表示方式

# 表示方法二
users:
  - name: Tom
    age: 18
  - name: lucy
    age: 20

users:
  -
    name: wei
    age: 18
  - 
    name: lucy
    age:20
    
users: [ {name:Tom,age:4},{name:jerry,age:5} ]

3.7、yaml数据格式的读取方式

  • 使用 @Value 读取单个数据，属性名引用方式：${一级属性名.二级属性名.....}
users:
  - name: Tom
    age: 18
  - name: lucy
    age: 20

读取上边数据：

@Value("${users[0].name}")
private String name;

打印结果显示 Tom

在配置文件中也可以将一些名称相同的配置进行统一管理，然后使用 ${配置名}，如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析。

  • 封装全部数据到 Enviroment 对象，通过该对象.getProperty(“属性名”) 来获取对应的属性。
@RestController
@RequestMapping("/books")
public void BookController(){
    @Autowired
    private  Enviroment env;
    @GetMapping("/{id}")
    public String getById(@PathVariable Interger id){
        System.out.println(env.getProperty("server.port"));
        
    }
}
  • 自定义对象封装指定数据
jdbc:
  drver: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://localhost:3306?sys_user
  username: root
  password: 123465

@Component
@ConfigurationProperties(prefix="jdbc")
public class DataSource{
    private String driver;
    private String url;
    private String username;
    private String password;
}

// 获取自定义封装的类对象
@RestController
@RequestMapping("/books")
public class BookController(){
    @Autowired
    private DataSource datasource;
}

使用自定义的对象封装指定数据的要点：

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

4、整合第三方技术

4.1、整合junit

  • spring 整合junit
@SpringBootTest
class Springboot07JunitApplicationTests {
	@Autowired
	private BookService bookService;
	@Test
	public void testSave(){
		bookService.save();
	}
}

整合要点：

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

如果测试类没有在springboot启动类的包或子包中，必须要设置classes={ 引导类}

@SpringTest(classes={Application.class})

4.2、整合mybatis

  1. 在项目初始化的时候，勾选 mybtais Framework 对应的 starter，数据库驱动池
  2. 数据库连接信息转换成yaml文件的中的配置
spring:
  datasource:
  driver-class-name: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://localhost:3306/ssm_db
  username: root
  password: root
  1. 数据库sql映射需要添加 @Mapper 被容器识别到

注意事项：

  • spring boot项目版本低于 2.4.3（不含），mysql 驱动版本大于8.0时，需要在url中拼接配置时区。
jdbc:mysql://localhost:3306/sys_test?serverTimezone= UTC
  • mysql8.0版本的数据库驱动名为 com.mysql.cj.jdbc.Driver

4.3、整合 Mybatis-plus

整合 mybatis 与 mybatis-plus 的区别

  • 导入坐标不同，如果使用官网的网址来创建项目，是没有坐标的，需要自己手动来添加坐标。也可以使用阿里云提供的项目创建方式来勾选mybtais-plus 坐标。
  • 数据层实现了简化。数据层可以通过继承 BaseMapper 这个类，通过在泛型中添加一个实体类型来获得父类中的基本增删改查方法。

具体开发步骤：

①：手动添加 Springboot整合 Mybatis-plus的坐标。

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

由于Springboot位收录myatis-plus的坐标，要指定对应的version

②：定义数据层接口与映射配置，继承 BaseMapper

@Mapper
public interface UserDao extends BaseMapper<User>{
 	// 里边通过继承父类BaseMapper 的方法，注入实体类 user 可以将user类实体的数据基本的增删改查方法获得。   
}

③：配置数据源，与mybatis 一致，不多做演示。

mybaits-plus 的日志调试

mybatis-plus:
  configuration:
    log-imol: org.apche.ibatis.logging.stdout.StrOutImpl

4.4、整合数据库连接池 Druid

  • 指定数据源类型
  • 导入对应的 springboot Starter
  • 根据 druid 提供的配置方式来进行数据源的配置。

4.5、基于 Springboot 的 ssmp 整合案例：

整和 ssmp 的核心原理就是在项目初始化的时候勾选我们开发时相应的依赖包。对于mybatis-plus 包我们需要手动导入，然后配置mybatis-plus的数据源。

4.5.1、数据层的开发：

  1. 分页功能

分页操作实在Mybatis-plus 的常规基础操作上增强得到，内部得到的是动态拼写的 SQL 语句，因此需要增强对应的功能，使用mybatis-plus拦截器实现

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加具体的拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

分页的具体代码实现：

@Override
public IPage<Book> getPage(int currentPage, int pageSize,Book book) {
    LambdaQueryWrapper<Book> blq = new LambdaQueryWrapper<>();
    // 拼接的分页条件查询
    blq.like(!("".equals(book.getType())),Book::getType,book.getType());
    blq.like(!("".equals(book.getName())),Book::getName,book.getName());
    blq.like(!("".equals(book.getDescription())),Book::getDescription,book.getDescription());
    // 将所有的查询对象对象封装在 Ipage 对象中。
    IPage bookPage = new Page(currentPage, pageSize);
    bookDao.selectPage(bookPage,blq);
    return bookPage;
}

4.5.2、业务层开发

在业务层开发的时候注意和数据层接口的定义具有较大区别，不要混用。比如对于登录功能而言，在业务层的方法名就是 login(String username,String password) ，在数据层接口的方法就是 selectUsernameAndPassword(String username,String password) 。

通常我们的业务层开发中，实在业务层上定义我们的业务接口，然后在定义一个实现类，在实现类中实现我们所有定义的方法。在这个案例中，由于我们使用的是 mybatis-plus 所以可以通过 mybatis-plus 提供的业务层开发方式简化我们的业务层开发。

  • 接口定义的时候继承 IService<业务层需要使用到的实体类>，**可以追加操作，追加的时候我们的方法名和继承的方法名是通过方法名称的不一致来区别的。**如下图所示：

image-20220519114255634

  • 实现类的定义
@Service
public class BookService extends ServiceImpl<BookDao,Book> implements IBookService{
    
}

总结：

①：使用通用接口 IService<T> 快速开发Service

②：使用通用实现类 ServiceImpl<M,T> 快速开发 ServiceImpl

③：可以在接口基础上做功能的重载或功能追加

④：注意重载时不要覆盖原始操作，避免原始操作提供的功能丢失。

4.5.3、表现层开发

  • 基于 Restful 进行表现层接口开发
  • 基于 Postman 测试表现层接口功能

1、基于 Restful 制作表现层接口

  • 新增 ： POST
  • 删除：DELETE
  • 修改： PUT
  • 查询：GET

2、接收参数

  • 实体数据：@RequestBody
  • 路径变量：@PathVariable

3、表现层消息一致性处理

为了将发送给前端的数据格式进行统一，封装一个 Result 实体对象，也称为前后端数据协议，其属性如下：

class Result{
	private boolean flag;// 表示操作是否成功
    private String msg;  // 错误和异常信息
    private Object data; // 操作之后的数据封装在data对象里边
}

4.5.4、后端异常处理：

数据层和业务层开发中的异常无需多做处理，直接抛出异常，交由控制层处理：在springboot项目中，我们可以使用@RestControllerAdvice 来标注他是一个异常处理类，在类里边我们可以使用@ExceptionHandler(异常类型)来处理不同类别的异常，示例如下：

package com.cxsw.controller.utils;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * @author xianXin
 * @date 2022-05-18
 */
@RestControllerAdvice
public class ProjectExceptionAdvice {

    @ExceptionHandler(Exception.class)
    public Result handlerException(Exception exception){
        exception.printStackTrace();
        return new Result(false,"服务端异常");
    }
}

4.5.5、前端静态资源

前端静态资源存放在static中。

总结：

  1. 配置起步依赖。pom.xml
  2. application.yml 配置文件中设置数据源、端口、技术、框架技术相关配置等。
  3. dao 层，继承 BaseMapper、设置 @Mapper，识别组件将对象注入spring对象中。
  4. service 层，调用数据层接口或者mybatis-plus提供的接口快速开发。
  5. controller 层，基于 Restful 风格开发，使用 postman 测试其是否跑通功能。
  6. 页面存放在 resourcers 目录下的 static 目录下。