Mybatis-Plus的使用方法(二) 使用自动生成的代码进行CRUD

最新推荐文章于 2024-07-25 19:52:45 发布

正在打杂的Java小白

最新推荐文章于 2024-07-25 19:52:45 发布

阅读量1.1w

点赞数

分类专栏： java 文章标签： mybatis-plus java

本文链接：https://blog.csdn.net/qq_41354631/article/details/90260486

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

接下来就准备开始使用生成的代码进行CURD了:

如果不知道怎么生成代码,请看上一篇Mybatis-Plus的使用方法(一) 安装和使用代码生成

本文示例均来自官方文档,只对部分接口加以解释说明

后续的博客上的代码尽量上传到Github上,但是现在没有时间,理解一下

Mapper CRUD 接口

说明:

通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
泛型 T 为任意实体对象
参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象 Wrapper 为条件构造器

insert

/**
 * <p>
 * 插入一条记录
 * </p>
 *
 * @param entity 实体对象
 * @return 插入成功记录数
 */
int insert(T entity);


// 测试代码

  @Test
    public void testinsert(){
        User user = new User();
        user.setId(100L);
        user.setAge(10);
        user.setName("jack");
        user.setUsername("最棒的男人1211qwe");
        user.setPassword("1234");
        int insert = userMapper.insert(user);
        System.out.println("受影响行数"+insert);
        System.out.println("主键返回值"+user.getId());
    }

//测试说明
//1 即使数据库中的主键类型是自增的,也可以自己设置主键,前提是主键唯一,你懂的
//2 返回值为受影响的行数
//3 如果是主键自增的话,这个方法会自动将主键返回回来的哦,不需要任何配置的

#deleteById

/**
 * <p>
 * 根据 ID 删除
 * </p>
 *
 * @param id 主键ID
 * @return 删除成功记录数
 */
int deleteById(Serializable id);

#deleteByMap

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

//测试代码
 @Test
    public void testDeleteMap(){
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("age",10);
        int i = userMapper.deleteByMap(columnMap);
        System.out.println("受影响行数"+i);

    }
//说明
//此项会删除所有age=10的数据,可以添加多个属性

#delete

/**
 * <p>
 * 根据 entity 条件，删除记录
 * </p>
 *
 * @param wrapper 实体对象封装操作类（可以为 null）
 * @return 删除成功记录数
 */
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
 
//测试代码
@Test
    public void delete(){
        int i = userMapper.delete(new QueryWrapper<User>().lt("age", 100));
        System.out.println("受影响行数"+i);
    }

//说明
//会删除age<100的数据,剩下的可以脑补一下,看看QueryWrapper下边可以构造多少条件

#deleteBatchIds

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

#updateById

/**
 * <p>
 * 根据 ID 修改
 * </p>
 *
 * @param entity 实体对象
 * @return 修改成功记录数
 */
int updateById(@Param(Constants.ENTITY) T entity);

#update

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

#selectById

/**
 * <p>
 * 根据 ID 查询
 * </p>
 *
 * @param id 主键ID
 * @return 实体
 */
T selectById(Serializable id);

#selectBatchIds

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


//测试代码
    @Test
    public void testSelectBatchIds(){
        List ids = new ArrayList();
        ids.add(7);
        ids.add(8);
        List result = userMapper.selectBatchIds(ids);
        result.forEach(System.out::println);
    }

//根据Id批量查询

#selectByMap

/**
 * <p>
 * 查询（根据 columnMap 条件）
 * </p>
 *
 * @param columnMap 表字段 map 对象
 * @return 实体集合
 */
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

//测试代码
    @Test
    public void testSelectByMap(){

       Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("name","jack");
        List<User> users = userMapper.selectByMap(columnMap);
        users.forEach(System.out::println);
    }
//说明
//条件查询都是死的,一个键一个值,不是很建议使用这种

#selectOne

/**
 * <p>
 * 根据 entity 条件，查询一条记录
 * </p>
 *
 * @param queryWrapper 实体对象
 * @return 实体
 */
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

#selectCount

/**
 * <p>
 * 根据 Wrapper 条件，查询总记录数
 * </p>
 *
 * @param queryWrapper 实体对象
 * @return 满足条件记录数
 */
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

#selectList

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


//测试代码
    @Test
    public void testSelectList(){
        List<User> result = userMapper.selectList(new QueryWrapper<User>().lt("age", 100).like("username","%s%"));
        result.forEach(System.out::println);
    }

//说明,具体研究QueryWrapper,这个类会有各种各样的查询条件构造

#selectMaps

/**
 * <p>
 * 根据 Wrapper 条件，查询全部记录
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 * @return 字段映射对象 Map 集合
 */
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

#selectObjs

/**
 * <p>
 * 根据 Wrapper 条件，查询全部记录
 * 注意： 只返回第一个字段的值
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 * @return 字段映射对象集合
 */
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

#selectPage

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

//测试代码
   @Test
    public void testSelectPage(){

        Integer pageNum = 1;
        Integer pageSize = 2;
        IPage<User> page = new Page<>(pageNum,pageSize);
        IPage<User> result = userMapper.selectPage(page, new QueryWrapper<>());
        long total = result.getTotal();
        System.out.println("total"+total);
        result.getRecords().forEach(System.out::println);
    }
//说明:这个地方比较坑,参数只传第几页,每页多少条,结果中会自动封装数据总条数










//这个地方需要加1个配置,不然就不会有分页效果 需要单独写一个类哦

@Configuration
public class MybatisPlusConfig {
    /**
     *   mybatis-plus分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor page = new PaginationInterceptor();
        page.setDialectType("mysql");
        return page;
    }

}
//参考博客:https://blog.csdn.net/qq_37174383/article/details/83107057

#selectMapsPage

/**
 * <p>
 * 根据 Wrapper 条件，查询全部记录（并翻页）
 * </p>
 *
 * @param page         分页查询条件
 * @param queryWrapper 实体对象封装操作类
 * @return 字段映射对象 Map 分页对象
 */
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

Service层的应用方法和Mapper层差不多,但是Service层会比Mapper层丰富了很多的方法,这里不过多介绍

Service CRUD 接口

说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为条件构造器

#save

/**
 * <p>
 * 插入一条记录（选择字段，策略插入）
 * </p>
 *
 * @param entity 实体对象
 */
boolean save(T entity);

#saveBatch

/**
 * 插入（批量）
 *
 * @param entityList 实体对象集合
 * @param batchSize  插入批次数量
 */
boolean saveBatch(Collection<T> entityList);

#saveBatch

/**
 * 插入（批量）
 * 
 * @param entityList 实体对象集合
 * @param batchSize  插入批次数量
 */
boolean saveBatch(Collection<T> entityList, int batchSize);

#saveOrUpdateBatch

/**
 * <p>
 * 批量修改插入
 * </p>
 *
 * @param entityList 实体对象集合
 */
boolean saveOrUpdateBatch(Collection<T> entityList);

#saveOrUpdateBatch

/**
 * <p>
 * 批量修改插入
 * </p>
 *
 * @param entityList 实体对象集合
 * @param batchSize  每次的数量
 */
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

#removeById

/**
 * <p>
 * 根据 ID 删除
 * </p>
 *
 * @param id 主键ID
 */
boolean removeById(Serializable id);

#removeByMap

/**
 * <p>
 * 根据 columnMap 条件，删除记录
 * </p>
 *
 * @param columnMap 表字段 map 对象
 */
boolean removeByMap(Map<String, Object> columnMap);

#remove

/**
 * <p>
 * 根据 entity 条件，删除记录
 * </p>
 *
 * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
boolean remove(Wrapper<T> queryWrapper);

#removeByIds

/**
 * <p>
 * 删除（根据ID 批量删除）
 * </p>
 *
 * @param idList 主键ID列表
 */
boolean removeByIds(Collection<? extends Serializable> idList);

#updateById

/**
 * <p>
 * 根据 ID 选择修改
 * </p>
 *
 * @param entity 实体对象
 */
boolean updateById(T entity);

#update

/**
 * <p>
 * 根据 whereEntity 条件，更新记录
 * </p>
 *
 * @param entity        实体对象
 * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
 */
boolean update(T entity, Wrapper<T> updateWrapper);

#updateBatchById

/**
 * <p>
 * 根据ID 批量更新
 * </p>
 *
 * @param entityList 实体对象集合
 * @param batchSize  更新批次数量
 */
boolean updateBatchById(Collection<T> entityList, int batchSize);

#saveOrUpdate

/**
 * <p>
 * TableId 注解存在更新记录，否插入一条记录
 * </p>
 *
 * @param entity 实体对象
 */
boolean saveOrUpdate(T entity);

#getById

/**
 * <p>
 * 根据 ID 查询
 * </p>
 *
 * @param id 主键ID
 */
T getById(Serializable id);

#listByIds

/**
 * <p>
 * 查询（根据ID 批量查询）
 * </p>
 *
 * @param idList 主键ID列表
 */
Collection<T> listByIds(Collection<? extends Serializable> idList);

#listByMap

/**
 * <p>
 * 查询（根据 columnMap 条件）
 * </p>
 *
 * @param columnMap 表字段 map 对象
 */
Collection<T> listByMap(Map<String, Object> columnMap);

#getOne

/**
 * <p>
 * 根据 Wrapper，查询一条记录
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 * @param throwEx      有多个 result 是否抛出异常
 */
T getOne(Wrapper<T> queryWrapper, boolean throwEx);

#getMap

/**
 * <p>
 * 根据 Wrapper，查询一条记录
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
Map<String, Object> getMap(Wrapper<T> queryWrapper);

#getObj

/**
 * <p>
 * 根据 Wrapper，查询一条记录
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
Object getObj(Wrapper<T> queryWrapper);

#count

/**
 * <p>
 * 根据 Wrapper 条件，查询总记录数
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
int count(Wrapper<T> queryWrapper);

#list

/**
 * <p>
 * 查询列表
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
List<T> list(Wrapper<T> queryWrapper);

#page

/**
 * <p>
 * 翻页查询
 * </p>
 *
 * @param page         翻页对象
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);

#listMaps

/**
 * <p>
 * 查询列表
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);

#listObjs

/**
 * <p>
 * 根据 Wrapper 条件，查询全部记录
 * </p>
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
List<Object> listObjs(Wrapper<T> queryWrapper);

#pageMaps

/**
 * <p>
 * 翻页查询
 * </p>
 *
 * @param page         翻页对象
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

官方文档地址:

https://mp.baomidou.com/guide/crud-interface.html#mapper-crud-%E6%8E%A5%E5%8F%A3

正在打杂的Java小白

关注

0
点赞
踩
17

收藏

觉得还不错? 一键收藏
4
评论
Mybatis-Plus的使用方法(二) 使用自动生成的代码进行CRUD

接下来就准备开始使用生成的代码进行CURD了:如果不知道怎么生成代码,请看上一篇Mybatis-Plus的使用方法(一) 安装和使用代码生成本文示例均来自官方文档,只对部分接口加以解释说明后续的博客上的代码尽量上传到Github上,但是现在没有时间,理解一下Mapper CRUD 接口说明:通用 CRUD 封装BaseMapper接口，为Mybatis-Plus启动时自...
复制链接

扫一扫