脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → MyBatis-Plus Mapper 接口

MyBatis-Plus Mapper 接口方法操作详解

 更新时间：2025年12月15日 09:48:44   作者：倚肆  
MyBatis-Plus的BaseMapper提供了丰富的开箱即用方法,所有方法都不需要编写SQL即可使用,可以满足95%以上的日常开发需求,本文给大家介绍MyBatis-Plus Mapper 接口方法详解,感兴趣的朋友跟随小编一起看看吧

MyBatis-Plus Mapper 接口方法详解

1. BaseMapper 核心方法概览

MyBatis-Plus 的 BaseMapper<T> 接口提供了丰富的 CRUD 操作方法，所有方法都不需要编写 SQL即可使用。

1.1 完整方法列表

方法类别方法名说明使用场景
插入insert(T entity)插入一条记录新增数据
删除deleteById(Serializable id)根据ID删除按主键删除
deleteBatchIds(Collection ids)批量ID删除批量删除
deleteByMap(Map map)根据Map删除简单条件删除
delete(Wrapper wrapper)条件删除复杂条件删除
更新updateById(T entity)根据ID更新按主键更新
update(T entity, Wrapper wrapper)条件更新复杂更新逻辑
查询selectById(Serializable id)根据ID查询按主键查询
selectBatchIds(Collection ids)批量ID查询按主键列表查询
selectByMap(Map map)根据Map查询简单条件查询
selectOne(Wrapper wrapper)查询单条记录确保结果唯一时
selectCount(Wrapper wrapper)查询记录数统计数量
selectList(Wrapper wrapper)查询列表条件查询
selectMaps(Wrapper wrapper)查询Map列表只需要部分字段
分页selectPage(Page page, Wrapper wrapper)分页查询分页数据查询
selectMapsPage(Page page, Wrapper wrapper)Map分页查询分页+部分字段
public interface BaseMapper<T> extends Mapper<T> {
// ========== 插入操作 ==========
int insert(T entity);
// ========== 删除操作 ==========
int deleteById(Serializable id);
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// ========== 更新操作 ==========
int updateById(@Param(Constants.ENTITY) T entity);
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// ========== 查询操作 ==========
T selectById(Serializable id);
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// ========== 分页查询 ==========
<E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
<E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

2. 插入操作（Insert）

2.1 基本插入方法

// Mapper接口定义
public interface UserMapper extends BaseMapper<User> {
// 无需额外声明，直接使用继承的方法
}
// 使用示例
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public void testInsert() {
    User user = new User();
    user.setName("张三");
    user.setAge(25);
    user.setEmail("zhangsan@example.com");
    // 插入一条记录
    int result = userMapper.insert(user);
    System.out.println("插入结果: " + result); // 影响行数
    System.out.println("自增ID: " + user.getId()); // 自动回填主键
}
}

2.2 插入相关配置

// 实体类配置示例
@Data
@TableName("user")
public class User {
@TableId(type = IdType.AUTO) // 自增主键
private Long id;
private String name;
private Integer age;
private String email;
@TableField(fill = FieldFill.INSERT)  // 自动填充
private LocalDateTime createTime;
}

3. 删除操作（Delete）

3.1 根据ID删除

// 根据主键删除
public void testDeleteById() {
// 删除ID为1的用户
int result = userMapper.deleteById(1L);
System.out.println("删除行数: " + result);
}
// 批量根据ID删除
public void testDeleteBatchIds() {
List<Long> ids = Arrays.asList(1L, 2L, 3L);
int result = userMapper.deleteBatchIds(ids);
System.out.println("批量删除行数: " + result);
}

3.2 条件删除

// 根据Map条件删除
public void testDeleteByMap() {
Map<String, Object> condition = new HashMap<>();
condition.put("name", "张三"); // name = '张三'
condition.put("age", 25); // AND age = 25
int result = userMapper.deleteByMap(condition);
System.out.println("条件删除行数: " + result);
}
// 使用Wrapper条件删除
public void testDeleteByWrapper() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三")
.ge(User::getAge, 18); // name = '张三' AND age >= 18
int result = userMapper.delete(wrapper);
System.out.println("Wrapper删除行数: " + result);
}

4. 更新操作（Update）

4.1 根据ID更新

// 根据主键更新
public void testUpdateById() {
User user = new User();
user.setId(1L);
user.setName("李四");
user.setEmail("lisi@example.com");
int result = userMapper.updateById(user);
System.out.println("更新行数: " + result);
}

4.2 条件更新

// 使用UpdateWrapper进行条件更新
public void testUpdateByWrapper() {
// 方法1：实体 + wrapper
User user = new User();
user.setEmail("updated@example.com");
UpdateWrapper<User> wrapper = new UpdateWrapper<>();
wrapper.eq("name", "张三")                    // 条件：name = '张三'
       .set("age", 30)                       // 直接设置字段值
       .setSql("version = version + 1");     // 自定义SQL片段
int result = userMapper.update(user, wrapper);
// 方法2：纯wrapper更新（推荐）
LambdaUpdateWrapper<User> lambdaWrapper = new LambdaUpdateWrapper<>();
lambdaWrapper.eq(User::getName, "张三")
            .set(User::getAge, 30)
            .set(User::getEmail, "updated@example.com");
int result2 = userMapper.update(null, lambdaWrapper);
}

5. 查询操作（Select）

5.1 根据ID查询

// 基本ID查询
public void testSelectById() {
User user = userMapper.selectById(1L);
System.out.println("查询结果: " + user);
}
// 批量ID查询
public void testSelectBatchIds() {
List<Long> ids = Arrays.asList(1L, 2L, 3L, 4L);
List<User> users = userMapper.selectBatchIds(ids);
System.out.println("批量查询结果: " + users.size());
}

5.2 条件查询

// 根据Map条件查询
public void testSelectByMap() {
Map<String, Object> condition = new HashMap<>();
condition.put("name", "张三");
condition.put("status", 1);
List<User> users = userMapper.selectByMap(condition);
System.out.println("Map条件查询: " + users);
}
// 查询单条记录
public void testSelectOne() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getName, "张三");
User user = userMapper.selectOne(wrapper);  // 必须确保结果唯一
System.out.println("单条查询: " + user);
}
// 查询数量
public void testSelectCount() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.ge(User::getAge, 18); // 年龄 >= 18
Long count = userMapper.selectCount(wrapper);
System.out.println("满足条件的记录数: " + count);
}

5.3 复杂查询示例

// 复杂条件查询
public void testComplexQuery() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
// 条件组合
wrapper.select(User::getId, User::getName, User::getAge)  // 指定查询字段
      .like(User::getName, "张")                          // 模糊查询
      .between(User::getAge, 18, 30)                      // 范围查询
      .isNotNull(User::getEmail)                        // 非空查询
      .in(User::getStatus, Arrays.asList(1, 2, 3))      // IN查询
      .orderByDesc(User::getCreateTime)                  // 排序
      .last("LIMIT 10");                                 // 自定义SQL后缀
List<User> users = userMapper.selectList(wrapper);
System.out.println("复杂查询结果: " + users);
}
// 查询特定字段
public void testSelectSpecificFields() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.select("id", "name", "email") // 只查询指定字段
.eq("status", 1);
List<User> users = userMapper.selectList(wrapper);
}
// 查询为Map列表
public void testSelectMaps() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.select(User::getId, User::getName)
.ge(User::getAge, 18);
List<Map<String, Object>> mapList = userMapper.selectMaps(wrapper);
// 结果: [{"id":1, "name":"张三"}, {"id":2, "name":"李四"}]
}

6. 分页查询

6.1 基本分页配置

// 配置分页插件
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
    return interceptor;
}
}

6.2 分页查询使用

// 分页查询示例
public void testSelectPage() {
// 创建分页对象：查询第1页，每页10条
Page<User> page = new Page<>(1, 10);
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.ge(User::getAge, 18)
      .orderByDesc(User::getCreateTime);
// 执行分页查询
Page<User> result = userMapper.selectPage(page, wrapper);
System.out.println("总记录数: " + result.getTotal());
System.out.println("总页数: " + result.getPages());
System.out.println("当前页数据: " + result.getRecords());
System.out.println("是否有下一页: " + result.hasNext());
}
// Map分页查询
public void testSelectMapsPage() {
Page<Map<String, Object>> page = new Page<>(1, 10);
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.select("id", "name", "age")
      .ge("age", 18);
Page<Map<String, Object>> result = userMapper.selectMapsPage(page, wrapper);
// 结果处理
result.getRecords().forEach(map -> {
    System.out.println("ID: " + map.get("id") + ", Name: " + map.get("name"));
});
}

7. 自定义方法扩展

7.1 自定义SQL方法

// 在BaseMapper基础上扩展自定义方法
public interface UserMapper extends BaseMapper<User> {
// 自定义查询方法
@Select("SELECT * FROM user WHERE age > #{minAge} AND age < #{maxAge}")
List<User> selectByAgeRange(@Param("minAge") Integer minAge, 
                           @Param("maxAge") Integer maxAge);
// 自定义更新方法
@Update("UPDATE user SET email = #{email} WHERE name = #{name}")
int updateEmailByName(@Param("name") String name, 
                     @Param("email") String email);
// 复杂查询方法
List<User> selectComplexUsers(@Param("name") String name,
                             @Param("minAge") Integer minAge,
                             @Param("statusList") List<Integer> statusList);
}

7.2 对应的XML配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
<select id="selectComplexUsers" resultType="User">
    SELECT * FROM user 
    <where>
        <if test="name != null">AND name LIKE CONCAT('%', #{name}, '%')</if>
        <if test="minAge != null">AND age >= #{minAge}</if>
        <if test="statusList != null and statusList.size() > 0">
            AND status IN
            <foreach collection="statusList" item="status" open="(" separator="," close=")">
                #{status}
            </foreach>
        </if>
    </where>
</select>
</mapper>

8. 完整使用示例

8.1 完整服务类示例

@Service
@Transactional
public class UserService {
@Autowired
private UserMapper userMapper;
/**
 * 完整的CRUD操作示例
 */
public void completeCrudExample() {
    // 1. 插入
    User newUser = new User();
    newUser.setName("测试用户");
    newUser.setAge(20);
    newUser.setEmail("test@example.com");
    userMapper.insert(newUser);
    Long userId = newUser.getId();
    // 2. 查询
    User dbUser = userMapper.selectById(userId);
    System.out.println("插入后查询: " + dbUser);
    // 3. 更新
    dbUser.setAge(25);
    userMapper.updateById(dbUser);
    // 4. 条件查询
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    wrapper.between(User::getAge, 20, 30)
          .orderByDesc(User::getId);
    List<User> users = userMapper.selectList(wrapper);
    // 5. 分页查询
    Page<User> page = new Page<>(1, 5);
    Page<User> pageResult = userMapper.selectPage(page, wrapper);
    // 6. 删除
    userMapper.deleteById(userId);
}
/**
 * 批量操作示例
 */
public void batchOperationExample() {
    // 批量插入
    List<User> userList = new ArrayList<>();
    for (int i = 1; i <= 5; i++) {
        User user = new User();
        user.setName("批量用户" + i);
        user.setAge(20 + i);
        userList.add(user);
    }
    // 注意：BaseMapper没有批量插入方法，需要自定义或使用Service的saveBatch
    userList.forEach(userMapper::insert);
    // 批量删除
    List<Long> ids = userList.stream()
        .map(User::getId)
        .collect(Collectors.toList());
    userMapper.deleteBatchIds(ids);
}
}

9. 最佳实践建议

  1. 简单CRUD：直接使用BaseMapper提供的方法
  2. 复杂查询：使用Wrapper构建查询条件
  3. 分页查询：配置分页插件后使用selectPage方法
  4. 自定义SQL：在BaseMapper基础上扩展自定义方法
  5. 事务管理：在Service层使用@Transactional注解
  6. 自动填充：利用@TableField(fill)实现自动填充
  7. 逻辑删除：使用@TableLogic实现逻辑删除
  8. 乐观锁：使用@Version实现乐观锁控制

MyBatis-Plus的BaseMapper提供了丰富的开箱即用方法，可以满足95%以上的日常开发需求。通过合理使用这些方法，可以显著提高开发效率，减少重复代码编写。

到此这篇关于MyBatis-Plus Mapper 接口方法详解的文章就介绍到这了,更多相关MyBatis-Plus Mapper 接口内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • springboot利用AOP完成日志统计的详细步骤

    springboot利用AOP完成日志统计的详细步骤

    项目用到了过滤器，可能有的人会不理解，之所以用过滤器是因为想要在日志记录post请求的json数据。本文重点给大家介绍springboot利用AOP完成日志统计的详细步骤，感兴趣的朋友跟随小编一起看看吧
    2021-12-12
  • java 反射getClass .class 的使用方法示例

    java 反射getClass .class 的使用方法示例

    这篇文章主要介绍了java 反射getClass .class 的使用方法,结合实例形式分析了java类反射机制的相关操作技巧,需要的朋友可以参考下
    2019-11-11
  • Spring事务中的事务传播行为使用方式详解

    Spring事务中的事务传播行为使用方式详解

    Spring框架作为一个轻量级的开源框架，在企业应用开发中被广泛使用，在Spring事务管理中，事务传播行为是非常重要的一部分，它定义了方法如何参与到已经存在的事务中或者如何开启新的事务，本文将详细介绍Spring事务中的几种事务传播行为，详细讲解具体使用方法
    2023-06-06
  • Java中使用内存映射实现大文件上传实例

    Java中使用内存映射实现大文件上传实例

    这篇文章主要介绍了Java中使用内存映射实现大文件上传实例,本文对比测试了FileInputStream 或者FileOutputStream 抑或RandomAccessFile的频繁读写操作,最后总结出映射到内存后进行读写以提高速度,需要的朋友可以参考下
    2015-01-01
  • Java日常练习题,每天进步一点点(15)

    Java日常练习题,每天进步一点点(15)

    下面小编就为大家带来一篇Java基础的几道练习题(分享)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，希望可以帮到你
    2021-07-07
  • Java控制台输入数组并逆序输出的方法实例

    Java控制台输入数组并逆序输出的方法实例

    这篇文章主要介绍了Java手动输入数组并逆向输出的方法实例,需要的朋友可以参考下。
    2017-08-08
  • Spring中的自动装配机制详解

    Spring中的自动装配机制详解

    这篇文章主要介绍了Spring中的自动装配机制详解,自动装配就是会通过Spring的上下文为你找出相应依赖项的类，通俗的说就是Spring会在上下文中自动查找，并自动给Bean装配与其相关的属性,需要的朋友可以参考下
    2023-08-08
  • 解决fastjson从1.1.41升级到1.2.28后报错问题详解

    解决fastjson从1.1.41升级到1.2.28后报错问题详解

    这篇文章主要介绍了解决fastjson从1.1.41升级到1.2.28后报错问题详解,需要的朋友可以参考下
    2020-02-02
  • java时间日期使用与查询代码详解

    java时间日期使用与查询代码详解

    这篇文章主要介绍了java时间日期使用与查询代码详解，具有一定借鉴价值，需要的朋友可以参考下。
    2017-11-11
  • springboot统一异常处理(返回json)并格式化异常

    springboot统一异常处理(返回json)并格式化异常

    这篇文章主要介绍了springboot统一异常处理(返回json)并格式化异常,对spring boot的默认异常处理方式进行修改，要统一返回数据格式，优雅的数据交互，优雅的开发应用,需要的朋友可以参考下
    2023-07-07

最新评论