MybatisPlus使用Wrapper实现增删改查功能

最新推荐文章于 2025-03-16 14:43:20 发布
最新推荐文章于 2025-03-16 14:43:20 发布
阅读量9.2k 收藏 27
点赞数 2
文章标签： java mybatis wrapper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32407233/article/details/121603284
版权
本文介绍了如何使用MyBatisPlus库进行Java服务层的CRUD操作。通过引入Maven依赖，我们可以方便地实现User服务的增删改查功能。例如，通过Service接口的save方法保存用户，使用Wrapper条件构造器进行条件查询和更新等操作，大大简化了代码编写。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

条件构造器的格式说明
在这里插入图片描述
导入maven依赖

        <dependency>
            <groupId>com.github.jeffreyning</groupId>
            <artifactId>mybatisplus-plus</artifactId>
            <version>1.5.1-RELEASE</version>
            <scope>compile</scope>
        </dependency>

Service 继承IService

/**
 * @Author lqq
 * @Date 2019/11/25 9:27
 * @Description
 * @Version 1.0
 */
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {


}

最常用的方法就增删改查

User user = new User();
user.setAge(23);
user.setEmail("344");
user.setName("test");
// 1.使用service新增
userService.save(user);
// 2.使用mapper 新增
userMapper.insert(user);

// 根据条件删除
userService.remove(Wrappers.<User>query().lambda().eq(User::getAge, 3));

// 更新
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>(); 
//修改语句
updateWrapper.set("name", "123");
//条件
updateWrapper.eq("id", user.getId());
userService.update(updateWrapper);

// 更新
UpdateWrapper<User> updateWrapper=new UpdateWrapper<>();
User user =new User();
user.setEmail("1234@qq.com");
//条件
updateWrapper.eq("id",6);
int rows = userService.update(user,updateWrapper);

QueryWrapper<User> wrapper=new QueryWrapper<>();
// 条件
wrapper.isNotNull("name") //name不为空的用户
       .isNotNull("email") //邮箱不为空的用户
       .ge("age",12); //年龄大于等于12
userService.selectList(wrapper).forEach(System.out::println);

IService

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.baomidou.mybatisplus.extension.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.springframework.transaction.annotation.Transactional;

public interface IService<T> {
    int DEFAULT_BATCH_SIZE = 1000;

    default boolean save(T entity) {
        return SqlHelper.retBool(this.getBaseMapper().insert(entity));
    }

    @Transactional(
        rollbackFor = {Exception.class}
    )
    default boolean saveBatch(Collection<T> entityList) {
        return this.saveBatch(entityList, 1000);
    }

    boolean saveBatch(Collection<T> entityList, int batchSize);

    @Transactional(
        rollbackFor = {Exception.class}
    )
    default boolean saveOrUpdateBatch(Collection<T> entityList) {
        return this.saveOrUpdateBatch(entityList, 1000);
    }

    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

    default boolean removeById(Serializable id) {
        return SqlHelper.retBool(this.getBaseMapper().deleteById(id));
    }

    default boolean removeByMap(Map<String, Object> columnMap) {
        Assert.notEmpty(columnMap, "error: columnMap must not be empty", new Object[0]);
        return SqlHelper.retBool(this.getBaseMapper().deleteByMap(columnMap));
    }

    default boolean remove(Wrapper<T> queryWrapper) {
        return SqlHelper.retBool(this.getBaseMapper().delete(queryWrapper));
    }

    default boolean removeByIds(Collection<? extends Serializable> idList) {
        return CollectionUtils.isEmpty(idList) ? false : SqlHelper.retBool(this.getBaseMapper().deleteBatchIds(idList));
    }

    default boolean updateById(T entity) {
        return SqlHelper.retBool(this.getBaseMapper().updateById(entity));
    }

    default boolean update(Wrapper<T> updateWrapper) {
        return this.update((Object)null, updateWrapper);
    }

    default boolean update(T entity, Wrapper<T> updateWrapper) {
        return SqlHelper.retBool(this.getBaseMapper().update(entity, updateWrapper));
    }

    @Transactional(
        rollbackFor = {Exception.class}
    )
    default boolean updateBatchById(Collection<T> entityList) {
        return this.updateBatchById(entityList, 1000);
    }

    boolean updateBatchById(Collection<T> entityList, int batchSize);

    boolean saveOrUpdate(T entity);

    default T getById(Serializable id) {
        return this.getBaseMapper().selectById(id);
    }

    default List<T> listByIds(Collection<? extends Serializable> idList) {
        return this.getBaseMapper().selectBatchIds(idList);
    }

    default List<T> listByMap(Map<String, Object> columnMap) {
        return this.getBaseMapper().selectByMap(columnMap);
    }

    default T getOne(Wrapper<T> queryWrapper) {
        return this.getOne(queryWrapper, true);
    }

    T getOne(Wrapper<T> queryWrapper, boolean throwEx);

    Map<String, Object> getMap(Wrapper<T> queryWrapper);

    <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

    default int count() {
        return this.count(Wrappers.emptyWrapper());
    }

    default int count(Wrapper<T> queryWrapper) {
        return SqlHelper.retCount(this.getBaseMapper().selectCount(queryWrapper));
    }

    default List<T> list(Wrapper<T> queryWrapper) {
        return this.getBaseMapper().selectList(queryWrapper);
    }

    default List<T> list() {
        return this.list(Wrappers.emptyWrapper());
    }

    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
        return this.getBaseMapper().selectPage(page, queryWrapper);
    }

    default <E extends IPage<T>> E page(E page) {
        return this.page(page, Wrappers.emptyWrapper());
    }

    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
        return this.getBaseMapper().selectMaps(queryWrapper);
    }

    default List<Map<String, Object>> listMaps() {
        return this.listMaps(Wrappers.emptyWrapper());
    }

    default List<Object> listObjs() {
        return this.listObjs(Function.identity());
    }

    default <V> List<V> listObjs(Function<? super Object, V> mapper) {
        return this.listObjs(Wrappers.emptyWrapper(), mapper);
    }

    default List<Object> listObjs(Wrapper<T> queryWrapper) {
        return this.listObjs(queryWrapper, Function.identity());
    }

    default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
        return (List)this.getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
    }

    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
        return this.getBaseMapper().selectMapsPage(page, queryWrapper);
    }

    default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
        return this.pageMaps(page, Wrappers.emptyWrapper());
    }

    BaseMapper<T> getBaseMapper();

    Class<T> getEntityClass();

    default QueryChainWrapper<T> query() {
        return ChainWrappers.queryChain(this.getBaseMapper());
    }

    default LambdaQueryChainWrapper<T> lambdaQuery() {
        return ChainWrappers.lambdaQueryChain(this.getBaseMapper());
    }

    default KtQueryChainWrapper<T> ktQuery() {
        return ChainWrappers.ktQueryChain(this.getBaseMapper(), this.getEntityClass());
    }

    default KtUpdateChainWrapper<T> ktUpdate() {
        return ChainWrappers.ktUpdateChain(this.getBaseMapper(), this.getEntityClass());
    }

    default UpdateChainWrapper<T> update() {
        return ChainWrappers.updateChain(this.getBaseMapper());
    }

    default LambdaUpdateChainWrapper<T> lambdaUpdate() {
        return ChainWrappers.lambdaUpdateChain(this.getBaseMapper());
    }

    default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
        return this.update(entity, updateWrapper) || this.saveOrUpdate(entity);
    }
}
屯庆笔记
关注
Mybatis-Plus 常用增删改查方法详解（Wrapper 条件构造器的使用）
zzvar的博客
06-27 1万+
Mybatis-Plus内容一、Mybatis-Plus 概念二、项目准备（以 SpringBoot 项目为例）1. 项目结构图2. 数据表2.1 数据表截图2.2 建表语句3. 项目依赖3.1 集成 SpringBoot 项目3.2 集成 SSM 项目4. application.properties 配置文件5. Employee 实体类6. EmployeeMapper7. App 启动类三、Mybatis-Plus 常用注解四、Mybatis-Plus 日志五、通用 BaseMapper 接口方法
Springboot+MybatisPlus高效实现增删改查
2401_85113244的博客
06-04 425
this.update(Wrappers.lambdaUpdate(User.class).set(User::getNickName,“柳大侠”).eq(User::getId,id));this.update(new UpdateWrapper().set(“nick_name”,“柳大侠”).eq(“id”,id));好了，这样你就可以使用顺利使用Mybatis-Plus的代码操作数据库了，接下去看下Mybatis-Plus的使用示例。
Mybatis-Plus
2402_88002981的博客
01-13 1268
‌条件构造器是 MyBatis-Plus 提供的一个核心功能，它用于构建 SQL 的 WHERE 条件部分。通过链式调用的方式，可以非常灵活地组合各种查询条件，避免了手写 SQL 的繁琐和易错性。 MyBatis-Plus 提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的 SQL 语句，从而提高开发效率并减少 SQL 注入的风险。
MyBatis-Plus 逻辑删除：让数据“消失”却不真正删除的秘密！
最新发布
qq_56158663的博客
03-16 989
想象一下，你有一个笔记本 📒，上面记录了很多信息。如果你想删除某一条信息，你不会真的把它从笔记本上撕掉 ✂️，而是用笔划掉它 ✏️，或者在旁边写上“已删除” ❌。这样，这条信息还在笔记本上，只是被标记为“已删除”，不再被使用。这就是逻辑删除！🎉 在数据库中，我们不会真的把数据从表中删除 🗑️，而是给这条数据加上一个“已删除”的标记（通常是一个字段，比如deleted），表示这条数据已经被删除了。
wrapper的使用增删改查
zouyang920的博客
05-26 1648
今天项目中使用wrapper，怎么都不行，还是这种lambda表达式又高效有准确的解决了。 参考链接
mybatis-plus案例 方法 一系列配置 增删改查
12-25
mybatis-plus案例 方法 一系列配置 增删改查 mybatis-plus将 mybatis封装成与hibernate一样的增删改查操作，同时也能自定义SQL
MyBatisPlus条件构造器带条件删除delete使用示例代码
04-23
MyBatisPlus条件构造器带条件删除delete使用示例代码
MyBatisPlus-QueryWrapper多条件查询以及修改
热门推荐
qq_37262663的博客
07-30 1万+
gt、ge、lt、le、isNull、isNotNull 大于 > 例: gt(“age”, 18) → age > 18 ge 大于等于 >= 例: ge(“age”, 18) → age >= 18 lt 小于 < 例: lt(“age”, 18) → age < 18 le 小于等于 <= 例: le(“age”, 18) → age <= 18 isNUll 字段 IS NULL 例: isNull(“name”) → name is null isN
MybatisPlus快速实现增删改查(含代码及接口测试工具测试数据)
小魏做编程
03-08 994
MybatisPlus的增删改查接口代码及测试数据
MyBatisPlus：基本增删改查
安晴晚风的博客
08-12 1756
MyBatisPlus：基本增删改查
MyBatisPlus基本增删改查（BaseMapper的使用方法）
后端小白个人学习记录
08-18 843
MyBatisPlus基本增删改查（BaseMapper的使用方法）
QXmlWrapper，实现XML文件的创建、删除以及元素节点的增加、删除、修改与查找等。
12-15
自己编写Qt的XML封装类QXmlWrapper，实现XML文件的创建、删除以及元素节点的增加、删除、修改与查找等。
MybatisPlus实现动态分表增删改查
qq_38152423的博客
12-11 812
/** * <p> * 工单记录表 * </p> * * @author ௸྄ིོུ倾心ღ᭄ᝰꫛꫀꪝ * @since 2021-12-11 * eph_ispc_order_his_y0000 * 动态分表 实体类 _后是动态表名后缀 */ @Data @EqualsAndHashCode(callSuper = false) @Accessors(chain = true) @TableName("eph_ispc_order_his_") public cl
Mybatis-plus使用Wrappers方法根据id删除两张表的内容
qq_57039307的博客
06-14 998
Mybatis-plus使用Wrappers方法根据id删除两张表的内容
Mybatis-plus逻辑删除
一个搬砖工人
07-10 187
package com.zs.testmybatisplus.entity; import com.baomidou.mybatisplus.annotation.TableLogic; import lombok.Data; import lombok.experimental.Accessors; /** * @author miemie * @since 2019-11-26 */ @Data @Accessors(chain = true) public class Null1 {
MyBatisPlus 的 Wrapper 和 增删该查
weixin_46189836的博客
07-05 6188
插入 @Test public void testInsert(){ User user = new User(); user.setName("狂神说Java"); user.setAge(3); user.setEmail("24736743@qq.com"); int result = userMapper.insert(user); // 帮我们自动生成id System.out.println(result); // 受影响的行数 System.out.println(user); // 发现，
Mybatis-Plus中增(insert)删(delete)改(update)方法讲解-V1.0
qq_53437402的博客
08-06 6466
Mybatis-Plus中增(insert)删(delete)改(update)的使用
mybatisplus 增删改查
淼淼不暴躁!
11-01 1177
我们在自己的Service接口中通过继承MyBatis-Plus提供的IService接口，不仅可以获得其提供的CRUD方法，而且还可以使用自身定义的方法。MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，因此我们继承该接口以后可以直接使用。，封装了常见的业务层逻辑，详情查看源码IService和ServiceImpl。MyBatis-Plus中有一个接口 **因此我们在使用的时候仅需在自己定义的****和其实现类 ServiceImpl。
MybatisPlus 接口方法 主键策略 逻辑删除 Wrapper构造器
qq_66851231的博客
05-10 1006
在 MyBatis-Plus 的查询操作中，被标记的字段会自动被考虑，以确保不会查询到被逻辑删除的记录。assertTrue("张三".equals(user.getName()) || "李四".equals(user.getName()));queryWrapper.and(wrapper -> wrapper.eq(User::getName, "张三"))queryWrapper.or(wrapper -> wrapper.eq(User::getName, "张三"))
mybatisplus实现对表的增删改查
04-03
MyBatis Plus是一个基于MyBatis的增强工具，它简化了对数据库的操作，提供了更加便捷的方式来实现对表的增删改查操作。下面是MyBatis Plus实现对表的增删改查的介绍： 1. 增加数据： 使用MyBatis Plus进行数据插入操作，可以通过调用Mapper接口的insert方法来实现。例如： ```java User user = new User(); user.setName("张三"); user.setAge(20); userMapper.insert(user); ``` 2. 删除数据： 使用MyBatis Plus进行数据删除操作，可以通过调用Mapper接口的deleteById方法或者delete方法来实现。例如： ```java userMapper.deleteById(1L); // 根据主键删除数据 userMapper.delete(new QueryWrapper<User>().eq("age", 20)); // 根据条件删除数据 ``` 3. 修改数据： 使用MyBatis Plus进行数据修改操作，可以通过调用Mapper接口的updateById方法或者update方法来实现。例如： ```java User user = new User(); user.setId(1L); user.setName("李四"); userMapper.updateById(user); // 根据主键更新数据 userMapper.update(user, new UpdateWrapper<User>().eq("age", 20)); // 根据条件更新数据 ``` 4. 查询数据： 使用MyBatis Plus进行数据查询操作，可以通过调用Mapper接口的selectById方法、selectList方法或者selectOne方法来实现。例如： ```java User user = userMapper.selectById(1L); // 根据主键查询数据 List<User> userList = userMapper.selectList(new QueryWrapper<User>().eq("age", 20)); // 根据条件查询数据 User user = userMapper.selectOne(new QueryWrapper<User>().eq("name", "张三")); // 根据条件查询单条数据 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值