07-MybatisPlus条件构造器

1. 简 介

条件构造器——Wrapper，用于构造SQL语句的执行条件（即SQL语句中，where后面的条件）。

Wrapper与QueryWrapper、UpdateWrapper的关系：

Wrapper  条件构造抽象类
    -- AbstractWrapper 查询条件封装，用于生成 sql 中的 where 语句。
        -- QueryWrapper Entity 对象封装操作类，用于查询。
        -- UpdateWrapper Update 条件封装操作类，用于更新。
        -- AbstractLambdaWrapper 使用 Lambda 表达式封装 wrapper
            -- LambdaQueryWrapper 使用 Lambda 语法封装条件，用于查询。
            -- LambdaUpdateWrapper 使用 Lambda 语法封装条件，用于更新。

2. 使 用

以下面这张表的数据为例，实现列出的使用范例

2.1 比较大小【allEq、eq、ne、gt、ge、lt、le】

allEq：全等于
eq：等于（=）
ne：不等于（!=或者<>）
gt：大于（>）
ge：大于等于（>=）
lt：小于（<）
le：小于等于（<=）

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/4 0:16
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 allEq--全等于 的使用
     */
    @Test
    public void testAllEqUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        //查询参数
        Map<String, Object> map = new HashMap<>();
        map.put("id", 85665L);
        map.put("name", "王二");
        //将参数放入条件构造器
        queryWrapper.allEq(map);
        //执行查询方法
        MybatisPlusUser mybatisPlusUser = mybatisPlusUserMapper.selectOne(queryWrapper);
        System.out.println("allEq的使用：" + mybatisPlusUser);
    }

    /**
     * 测试 Eq--等于 的使用
     */
    @Test
    public void testEqUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id", 85665L).eq("name", "王二");
        //执行查询方法
        MybatisPlusUser mybatisPlusUser1 = mybatisPlusUserMapper.selectOne(queryWrapper);
        System.out.println("Eq的使用：" + mybatisPlusUser1);
    }

    /**
     * 测试 ne--不等于 的使用
     */
    @Test
    public void testNeUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("age", 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("ne的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 gt--大于 的使用
     */
    @Test
    public void testGtUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age", 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("gt的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 ge--大于等于 的使用
     */
    @Test
    public void testGeUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.ge("age", 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("ge的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 lt--小于 的使用
     */
    @Test
    public void testLtUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.lt("age", 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("lt的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 le--小于等于 的使用
     */
    @Test
    public void testLeUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.le("age", 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("le的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.2 范围查找【between、not between、in、not in】

between：介于a and b 之间
not between：不介于a and b 之间
in：在某个范围内
not in：不在某个范围内

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/4 0:16
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 between--介于a与b之间 的使用
     */
    @Test
    public void testBetween() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.between("age", 25, 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("between的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 not between--不介于a与b之间 的使用
     */
    @Test
    public void testNotBetween() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.notBetween("age", 25, 30);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("notBetween的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 in--在什么之中 的使用
     */
    @Test
    public void testInUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("age", 20, 25, 29, 30, 35);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("in的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 not in--不在什么之中 的使用
     */
    @Test
    public void testNotInUse() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.notIn("age", 20, 25, 29, 30, 35);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("notIn的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.3 模糊匹配【like、notLike、likeLeft、likeRight】

like：like ‘%值%’
notLike：not like ‘%值%’
likeLeft：like ‘%值’
likeRight：like ‘值%’

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/4 0:16
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 like--模糊查询 的使用
     */
    @Test
    public void testLike() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("id", 4646);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("like的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 not like--模糊查询 的使用
     */
    @Test
    public void testNotLike() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.notLike("id", 4646);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("NotLike的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 likeLeft--左模糊 的使用
     */
    @Test
    public void testLikeLeft() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeLeft("age", 0);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("likeLeft的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 likeRight--右模糊 的使用
     */
    @Test
    public void testLikeRight() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeRight("age", 2);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("likeRight的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.4 空值比较【isNull、isNotNull】

isNull：为null
isNotNull：不为null

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/4 0:16
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 isNull--为空 的使用
     */
    @Test
    public void testIsNull() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("isNull的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 isNotNull--不为空 的使用
     */
    @Test
    public void testisNotNull() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNotNull("age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("isNotNull的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.5 分组排序【groupBy、orderByAsc、orderByDesc、orderBy、having】

groupBy：分组
orderByAsc：升序排序
orderByDesc：倒序排序
orderBy：排序
having：对分组后的数据，按指定条件过滤

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;
import java.util.Map;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/4 0:16
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 groupBy--分组 的使用
     */
    @Test
    public void testGroupBy() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("age");
        queryWrapper.groupBy("age");
        //执行查询方法
        List<Map<String, Object>> mybatisPlusUsers = mybatisPlusUserMapper.selectMaps(queryWrapper);
        System.out.println("groupBy的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 orderByAsc--升序排序 的使用
     */
    @Test
    public void testOrderByAsc() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByAsc("age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("orderByAsc的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 orderByDesc--升序排序 的使用
     */
    @Test
    public void testOrderByDesc() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("orderByDesc的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 orderBy--排序 的使用
     */
    @Test
    public void testOrderBy() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.orderBy(true, true, "age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("orderBy的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 Having--对分组后的数据，按指定条件过滤 的使用
     */
    @Test
    public void testHaving() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("age")
                .groupBy("age")
                .having("age > 25");
        //执行查询方法
        List<Map<String, Object>> maps = mybatisPlusUserMapper.selectMaps(queryWrapper);
        System.out.println("Having的使用：" + maps);
    }
}

运行结果

2.6 拼接嵌套【and、or、nested、apply、last、exists、notExists】

and：且
or：或者
nested：正常嵌套，不带and、or
apply：拼接参数
last：无视优化规则直接拼接到 sql 的最后
exists：拼接 exists ( sql语句 )
notExists：拼接 not exists ( sql语句 )

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/5 01:46
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 and嵌套--且 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE version = ? AND (age = ? AND name <> ?)
     */
    @Test
    public void testAnd() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("version", 1).and(wrapper -> wrapper.eq("age", 20).ne("name", "王二"));
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("and的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 or嵌套--或 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE version = ? OR (age = ? AND name <> ?)
     */
    @Test
    public void testOr() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("version", 1).or(wrapper -> wrapper.eq("age", 20).ne("name", "张三"));
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("or嵌套的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 or非嵌套--或 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE age = ? OR name = ?
     */
    @Test
    public void testOr1() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", 29).or().eq("name", "王二");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("or非嵌套的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 nested--正常嵌套 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE (age = ? AND name <> ?) AND version = ?
     */
    @Test
    public void testNested() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.nested(i -> i.eq("age", 29).ne("name", "王二")).eq("version", 1);
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("nested的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 apply--拼接参数 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE age = ? AND name = '王二'
     */
    @Test
    public void testApply() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", 20).apply("name = '王二'");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("apply的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 last--无视优化规则直接拼接到sql的最后 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE age <> ? and name <> '王二'
     */
    @Test
    public void testLast() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("age", 30).last("and name <> '王二'");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("last的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 exists--拼接exists语句 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE age = ? AND EXISTS (select name from mybatis_plus_user where age > 26)
     */
    @Test
    public void testExists() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", 29).exists("select name from mybatis_plus_user where age > 26");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("exists的使用：" + mybatisPlusUsers);
    }

    /**
     * 测试 notExists--拼接notExists语句 的使用
     * <p>
     * SELECT id,name,age,email,create_time,update_time,version,deleted
     * FROM mybatis_plus_user
     * WHERE age = ? AND NOT EXISTS (select name from mybatis_plus_user where age > 26)
     */
    @Test
    public void testNotExists() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", 29).notExists("select name from mybatis_plus_user where age > 26");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("notExists的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.7 QueryWrapper【select】

通过使用QueryWrapper中的select方法，可以自定义指定需要返回值的字段，避免查询所有字段的值

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

import java.util.List;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/5 01:46
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 QueryWrapper中select 的使用
     * <p>
     * select，用于定义需要返回的字段
     */
    @Test
    public void testQueryWrapper() {
        QueryWrapper<MybatisPlusUser> queryWrapper = new QueryWrapper<>();
        //相当于只查询三列，select id,name,age from table
        queryWrapper.select("id", "name", "age");
        //执行查询方法
        List<MybatisPlusUser> mybatisPlusUsers = mybatisPlusUserMapper.selectList(queryWrapper);
        System.out.println("select的使用：" + mybatisPlusUsers);
    }
}

运行结果

2.8 UpdateWrapper【set】

通过使用UpdateWrapper中的set方法，可以自定义指定需要设置值的字段

实现代码

package springboot.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import springboot.mybatisplus.entity.MybatisPlusUser;
import springboot.mybatisplus.mapper.MybatisPlusUserMapper;

/**
 * @Description 条件构造器测试
 * @ClassName WrapperTest
 * @Author yuhuofei
 * @Date 2022/4/5 01:46
 * @Version 1.0
 */
@SpringBootTest
public class WrapperTest {

    @Autowired
    private MybatisPlusUserMapper mybatisPlusUserMapper;

    /**
     * 测试 UpdateWrapper中set 的使用
     * <p>
     * set，用于设置字段值
     */
    @Test
    public void testUpdateWrapper() {
        UpdateWrapper<MybatisPlusUser> userUpdateWrapper = new UpdateWrapper<>();
        //设置的值
        userUpdateWrapper.set("name", "哈哈哈");
        //条件
        userUpdateWrapper.eq("id", 85665L);
        //执行查询方法
        mybatisPlusUserMapper.update(new MybatisPlusUser(), userUpdateWrapper);
    }
}

运行结果