BaseMapper 通用 CRUD

  BaseMapper 是 MyBatis-Plus 的核心接口，提供了 17 种通用 CRUD 方法，单表操作无需写一行 SQL。

一、BaseMapper 方法全览

public interface BaseMapper<T> {

    // ========== 插入 ==========
    int insert(T entity);                              // 插入一条记录
    int insertBatch(Collection<T> entityList);         // 批量插入（3.5.4+）

    // ========== 删除 ==========
    int deleteById(Serializable id);                   // 根据 ID 删除
    int deleteByMap(Map<String, Object> columnMap);    // 根据 map 条件删除
    int delete(Wrapper<T> queryWrapper);               // 根据条件删除
    int deleteBatchIds(Collection<?> idList);          // 批量删除

    // ========== 修改 ==========
    int updateById(T entity);                          // 根据 ID 更新
    int update(T entity, Wrapper<T> updateWrapper);    // 根据条件更新

    // ========== 查询 ==========
    T selectById(Serializable id);                     // 根据 ID 查询
    List<T> selectBatchIds(Collection<?> idList);      // 批量 ID 查询
    List<T> selectByMap(Map<String, Object> columnMap); // 根据 map 条件查询
    T selectOne(Wrapper<T> queryWrapper);              // 查询一条（多条会报错）
    boolean exists(Wrapper<T> queryWrapper);           // 判断是否存在
    Long selectCount(Wrapper<T> queryWrapper);         // 统计数量
    List<T> selectList(Wrapper<T> queryWrapper);       // 列表查询
    List<Map<String, Object>> selectMaps(Wrapper<T> queryWrapper); // 查询返回 Map
    List<Object> selectObjs(Wrapper<T> queryWrapper);  // 查询返回单列
    <P> IPage<T> selectPage(IPage<T> page, Wrapper<T> queryWrapper); // 分页查询
}

二、插入操作

2.1 基础插入

// 插入一条记录
User user = new User();
user.setName("张三");
user.setAge(25);
userMapper.insert(user);
// 执行：INSERT INTO user (name, age) VALUES (?, ?)
// user.getId() 自动被雪花算法赋值

2.2 批量插入

// 方式一：BaseMapper 批量插入（3.5.4+）
List<User> users = Arrays.asList(
    new User("张三", 25),
    new User("李四", 30),
    new User("王五", 28)
);
userMapper.insertBatch(users);

// 方式二：Service 层批量插入
userService.saveBatch(users);
userService.saveBatch(users, 100);  // 每 100 条一批

三、删除操作

3.1 根据 ID 删除

userMapper.deleteById(1L);
// 逻辑删除：UPDATE user SET deleted = 1 WHERE id = 1
// 物理删除：DELETE FROM user WHERE id = 1

3.2 根据条件删除

// 删除所有年龄 > 50 的用户
userMapper.delete(
    new LambdaQueryWrapper<User>()
        .gt(User::getAge, 50)
);

// 根据 Map 删除
Map<String, Object> map = new HashMap<>();
map.put("name", "张三");
map.put("age", 25);
userMapper.deleteByMap(map);
// DELETE FROM user WHERE name = '张三' AND age = 25

3.3 批量删除

userMapper.deleteBatchIds(Arrays.asList(1L, 2L, 3L));
// DELETE FROM user WHERE id IN (1, 2, 3)

四、更新操作

4.1 根据 ID 更新

User user = new User();
user.setId(1L);
user.setAge(30);
userMapper.updateById(user);
// UPDATE user SET age = 30 WHERE id = 1
// 注意：只更新非 null 字段

4.2 根据条件更新

// 把所有年龄 > 30 的用户年龄设置为 40
User user = new User();
user.setAge(40);

userMapper.update(user,
    new LambdaUpdateWrapper<User>()
        .gt(User::getAge, 30)
);
// UPDATE user SET age = 40 WHERE age > 30

4.3 链式更新（Service 层）

// Lambda 链式更新
userService.lambdaUpdate()
    .set(User::getAge, 40)
    .gt(User::getAge, 30)
    .update();

五、查询操作

5.1 根据 ID 查询

User user = userMapper.selectById(1L);
// SELECT * FROM user WHERE id = 1

5.2 批量 ID 查询

List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
// SELECT * FROM user WHERE id IN (1, 2, 3)

5.3 条件查询

// 查询所有年龄 > 20 的用户
List<User> users = userMapper.selectList(
    new LambdaQueryWrapper<User>()
        .gt(User::getAge, 20)
        .orderByDesc(User::getCreateTime)
);

// 统计数量
Long count = userMapper.selectCount(
    new LambdaQueryWrapper<User>()
        .eq(User::getAge, 25)
);

// 判断是否存在
boolean exists = userMapper.exists(
    new LambdaQueryWrapper<User>()
        .eq(User::getName, "张三")
);

5.4 查询一条

User user = userMapper.selectOne(
    new LambdaQueryWrapper<User>()
        .eq(User::getEmail, "zhangsan@test.com")
);
// 注意：结果 > 1 条会抛异常 TooManyResultsException

5.5 查询返回 Map

// 只查部分字段，返回 Map
List<Map<String, Object>> maps = userMapper.selectMaps(
    new LambdaQueryWrapper<User>()
        .select(User::getId, User::getName)
);
// 结果：[{id=1, name=张三}, {id=2, name=李四}]

5.6 查询返回单列

// 只查 ID 列表
List<Object> ids = userMapper.selectObjs(
    new LambdaQueryWrapper<User>()
        .select(User::getId)
);
// 结果：[1, 2, 3]

5.7 链式查询（Service 层）

// Lambda 链式查询
List<User> list = userService.lambdaQuery()
    .gt(User::getAge, 20)
    .like(User::getName, "张")
    .orderByDesc(User::getCreateTime)
    .list();

// 链式查询单个
User user = userService.lambdaQuery()
    .eq(User::getEmail, "zhangsan@test.com")
    .one();

// 链式统计
long count = userService.lambdaQuery()
    .gt(User::getAge, 20)
    .count();

六、速记总结

BaseMapper 方法分类：

  插入：insert、insertBatch
  删除：deleteById、deleteByMap、delete、deleteBatchIds
  更新：updateById、update
  查询：selectById、selectBatchIds、selectByMap、selectOne、
        selectCount、selectList、selectMaps、selectObjs、selectPage
  判断：exists

速记口诀：
  增删改查 17 种，单表操作零 SQL，
  insert/update/delete/select，ById 靠 ID，
  ByMap 靠 Map，Batch 靠批量，Wrapper 靠条件。

七、面试要点

问题	答案要点
BaseMapper 提供多少方法？	17 种通用 CRUD 方法
updateById 更新策略？	只更新非 null 字段
selectOne 注意事项？	结果 > 1 条会抛异常
批量插入怎么用？	insertBatch 或 saveBatch(分批)