Mybatis-Plus详细解读（二）Mybatis-Plus基本CRUD

港控/mmm° 2023-10-05 22:14 53阅读 0赞

### 一、 基本CRUD ###

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，我们可以直接使用，接口如下：  
public interface BaseMapper extends Mapper \{

*  插入一条记录
 *  @param entity 实体对象

> int insert(T entity);

*  根据 ID 删除
 *  @param id 主键ID

> int deleteById(Serializable id);

*  根据实体(ID)删除
 *  @param entity 实体对象
 *  @since 3.4.4

> int deleteById(T entity);

*  根据 columnMap 条件，删除记录
 *  @param columnMap 表字段 map 对象

> int deleteByMap(@Param(Constants.COLUMN\_MAP) Map<String, Object>  
> columnMap);

*  根据 entity 条件，删除记录
 *  @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity
 *  用于生成 where语句）

> int delete(@Param(Constants.WRAPPER) Wrapper queryWrapper);

*  删除（根据ID 批量删除）
 *  @param idList 主键ID列表(不能为 null 以及 empty)

> int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends  
> Serializable> idList);

*  根据 ID 修改
 *  @param entity 实体对象

> int updateById(@Param(Constants.ENTITY) T entity);

*  根据 whereEntity 条件，更新记录
 *  @param entity 实体对象 (set 条件值,可以为 null)
 *  @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成where 语句）

> int update(@Param(Constants.ENTITY) T entity,  
> @Param(Constants.WRAPPER) Wrapper updateWrapper);

*  根据 ID 查询
 *  @param id 主键ID

> T selectById(Serializable id);

*  查询（根据ID 批量查询）
 *  @param idList 主键ID列表(不能为 null 以及 empty)

> List selectBatchIds(@Param(Constants.COLLECTION) Collection<?  
> extends Serializable> idList);

*  查询（根据 columnMap 条件）
 *  @param columnMap 表字段 map 对象

> List selectByMap(@Param(Constants.COLUMN\_MAP) Map<String, Object>  
> columnMap);

*  根据 entity 条件，查询一条记录
 *  查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

> default T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper)  
> \{  
> List ts = this.selectList(queryWrapper);  
> if (CollectionUtils.isNotEmpty(ts)) \{  
> if (ts.size() != 1) \{  
> throw ExceptionUtils.mpe(“One record is expected, but the query result is multiple records”);  
> \}  
> return ts.get(0); \}  
> return null; \}

*  根据 Wrapper 条件，查询总记录数
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

> Long selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);

*  根据 entity 条件，查询全部记录
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

> List selectList(@Param(Constants.WRAPPER) Wrapper  
> queryWrapper);

*  根据 Wrapper 条件，查询全部记录
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

> List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER)  
> Wrapper queryWrapper);

*  根据 Wrapper 条件，查询全部记录
 *  注意： 只返回第一个字段的值
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

> List selectObjs(@Param(Constants.WRAPPER) Wrapper  
> queryWrapper);

*  根据 entity 条件，查询全部记录（并翻页）
 *  @param page 分页查询条件（可以为 RowBounds.DEFAULT）
 *  @param queryWrapper 实体对象封装操作类（可以为 null）

>   <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER)
    > Wrapper<T> queryWrapper);

*  根据 Wrapper 条件，查询全部记录（并翻页）
 *  @param page 分页查询条件
 *  @param queryWrapper 实体对象封装操作类

>   <P extends IPage<Map<String, Object>>> P selectMapsPage(P page,
    > @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

### 二、 基本CRUD ###

1.增加

@Test
    public void testInsert(){
        
      User user = new User(null, "张三", 23, "zhangsan@atguigu.com");
      //INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
      int result = userMapper.insert(user);
      System.out.println("受影响行数："+result);
      //1475754982694199298
      System.out.println("id自动获取："+user.getId());
    }

2.删除

a>通过id删除记录

@Test
    public void testDeleteById(){
        
      //通过id删除用户信息
      //DELETE FROM user WHERE id=?
      int result = userMapper.deleteById(1475754982694199298L);
      System.out.println("受影响行数："+result);
    }

b>通过id批量删除记录

@Test
    public void testDeleteBatchIds(){
        
      //通过多个id批量删除
      //DELETE FROM user WHERE id IN ( ? , ? , ? )
      List<Long> idList = Arrays.asList(1L, 2L, 3L);
      int result = userMapper.deleteBatchIds(idList);
      System.out.println("受影响行数："+result);
    }

c>通过map条件删除记录

@Test
    public void testDeleteByMap(){
        
      //根据map集合中所设置的条件删除记录
      //DELETE FROM user WHERE name = ? AND age = ?
      Map<String, Object> map = new HashMap<>();
      map.put("age", 23);
      map.put("name", "张三");
      int result = userMapper.deleteByMap(map);
      System.out.println("受影响行数："+result);
    }

3.修改

@Test
    public void testUpdateById(){
        
      User user = new User(4L, "admin", 22, null);
      //UPDATE user SET name=?, age=? WHERE id=?
      int result = userMapper.updateById(user);
      System.out.println("受影响行数："+result);
    }

4.查询  
a>根据id查询用户信息

@Test
    public void testSelectById(){
        
      //根据id查询用户信息
      //SELECT id,name,age,email FROM user WHERE id=?
      User user = userMapper.selectById(4L);
      System.out.println(user);
    }

b>根据多个id查询多个用户信息

@Test
    public void testSelectBatchIds(){
        
      //根据多个id查询多个用户信息
      //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
      List<Long> idList = Arrays.asList(4L, 5L);
      List<User> list = userMapper.selectBatchIds(idList);
      list.forEach(System.out::println);
    }

c>通过map条件查询用户信息

@Test
    public void testSelectByMap(){
        
      //通过map条件查询用户信息
      //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
      Map<String, Object> map = new HashMap<>();
      map.put("age", 22);
      map.put("name", "admin");
      List<User> list = userMapper.selectByMap(map);
      list.forEach(System.out::println);
    }

d>查询所有数据

@Test
    public void testSelectList(){
        
      //查询所有用户信息
      //SELECT id,name,age,email FROM user
      List<User> list = userMapper.selectList(null);
      list.forEach(System.out::println);
    }