MybatisPlus入门-每日运维

通过项目一的开发大家应该能发现，单表的CRUD功能代码重复度很高，也没有什么难度。而这部分代码量往往比较大，开发起来比较费时。
因此，目前企业中都会使用一些组件来简化或省略单表的CRUD开发工作。目前在国内使用较多的一个组件就是MybatisPlus.
官方网站如下：
简介 | MyBatis-Plus

当然，MybatisPlus不仅仅可以简化单表操作，而且还对Mybatis的功能有很多的增强。可以让我们的开发更加的简单，高效。

通过今天的学习，我们要达成下面的目标：

能利用MybatisPlus实现基本的CRUD
会使用条件构建造构建查询和更新语句
会使用MybatisPlus中的常用注解
会使用MybatisPlus处理枚举、JSON类型字段
会使用MybatisPlus实现分页

1.快速入门

为了方便测试，我们先创建一个新的项目，并准备一些基础数据。

1.1.环境准备

复制课前资料提供好的一个项目到你的工作空间（不要包含空格和特殊字符）：

然后用你的IDEA工具打开，项目结构如下：

注意配置一下项目的JDK版本为JDK11。首先点击项目结构设置：

在弹窗中配置JDK：

接下来，要导入两张表，在课前资料中已经提供了SQL文件：

对应的数据库表结构如下：

最后，在application.yaml中修改jdbc参数为你自己的数据库参数：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: MySQL123
logging:
  level:
    com.itheima: debug
  pattern:
    dateformat: HH:mm:ss

1.2.快速开始

比如我们要实现User表的CRUD，只需要下面几步：

引入MybatisPlus依赖
定义Mapper

1.2.1引入依赖

MybatisPlus提供了starter，实现了自动Mybatis以及MybatisPlus的自动装配功能，坐标如下：


    com.baomidou
    mybatis-plus-boot-starter
    3.5.3.1

由于这个starter包含对mybatis的自动装配，因此完全可以替换掉Mybatis的starter。
最终，项目的依赖如下：


    
        com.baomidou
        mybatis-plus-boot-starter
        3.5.3.1
    
    
        com.mysql
        mysql-connector-j
        runtime
    
    
        org.projectlombok
        lombok
        true
    
    
        org.springframework.boot
        spring-boot-starter-test
        test

1.2.2.定义Mapper

为了简化单表CRUD，MybatisPlus提供了一个基础的BaseMapper接口，其中已经实现了单表的CRUD：

因此我们自定义的Mapper只要实现了这个BaseMapper，就无需自己实现单表CRUD了。
修改mp-demo中的com.itheima.mp.mapper包下的UserMapper接口，让其集成BaseMapper：

代码如下：

package com.itheima.mp.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.mp.domain.po.User;

public interface UserMapper extends BaseMapper {
}

1.2.3.测试

新建一个测试类，编写几个单元测试，测试基本的CRUD功能：

package com.itheima.mp.mapper;

import com.itheima.mp.domain.po.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.LocalDateTime;
import java.util.List;

@SpringBootTest
class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    void testInsert() {
        User user = new User();
        user.setId(5L);
        user.setUsername("Lucy");
        user.setPassword("123");
        user.setPhone("18688990011");
        user.setBalance(200);
        user.setInfo("{"age": 24, "intro": "英文老师", "gender": "female"}");
        user.setCreateTime(LocalDateTime.now());
        user.setUpdateTime(LocalDateTime.now());
        userMapper.insert(user);
    }

    @Test
    void testSelectById() {
        User user = userMapper.selectById(5L);
        System.out.println("user = " + user);
    }

    @Test
    void testSelectByIds() {
        List users = userMapper.selectBatchIds(List.of(1L, 2L, 3L, 4L, 5L));
        users.forEach(System.out::println);
    }

    @Test
    void testUpdateById() {
        User user = new User();
        user.setId(5L);
        user.setBalance(20000);
        userMapper.updateById(user);
    }

    @Test
    void testDelete() {
        userMapper.deleteById(5L);
    }
}

可以看到，在运行过程中打印出的SQL日志，非常标准：

11:05:01  INFO 15524 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
11:05:02  INFO 15524 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
11:05:02 DEBUG 15524 --- [           main] c.i.mp.mapper.UserMapper.selectById      : ==>  Preparing: SELECT id,username,password,phone,info,status,balance,create_time,update_time FROM user WHERE id=?
11:05:02 DEBUG 15524 --- [           main] c.i.mp.mapper.UserMapper.selectById      : ==> Parameters: 5(Long)
11:05:02 DEBUG 15524 --- [           main] c.i.mp.mapper.UserMapper.selectById      : = 1000
    QueryWrapper wrapper = new QueryWrapper()
            .select("id", "username", "info", "balance")
            .like("username", "o")
            .ge("balance", 1000);
    // 2.查询数据
    List users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

更新：更新用户名为jack的用户的余额为2000，代码如下：

@Test
void testUpdateByQueryWrapper() {
    // 1.构建查询条件 where name = "Jack"
    QueryWrapper wrapper = new QueryWrapper().eq("username", "Jack");
    // 2.更新数据，user中非null字段都会作为set语句
    User user = new User();
    user.setBalance(2000);
    userMapper.update(user, wrapper);
}

2.1.2.UpdateWrapper

基于BaseMapper中的update方法更新时只能直接赋值，对于一些复杂的需求就难以实现。
例如：更新id为1,2,4的用户的余额，扣200，对于的SQL应该是：

UPDATE user SET balance = balance - 200 WHERE id in (1, 2, 4)

SET的赋值结果是基于字段现有值的，这个时候就要利用UpdateWrapper中的setSql功能了：

@Test
void testUpdateWrapper() {
    List ids = List.of(1L, 2L, 4L);
    // 1.生成SQL
    UpdateWrapper wrapper = new UpdateWrapper()
            .setSql("balance = balance - 200") // SET balance = balance - 200
            .in("id", ids); // WHERE id in (1, 2, 4)
	// 2.更新，注意第一个参数可以给null，也就是不填更新字段和数据，
    // 而是基于UpdateWrapper中的setSQL来更新
    userMapper.update(null, wrapper);
}

2.1.3.LambdaQueryWrapper

无论是QueryWrapper还是UpdateWrapper在构造条件的时候都需要写死字段名称，会出现字符串魔法值。这在编程规范中显然是不推荐的。
那怎么样才能不写字段名，又能知道字段名呢？

其中一种办法是基于变量的gettter方法结合反射技术。因此我们只要将条件对应的字段的getter方法传递给MybatisPlus，它就能计算出对应的变量名了。而传递方法可以使用JDK8中的方法引用和Lambda表达式。
因此MybatisPlus又提供了一套基于Lambda的Wrapper，包含两个：

LambdaQueryWrapper
LambdaUpdateWrapper

分别对应QueryWrapper和UpdateWrapper

其使用方式如下：

@Test
void testLambdaQueryWrapper() {
    // 1.构建条件 WHERE username LIKE "%o%" AND balance >= 1000
    QueryWrapper wrapper = new QueryWrapper();
    wrapper.lambda()
            .select(User::getId, User::getUsername, User::getInfo, User::getBalance)
            .like(User::getUsername, "o")
            .ge(User::getBalance, 1000);
    // 2.查询
    List users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

2.2.自定义SQL

在演示UpdateWrapper的案例中，我们在代码中编写了更新的SQL语句：

这种写法在某些企业也是不允许的，因为SQL语句最好都维护在持久层，而不是业务层。就当前案例来说，由于条件是in语句，只能将SQL写在Mapper.xml文件，利用foreach来生成动态SQL。
这实在是太麻烦了。假如查询条件更复杂，动态SQL的编写也会更加复杂。

所以，MybatisPlus提供了自定义SQL功能，可以让我们利用Wrapper生成查询条件，再结合Mapper.xml编写SQL

2.2.1.基本用法

以当前案例来说，我们可以这样写：

@Test
void testCustomWrapper() {
    // 1.准备自定义查询条件
    List ids = List.of(1L, 2L, 4L);
    QueryWrapper wrapper = new QueryWrapper().in("id", ids);

    // 2.调用mapper的自定义方法，直接传递Wrapper
    userMapper.deductBalanceByIds(200, wrapper);
}

然后在UserMapper中自定义SQL：

public interface UserMapper extends BaseMapper {
    @Select("UPDATE user SET balance = balance - #{money} ${ew.customSqlSegment}")
    void deductBalanceByIds(@Param("money") int money, @Param("ew") QueryWrapper wrapper);
}

这样就省去了编写复杂查询条件的烦恼了。

2.2.2.多表关联

理论上来将MyBatisPlus是不支持多表查询的，不过我们可以利用Wrapper中自定义条件结合自定义SQL来实现多表查询的效果。
例如，我们要查询出所有收货地址在北京的并且用户id在1、2、4之中的用户
要是自己基于mybatis实现SQL，大概是这样的：

  
      SELECT *
      FROM user u
      INNER JOIN address a ON u.id = a.user_id
      WHERE u.id
      
          #{id}
      
      AND a.city = #{city}

可以看出其中最复杂的就是WHERE条件的编写，如果业务复杂一些，这里的SQL会更变态。但是基于自定义SQL结合Wrapper的玩法，我们就可以利用Wrapper来构建查询条件，然后手写SELECT及FROM部分，实现多表查询。
查询条件这样来构建：

@Test
void testCustomJoinWrapper() {
    // 1.准备自定义查询条件
    QueryWrapper wrapper = new QueryWrapper()
            .in("u.id", List.of(1L, 2L, 4L))
            .eq("a.city", "北京");

    // 2.调用mapper的自定义方法
    List users = userMapper.queryUserByWrapper(wrapper);

    users.forEach(System.out::println);
}

然后在UserMapper中自定义方法：

@Select("SELECT u.* FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}")
List queryUserByWrapper(@Param("ew")QueryWrapper wrapper);

当然，也可以在UserMapper.xml中写SQL：


    SELECT * FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}

2.3.Service接口

MybatisPlus不仅提供了BaseMapper，还提供了通用的Service接口及默认实现，封装了一些常用的service模板方法。
通用接口为IService，默认实现为ServiceImpl，其中封装的方法可以分为以下几类：

save：新增
remove：删除
update：更新
get：查询单个结果
list：查询集合结果
count：计数
page：分页查询

2.3.1.CRUD

我们先俩看下基本的CRUD接口。
新增：

save是新增单个元素
saveBatch是批量新增
saveOrUpdate是根据id判断，如果数据存在就更新，不存在则新增
saveOrUpdateBatch是批量的新增或修改

删除：

removeById：根据id删除
removeByIds：根据id批量删除
removeByMap：根据Map中的键值对为条件删除
remove(Wrapper)：根据Wrapper条件删除
~~removeBatchByIds~~：暂不支持

修改：

updateById：根据id修改
update(Wrapper)：根据UpdateWrapper修改，Wrapper中包含set和where部分
update(T，Wrapper)：按照T内的数据修改与Wrapper匹配到的数据
updateBatchById：根据id批量修改

Get：

getById：根据id查询1条数据
getOne(Wrapper)：根据Wrapper查询1条数据
getBaseMapper：获取Service内的BaseMapper实现，某些时候需要直接调用Mapper内的自定义SQL时可以用这个方法获取到Mapper

List：

listByIds：根据id批量查询
list(Wrapper)：根据Wrapper条件查询多条数据
list()：查询所有

Count：

count()：统计所有数量
count(Wrapper)：统计符合Wrapper条件的数据数量

getBaseMapper：
当我们在service中要调用Mapper中自定义SQL时，就必须获取service对应的Mapper，就可以通过这个方法：

2.3.2.基本用法

由于Service中经常需要定义与业务有关的自定义方法，因此我们不能直接使用IService，而是自定义Service接口，然后继承IService以拓展方法。同时，让自定义的Service实现类继承ServiceImpl，这样就不用自己实现IService中的接口了。

首先，定义UserService，继承IService：

package com.itheima.mp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.itheima.mp.domain.po.User;

public interface UserService extends IService {
    // 拓展自定义方法
}

然后，编写UserServiceImpl类，继承ServiceImpl，实现UserService：

package com.itheima.mp.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itheima.mp.domain.po.User;
import com.itheima.mp.domain.po.service.UserService;
import com.itheima.mp.mapper.UserMapper;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl
													implements UserService {
}

项目结构如下：

最后，编写一个测试类，测试一下：

package com.itheima.mp.service;

import com.itheima.mp.domain.po.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class UserServiceTest {

    @Autowired
    UserService userService;

    @Test
    void testService() {
        List list = userService.list();
        list.forEach(System.out::println);
    }
}

2.3.3.批量新增

IService中的批量新增功能使用起来非常方便，但有一点注意事项，我们先来测试一下。
首先我们测试逐条插入数据：

@Test

void testSaveOneByOne() {

    long b = System.currentTimeMillis();

    for (int i = 1; i

MybatisPlus入门

1.1.环境准备

1.2.快速开始

1.2.1引入依赖

1.2.2.定义Mapper

1.2.3.测试

2.1.2.UpdateWrapper

2.1.3.LambdaQueryWrapper

2.2.自定义SQL

2.2.1.基本用法

2.2.2.多表关联

2.3.Service接口

2.3.1.CRUD

2.3.2.基本用法

2.3.3.批量新增

相关文章

发布评论取消回复

泡泡

百度搜索：蓝易云 – Docker的安装与卸载(Centos、Ubuntu )

PostgreSQL系数据库使用COPY导数时如何实现增量及重复数据更新导入

【OceanBase DBA早下班系列】—— obdiag 收集的 SQL Monitor Report 如何解读

MybatisPlus入门

1.1.环境准备

1.2.快速开始

1.2.1引入依赖

1.2.2.定义Mapper

1.2.3.测试

2.1.2.UpdateWrapper

2.1.3.LambdaQueryWrapper

2.2.自定义SQL

2.2.1.基本用法

2.2.2.多表关联

2.3.Service接口

2.3.1.CRUD

2.3.2.基本用法

2.3.3.批量新增

相关文章

发布评论 取消回复

泡泡

百度搜索：蓝易云 – Docker的安装与卸载(Centos、Ubuntu )

PostgreSQL系数据库使用COPY导数时如何实现增量及重复数据更新导入

【OceanBase DBA早下班系列】—— obdiag 收集的 SQL Monitor Report 如何解读

发布评论取消回复