一，初始 MyBatis-Plus

一，初始 MyBatis-Plus

@
目次

• 一，初始 MyBatis-Plus
  
• 1. MyBatis-Plus 的概述
  
• 2. 入门设置第一个 MyBatis-Plus 案例
  
• 3. 补充说明：
  
  
  
  • 3.1 通用 Mapper 接口先容
    
    
    
    • 3.1.1 Mapper 接口的 “增删改查”
      
      
      
      • 3.1.1.1 查询所有记录
        
      • 3.1.1.2 插入一条数据
        
      • 3.1.1.3 删除一条数据
        
      • 3.1.1.4 更新一条数据
        
      • 3.1.1.5 查询一条数据
        
      
      
    
    
  • 3.2 通用 service接口先容
    
    
    
    • 3.2.1 Service 接口的“增删改查”
      
      
      
      • 3.2.1.1 添加一条记录
        
      • 3.2.1.2 删除一条记录
        
      • 3.2.1.3 修改一条记录
        
      • 3.2.1.4 查询一条记录
        
      
      
    
    
  • 3.3 自界说方法
    
    
    
    • 3.3.1 自界说Mapper接口方法
      
    
    
  
  
• 4. 总结：
  
• 6. 最后：
  

1. MyBatis-Plus 的概述

学习 MyBatis -Plus 之前，我们可以先来简单的，轻微的，回顾一下，MyBatis 框架的一些问题：
这里只是简单的回顾，关于MyBatis 的更多具体内容各人可以移步至：✏️✏️✏️ MyBatis_ChinaRainbowSea的博客-CSDN博客
我们来简单思考一下，MyBatis 框架的开发效率怎么样？

开发效率也就是我们使用这款框架开发的速度快不快，是否简单好用易上手。从这个角度思考，每当我们需要编写一个SQL需求的时间，我们需要做几步：

• Mapper 接口提供一个抽象方法。
  
• Mapper 接口对应的映射设置文件提供对应的标签和SQL语句
  
• 在 Service 中依赖 Mapper 实例对象
  
• 调用 Mapper 实例中的方法
  
• 在Controller 中依赖 Service 实例对象
  
• 调用 Service 实例中的方法
  

通过上面的发现，对于一个SQL需求，无论是单表照旧多表，我们是需要完成如上几步，才气实现SQL需求的开发。

但是在开发中，有一些操纵是通过逻辑，这些通用逻辑是可以被简化的，比方：

• 对于 dao ，是否可以由框架帮我们提供好单表的 Mapper 抽象方法，和对应的SQL实现，不需要程序员去实现这些。
  
• 对于 service，使用可以有框架直接帮我们提供好一些 serivce 的抽象方法，和对应的实现，不需要程序员去实现这些。
  
• 一些别的的企业开发中所需要的操纵
  

分析到这里我们发现，其实核心框架并没有发生变化，依赖照旧 Mybatis，只不外我们希望对于 MyBatis 进行一些封装和优化，让他更加的好用，更加的易用。
以是：MyBatis Plus 它就来了，它是 MyBatis 的一款增强工具。

MybatisPlus，从名称上来看，我们就发现，他和Mybatis长得很像，其实MybatisPlus就是Mybatis的孪生兄弟。学习MyBatis-Plus 首先，我们来看看它的官网地点是：https://baomidou.com/

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

愿景
我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

MyBatis-Plus的特性说明：

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  
• 损耗小：启动即会自动注入根本 CURD，性能根本无损耗，直接面向对象操纵
  
• 强盛的 CRUD 操纵：内置通用 Mapper、通用 Service，仅仅通过少量设置即可实现单表大部分 CRUD 操纵，更有强盛的条件构造器，满足各类使用需求
  
• 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  
• 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由设置，完善解决主键问题
  
• 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继续 Model 类即可进行强盛的 CRUD 操纵
  
• 支持自界说全局通用操纵：支持全局通用方法注入（ Write once, use anywhere ）
  
• 内置代码生成器：采用代码大概 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自界说设置等您来使用
  
• 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操纵，设置好插件之后，写分页等同于普通 List 查询
  
• 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  
• 内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  
• 内置全局拦截插件：提供全表 delete 、 update 操纵智能分析阻断，也可自界说拦截规则，预防误操纵
  

MyBatis-Plus 的框架结构：

什么是Mybatis框架呢，他是一个持久层框架，目的是简化持久层的开发。在这里我们就使用springboot整合Mybatis，实现Mybatis框架的搭建。

特别说明：这里这个是 IDEA 2021 创建项目的操纵步调：
我们首先创建一个空的工程

工程名称是mp

创建springboot模块

这里我们选择springboot2.7.8的版本，并不勾选依赖，随后通过pom.xml手动添加

特别说明：下面这个是：IDEA 2024 的操纵设置

2. 入门设置第一个 MyBatis-Plus 案例

第一步：  创建数据库 mybatisplus

这些测试表，是来自于 MyBatis-Plus 官网教学的内容，各人也可以移步去看看：✏️✏️✏️ https://baomidou.com/getting-started/

现有一张 User 表，其表结构如下：
idnameageemail1Jone18test1@baomidou.com2Jack20test2@baomidou.com3Tom28test3@baomidou.com4Sandy21test4@baomidou.com5Billie24test5@baomidou.com其对应的数据库 Schema 脚本如下：

1. DROP TABLE IF EXISTS `user`;
3. CREATE TABLE `user`
4. (
5.     id BIGINT NOT NULL COMMENT '主键ID',
6.     name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
7.     age INT NULL DEFAULT NULL COMMENT '年龄',
8.     email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
9.     PRIMARY KEY (id)
10. );

复制代码

其对应的数据库 Data 脚本如下：

1. DELETE FROM `user`;
3. INSERT INTO `user` (id, name, age, email) VALUES
4. (1, 'Jone', 18, 'test1@baomidou.com'),
5. (2, 'Jack', 20, 'test2@baomidou.com'),
6. (3, 'Tom', 28, 'test3@baomidou.com'),
7. (4, 'Sandy', 21, 'test4@baomidou.com'),
8. (5, 'Billie', 24, 'test5@baomidou.com');

复制代码

第二步： 引入相关依赖，在 pom.xml 文件当中设置我们所需要的 jar 依赖。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
5.     <parent>
6.         <groupId>org.springframework.boot</groupId>
7.         <artifactId>spring-boot-starter-parent</artifactId>
8.         <version>2.5.3</version>
9.         <relativePath/>
10.     </parent>
11.     <groupId>com.rainbowsea</groupId>
12.     <artifactId>mp02</artifactId>
13.     <version>0.0.1-SNAPSHOT</version>
14.     <name>mp02</name>
15.     <description>mp02</description>
16.     <url/>
17.     <licenses>
18.         <license/>
19.     </licenses>
20.     <developers>
21.         <developer/>
22.     </developers>
23.     <scm>
24.         <connection/>
25.         <developerConnection/>
26.         <tag/>
27.         <url/>
28.     </scm>
29.     <properties>
30.         <java.version>8</java.version>
31.     </properties>
32.     <dependencies>
33.         <dependency>
34.             <groupId>org.springframework.boot</groupId>
35.             <artifactId>spring-boot-starter</artifactId>
36.         </dependency>
38.         <dependency>
39.             <groupId>org.springframework.boot</groupId>
40.             <artifactId>spring-boot-starter-test</artifactId>
41.             <scope>test</scope>
42.         </dependency>
45.         
46.         <dependency>
47.             <groupId>org.springframework.boot</groupId>
48.             <artifactId>spring-boot-starter-web</artifactId>
49.         </dependency>
52.         
53.         <dependency>
54.             <groupId>mysql</groupId>
55.             <artifactId>mysql-connector-java</artifactId>
56.         </dependency>
58.         
59.         <dependency>
60.             <groupId>org.projectlombok</groupId>
61.             <artifactId>lombok</artifactId>
62.         </dependency>
64.         
65.         <dependency>
66.             <groupId>com.alibaba</groupId>
67.             <artifactId>druid</artifactId>
68.             <version>1.2.8</version>
69.         </dependency>
71.         
72.         <dependency>
73.             <groupId>com.baomidou</groupId>
74.             <artifactId>mybatis-plus-boot-starter</artifactId>
75.             <version>3.4.3</version>
76.         </dependency>
79.     </dependencies>
81.     <build>
82.         <plugins>
83.             <plugin>
84.                 <groupId>org.springframework.boot</groupId>
85.                 <artifactId>spring-boot-maven-plugin</artifactId>
86.             </plugin>
87.         </plugins>
88.     </build>
89.     <repositories>
90.         <repository>
91.             <id>spring-snapshots</id>
92.             <name>Spring Snapshots</name>
93.             <url>https://repo.spring.io/snapshot</url>
94.             <releases>
95.                 <enabled>false</enabled>
96.             </releases>
97.         </repository>
98.     </repositories>
99.     <pluginRepositories>
100.         <pluginRepository>
101.             <id>spring-snapshots</id>
102.             <name>Spring Snapshots</name>
103.             <url>https://repo.spring.io/snapshot</url>
104.             <releases>
105.                 <enabled>false</enabled>
106.             </releases>
107.         </pluginRepository>
108.     </pluginRepositories>
110. </project>

复制代码

特别说明：这里我们，将 Spring boot 改为：2.5.3 版本的。

在：MyBatis-Plus 当中是包含了MyBatis 的依赖的。以是，引入了 MyBatis-Plus 也就引入了MyBatis了。

第三步： 编写该项目/模块的场景启动器：

第四步： 根据数据表创建对应的实体类：

1. package com.rainbowsea.bean;
3. import lombok.AllArgsConstructor;
4. import lombok.Data;
5. import lombok.NoArgsConstructor;
7. @Data
8. @NoArgsConstructor
9. @AllArgsConstructor
10. public class User {
12.     private Long id;
13.     private String name;
14.     private Integer age;
15.     private String email;
16. }

复制代码

第五步： 切换数据库连接池为 Druid 。这里我们编写设置类的方式，切换数据库连接池。

• 在 resoucre 类路径下，创建名为 applicaiton.yaml 的设置文件，其中编写连接数据库的设置信息。
  

1. spring:
2.   datasource:
3.     driver-class-name: com.mysql.cj.jdbc.Driver
4.     url: jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
5.     username: root
6.     password: MySQL123

复制代码

• 编写设置类，切换数据库为 Druid
  

1. package com.rainbowsea.config;
4. import com.alibaba.druid.pool.DruidDataSource;
6. import org.springframework.boot.context.properties.ConfigurationProperties;
7. import org.springframework.context.annotation.Bean;
8. import org.springframework.context.annotation.Configuration;
10. import javax.sql.DataSource;
12. /**
13. * 配置切换，Druid 数据库连接池
14. */
15. @Configuration  // 标志配置类
16. public class DruidDataSourceConfig {
19.     @Bean  // 被 Spring ioc 容器管理起来
20.     @ConfigurationProperties(value = "spring.datasource")
21.     public DataSource getDataSource() {
22.         DruidDataSource druidDataSource = new DruidDataSource();
24.         return druidDataSource;
25.     }
26. }

复制代码

特别说明：关于spring boot 中切换数据库连接池的具体内容，各人可以移步至：✏️✏️✏️  十六，Spring Boot 整合 Druid 以及使用 Druid 监控功能-CSDN博客

测试：看看我们是否成功切换为了 Druid 数据库连接池。

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
15.     @Resource
16.     private JdbcTemplate jdbcTemplate;
18.     @Test
19.     void contextLoads() {
20.         System.out.println(jdbcTemplate.getDataSource().getClass());
22.     }
23. }

复制代码

第六步： 背面的都是对应 MyBatis-Plus 的内容上的重点内容。
编写 Mapper接口

1. package com.rainbowsea.mapper;
4. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
5. import com.rainbowsea.bean.User;
6. import org.apache.ibatis.annotations.Mapper;
8. @Mapper // 被Spring Boot 扫描到
9. public interface UserMapper extends BaseMapper<User> {
12. }

复制代码

我们的自己编写的 Mapper  接口 extends(继续) BaseMapper 接口就会拥有了其该接口下的方法。

第七步： 编写 Service 接口

1. package com.rainbowsea.service;
3. import com.baomidou.mybatisplus.extension.service.IService;
4. import com.rainbowsea.bean.User;
6. import java.util.List;
8. public interface UserService extends IService<User> {
10.     // 当 IService 当中提供的方法，不能满足我们的业务需要的时候，
11.     // 我们可以自定义方法。
12.     // 自定义的方法
13.     List<User> selectAll();
14. }

复制代码

第八步： 编写ServiceImpl

1. package com.rainbowsea.service.Impl;
3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
4. import com.rainbowsea.bean.User;
5. import com.rainbowsea.mapper.UserMapper;
6. import com.rainbowsea.service.UserService;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.stereotype.Service;
10. import javax.annotation.Resource;
11. import java.util.Collections;
12. import java.util.List;
15. @Service
16. public class UserServiceImpl extends ServiceImpl<UserMapper,User>
17.         implements UserService  {
19.     //@Resource
20.     @Autowired  // 自动装配
21.     private UserMapper userMapper;
24.     // 对自定义方法的，重写实现
25.     @Override
26.     public List<User> selectAll() {
27.         return userMapper.selectList(null);
28.     }
29. }

复制代码

它们之间的关系结构如下：

第九步：编写Controller 控制器：

1. package com.rainbowsea.controller;
4. import com.rainbowsea.bean.User;
5. import com.rainbowsea.service.UserService;
6. import org.springframework.web.bind.annotation.GetMapping;
7. import org.springframework.web.bind.annotation.RestController;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @RestController
13. public class UserController {
15.     @Resource
16.     private UserService userService;
19.     @GetMapping(value = {"/selectList"})
20.     public List<User> selectList() {
21.         return userService.selectAll();
22.     }
23. }

复制代码

第十一步 ：打开浏览器运行测试。

3. 补充说明：

3.1 通用 Mapper 接口先容

有关于 Mapper 接口，之前我们已经看到了，我们自己编写的Mapper接口继续 自己 BaseMapper 接口，由 BaseMapper 接口提供了很多单表的增删改查 相关的操纵方法，在入门案例种，我们测试了查询所有的操纵。我们先容一些简单的Mapper 接口中的方法，主要是感觉一下。Mapper接口中对于单表的增删改查的操纵都有涉及，更加高级的一些操纵。

3.1.1 Mapper 接口的 “增删改查”

3.1.1.1 查询所有记录

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
16.     @Resource
17.     private UserMapper userMapper;
20.     // 查询所有
21.     @Test
22.     void selectList() {
23.         List<User> users = userMapper.selectList(null);
25.         for (User user : users) {
26.             System.out.println(user);
27.         }
28.     }
29. }

复制代码

3.1.1.2 插入一条数据

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
16.     @Resource
17.     private UserMapper userMapper;
19.     // 简单添加
20.     @Test
21.     void insert() {
23.         User user = new User();
24.         user.setId(6L);
25.         user.setAge(18);
26.         user.setName("Lihua");
27.         user.setEmail("test6@baomidou.com");
28.         userMapper.insert(user);
29.     }
30. }

复制代码

3.1.1.3 删除一条数据

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
16.     @Resource
17.     private UserMapper userMapper;
21.     // 简单删除
22.     @Test
23.     void deleteOne() {
24.         userMapper.deleteById(4L);
26.     }
28. }

复制代码

3.1.1.4 更新一条数据

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Resource
15.     private UserMapper userMapper;
17.     // 简单更新
18.     @Test
19.     void updateById() {
20.         User user = new User();
21.         user.setId(2L);
22.         user.setAge(18);
23.         user.setName("李华");
24.         user.setEmail("lihua@baomidou.com");
26.         userMapper.updateById(user);
27.     }
29. }

复制代码

3.1.1.5 查询一条数据

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Resource
15.     private UserMapper userMapper;
17.     // 简单查询
18.     @Test
19.     void selectById() {
20.         User user = userMapper.selectById(6L);
21.         System.out.println(user);
22.     }
24. }

复制代码

3.2 通用 service接口先容

除了Mapper接口，MybatisPlus还提供了IService接口和对应的实现类ServiceImpl，该实现类已经提供好了一些对应的Service相关的方法，在某些场景下，我们可以直接使用ServiceImpl提供的方法，实现对应的功能。
IService接口

IService接口中包含了service相关的一些增删改查方法

ServiceImpl实现类

ServiceImpl实现类提供了service相关的增删改查方法的实现

UserService接口继续自IService接口

UserServiceImpl类继续ServiceImpl

注入UserService对象，测试相关方法

3.2.1 Service 接口的“增删改查”

3.2.1.1 添加一条记录

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Autowired
15.     private UserService userService;
16.    
17.     //  UserService 添加
18.     @Test
19.     void insertService() {
20.         User user = new User();
21.         user.setId(7L);
22.         user.setAge(18);
23.         user.setName("Tom");
24.         user.setEmail("Tom@baomidou.com");
26.         userService.save(user);
28.     }
30. }

复制代码

3.2.1.2 删除一条记录

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Autowired
15.     private UserService userService;
18.     // UserService 删除
19.     @Test
20.     void deleteServie() {
21.         userService.removeById(2L);
22.     }
23. }

复制代码

3.2.1.3 修改一条记录

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Autowired
15.     private UserService userService;
17.     // userService 修改
18.     @Test
19.     void updateService() {
20.         User user = new User();
21.         user.setId(3L);
22.         user.setAge(22);
24.         userService.updateById(user);
25.     }
28. }

复制代码

3.2.1.4 查询一条记录

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
14.     @Autowired
15.     private UserService userService;
19.     // UserService 查询
20.     @Test
21.     void selectService() {
22.         List<User> users = userService.selectAll();
23.         for (User user : users) {
24.             System.out.println(user);
25.         }
26.     }
27. }

复制代码

3.3 自界说方法

MybatisPlus除了给我们提供了这些丰富的接口方法以外，对于我们自己的需求，也可以编写自界说的接口方法，我们通过自己编写SQL语句的形式，实现想要的SQL需求
3.3.1 自界说Mapper接口方法

Mapper接口中提供抽象方法

1. package com.rainbowsea.mapper;
4. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
5. import com.rainbowsea.bean.User;
6. import org.apache.ibatis.annotations.Mapper;
8. @Mapper // 被Spring Boot 扫描到
9. public interface UserMapper extends BaseMapper<User> {
11.     // 自定义方法
12.   User selectByName(String name);
14. }

复制代码

提供映射设置文件，提供对应的SQL语句

注意：对应的映射的 SQL 设置文件的路径/包要同等，以及名称也要同等，才行。

1. <?xml version="1.0" encoding="UTF-8"?>
3. <!DOCTYPE mapper
4.                 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
5.                 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
7. <mapper namespace="com.rainbowsea.mapper.UserMapper" >
9.         <select id="selectByName" resultType="com.rainbowsea.bean.User" parameterType="string">
10.                 select id,age,name,email
11.                 from user
12.                 where name = #{value}
14.         </select>
15. </mapper>

复制代码

测试自界说的Mapper接口方法

1. import com.rainbowsea.bean.User;
2. import com.rainbowsea.mapper.UserMapper;
3. import com.rainbowsea.service.UserService;
4. import org.junit.jupiter.api.Test;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.boot.test.context.SpringBootTest;
7. import org.springframework.jdbc.core.JdbcTemplate;
9. import javax.annotation.Resource;
10. import java.util.List;
12. @SpringBootTest(classes = Mp02Application.class)  // Spring Boot 当中的测试，必须要有 项目的启动场景，不然无法测试报错
13. class Mp02ApplicationTests {
15.     @Resource
16.     private UserMapper userMapper;
19.     // 测试自定义方法
20.     @Test
21.     void myMethod() {
22.         User tom = userMapper.selectByName("Lihua");
23.         System.out.println(tom);
24.     }
25. }

复制代码

4. 总结：

• MyBatis-Plus官网地点：https://baomidou.com/
  
• MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
  
• 记忆理解 MyBatis-Plus 内置的 Mapper 接口，和 Service 接口
  

6. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上罗致了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。