Mybatis-plus中通用mapper的CRUD（增、删、改、查）操作封装BaseMapper和IService（最详细）

使用Mybatis的开发者，大多数都会遇到一个问题，就是要写大量的SQL在xml文件中，除了特殊的业务逻辑SQL之外，还有大量结构类似的增删改查SQL。而且，当数据库表结构改动时，对应的所有SQL以及实体类都需要更改。这工作量和效率的影响或许就是区别增删改查程序员和真正程序员的屏障。

Mybatis−plus中通用mapper就把普通的增删改查操作封装成了BaseMapper和IService

* 1.公共的方法进行抽取,抽取到BaseMapper接口中,将用户操作的方法对象,转化为数据库能够识别的SQL语句
* 2.通过userMapper查找父级接口BaseMapper
* 3.根据BaseMapper查找泛型对象User对象
* 4.根据user对象查找指定的注解@TableName,获取表明
* 5.根据user对象的属性,动态获取表中的字段
* 6.在获取字段的同事,获取属性的值,最后进行SQL的拼接
* 7.MP将拼接好的SQL交给Mybatis框架处理执行

一、代码生成

  使用Mybatis-plus 代码生成器 AutoGenerator 以及添加相关依赖，生成代码。这些步骤我上一篇博客已经谢过了，这里是链接：

  Mybatis-plus 代码生成器 AutoGenerator 的简介和（最详细）使用

二、BaseMapper CRUD 接口

说明：

• 通用 CRUD 封装BaseMapper接口，为 M y b a t i s − P l u s \color{#A4A4A4}{Mybatis-Plus}Mybatis−Plus启动时自动解析实体表关系映射转换为 M y b a t i s \color{#A4A4A4}{Mybatis}Mybatis内部对象注入容器
• 泛型 T 为任意实体对象
• 参数 S e r i a l i z a b l e \color{#A4A4A4}{Serializable}Serializable 为任意类型主键 M y b a t i s − P l u s \color{#A4A4A4}{Mybatis-Plus}Mybatis−Plus不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
• 对象 W r a p p e r \color{#A4A4A4}{Wrapper }Wrapper为 条件构造器

BaseMapper-CRUD官方文档：https://mybatis.plus/guide/crud-interface.html#mapper-crud-%E6%8E%A5%E5%8F%A3

1、增（Insert）

// 官网API
// 插入一条记录
// int insert(T entity);

@Autowired
private UserMapper userMapper;

//添加 -- BaseMapper api不支持批量添加
public void insert() {
//当前数据库id设置为自增,id策略需设置id-type配置
    User user = new User();
    user.setName("wangsong");
    user.setAge(23);
    user.setEmail("1720696548@qq.com");
    userMapper.insert(user);
    System.out.println(user.getId());
}

2、删（Delete）

//    官网api
//    // 根据 entity 条件，删除记录
//    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
//    // 删除（根据ID 批量删除）
//    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
//    // 根据 ID 删除
//    int deleteById(Serializable id);
//    // 根据 columnMap 条件，删除记录
//    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

@Autowired
private UserMapper userMapper;

// id删除
public void deleteById() {
    userMapper.deleteById(8);
}

// ids 批量删除
public void deleteBatchIds() {
    List<Long> ids = new ArrayList<>();
    ids.add(7);
    ids.add(6);
    userMapper.deleteBatchIds(ids);
}

// columnMap 条件删除
public void deleteByMap() {
    //kay是字段名 value是字段值
    Map<String,Object> map = new HashMap<>();
    map.put("id","6");
    userMapper.deleteByMap(map);
}

// wrapper 条件删除
public void delete() {
    // 拼接sql参考：DELETE FROM user WHERE (id = ? AND name = ?)
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // kay是字段名 value是字段值
    wrapper.eq("id",6)
    .eq("name","wangsong");
    userMapper.delete(wrapper);
}

3、改（Update）

//    官网api
//    //根据 whereEntity 条件，更新记录
//    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
//    //根据 ID 修改
//    int updateById(@Param(Constants.ENTITY) T entity);

@Autowired
private UserMapper userMapper;

// 根据id 更新修改
public void updateById() {
    User user = new User();
    //需要修改的数据 Id
    user.setId(9);
    //需要修改的数据
    user.setName("erping");
    user.setAge(23);
    user.setEmail("1720696548@qq.com");
    userMapper.updateById(user);
}

// 使用 updateWrapper 条件修改（2种方式任选其一）
public void update() {
    //方式一
    // 更新修改字段
    User user = new User();
    user.setEmail("xie430423@163.com");
    // 更新添加,未设置条件 sql： UPDATE user SET email=?  ，设置后：UPDATE user SET email=? WHERE (id = ?)
    UpdateWrapper<User> wrapper1 = new UpdateWrapper<User>();
    wrapper1.eq("id",9);
    userMapper.update(user,wrapper1);

    //方式二
//      UpdateWrapper<User> wrapper2 = new UpdateWrapper<User>();
//      wrapper2.set("email","666666@qq.com")   // 更新的内容，可往后 .set连接
//              .eq("id",9);                    // 更新的条件，可往后 .eq 添加
//      userMapper.update(null,wrapper2);
}

4、查（Select）

//    官网api
//
//    // 根据 ID 查询
//    T selectById(Serializable id);
//    // 根据 entity 条件，查询一条记录
//    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//
//    // 查询（根据ID 批量查询）
//    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
//    // 根据 entity 条件，查询全部记录
//    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//    // 查询（根据 columnMap 条件）
//    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
//    // 根据 Wrapper 条件，查询全部记录
//    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//    // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
//    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//
//    // 根据 entity 条件，查询全部记录（并翻页）
//    IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//    // 根据 Wrapper 条件，查询全部记录（并翻页）
//    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
//    // 根据 Wrapper 条件，查询总记录数
//    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@Autowired
private UserMapper userMapper;

// id查询
@Test
public void selectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user.toString());
}

// ids 批量查询
public void selectBatchIds(){
    List<Long> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    List<User> users = userMapper.selectBatchIds(ids);
    System.out.println(users.toString());
}

// 查询全部
public void selectList(){
    List<User> users = userMapper.selectList(null);
    System.out.println(users.toString());
}

//  条件查询 queryWrapper（无条件则查询全部）
public void selectListWrapper(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("id",1);
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users.toString());
}

//  分页查询 selectPage
//  需添加分页插件配置： 详见config/MybatisPlusConfig.java
public void selectPage(){
    // 页数 /每页记录数
    Page<User> page = new Page<>(1,2);
    // 分页 / 参数二：wrapper查询条件
    Page<User> userPage = userMapper.selectPage(page, null);
    System.out.println("总页数"+userPage.getPages());
    System.out.println("总记录数"+userPage.getTotal());
    System.out.println(userPage.getRecords().toString());
}

5、配置分页拦截器

//Spring boot方式
@EnableTransactionManagement
@Configuration
@MapperScan("com.xxgg.blog.mapper")
public class MybatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }
}

三、IBaseService CRUD 接口

说明：

• 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 g e t 查询单行、 r e m o v e 删除、 l i s t 查询集合、 p a g e 分页,前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 I B a s e S e r v i c e继承 Mybatis-Plus 提供的基类
• 对象W r a p p e r 为 条件构造器

Service官网Api文档：https://mybatis.plus/guide/crud-interface.html#service-crud

注： B a s e M a p p e r 不支持批量操作， I B a s e S e r v i c e 支持批量操作

1、save（增）

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

2、SaveOrUpdate（增或改）

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

3、Remove（删）

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

4、Update（改）

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereEntity 条件，更新记录
boolean update(T entity, Wrapper<T> updateWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

5、Get（按条件查）

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

6、List（查）

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

7、Page（分页查）

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

8、Count（查记录数）

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

9、Chain（链式）

query（链式查询）

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery(); 

// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

update（链式更改）

// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

四、参数说明

下面列举前面出现的参数说明：

官方文档：https://mybatis.plus/guide/