近期也是计划学习mybatis-plus,扩展知识;
推荐官方文档食用学习–>https://baomidou.com/
Mybatis-plus官方文档

本次学习根据B站尚硅谷教学视频:【尚硅谷】2022版MyBatisPlus教程（一套玩转mybatis-plus）

---

1.基本概述

---

Mybatis-plus是一个Mybatis增强工具,简化开发,提升效率;提供通用的mapper映射和service服务.可选择不编写SQL,完成对于简单的单个数据表进行CRUD,批量查询,分页,删除操作.

---

---

2.入门案例搭建

---

首先创建数据表

CREATE DATABASE `mybatis_plus_study_xiaozhi` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
USE `mybatis_plus_study_xiaozhi`;
CREATE TABLE `user` (
`id` BIGINT(20) NOT NULL COMMENT '主键ID',
`name` VARCHAR(30) DEFAULT NULL COMMENT '姓名',
`age` INT(11) DEFAULT NULL COMMENT '年龄',
`email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9

填充部分数据

#填充数据;
INSERT INTO USER (id, NAME, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');
1
2
3
4
5
6
7

然后创建一个基础的springboot工程;

注意调整位置

然后在pom.xml文件中引入依赖;

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--mybatis-plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.1</version>
    </dependency>
    <!--lombok工具-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!--mysql连接驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

当然,要保证安装了lombok插件,不然无法使用依赖的lombok功能;

---

配置application.yml文件,主要配置数据库对应文件.

# 设置数据源类型,数据库信息;
spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:mysql://127.0.0.1:3306/mybatis_plus_study_xiaozhi?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=Asia/Shanghai
    username: root
    password: 数据库密码
    driver-class-name: com.mysql.cj.jdbc.Driver
1
2
3
4
5
6
7
8

进行实体类的创建使用,采用lombok插件生成方法等.

/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus.entity
 * @Author: 信计1801 李智青
 * @Date: 2022/5/30 20:18
 * @Description: 用户实体类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor

public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

然后是创建mapper接口.

需要继承BaseMapper接口,作为一个基础的持久层接口,包含了一些内置的方法;

/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus.mapper
 * @Author: 信计1801 李智青
 * @Date: 2022/5/30 20:27
 * @Description: 用户类持久层映射接口
 */
 @Repository
public interface UserMapper extends BaseMapper<User> {

}
1
2
3
4
5
6
7
8
9
10
11

然后在核心的启动类配置; @MapperScan用于扫描mapper影射接口所在的包;

创建测试类MybatisPlusTest,进行入门案例测试;

注意在之前使用mybatis的时候,需要在mapper接口中定义方法之后,然后在对应的mapper映射文件中编写sql进行使用; 但本次使用的mybatis-plus则可以直接省略其中的一些步骤;

比如写一个查询数据表的所有信息,封装到list集合中,由于不需要其他的参数,所以这个Wrapper不需要编写查询的条件;

/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus
 * @Author: 信计1801 李智青
 * @Date: 2022/6/4 16:01
 * @Description: 测试类
 */
@SpringBootTest
public class MybatisPlusTest {
    //使用mapper映射接口;
    @Autowired
    UserMapper userMapper;

    //第一个测试方法;尝试查询整个数据表的数据;封装到集合中进行显示;
    @Test
    public void startTestOne(){
        //查询一个list集合;无条件可设置参数为null;
        List<User> usersList = userMapper.selectList(null);
        //输出查询的结果;
        usersList.forEach(System.out::println);
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果;可完整查询到数据表中的数据信息;

---

加入日志功能

打开application.yml配置文件;

# 设置数据源类型,数据库信息;
spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:mysql://127.0.0.1:3306/mybatis_plus_study_xiaozhi?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=Asia/Shanghai
    username: root
    password: 数据库密码
    driver-class-name: com.mysql.cj.jdbc.Driver
#加入日志功能;
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
1
2
3
4
5
6
7
8
9
10
11
12

再次运行入门案例测试类;即可看到在执行查询数据表时采用的sql语句执行过程;

那么再次回顾一下执行的操作,实际上并没有编写查询的SQL,但是它自动生成了查询的sql进行查询;

实际上,首先扫描实体类User,将实体类的属性进行抽取,对应数据表的字段;再生成sql,存入到容器中.

---

3.BaseMapper

---

3.1新增功能测试

---

在测试类MybatisPlusTest中编写测试方法;
使用内置的insert方法,将创建的User对象属性传入,当然在新增插入数据后,也可以立即获取主键;

//测试新增功能;
@Test
public void startAdd(){
    User user = new User();
    user.setName("小智");
    user.setAge(22);
    user.setEmail("xiaozhi@ceshi.com");
    //新增数据;
    int insert = userMapper.insert(user);
    //是否添加成功;
    System.out.println("新增了"+insert+"条数据----------");
    //立即获取到添加数据的主键Id;
    System.out.println("立即获取新增的用户主键:"+user.getId());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行之;

实际执行语句

INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )

这里发现新增的主键id,并未按照预期的6;而是1533009403773566978;
那么它为何生成这样的id呢?实际采用了雪花算法生成Id,具体会在后半部分进行介绍;

---

3.2删除功能测试

---

查看BaseMapper接口定义的方法,删除方法有5个;可根据id删除;根据map集合删除,根据条件构造器删除,根据多个id批量删除;

在测试类MybatisPlusTest中编写测试方法;

首先看根据id删除

比如说根据id删除,放入刚才新增的数据,但是注意到这个id已经超出int的最大范围了;那么就需要加L标明为long类型的数据;

//测试删除功能1;
@Test
public void startDelOne(){
    //根据id删除;
    int delete = userMapper.deleteById(1533009403773566978L);

    System.out.println("删除的数据条数"+delete+"条------");
}
1
2
3
4
5
6
7
8

运行之;实际执行语句

DELETE FROM user WHERE id=?

---

根据Map集合删除
编写测试删除方法2;

//测试删除功能2;
@Test
public void startDelTwo() {
    //创建删除条件;
    Map<String, Object> map = new HashMap<>();
    map.put("name", "Tom");
    map.put("age", "38");
    //根据Map集合作为条件删除;
    int delete = userMapper.deleteByMap(map);

    System.out.println("删除的数据条数" + delete + "条------");
}
1
2
3
4
5
6
7
8
9
10
11
12

运行之,实际执行语句;

DELETE FROM user WHERE name = ? AND age = ?

注意,由于数据表并不存在name为Tom,年龄为38的用户,所以删除失败;

---

批量删除功能

//测试删除功能3;
@Test
public void startDelThree() {
    //首先创建用户id的集合;
    List<Long> longs = Arrays.asList(1L, 2L, 3L);
    //批量删除;
    int ids = userMapper.deleteBatchIds(longs);

    System.out.println("删除的数据条数" + ids + "条------");
}
1
2
3
4
5
6
7
8
9
10

运行之,实际执行的语句;

DELETE FROM user WHERE id IN ( ? , ? , ? )

---

3.2更新功能测试

---

在测试类MybatisPlusTest中编写测试方法;

//测试更新功能;
@Test
public void startUpdateOne() {
    User user = new User();
    //修改id为5的用户;
    user.setId(5L);
    user.setName("小智RE0");
    user.setEmail("xiaozhi@ceshi.com");
    //修改用户信息;
    int update = userMapper.updateById(user);

    System.out.println("修改的数据条数" + update + "条------");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行之,实际执行的语句为:

UPDATE user SET name=?, email=? WHERE id=?

---

3.4查询功能测试

---

先在数据表中存入几个新数据,用于后面的数据查询.

首先,使用简单的根据id查询;

//测试查询功能1;
@Test
public void startSelOne() {
    //根据id查询数据;
    //实际语句 SELECT id,name,age,email FROM user WHERE id=?
    User user = userMapper.selectById(1L);

    System.out.println(user);
}
1
2
3
4
5
6
7
8
9

运行之,可查询到id为1的数据;
实际执行语句为:

SELECT id,name,age,email FROM user WHERE id=?

---

再试试批量查询;

//测试查询功能2;
@Test
public void startSelTwo() {
    //首先创建用户的id集合;
    List<Long> list = Arrays.asList(1L, 2L, 3L, 4L, 6L);

    //批量查询;
    List<User> userList = userMapper.selectBatchIds(list);
    //输出
    userList.forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10
11

运行之,实际执行语句为:

SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? , ? , ? )

---

以map集合设定的条件进行查询;

//测试查询功能3;
@Test
public void startSelThree() {
    //首先创建map条件;
    Map<String, Object> map = new HashMap<>();
    map.put("name", "mark");
    map.put("age", "22");
    //根据map设定的条件进行查询;
    List<User> userList = userMapper.selectByMap(map);
    //输出
    userList.forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10
11
12

运行之,实际执行语句为:

SELECT id,name,age,email FROM user WHERE name = ? AND age = ?

---

查询数据表的所有数据

//测试查询功能4;
@Test
public void startSelFour() {
    //查询所有数据;
    List<User> userList = userMapper.selectList(null);
    //输出
    userList.forEach(System.out::println);
}
1
2
3
4
5
6
7
8

运行之,实际执行语句为:

SELECT id,name,age,email FROM user

---

3.5测试自定义功能

---

介于这种自带的sql仅用于简单的一些查询功能,当我们需要自定义功能时,就需要在mapper.xml映射文件中编写sql;

注意,这个mapper.xml映射文件的地址默认有一个;

在resources目录下创建mapper文件夹,创建UserMapper.xml映射文件;

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiaozhi.mybatisplus.mapper.UserMapper">
    <!--可编写sql文件-->

</mapper>
1
2
3
4
5
6
7

可编写一个测试方法接口

在UserMapper接口写测试方法;

@Repository
public interface UserMapper extends BaseMapper<User> {
    /*自定义测试方法,根据Id查询集合数据*/
    Map<String, Object> selectMapById(Long id);
}
1
2
3
4
5

对应的UserMapper.xml文件编写sql

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiaozhi.mybatisplus.mapper.UserMapper">
    <!--根据Id查询集合数据-->
    <select id="selectMapById" resultType="map">
            select id,name,age,email from user where id = #{id}
    </select>
</mapper>
1
2
3
4
5
6
7
8
9

在测试类MybatisPlusTest中测试

//测试查询功能5;
@Test
public void startSelFive() {
    //查询所有数据;
    Map<String, Object> selectMapById = userMapper.selectMapById(1L);
    //输出
    System.out.println(selectMapById);
}
1
2
3
4
5
6
7
8

运行之.

---

4.通用Service接口

---

在官方文档中即这部分的学习:

MyBatis-Plus中封装了通用的接口 IService和实现类 ServiceImpl，可用于处理常用业务.

在之前的mybatisplus目录下创建service服务层目录,在其下创建UserService接口;继承通用接口IService

import com.baomidou.mybatisplus.extension.service.IService;
import com.xiaozhi.mybatisplus.entity.User;
import org.springframework.stereotype.Service;
/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus
 * @Author: 信计1801 李智青
 * @Date: 2022/6/29 18:09
 * @Description: 用户类服务层接口
 */
public interface UserService extends IService<User> {
}
1
2
3
4
5
6
7
8
9
10
11
12

在service目录下创建impl目录,创建UserServiceImpl类(用户服务层实现类),注意需要继承通用接口的实现类ServiceImpl,[注意泛型的类型:1-映射层接口名,2-实体类]

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaozhi.mybatisplus.entity.User;
import com.xiaozhi.mybatisplus.mapper.UserMapper;
import com.xiaozhi.mybatisplus.service.UserService;
/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus.service
 * @Author: 信计1801 李智青
 * @Date: 2022/6/29 18:15
 * @Description: 用户服务层实现类
 */
 @Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

4.1 测试查询总记录数

---

在之前的测试目录下创建MybatisPlusServiceTest测试类;

import com.xiaozhi.mybatisplus.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @BelongsProject: mybatis-plus
 * @BelongsPackage: com.xiaozhi.mybatisplus
 * @Author: 信计1801 李智青
 * @Date: 2022/6/29 18:23
 * @Description: 通用service接口测试;
 */
@SpringBootTest
public class MybatisPlusServiceTest {
    @Autowired
    UserService userService;
    /*
     * 测试查询数据的总记录数
     * */
    @Test
    public void testServiceOne() {
        long count = userService.count();
        System.out.println("查询数据总记录数--"+count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行之;默认执行sql:SELECT COUNT( * ) FROM user 查询数据的总记录数

---

4.2 测试批量存储数据功能

---

/*
 * 测试批量插入功能
 * */
@Test
public void testServiceTwo() {
    //首先创建要添加的集合;
    List<User> userList = new ArrayList();
    for (int i = 1; i <= 7; i++) {
        User user = new User();
        user.setName("xiaozhire" + i);
        user.setAge(22 + i);
        user.setEmail(i + "lzq@qq.com");
        userList.add(user);
    }
    //批量存入数据,返回值可查看数据是否添加成功;
    boolean b = userService.saveBatch(userList);
    System.out.println("批量插入是否成功--" + b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行之;

数据添加成功

---