Java – MybatisPlus – 通用CRUD方法

简介

Mapper接口通过继承BaseMapper就可以获取到各种各样的单表操作

插入 方法

insert 方法是通过POJO实体类的属性对数据表进行插入操作。

使用方法

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
    // 自动装配 mapper 接口
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert(){
        // 创建User实体类对象
        User user = new User();
        user.setAge(20);
        user.setEmail("test@itcast.cn");
        user.setName("曹操");
        user.setUserName("caocao");
        user.setPassword("123456");

        // 执行插入操作
        int result = this.userMapper.insert(user); //返回的result是受影响的行数，并不是自增
        后的id
        System.out.println("result = " + result);

        // 插入操作过后，可以通过 user.getId() 获取自增值
        System.out.println(user.getId()); //自增后的id会回填到对象中
    }
}

自增值类型（@TableId）

MybatisPlus对ID自增值有多种选项，默认MybatisPlus不会使用数据库提供的自增值，而是通过自己计算出一个唯一ID值并写到数据表中。具体自增值选项如下：

    /**
     * 数据库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);

 如果需要使用数据库自增值，可以通过在POJO实体类的成员变量中注册【@TableId(type = IdType.AUTO)】

MybatisPlus特点：

1.对POJO实体类的属性默认进行驼峰互换，也就是说，不需要进行配置，默认支持【userName -> user_name】和【user_name -> userName】的转换。

2.对insert插入方法返回值，表示该插入操作所影响的数据库记录行数。

3.对insert插入方法后，MybatisPlus会自动把自增id赋值给POJO实体类的id属性，可以通过pojo.getId()获取自增值，但是ID值有多种生成选项，通过【@TableId】注解定义。

字段属性设置（@TableField）

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

1、对象中的属性名和字段名不一致的问题（非驼峰）

2、对象中的属性字段在表中不存在的问题

3、对象中的某些属性不希望被查询出来（保护）

public class User {

    private String username;

    /**
     * TableField 注解用法一：过滤不需查询字段
     * 设置 select = false 时，
     * 则数据库查询时，该字段不会被查询出来
     */
    @TableField(select = false)
    private String password;

    private Integer age;

    private String gender;

    /**
     * TableField 注解用法二：字段名和实体类属性名不标准
     * 当属性名既不和字段名相同，也不是驼峰命名时
     * 通过设置 value = "email" 可以绑定该属性名和字段名的关系。
     */
    @TableField(value = "email")
    private String mail;

    /**
     * TableField 注解用法三：数据库字段中不存在的字段名
     * 当实体类中出现某些属性是数据表中不存在的字段时，查询会报错
     * 而我们不希望这个属性影响数据表，希望 MyBatis 忽略该属性
     * 通过设置 exist = false 可以让 MyBatis 忽略该属性在数据表中的操作行为。
     */
    @TableField(exist = false)
    private String address;
}

更新 方法

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

updateById

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

updateById 方法也是通过传入一个POJO实体类进行操作，MybatisPlus 会根据 POJO 实体类中的属性是否为null判断该字段是否需要被修改，并且获取 POJO 实体类的 id属性作为修改数据表中的ID值。

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

update

update 方法提供两种更新方式：

1.一种是需要提供POJO实体类需要更新的属性，并提供条件查询包装对象（QueryWrapper）

    @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);
    }

2.一种是只需要提供条件查询包装对象（UpdateWrapper）

    @Test
    public void testUpdate() {

        //更新的条件
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.set("age",23).set("user_name","张三").eq("id",1);

        //执行更新操作
        int result = this.userMapper.update(null, wrapper);
        System.out.println("result = " + result);
    }

注意：set 方法中的字段名，是数据表中的字段名，非POJO实体类中的属性名。

删除 方法

deleteById

通过ID删除记录。

定义

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

通过ID删除

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

deleteByMap

通过一个Map集合对多条件删除，Map中的key表示字段名，value表示字段值，多个Map集合以【AND】组合关系

定义

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

通过Map删除

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

delete

通过POJO实体类或Wrapper条件包装类进行删除。

定义

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

通过POJO实体类进行删除

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

查询 方法

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

selectById

通过ID查询记录表

定义

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

通过传入ID查询，数据将通过POJO实体类返回

    @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

查询一条记录数据，查询出来的记录必须仅有0条或1条，如果查询的记录大于1条，会报出异常。

定义

    /**
     * 根据 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", "李四");
        
        //根据条件查询一条数据，如果结果超过一条会报错
        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);
    }

注意：相关条件符号，都可以在QueryWrapper条件包装类中找到。

selectList

通过条件包装类，查询多条记录数据，数据以List集合的POJO实体类。

定义

/**
* 根据 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

MybatisPlus提供一种通过查询记录封装成分页的查询方式。

定义

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

selectPage 方法需要提供IPage对象，IPage的实现类Page类。

selectPage 方法中所需要的IPage的目的是需要提供当前页码和单页记录数等等基础分页信息。

    @Test
    public void testSelectPage() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        
        wrapper.gt("age", 20); //年龄大于20岁

        // 当前页数为1,一页显示2条记录
        Page<User> page = new Page<>(1,2);
        
        //根据条件查询数据
        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);
        }
    }

注意：关于分页查询，可能需要用到分页插件【PaginationInterceptor】Bean