• MybatisPlus 核心功能 条件构造器 自定义SQL Service接口 静态工具

    MybatisPlus 快速入门 常见注解 配置_软工菜鸡的博客-CSDN博客

    2.核心功能

    刚才的案例中都是以id为条件的简单CRUD，一些复杂条件的SQL语句就要用到一些更高级的功能了。

    2.1.条件构造器

    除了新增以外，修改、删除、查询的SQL语句都需要指定where条件。因此BaseMapper中提供的相关方法除了以id作为where条件以外，还支持更加复杂的where条件。

    参数中的Wrapper就是条件构造的抽象类，其下有很多默认实现，继承关系如图：

    Wrapper的子类AbstractWrapper提供了where中包含的所有条件构造方法：

    而QueryWrapper在AbstractWrapper的基础上拓展了一个select方法，允许指定查询字段：

    而UpdateWrapper在AbstractWrapper的基础上拓展了一个set方法，允许指定SQL中的SET部分：

    接下来，我们就来看看如何利用Wrapper实现复杂查询。

    2.1.1.QueryWrapper

    无论是修改、删除、查询，都可以使用QueryWrapper来构建查询条件。接下来看一些例子：

    查询：查询出名字中带o的，存款大于等于1000元的人。代码如下：

    1. @Test
    2. void testQueryWrapper() {
    3.     // 1.构建查询条件 where name like "%o%" AND balance >= 1000
    4.     QueryWrapper<User> wrapper = new QueryWrapper<User>()
    5.             .select("id", "username", "info", "balance")
    6.             .like("username", "o")
    7.             .ge("balance", 1000);
    8.     // 2.查询数据
    9.     List<User> users = userMapper.selectList(wrapper);
    10.     users.forEach(System.out::println);
    11. }

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

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

    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功能 来-200了：

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

    2.1.3.LambdaQueryWrapper

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

    那怎么样才能不写字段名，又能知道字段名呢？

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

    因此MybatisPlus又提供了一套基于Lambda的Wrapper，包含两个：

    • LambdaQueryWrapper
    • LambdaUpdateWrapper

    分别对应QueryWrapper和UpdateWrapper

    其使用方式如下：

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

    2.2.自定义SQL

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

    这种写法在某些企业也是不允许的，因为SQL语句最好都维护在持久层，而不是业务层。就当前案例来说，由于条件是in语句，只能将SQL写在Mapper.xml文件，利用foreach来生成动态SQL。

    这实在是太麻烦了。假如查询条件更复杂，动态SQL的编写也会更加复杂。

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

    2.2.1.基本用法

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

    1. @Test
    2. void testCustomWrapper() {
    3.     // 1.准备自定义查询条件
    4.     List<Long> ids = List.of(1L, 2L, 4L);
    5.     QueryWrapper<User> wrapper = new QueryWrapper<User>().in("id", ids);
    6.  
    7.     // 2.调用mapper的自定义方法，直接传递Wrapper
    8.     userMapper.deductBalanceByIds(200, wrapper);
    9. }

    然后在UserMapper中自定义SQL：

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

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

    2.2.2.多表关联

    理论上来将MyBatisPlus是不支持多表查询的，不过我们可以利用Wrapper中自定义条件结合自定义SQL来实现多表查询的效果。

    例如，我们要查询出所有收货地址在北京的并且用户id在1、2、4之中的用户

    要是自己基于mybatis实现SQL，大概是这样的：

    1.   <select id="queryUserByIdAndAddr" resultType="com.itheima.mp.domain.po.User">
    2.       SELECT *
    3.       FROM user u
    4.       INNER JOIN address a ON u.id = a.user_id
    5.       WHERE u.id
    6.       <foreach collection="ids" separator="," item="id" open="IN (" close=")">
    7.           #{id}
    8.       </foreach>
    9.       AND a.city = #{city}
    10.   </select>

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

    查询条件这样来构建：

    1. @Test
    2. void testCustomJoinWrapper() {
    3.     // 1.准备自定义查询条件
    4.     QueryWrapper<User> wrapper = new QueryWrapper<User>()
    5.             .in("u.id", List.of(1L, 2L, 4L))
    6.             .eq("a.city", "北京");
    7.  
    8.     // 2.调用mapper的自定义方法
    9.     List<User> users = userMapper.queryUserByWrapper(wrapper);
    10.  
    11.     users.forEach(System.out::println);
    12. }

    然后在UserMapper中自定义方法：

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

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

    1. <select id="queryUserByIdAndAddr" resultType="com.itheima.mp.domain.po.User">
    2.     SELECT * FROM user u INNER JOIN address a ON u.id = a.user_id ${ew.customSqlSegment}
    3. </select>

    2.3.Service接口

    关于mybatis-plus中Service和Mapper的分析

    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：

    1. package com.itheima.mp.service;
    2. import com.baomidou.mybatisplus.extension.service.IService;
    3. import com.itheima.mp.domain.po.User;
    4.  
    5. public interface UserService extends IService<User> {
    6.     // 拓展自定义方法
    7. }

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

    1. package com.itheima.mp.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    4. import com.itheima.mp.domain.po.User;
    5. import com.itheima.mp.domain.po.service.UserService;
    6. import com.itheima.mp.mapper.UserMapper;
    7. import org.springframework.stereotype.Service;
    8.  
    9. @Service
    10. public class UserServiceImpl extends ServiceImpl, User> implements UserService {
    11. }

    项目结构如下：

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

    1. package com.itheima.mp.service;
    2.  
    3. import com.itheima.mp.domain.po.User;
    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. import java.util.List;
    9.  
    10. import static org.junit.jupiter.api.Assertions.*;
    11.  
    12. @SpringBootTest
    13. class UserServiceTest {
    14.  
    15.     @Autowired
    16.     UserService userService;
    17.  
    18.     @Test
    19.     void testService() {
    20.         List list = userService.list();
    21.         list.forEach(System.out::println);
    22.     }
    23. }

    2.3.3.批量新增

    IService中的批量新增功能使用起来非常方便，但有一点注意事项，我们来测试一下。

    首先我们测试逐条插入数据：

    1. @Test
    2. void testSaveOneByOne() {
    3.     long b = System.currentTimeMillis();
    4.     for (int i = 1; i <= 100000; i++) {
    5.         userService.save(buildUser(i));
    6.     }
    7.     long e = System.currentTimeMillis();
    8.     System.out.println("耗时：" + (e - b));
    9. }
    10.  
    11. private User buildUser(int i) {
    12.     User user = new User();
    13.     user.setUsername("user_" + i);
    14.     user.setPassword("123");
    15.     user.setPhone("" + (18688190000L + i));
    16.     user.setBalance(2000);
    17.     user.setInfo("{\"age\": 24, \"intro\": \"英文老师\", \"gender\": \"female\"}");
    18.     user.setCreateTime(LocalDateTime.now());
    19.     user.setUpdateTime(user.getCreateTime());
    20.     return user;
    21. }

    执行结果如下：

    可以看到速度非常慢。

    然后再试试MybatisPlus的批处理：

    1. @Test
    2. void testSaveBatch() {
    3.     // 准备10万条数据
    4.     List<User> list = new ArrayList<>(1000);
    5.     long b = System.currentTimeMillis();
    6.     for (int i = 1; i <= 100000; i++) {
    7.         list.add(buildUser(i));
    8.         // 每1000条批量插入一次
    9.         if (i % 1000 == 0) {
    10.             userService.saveBatch(list);
    11.             list.clear();
    12.         }
    13.     }
    14.     long e = System.currentTimeMillis();
    15.     System.out.println("耗时：" + (e - b));
    16. }

    执行最终耗时如下：

    可以看到使用了批处理以后，比逐条新增效率提高了10倍左右，性能还是不错的。

    不过，我们简单查看一下MybatisPlus源码：

    1. @Transactional(rollbackFor = Exception.class)
    2. @Override
    3. public boolean saveBatch(Collection<T> entityList, int batchSize) {
    4.     String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
    5.     return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
    6. }
    7. // ...SqlHelper
    8. public static <E> boolean executeBatch(Class<?> entityClass, Log log, Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
    9.     Assert.isFalse(batchSize < 1, "batchSize must not be less than one");
    10.     return !CollectionUtils.isEmpty(list) && executeBatch(entityClass, log, sqlSession -> {
    11.         int size = list.size();
    12.         int idxLimit = Math.min(batchSize, size);
    13.         int i = 1;
    14.         for (E element : list) {
    15.             consumer.accept(sqlSession, element);
    16.             if (i == idxLimit) {
    17.                 sqlSession.flushStatements();
    18.                 idxLimit = Math.min(idxLimit + batchSize, size);
    19.             }
    20.             i++;
    21.         }
    22.     });
    23. }

    可以发现其实MybatisPlus的批处理是基于PrepareStatement的预编译模式，然后批量提交，最终在数据库执行时还是有多条insert语句，逐条插入数据。SQL类似这样：

    1. Preparing: INSERT INTO user ( username, password, phone, info, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
    2. Parameters: user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01
    3. Parameters: user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01
    4. Parameters: user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01

    而如果想要得到最佳性能，最好是将多条SQL合并为一条，像这样：

    1. INSERT INTO user ( username, password, phone, info, balance, create_time, update_time )
    2. VALUES 
    3. (user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01),
    4. (user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01),
    5. (user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01),
    6. (user_4, 123, 18688190004, "", 2000, 2023-07-01, 2023-07-01);

    该怎么做呢？

    MySQL的客户端连接参数中有这样的一个参数：rewriteBatchedStatements。顾名思义，就是重写批处理的statement语句。参考文档：

    cj-conn-prop_rewriteBatchedStatements

    这个参数的默认值是false，我们需要修改连接参数，将其配置为true

    修改项目中的application.yml文件，在jdbc的url后面添加参数&rewriteBatchedStatements=true:

    1. spring:
    2.   datasource:
    3.     url: jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
    4.     driver-class-name: com.mysql.cj.jdbc.Driver
    5.     username: root
    6.     password: MySQL123

    再次测试插入10万条数据，可以发现速度有非常明显的提升：

    在ClientPreparedStatement的executeBatchInternal中，有判断rewriteBatchedStatements值是否为true并重写SQL的功能：

    最终，SQL被重写了：

    2.3.4.Lambda

    Service中对LambdaQueryWrapper和LambdaUpdateWrapper的用法进一步做了简化。我们无需自己通过new的方式来创建Wrapper，而是直接调用lambdaQuery和lambdaUpdate方法：

    基于Lambda查询：

    1. @Test
    2. void testLambdaQuery() {
    3.     // 1.查询1个
    4.     User rose = userService.lambdaQuery()
    5.             .eq(User::getUsername, "Rose")
    6.             .one(); // .one()查询1个
    7.     System.out.println("rose = " + rose);
    8.  
    9.     // 2.查询多个
    10.     List<User> users = userService.lambdaQuery()
    11.             .like(User::getUsername, "o")
    12.             .list(); // .list()查询集合
    13.     users.forEach(System.out::println);
    14.  
    15.     // 3.count统计
    16.     Long count = userService.lambdaQuery()
    17.             .like(User::getUsername, "o")
    18.             .count(); // .count()则计数
    19.     System.out.println("count = " + count);
    20. }

    可以发现lambdaQuery方法中除了可以构建条件，而且根据链式编程的最后一个方法来判断最终的返回结果，可选的方法有：

    • .one()：最多1个结果
    • .list()：返回集合结果
    • .count()：返回计数结果

    lambdaQuery还支持动态条件查询。比如下面这个需求：

    定义一个方法，接收参数为username、status、minBalance、maxBalance，参数可以为空。
    如果username参数不为空，则采用模糊查询;
    如果status参数不为空，则采用精确匹配；
    如果minBalance参数不为空，则余额必须大于minBalance
    如果maxBalance参数不为空，则余额必须小于maxBalance

    这个需求就是典型的动态查询，在业务开发中经常碰到，实现如下：

    1. @Test
    2. void testQueryUser() {
    3.     List<User> users = queryUser("o", 1, null, null);
    4.     users.forEach(System.out::println);
    5. }
    6.  
    7. public List<User> queryUser(String username, Integer status, Integer minBalance, Integer maxBalance) {
    8.     return userService.lambdaQuery()
    9.             .like(username != null , User::getUsername, username)
    10.             .eq(status != null, User::getStatus, status)
    11.             .ge(minBalance != null, User::getBalance, minBalance)
    12.             .le(maxBalance != null, User::getBalance, maxBalance)
    13.             .list();
    14. }

    基于Lambda更新：

    1. @Test
    2. void testLambdaUpdate() {
    3.     userService.lambdaUpdate()
    4.             .set(User::getBalance, 800) // set balance = 800
    5.             .eq(User::getUsername, "Jack") // where username = "Jack"
    6.             .update(); // 执行Update
    7. }

    lambdaUpdate()方法后基于链式编程，可以添加set条件和where条件。但最后一定要跟上update()，否则语句不会执行。

    lambdaUpdate()同样支持动态条件，例如下面的需求：

    基于IService中的lambdaUpdate()方法实现一个更新方法，满足下列需求：
    1 参数为balance、id、username
    2 id或username至少一个不为空，根据id或username精确匹配用户
    3 将匹配到的用户余额修改为balance
    4 如果balance为0，则将用户status修改为冻结状态（2）

    实现如下：

    1. @Test
    2. void testUpdateBalance() {
    3.     updateBalance(0L, 1L, null);
    4. }
    5.  
    6. public void updateBalance(Long balance, Long id, String username){
    7.     userService.lambdaUpdate()
    8.             .set(User::getBalance, balance)
    9.             .set(balance == 0, User::getStatus, 2)
    10.             .eq(id != null, User::getId, id)
    11.             .eq(username != null, User::getId, username)
    12.             .update();
    13. }

    2.4.静态工具

    有的时候Service之间也会相互调用，为了避免出现循环依赖问题，可以调用Service 的mapper或者MybatisPlus提供一个静态工具类：Db，其中的一些静态方法与IService中方法签名基本一致，也可以帮助我们实现CRUD功能：

    Db的静态方法与IService中方法区别：除了save、update其他的参数带class类，然后就知道要操作哪个表了

    示例：

    1. @Test
    2. void testDbGet() {
    3.     User user = Db.getById(1L, User.class);
    4.     System.out.println(user);
    5. }
    6.  
    7. @Test
    8. void testDbList() {
    9.     // 利用Db实现复杂条件查询
    10.     List<User> list = Db.lambdaQuery(User.class)
    11.             .like(User::getUsername, "o")
    12.             .ge(User::getBalance, 1000)
    13.             .list();
    14.     list.forEach(System.out::println);
    15. }
    16.  
    17. @Test
    18. void testDbUpdate() {
    19.     Db.lambdaUpdate(User.class)
    20.             .set(User::getBalance, 2000)
    21.             .eq(User::getUsername, "Rose");
    22. }
  • 相关阅读:
    我国实战攻防演练的发展现状
    修改smartbi的JVM调优
    【面试题】智力题
    CA周记 - Build 2022 上开发者最应关注的七大方向主要技术更新
    从mysql 数据库表导入数据到elasticSearch的几种方式
    SpringMVC ---- RESTful案例
    APP中RN页面热更新流程-ReactNative源码分析
    android免root读写u盘最新方法，支持安卓Q+
    数据结构基础内容-----第三章 线性表
    【实例分割】论文详解YOLACT：Real-time Instance Segmentation
  • 原文地址：https://blog.csdn.net/m0_67184231/article/details/132676911