通过前?的学习，我们了解到通过继承 BaseMapper 就可以获取到各种各样的单表操作，接下来我们将详细讲解这些操作。

通?CRUD

1 插?操作

?法定义

/**
 * 插??条记录
 *
 * @param entity 实体对象.
 */
 int insert(T entity);

测试?例

@Test
    public void testInsert(){
        User user = new User();
        user.setAge(18);
        user.setEmail("test@123.cn");
        user.setName("小明");
        //返回的result是受影响的?数，并不是?增后的id
        int result = userMapper.insert(user);
        System.out.println(result);
        System.out.println(user.getId());
    }

MP ?持的 id 策略：

package com.baomidou.mybatisplus.annotation;
import lombok.Getter;
/**
* ?成ID类型枚举类
*
* @author hubin
* @since 2015-11-10
*/
@Getter
public enum IdType {
   /**
   * 数据库ID?增
   */
   AUTO(0),
   /**
   * 该类型为未设置主键类型
   */
   NONE(1),
   /**
   * ?户输?ID
   * <p>该类型可以通过??注册?动填充插件进?填充</p>
   */
   INPUT(2),
   /* 以下3种类型、只有当插?对象ID 为空，才?动填充。 */
   /**
   * 全局唯?ID (idWorker)
   */
   ID_WORKER(3),
   /**
   * 全局唯?ID (UUID)
   */
   UUID(4),
   /**
   * 字符串全局唯?ID (idWorker 的字符串表示)
   */
   ID_WORKER_STR(5);
   private final int key;
   IdType(int key) {
   		this.key = key;
   }
}

修改 User 对象：

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
     @TableId(type = IdType.AUTO) //指定id类型为?增?
     private Long id;
     private String userName;
     private String password;
     private String name;
     private Integer age;
     private String email;
}

@TableField

在 MP 中通过 @TableField 注解可以指定字段的?些属性，常常解决的问题有 2 个：

• 1 、对象中的属性名和字段名不?致的问题（?驼峰）
• 2 、对象中的属性字段在表中不存在的问题

其他?法，如?字段不加?查询字段：

效果：

User(id=1, name=null, age=18, email=test1@baomidou.com, address=null)
User(id=2, name=null, age=20, email=test2@baomidou.com, address=null)
User(id=3, name=null, age=28, email=test3@baomidou.com, address=null)
User(id=4, name=null, age=21, email=test4@baomidou.com, address=null)
User(id=5, name=null, age=24, email=test5@baomidou.com, address=null)

2 更新操作

在 MP 中，更新操作有 2 种，?种是根据 id 更新，另?种是根据条件更新。

根据 id 更新

?法定义：

 /**
 * 根据 ID 修改
 *
 * @param entity 实体对象
 */
 int updateById(@Param(Constants.ENTITY) T entity);

测试：

@Test
    public void testUpdateById() {
        User user = new User();
        user.setId(6L); //主键
        user.setAge(21); //更新的字段
        //根据id更新，更新不为null的字段
        this.userMapper.updateById(user);
    }

根据条件更新

?法定义：

/**
 * 根据 whereEntity 条件，更新记录
 *
 * @param entity 实体对象 (set 条件值,可以为 null)
 * @param updateWrapper 实体对象封装操作类（可以为 null,??的 entity ?于?成
where 语句）
 */
 int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

测试?例：

@Test
    public void testUpdate() {
        User user = new User();
        user.setAge(22); //更新的字段
        //更新的条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("id", 6);
        //执?更新操作
        int result = this.userMapper.update(user, wrapper);
        System.out.println("result = " + result);
    }

3 删除操作

deleteById：

?法定义：

/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);

测试?例：

@Test
    public void testDeleteById() {
        //执?删除操作
        int result = this.userMapper.deleteById(6L);
        System.out.println("result = " + result);
    }

deleteByMap：

?法定义：

/**
 * 根据 columnMap 条件，删除记录
 *
 * @param columnMap 表字段 map 对象
 */
 int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

测试?例：

@Test
 public void testDeleteByMap() {
   Map<String, Object> columnMap = new HashMap<>();
   columnMap.put("age",21);
   columnMap.put("name","小明");
   //将columnMap中的元素设置为删除的条件，多个之间为and关系
   int result = this.userMapper.deleteByMap(columnMap);
   System.out.println("result = " + result);
 }

delete

?法定义：

/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

测试?例：

@Test
    public void testDelete() {
        User user = new User();
        user.setAge(20);
        user.setName("小明");
        //将实体对象进?包装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);
        int result = this.userMapper.delete(wrapper);
        System.out.println("result = " + result);
    }

deleteBatchIds

?法定义：

/**
 * 删除（根据ID 批量删除）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
 int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

测试?例：

@Test
    public void deleteBatchIds() {
        //根据id集合批量删除
        int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
        System.out.println("result = " + result);
    }

4 查询操作

MP 提供了多种查询操作，包括根据 id 查询、批量查询、查询单条数据、查询列表、分?查询等操作。

selectById

?法定义：

 /**
 * 根据 ID 查询
 *
 * @param id 主键ID
 */
 T selectById(Serializable id);

测试?例：

@Test
    public void testSelectById() {
        //根据id查询数据
        User user = this.userMapper.selectById(2L);
        System.out.println("result = " + user);
    }

selectBatchIds

?法定义：

/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

测试?例：

@Test
    public void testSelectBatchIds() {
        //根据id集合批量查询
        List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
        for (User user : users) {
            System.out.println(user);
        }
    }

selectOne

?法定义：

/**
* 根据 entity 条件，查询?条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试?例：

@Test
 public void testSelectOne() {
 QueryWrapper<User> wrapper = new QueryWrapper<User>();
 wrapper.eq("name", "jack");
 //根据条件查询?条数据，如果结果超过?条会报错
 User user = this.userMapper.selectOne(wrapper);
 System.out.println(user);
 }

selectCount

?法定义：

/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试?例：

@Test
    public void testSelectCount() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄?于23岁
        //根据条件查询数据条数
        Integer count = this.userMapper.selectCount(wrapper);
        System.out.println("count = " + count);
    }

selectList

?法定义：

/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试?例：

@Test
    public void testSelectList() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年龄?于23岁
        //根据条件查询数据
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

selectPage

?法定义：

/**
* 根据 entity 条件，查询全部记录（并翻?）
*
* @param page 分?查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

配置分?插件：

@Configuration
@MapperScan("com.mp.sb.mapper") //设置mapper接?的扫描包
public class MybatisPlusConfig {
    /**
     * 分?插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

测试?例：

@Test
    public void testSelectPage() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 20); //年龄?于20岁
        Page<User> page = new Page<>(1,1);
        //根据条件查询数据
        IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数：" + iPage.getTotal());
        System.out.println("总?数：" + iPage.getPages());
        List<User> users = iPage.getRecords();
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

结果：

数据总条数：3
总?数：3
user = User(id=3, name=null, age=28, email=test3@baomidou.com, address=null)