MyBatis-Plus(CRUD的使用)

柔光的暖阳◎ 2022-11-27 15:56 429阅读 0赞

## MyBatis-Plus(CRUD的使用) ##

### 1.在控制层的调用（controller） ###

说明：

*  mybatis-plus封装了业务（IService）接口方法，来给控制层调用。其中，封装 CRUD 采用 `get 查询单行` `remove 删除` `list 查询集合` `page 分页`
 *  mybatis-plus里面的泛型 `T` 为任意实体对象
 *  mybatis-plus里面的对象 `Wrapper` 为 条件构造器
 *  插入，修改的事务mybatis-plus已经帮我们写好了，无需担心事务

#### 1.插入（存储数据） ####

##### save方法 #####

// 插入一条记录（选择字段，策略插入）
    boolean save(T entity);
    // 插入（批量）
    boolean saveBatch(Collection<T> entityList);
    // 插入（批量插入，其中batchSize为插入批次数量） 
    boolean saveBatch(Collection<T> entityList, int batchSize);
    
    例子：
      1.//插入user对象数据
      userService.save(User);
      2.//批量插入user对象
        List<User> list = new ArrayList<>(); 
        userService.saveBatch(user);
      3.//批量插入10次user对象
        List<User> list = new ArrayList<>(); 
        userService.saveBatch(user,10);

参数说明

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">参数名</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">T</td> 
   <td align="center">entity</td> 
   <td align="center">实体对象</td> 
  </tr> 
  <tr> 
   <td align="center">Collection</td> 
   <td align="center">entityList</td> 
   <td align="center">实体对象集合</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">batchSize</td> 
   <td align="center">插入批次数量</td> 
  </tr> 
 </tbody> 
</table>

##### SaveOrUpdate方法 #####

// 查询数据库id是否存在，存在更新记录，不存在插入一条记录
    boolean saveOrUpdate(T entity);
    // 根据updateWrapper查询数据是否存在，存在用T对象更新，不存在就插入
    boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
    // 批量修改插入，集合里如果对象id数据库存在，则更新记录，不存在插入数据
    boolean saveOrUpdateBatch(Collection<T> entityList);
    // 批量修改插入，集合里如果对象id数据库存在，则更新记录，不存在插入数据，但设置插入数量
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
    
    例子：
      1.// 查询user对象的id是否存在，存在更新记录，不存在插入数据
        userService.saveOrUpdate(user);
      2.// 根据updateWrapper查询数据是否存在，存在用T对象更新，不存在就插入
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("username", "lin");
        userService.saveOrUpdate(user,updateWrapper);
      3.//批量修改插入，集合里如果User对象id数据库存在，则更新记录，不存在插入数据
        List<User> list = new ArrrayList();
        userService.saveOrUpdateBatch(list);
      4.//批量修改插入，集合里如果User对象id数据库存在，则更新记录，不存在插入数据,但设置插入数量
        List<User> list = new ArrrayList();
        userService.saveOrUpdateBatch(list,10);

参数说明

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">参数名</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">T</td> 
   <td align="center">entity</td> 
   <td align="center">实体对象</td> 
  </tr> 
  <tr> 
   <td align="center">Wrapper</td> 
   <td align="center">updateWrapper</td> 
   <td align="center">实体对象封装操作类 UpdateWrapper</td> 
  </tr> 
  <tr> 
   <td align="center">Collection</td> 
   <td align="center">entityList</td> 
   <td align="center">实体对象集合</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">batchSize</td> 
   <td align="center">插入批次数量</td> 
  </tr> 
 </tbody> 
</table>

#### 2.删除 ####

##### 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);
    
    例子：
      1.//根据queryWrapper条件删除记录
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", "lin");
        userService.remove(queryWrapper);
      2.//根据user对象的id删除记录
        userService.removeById(userId);
      3.//根据columnMap条件删除username和id符合的数据
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("username", user.getUsername());
        columnMap.put("id", user.getId());
        userService.removeByMap(columnMap);
      4.//根据list的id集合，批量删除
        List<Integer> list = new ArrayList<>;
        userService.removeByIds(list);

参数说明

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">参数名</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Wrapper</td> 
   <td align="center">queryWrapper</td> 
   <td align="center">实体包装类 QueryWrapper</td> 
  </tr> 
  <tr> 
   <td align="center">Serializable</td> 
   <td align="center">id</td> 
   <td align="center">主键ID</td> 
  </tr> 
  <tr> 
   <td align="center">Map&lt;String, Object&gt;</td> 
   <td align="center">columnMap</td> 
   <td align="center">表字段 map 对象</td> 
  </tr> 
  <tr> 
   <td align="center">Collection&lt;? extends Serializable&gt;</td> 
   <td align="center">idList</td> 
   <td align="center">主键ID列表</td> 
  </tr> 
 </tbody> 
</table>

#### 3.修改 ####

##### Update方法 #####

// 根据 updateWrapper 条件，使用对象T更新记录
    boolean update(T entity, Wrapper<T> updateWrapper);
    // 根据 对象T的ID 选择修改
    boolean updateById(T entity);
    // 根据对象集合中的对象ID 批量更新
    boolean updateBatchById(Collection<T> entityList);
    // 根据对象集合中的对象ID 批量更新，但设置更新数量
    boolean updateBatchById(Collection<T> entityList, int batchSize);
    
    1.// 根据 updateWrapper 条件，使用对象User更新记录
      UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
      updateWrapper.eq("username", "lin");
      userService.update(user,updateWrapper);
    2.// 根据User对象的ID进行更新记录
      userService.updateById(user);
    3.// 根据user对象集合进行批量更新记录(使用user对象的id更新)
      List<User> list = new ArrayList<>;
      userService.updateBatchById(list);
    4.// 根据user对象集合进行批量更新记录(使用user对象的id更新)，但设置更新数量
      List<User> list = new ArrayList<>;
      userService.updateBatchById(list，10);

参数说明

<table> 
 <thead> 
  <tr> 
   <th align="center">类型</th> 
   <th align="center">参数名</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Wrapper</td> 
   <td align="center">updateWrapper</td> 
   <td align="center">实体对象封装操作类 UpdateWrapper</td> 
  </tr> 
  <tr> 
   <td align="center">T</td> 
   <td align="center">entity</td> 
   <td align="center">实体对象</td> 
  </tr> 
  <tr> 
   <td align="center">Collection</td> 
   <td align="center">entityList</td> 
   <td align="center">实体对象集合</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">batchSize</td> 
   <td align="center">更新批次数量</td> 
  </tr> 
 </tbody> 
</table>

#### 4.查询 ####

##### get方法（查询单条记录） #####

// 根据 ID 查询
    T getById(Serializable id);
    // 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
    T getOne(Wrapper<T> queryWrapper);
    // 根据 Wrapper，查询一条记录，throwEx参数如果是true，有多个结果集抛出异常，false不抛出异常，默认为true
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);
    
    例子：
       1.// 根据user对象的ID进行查询
       userService.getById(userId);
       2.// 根据Wrapper条件进行查询
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username", "lin");
       userService.getOne(queryWrapper);
       3.// 根据Wrapper条件进行查询,添加throwEx参数
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username", "lin");
       userService.getOne(queryWrapper,false);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Serializable</td> 
   <td>id</td> 
   <td>主键ID</td> 
  </tr> 
  <tr> 
   <td>Wrapper</td> 
   <td>queryWrapper</td> 
   <td>实体对象封装操作类 QueryWrapper</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>throwEx</td> 
   <td>有多个 result 是否抛出异常</td> 
  </tr> 
  <tr> 
   <td>T</td> 
   <td>entity</td> 
   <td>实体对象</td> 
  </tr> 
 </tbody> 
</table>

##### list方法（查询多条记录） #####

// 查询所有
    List<T> list();
    // 根据queryWrapper条件，查询列表
    List<T> list(Wrapper<T> queryWrapper);
    // 查询（根据ID 批量查询）
    Collection<T> listByIds(Collection<? extends Serializable> idList);
    // 查询（根据 columnMap 条件）
    Collection<T> listByMap(Map<String, Object> columnMap);
    // 查询全部记录
    List<Object> listObjs();
    // 根据 Wrapper 条件，查询全部记录
    List<Object> listObjs(Wrapper<T> queryWrapper);
    
    例子：
      1.// 查询所有user表数据
      userService.list();
      2.// 根据queryWrapper条件，查询列表
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("username", "lin");
      userService.list(queryWrapper);
      3.// 根据集合ID批量查询
      List<Integer> list = new ArrayList<>;
      userService.listByMap(list);
      4.// 查询（根据 columnMap 条件）
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("username", user.getUsername());
        columnMap.put("id", user.getId());
        userService.listByMap(columnMap);
      5.// 查询所有数据
        userService.listObjs();
      6.//根据 Wrapper 条件，查询全部记录
       QueryWrapper<User> queryWrapper = new QueryWrapper<>();
       queryWrapper.eq("username", "lin");
       userService.listObjs(queryWrapper);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Wrapper</td> 
   <td>queryWrapper</td> 
   <td>实体对象封装操作类 QueryWrapper</td> 
  </tr> 
  <tr> 
   <td>Collection&lt;? extends Serializable&gt;</td> 
   <td>idList</td> 
   <td>主键ID列表</td> 
  </tr> 
  <tr> 
   <td>Map&lt;?String, Object&gt;</td> 
   <td>columnMap</td> 
   <td>表字段 map 对象</td> 
  </tr> 
 </tbody> 
</table>

##### Page方法（分页查询） #####

// 无条件分页查询
    IPage<T> page(IPage<T> page);
    // 条件分页查询
    IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
    
    例子：
      1.// 无条件分页
       Page<User> page = new Page<>(page, pageSize);
       userService.page(page);
      2.// 条件分页查询
      Page<User> page = new Page<>(page, pageSize);
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("username", "lin");
      userService.page(page,queryWrapper);

**参数说明**

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>IPage</td> 
   <td>page</td> 
   <td>翻页对象</td> 
  </tr> 
  <tr> 
   <td>Wrapper</td> 
   <td>queryWrapper</td> 
   <td>实体对象封装操作类 QueryWrapper</td> 
  </tr> 
 </tbody> 
</table>

##### Count方法（查询总数） #####

// 查询总记录数
    int count();
    // 根据 Wrapper 条件，查询总记录数
    int count(Wrapper<T> queryWrapper);
    
    例子：
      1.// 查询user表总记录数
      userService.count();
      2.// 根据条件查询总记录数
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("username", "lin");
      userService.count(queryWrapper);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Wrapper</td> 
   <td>queryWrapper</td> 
   <td>实体对象封装操作类 QueryWrapper</td> 
  </tr> 
 </tbody> 
</table>

### 2.在业务层的调用( service ) ###

说明:

*  mybatis-plus封装了持久层（Mapper）接口方法，来给业务层调用。通用 CRUD 封装[BaseMapper][]接口，为 `Mybatis-Plus` 启动时自动解析实体表关系映射转换为 `Mybatis` 内部对象注入容器
 *  泛型 `T` 为任意实体对象
 *  参数 `Serializable` 为任意类型主键 `Mybatis-Plus` 不推荐使用复合主键约定每一张表都有自己的唯一 `id` 主键
 *  对象 `Wrapper` 为 条件构造器
 *  需自己手动添加事务
 *  调用方法为baseMapper.方法名()

#### 1.插入( 存储数据 ) ####

##### insert方法 #####

// 插入一条记录
    int insert(T entity);
    
    例子：
      1.// 插入User对象数据到数据库
      baseMapper.insert(user);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>T</td> 
   <td>entity</td> 
   <td>实体对象</td> 
  </tr> 
 </tbody> 
</table>

#### 2.删除 ####

##### delete方法 #####

// 根据 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);
    
    例子：
      1.// 根据wrapper条件删除记录
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("username", "lin");
      baseMapper.delete(@Param(queryWrapper);
      2.// 根据user的id集合批量删除记录
      List<Integer> list = new ArrayList<>;
      baseMapper.deleteBatchIds(list);
      3.// 根据user的id删除记录
      baseMapper.deleteById(userId);
      4.// 根据 columnMap 条件，删除记录
      Map<String, Object> columnMap = new HashMap<>();
      columnMap.put("username", user.getUsername());
      columnMap.put("id", user.getId());
      baseMapper.deleteByMap(columnMap);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Wrapper</td> 
   <td>wrapper</td> 
   <td>实体对象封装操作类（可以为 null）</td> 
  </tr> 
  <tr> 
   <td>Collection&lt;? extends Serializable&gt;</td> 
   <td>idList</td> 
   <td>主键ID列表(不能为 null 以及 empty)</td> 
  </tr> 
  <tr> 
   <td>Serializable</td> 
   <td>id</td> 
   <td>主键ID</td> 
  </tr> 
  <tr> 
   <td>Map&lt;String, Object&gt;</td> 
   <td>columnMap</td> 
   <td>表字段 map 对象</td> 
  </tr> 
 </tbody> 
</table>

#### 3.修改 ####

##### Update方法 #####

// 根据 whereEntity 条件，更新记录
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
    // 根据 ID 修改
    int updateById(@Param(Constants.ENTITY) T entity);
    
    例子：
      1.// 根据条件进行更新记录
      UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
      updateWrapper.eq("username", "lin");
      baseMapper.update(user,updateWrapper);
      2.// 根据user的ID进行修改
      baseMapper.updateById(user);

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>T</td> 
   <td>entity</td> 
   <td>实体对象 (set 条件值,可为 null)</td> 
  </tr> 
  <tr> 
   <td>Wrapper</td> 
   <td>updateWrapper</td> 
   <td>实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）</td> 
  </tr> 
 </tbody> 
</table>

#### 4.查询 ####

##### select方法 #####

// 根据 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);
    
    例子：
      1.// 根据user的id进行查询单条记录
      baseMapper.selectById(userId);
      2.// 根据条件进行查询单条记录
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
      queryWrapper.eq("username", "lin");
      baseMapper.selectOne(queryWrapper);
      3.// 根据map条件查询多条记录
      Map<String, Object> map = new HashMap<>();
      map.put("username", user.getUsername());
      map.put("id", user.getId());
      baseMapper.selectByMap(map);
      4.

参数说明

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>参数名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Serializable</td> 
   <td>id</td> 
   <td>主键ID</td> 
  </tr> 
  <tr> 
   <td>Wrapper</td> 
   <td>queryWrapper</td> 
   <td>实体对象封装操作类（可以为 null）</td> 
  </tr> 
  <tr> 
   <td>Collection&lt;? extends Serializable&gt;</td> 
   <td>idList</td> 
   <td>主键ID列表(不能为 null 以及 empty)</td> 
  </tr> 
  <tr> 
   <td>Map&lt;String, Object&gt;</td> 
   <td>columnMap</td> 
   <td>表字段 map 对象</td> 
  </tr> 
  <tr> 
   <td>IPage</td> 
   <td>page</td> 
   <td>分页查询条件（可以为 RowBounds.DEFAULT）</td> 
  </tr> 
 </tbody> 
</table>

[BaseMapper]: https://gitee.com/baomidou/mybatis-plus/blob/3.0/mybatis-plus-core/src/main/java/com/baomidou/mybatisplus/core/mapper/BaseMapper.java