BaseMapper 自定义查询 basemapper实现类

文章目录

• MybaitsPlus核心类
• BaseMapper类源码
• 案例查询API

• 根据id查询
• 根据id批量查询
• 查询一条记录
• 统计行数
• 查询全部

• 案例新增API

• 插入一条记录

• 案例删除API

• 根据id删除
• 条件删除

• 案例更新API

• queryWrapper更新操作
• updateWrapper更新操作

MybaitsPlus核心类

MybaitsPlus封装了一些CRUD的接口，可以在service层进行调用封装的方法，只需要mapper接口继承相关类即可，不需要写mapper接口写方法、也不需要写xml配置文件

其中，在service层使用封装的CRUD方法用到的QueryWrapper<>类，mapper层继承的BaseMapper<T>类，是MybaitsPlus核心类

BaseMapper：封装了CRUD的方法
QueryWrapper：查询包装类，可以封装多数查询条件，泛型指定返回的实体类

BaseMapper类源码

Ctrl+点击BaseMapper进入到源文件，可以看到里面封装的方法：

public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

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

    /**
     * 根据 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<T> 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<T> updateWrapper);

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

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

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

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

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

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

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

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

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

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

案例查询API

根据id查询

// T selectById(Serializable id)
public void testSelectById(){
	BannerDO bannerDO = bannerMapper.selectById(1);
	log.info("bannerDO: {}",bannerDO);
}

根据id批量查询

// List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
public void testSelectBatchIds(){
	List<BannerDO> list = bannerMapper.selectBatchIds( Arrays.asList(1,10));
	log.info("bannerDO: {}",list);
}

Arrays.asList():将数组转化成List集合，用此方法得到的List的长度是不可改变的

查询一条记录

// T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
public void testSelectOne(){
	BannerDO bannerDO = bannerMapper.selectOne(new QueryWrapper<BannerDO>().eq("id",1));
	log.info("bannerDO: {}",bannerDO);
}

统计行数

// Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
public void testSelectCount(){
	int size = bannerMapper.selectCount(null);
	log.info("bannerDO: {}",size);
}

查询全部

// List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
public void testBannerList(){
	List<BannerDO> list = bannerMapper.selectList(new QueryWrapper<>());
	log.info("轮播图列表:{}",list);
}

案例新增API

插入一条记录

// int insert(T entity);
public void testAdd(){
	BannerDO bannerDO = new BannerDO();
	bannerDO.setImg("xxxxx");
	bannerDO.setUrl("xdcalss.net");
	bannerMapper.insert(bannerDO);
	log.info("轮播图:{}",bannerDO);
}

案例删除API

根据id删除

// int deleteById(Serializable id);
public void testDeleteId(){
	int rows = bannerMapper.deleteById(13);
	log.info("rows:{}",rows);
}

条件删除

// int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
public void testCommonDeleteByMap() {
	Map<String, Object> columnMap = new HashMap<>();
	columnMap.put("weight",12);
	columnMap.put("url","bbb");
	int result=bannerMapper.deleteByMap(columnMap);

	System.out.println("*******************"+result);
}

案例更新API

queryWrapper更新操作

空字段不会更新

// int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
public void testUpdate(){
BannerDO bannerDO = new BannerDO();
       bannerDO.setUrl("taobao.com");
       int rows = bannerMapper.update(bannerDO,new QueryWrapper<BannerDO>().eq("id",1));
        log.info("rows:{}",rows);
    }

updateWrapper更新操作

public void testUpdateWrapper(){
	UpdateWrapper updateWrapper = new UpdateWrapper();
	updateWrapper.set("url","aaaa.com");
	updateWrapper.eq("id",1);
	int rows = bannerMapper.update(null,updateWrapper);
	log.info("rows:{}",rows);
}