详细讲解MybatisPlus中的IService类中的CRUD功能(全)

发布时间:2024年01月01日

前言

大部分CRUD都来源这个类,对此有意义剖析,方便之后的功能开发

1. 基本概念

在 MyBatis-Plus 中,IService 是 MyBatis-Plus 提供的服务层的接口,用于定义业务层的一些通用方法。

这个接口位于 MyBatis-Plus 的核心模块中,与 BaseMapper 接口一同构成 MyBatis-Plus 的基础架构。

以下是关于 IService 类的一般概念、作用和功能:

概念作用功能
类似于 BaseMapper 是数据访问层的通用接口,IService 是服务层的通用接口,提供了一组常用的业务操作方法。1.提供了通用的业务层方法,包括常见的增、删、改、查等操作。
2.简化了业务层的开发,通过继承 IService,开发者可以直接使用其中定义的通用方法,而无需编写重复代码。
3.支持事务管理,可以在业务层的方法中实现事务控制。
4、与 BaseMapper 配合使用,形成数据访问层和服务层的整体解决方案,提高代码的可维护性和可扩展性。
1.通用的 CRUD 操作: 提供了基本的增、删、改、查方法,与 BaseMapper 中的对应方法一致。
2.事务管理: 支持事务,可以在业务层的方法上使用 @Transactional 注解实现事务控制。
3.业务层方法: 除了 CRUD 操作外,还可以在接口中定义其他业务层方法,根据具体业务需求进行扩展。
4.Lambda 表达式查询: 支持在业务层使用 Lambda 表达式进行查询,提高查询条件的类型安全性。
5.逻辑删除: 支持逻辑删除,通过标记删除而不是物理删除,提高了数据安全性。
6.乐观锁: 支持乐观锁机制,用于处理并发更新时的数据一致性。

示例代码:

import com.baomidou.mybatisplus.extension.service.IService;

public interface UserService extends IService<User> {
    // 无需手动编写业务逻辑,通过继承 IService 即可使用通用的 CRUD 方法
    // 可以在接口中定义其他业务层方法
}

通过继承 IService 接口,开发者可以直接使用其中定义的通用方法,同时可以在接口中定义业务层方法,形成业务层的整体解决方案。

这样的设计可以提高代码的可维护性、可读性,同时减少了开发者对底层实现的关注,更专注于业务逻辑的实现。

对应的源码如下:

public interface IService<T> {

    /**
     * 默认批次提交数量
     */
    int DEFAULT_BATCH_SIZE = 1000;

    /**
     * 插入一条记录(选择字段,策略插入)
     *
     * @param entity 实体对象
     */
    default boolean save(T entity) {
        return SqlHelper.retBool(getBaseMapper().insert(entity));
    }

    /**
     * 插入(批量)
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveBatch(Collection<T> entityList) {
        return saveBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 插入(批量)
     *
     * @param entityList 实体对象集合
     * @param batchSize  插入批次数量
     */
    boolean saveBatch(Collection<T> entityList, int batchSize);

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveOrUpdateBatch(Collection<T> entityList) {
        return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     * @param batchSize  每次的数量
     */
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    default boolean removeById(Serializable id) {
        return SqlHelper.retBool(getBaseMapper().deleteById(id));
    }

    /**
     * 根据 columnMap 条件,删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    default boolean removeByMap(Map<String, Object> columnMap) {
        Assert.notEmpty(columnMap, "error: columnMap must not be empty");
        return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
    }

    /**
     * 根据 entity 条件,删除记录
     *
     * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default boolean remove(Wrapper<T> queryWrapper) {
        return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
    }

    /**
     * 删除(根据ID 批量删除)
     *
     * @param idList 主键ID列表
     */
    default boolean removeByIds(Collection<? extends Serializable> idList) {
        if (CollectionUtils.isEmpty(idList)) {
            return false;
        }
        return SqlHelper.retBool(getBaseMapper().deleteBatchIds(idList));
    }

    /**
     * 根据 ID 选择修改
     *
     * @param entity 实体对象
     */
    default boolean updateById(T entity) {
        return SqlHelper.retBool(getBaseMapper().updateById(entity));
    }

    /**
     * 根据 UpdateWrapper 条件,更新记录 需要设置sqlset
     *
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(Wrapper<T> updateWrapper) {
        return update(null, updateWrapper);
    }

    /**
     * 根据 whereEntity 条件,更新记录
     *
     * @param entity        实体对象
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(T entity, Wrapper<T> updateWrapper) {
        return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean updateBatchById(Collection<T> entityList) {
        return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     * @param batchSize  更新批次数量
     */
    boolean updateBatchById(Collection<T> entityList, int batchSize);

    /**
     * TableId 注解存在更新记录,否插入一条记录
     *
     * @param entity 实体对象
     */
    boolean saveOrUpdate(T entity);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    default T getById(Serializable id) {
        return getBaseMapper().selectById(id);
    }

    /**
     * 查询(根据ID 批量查询)
     *
     * @param idList 主键ID列表
     */
    default List<T> listByIds(Collection<? extends Serializable> idList) {
        return getBaseMapper().selectBatchIds(idList);
    }

    /**
     * 查询(根据 columnMap 条件)
     *
     * @param columnMap 表字段 map 对象
     */
    default List<T> listByMap(Map<String, Object> columnMap) {
        return getBaseMapper().selectByMap(columnMap);
    }

    /**
     * 根据 Wrapper,查询一条记录 <br/>
     * <p>结果集,如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last("LIMIT 1")</p>
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default T getOne(Wrapper<T> queryWrapper) {
        return getOne(queryWrapper, true);
    }

    /**
     * 根据 Wrapper,查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param throwEx      有多个 result 是否抛出异常
     */
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);

    /**
     * 根据 Wrapper,查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    Map<String, Object> getMap(Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper,查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

    /**
     * 查询总记录数
     *
     * @see Wrappers#emptyWrapper()
     */
    default int count() {
        return count(Wrappers.emptyWrapper());
    }

    /**
     * 根据 Wrapper 条件,查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default int count(Wrapper<T> queryWrapper) {
        return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<T> list(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectList(queryWrapper);
    }

    /**
     * 查询所有
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<T> list() {
        return list(Wrappers.emptyWrapper());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<T>> E page(E page) {
        return page(page, Wrappers.emptyWrapper());
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMaps(queryWrapper);
    }

    /**
     * 查询所有列表
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<Map<String, Object>> listMaps() {
        return listMaps(Wrappers.emptyWrapper());
    }

    /**
     * 查询全部记录
     */
    default List<Object> listObjs() {
        return listObjs(Function.identity());
    }

    /**
     * 查询全部记录
     *
     * @param mapper 转换函数
     */
    default <V> List<V> listObjs(Function<? super Object, V> mapper) {
        return listObjs(Wrappers.emptyWrapper(), mapper);
    }

    /**
     * 根据 Wrapper 条件,查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Object> listObjs(Wrapper<T> queryWrapper) {
        return listObjs(queryWrapper, Function.identity());
    }

    /**
     * 根据 Wrapper 条件,查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
        return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMapsPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
        return pageMaps(page, Wrappers.emptyWrapper());
    }

    /**
     * 获取对应 entity 的 BaseMapper
     *
     * @return BaseMapper
     */
    BaseMapper<T> getBaseMapper();

    /**
     * 以下的方法使用介绍:
     *
     * 一. 名称介绍
     * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
     * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
     *
     * 二. 支持介绍
     * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
     * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
     *
     * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
     * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
     * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
     *
     */

    /**
     * 链式查询 普通
     *
     * @return QueryWrapper 的包装类
     */
    default QueryChainWrapper<T> query() {
        return ChainWrappers.queryChain(getBaseMapper());
    }

    /**
     * 链式查询 lambda 式
     * <p>注意:不支持 Kotlin </p>
     *
     * @return LambdaQueryWrapper 的包装类
     */
    default LambdaQueryChainWrapper<T> lambdaQuery() {
        return ChainWrappers.lambdaQueryChain(getBaseMapper());
    }

    /**
     * 链式更改 普通
     *
     * @return UpdateWrapper 的包装类
     */
    default UpdateChainWrapper<T> update() {
        return ChainWrappers.updateChain(getBaseMapper());
    }

    /**
     * 链式更改 lambda 式
     * <p>注意:不支持 Kotlin </p>
     *
     * @return LambdaUpdateWrapper 的包装类
     */
    default LambdaUpdateChainWrapper<T> lambdaUpdate() {
        return ChainWrappers.lambdaUpdateChain(getBaseMapper());
    }

    /**
     * <p>
     * 根据updateWrapper尝试更新,否继续执行saveOrUpdate(T)方法
     * 此次修改主要是减少了此项业务代码的代码量(存在性验证之后的saveOrUpdate操作)
     * </p>
     *
     * @param entity 实体对象
     */
    default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
        return update(entity, updateWrapper) || saveOrUpdate(entity);
    }
}

2. CRUD

初始的搭建项目可看这篇文章:Springboot整合MybatisPlus的基本CRUD

在这个类中有一个变量:int DEFAULT_BATCH_SIZE = 1000;,该变量为默认批次提交的数量。

由上述源码可看到,还会使用一部分Mapper类中的功能函数,比如save是使用Mapper中的insert函数

目前数据库表内容如下:

在这里插入图片描述

count为返回的记录个数

    @Test
    public void test14(){
        // 返回数据的记录数
        long result =userService.count(); 
        System.out.println(result);
    }

2.1 插入

2.1.1 save

新增功能 save 函数整体如下:
该函数,不管主键ID存在与否,都直接是插入一个新数据

函数大致描述
boolean save(T entity)插入一条记录
boolean saveBatch(Collection<T> entityList)批量插入对象集合,默认是1000条一次
saveBatch(Collection<T> entityList, int batchSize)批量插入集合

示例函数如下:()

    @Test
    public void test1(){
        // 插入一条数据
        User user = new User();
        user.setUsername("user8");
        user.setPassword("pass8");
        userService.save(user);
        System.out.println(user);


        // 批量插入数据
        User user1 = new User();
        user1.setUsername("user9");user1.setPassword("pass9");
        User user2 = new User();
        user2.setUsername("user10");user2.setPassword("pass10");
        List<User> lists = Arrays.asList(user1,user2);
        userService.saveBatch(lists);
        lists.forEach(System.out::println);
    }

对应的终端输出如下:
在这里插入图片描述

对应的数据表如下:

在这里插入图片描述

对应上述的封装,也可是用这种方式,但原先的构造可能会失效:User user1 = new User();

        //批量插入的时候可以使用bulid来封装
        User user3 = User.builder().username("user11").password("pass11").build();
        User user4 = User.builder().username("user12").password("pass12").build();
        lists = Arrays.asList(user3,user4);
        userService.saveBatch(lists);
        lists.forEach(System.out::println);

前提需要在entity实体类中加入该注解:@Builder
大致如下:

@Builder
@Data
//@AllArgsConstructor
//@NoArgsConstructor
@TableName("test_user")
public class User {
    @TableId(value = "id", type = IdType.AUTO)
    private int id;
    private String username;
    private String password;
    // 其他字段...
}

2.1.2 saveOrUpdate

新增功能 saveOrUpdate函数整体如下:

对于该功能函数,主要逻辑如下:

  • 若存在主键ID值,则进行更新
  • 若不存在主键ID值,则进行插入
函数大致描述
boolean saveOrUpdate(T entity)TableId 注解存在更新记录,否插入一条记录
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper)根据updateWrapper尝试更新,否继续执行saveOrUpdate(T)方法
boolean saveOrUpdateBatch(Collection<T> entityList)批量修改插入,默认是1000条一次
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize)批量修改插入

对应的代码如下:

    @Test
    public void test6(){
        // 插入的数据不带主键ID值
        User user1 = new User();
        user1.setUsername("user11");user1.setPassword("pass11");
        userService.saveOrUpdate(user1);
        System.out.println(user1);

        // 插入的数据带主键ID值,且数据库中原先存在该ID值
        User user2 = new User();
        user2.setId(11);
        user2.setUsername("update_user11");user2.setPassword("update_pass11");
        userService.saveOrUpdate(user2);
        System.out.println(user2);

        // 插入的数据带主键ID值,且数据库中原先不存在该ID值
        User user3 = new User();
        user3.setId(12);
        user3.setUsername("user12");user3.setPassword("pass12");
        userService.saveOrUpdate(user3);
        System.out.println(user3);
    }

查看终端中的输出值:

在这里插入图片描述

查看数据库值:

在这里插入图片描述

2.2 删除

删除功能函数整体如下:

函数大致描述
boolean removeById(Serializable id)根据主键id删除
boolean removeByMap(Map<String, Object> columnMap)根据Map进行删除
boolean remove(Wrapper<T> queryWrapper)根据entity进行删除
boolean removeByIds(Collection<? extends Serializable> idList)批量根据主键ID进行删除
    @Test
    public void test7(){
        // 删除数据
        Boolean result1 = userService.removeById(12);
        System.out.println(result1);

        // 根据Map进行删除
        HashMap<String,Object>map = new HashMap<>();
        map.put("username","user13");
        map.put("password","pass13");

        Boolean result2 = userService.removeByMap(map);
        System.out.println(result2);


    }

表中会删除ID为12的行
在这里插入图片描述
对应如果删除模糊的数据,或者加一些判断,可以这样写:

	@Test
    public void test9(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("username","update");
        userService.remove(wrapper);
    }

最终的数据表如下所示:

在这里插入图片描述

2.3 修改

修改功能函数整体如下:

函数大致描述
boolean updateById(T entity)根据ID进行修改
boolean update(Wrapper<T> updateWrapper)根据 UpdateWrapper 条件,更新记录 需要设置sqlset
boolean update(T entity, Wrapper<T> updateWrapper)根据 whereEntity 条件,更新记录
boolean updateBatchById(Collection<T> entityList)根据ID 批量更新
updateBatchById(Collection<T> entityList, int batchSize)根据ID 批量更新

对于updateById 的是通过entity类进行传输,且updateBatchById 也就是 updateById 一个扩展版,通过list集合进行叠加,上述代码也有过展示

    @Test
    public void test10(){
        User user = new User();
        user.setUsername("user11");user.setPassword("pass11");
        userService.updateById(user);
    }

2.4 查询

修改功能函数整体如下:

注意get功能只能查一条,而list可以查多条

2.4.1 get

函数大致描述
T getById(Serializable id)根据 ID 查询
T getOne(Wrapper<T> queryWrapper)根据 Wrapper,查询一条记录,如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last(“LIMIT 1”)
T getOne(Wrapper<T> queryWrapper, boolean throwEx)根据 Wrapper,查询一条记录。有多个 result 是否抛出异常
Map<String, Object> getMap(Wrapper<T> queryWrapper)根据 Wrapper,查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper)根据 Wrapper,查询一条记录
    @Test
    public void test11(){
        // 根据ID主键查询
        User user = userService.getById(1);
        System.out.println(user);


        // 根据Wrapper查询
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("username","user5");
        User user1 = userService.getOne(wrapper);
        System.out.println(user1);



    }

截图如下:

在这里插入图片描述

2.4.2 list

函数大致描述
List<T> listByIds(Collection<? extends Serializable> idList)查询(根据ID 批量查询)
List<T> listByMap(Map<String, Object> columnMap)查询(根据 columnMap 条件)
List<T> list(Wrapper<T> queryWrapper)查询列表
List<T> list()查询所有
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper)查询列表
List<Map<String, Object>> listMaps()查询所有列表
List<Object> listObjs()查询全部记录
    @Test
    public void test12(){
        // 查询所有,返回数据是实体类集合
        List<User> result =userService.list();
        System.out.println(result);

        // 根据Id批量查询
        List<Integer> list = Arrays.asList(1,2);
        result =userService.listByIds(list);
        System.out.println(result);


        // 根据 columnMap 条件查询
        HashMap<String,Object> map = new HashMap<>();
        map.put("username","user9");
        map.put("password","pass9");
        result =userService.listByMap(map);
        System.out.println(result);


        // 查询所有列表-返回map集合
        List<Map<String, Object>> result1 =userService.listMaps();
        System.out.println(result1);

        // 查询全部记录-返回id集合
        List<Object> result2 =userService.listObjs();
        System.out.println(result2);
    }

截图如下:

在这里插入图片描述

2.4.3 page

函数大致描述
<E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper)翻页查询
<E extends IPage<T>> E page(E page)无条件翻页查询
    @Test
    public void test13(){
        // 无条件分页查询-返回实体
        // 第一个参数为当前页,第二个参数为页面大小
        //第一种写法
        Page<User> page1 = new Page<>(2,3);
        userService.page(page1,null);
        page1.getRecords().forEach(System.out::println);
        //总页数
        System.out.println(page1.getPages());

        //第二种写法
        page1 = userService.page(new Page<>(1,2),null);
        page1.getRecords().forEach(System.out::println);
        // 总页数
        System.out.println(page1.getPages());

        /*
        * -----------------------
        * */

        //无条件分页查询-返回map
        //第一种写法
        Page<Map<String, Object>> page2 = new Page<>(2,3);
        userService.pageMaps(page2,null);
        page2.getRecords().forEach(System.out::println);
        //总页数
        System.out.println(page2.getPages());

        //第二种写法
        Page<Map<String, Object>> page3 = userService.pageMaps(new Page<>(1,2),null);
        page3.getRecords().forEach(System.out::println);
        System.out.println(page3.getPages());

    }

2.5 chain链式函数

使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
* 1. 根据条件获取一条数据: query().eq("column", value).one()
* 2. 根据条件删除一条数据: update().eq("column", value).remove()

函数大致描述
QueryChainWrapper<T> query()链式查询 普通
LambdaQueryChainWrapper<T> lambdaQuery()链式查询 lambda 式
UpdateChainWrapper<T> update()链式更改 普通
LambdaUpdateChainWrapper<T> lambdaUpdate()链式更改 lambda 式

对应的查询代码如下:

    @Test
    public void test14(){
        // 查询一条,返回数据是实体类
        User result1 = userService.query().eq("username", "user1").one();
        System.out.println(result1);

        // 查询多条,返回数据是实体类集合
        List<User> result2 =userService.query().eq("username", "user1").isNotNull("username").list();
        System.out.println(result2);
        // 另外的写法,lambdaQuery
        List<User> result3 =userService.lambdaQuery().eq(User::getUsername,"user1").list();
        System.out.println(result3);
    }

截图如下所示:

在这里插入图片描述

目前表数据如下:

在这里插入图片描述

    @Test
    public void test15(){
        User user1 = new User();
        user1.setId(1);user1.setPassword("pass1111");
        Boolean result =  userService.update().eq("username", "user1").isNotNull("username").update(user1);
        System.out.println(result);

        User user2 = new User();
        user2.setPassword("pass1111");
        result = userService.update().eq("username", "user1").isNotNull("username").update(user2);
        System.out.println(result);

        User user3 = new User();
        user3.setId(20);user3.setPassword("pass1111");
        result = userService.update().eq("username", "user1").isNotNull("username").update(user3);
        System.out.println(result);
    }

最终的输出如下:

在这里插入图片描述

而且表中的数据如下:

在这里插入图片描述

说明有无主键都可返回true

文章来源:https://blog.csdn.net/weixin_47872288/article/details/135308109
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。