mybatis-plus mapper-locations(grbl源码分析)

大家好，又见面了，我是你们的朋友全栈君。

BaseMapper接口

继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能

public interface BaseMapper<T> { 
   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

IService接口

顶级 Service

IService是对BaseMapper的扩展，IService 的默认实现
com.baomidou.mybatisplus.extension.service.impl.ServiceImpl 就是调用
BaseMapper 来操作数据库

IService 依赖于 Spring 容器，而 BaseMapper 不依赖；BaseMapper
可以继承并添加新的数据库操作，IService 要扩展的话还是得调用 Mapper，

public interface IService<T> { 
   

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

    /** * <p> * 插入（批量），该方法不适合 Oracle * </p> * * @param entityList 实体对象集合 */
    default boolean saveBatch(Collection<T> entityList) { 
   
        return saveBatch(entityList, 30);
    }

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

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

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

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

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

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

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

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

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

    /** * <p> * 根据ID 批量更新 * </p> * * @param entityList 实体对象集合 */
    default boolean updateBatchById(Collection<T> entityList) { 
   
        return updateBatchById(entityList, 30);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /** * <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);
}

ServiceImpl类

IService 实现类( 泛型：M 是 mapper 对象，T 是实体， PK 是主键泛型）

public class ServiceImpl<M extends BaseMapper<T>, T> implements IService<T> { 
   

    @Autowired
    protected M baseMapper;

    /** * <p> * 判断数据库操作是否成功 * </p> * * @param result 数据库操作返回影响条数 * @return boolean */
    protected boolean retBool(Integer result) { 
   
        return SqlHelper.retBool(result);
    }

    protected Class<T> currentModelClass() { 
   
        return ReflectionKit.getSuperClassGenericType(getClass(), 1);
    }

    /** * <p> * 批量操作 SqlSession * </p> */
    protected SqlSession sqlSessionBatch() { 
   
        return SqlHelper.sqlSessionBatch(currentModelClass());
    }

    /** * 释放sqlSession * * @param sqlSession session */
    protected void closeSqlSession(SqlSession sqlSession) { 
   
        SqlSessionUtils.closeSqlSession(sqlSession, GlobalConfigUtils.currentSessionFactory(currentModelClass()));
    }

    /** * 获取SqlStatement * * @param sqlMethod * @return */
    protected String sqlStatement(SqlMethod sqlMethod) { 
   
        return SqlHelper.table(currentModelClass()).getSqlStatement(sqlMethod.getMethod());
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean save(T entity) { 
   
        return retBool(baseMapper.insert(entity));
    }

    /** * 批量插入 * * @param entityList * @param batchSize * @return */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveBatch(Collection<T> entityList, int batchSize) { 
   
        int i = 0;
        String sqlStatement = sqlStatement(SqlMethod.INSERT_ONE);
        try (SqlSession batchSqlSession = sqlSessionBatch()) { 
   
            for (T anEntityList : entityList) { 
   
                batchSqlSession.insert(sqlStatement, anEntityList);
                if (i >= 1 && i % batchSize == 0) { 
   
                    batchSqlSession.flushStatements();
                }
                i++;
            }
            batchSqlSession.flushStatements();
        }
        return true;
    }

    /** * <p> * TableId 注解存在更新记录，否插入一条记录 * </p> * * @param entity 实体对象 * @return boolean */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveOrUpdate(T entity) { 
   
        if (null != entity) { 
   
            Class<?> cls = entity.getClass();
            TableInfo tableInfo = TableInfoHelper.getTableInfo(cls);
            if (null != tableInfo && StringUtils.isNotEmpty(tableInfo.getKeyProperty())) { 
   
                Object idVal = ReflectionKit.getMethodValue(cls, entity, tableInfo.getKeyProperty());
                if (StringUtils.checkValNull(idVal)) { 
   
                    return save(entity);
                } else { 
   
                    /* * 更新成功直接返回，失败执行插入逻辑 */
                    return updateById(entity) || save(entity);
                }
            } else { 
   
                throw ExceptionUtils.mpe("Error: Can not execute. Could not find @TableId.");
            }
        }
        return false;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveOrUpdateBatch(Collection<T> entityList) { 
   
        return saveOrUpdateBatch(entityList, 30);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize) { 
   
        if (CollectionUtils.isEmpty(entityList)) { 
   
            throw new IllegalArgumentException("Error: entityList must not be empty");
        }
        Class<?> cls = null;
        TableInfo tableInfo = null;
        int i = 0;
        try (SqlSession batchSqlSession = sqlSessionBatch()) { 
   
            for (T anEntityList : entityList) { 
   
                if (i == 0) { 
   
                    cls = anEntityList.getClass();
                    tableInfo = TableInfoHelper.getTableInfo(cls);
                }
                if (null != tableInfo && StringUtils.isNotEmpty(tableInfo.getKeyProperty())) { 
   
                    Object idVal = ReflectionKit.getMethodValue(cls, anEntityList, tableInfo.getKeyProperty());
                    if (StringUtils.checkValNull(idVal)) { 
   
                        String sqlStatement = sqlStatement(SqlMethod.INSERT_ONE);
                        batchSqlSession.insert(sqlStatement, anEntityList);
                    } else { 
   
                        String sqlStatement = sqlStatement(SqlMethod.UPDATE_BY_ID);
                        MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
                        param.put(Constants.ENTITY, anEntityList);
                        batchSqlSession.update(sqlStatement, param);
                        //不知道以后会不会有人说更新失败了还要执行插入 ???
                    }
                    if (i >= 1 && i % batchSize == 0) { 
   
                        batchSqlSession.flushStatements();
                    }
                    i++;
                } else { 
   
                    throw ExceptionUtils.mpe("Error: Can not execute. Could not find @TableId.");
                }
                batchSqlSession.flushStatements();
            }
        }
        return true;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean removeById(Serializable id) { 
   
        return SqlHelper.delBool(baseMapper.deleteById(id));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean removeByMap(Map<String, Object> columnMap) { 
   
        if (ObjectUtils.isEmpty(columnMap)) { 
   
            throw ExceptionUtils.mpe("removeByMap columnMap is empty.");
        }
        return SqlHelper.delBool(baseMapper.deleteByMap(columnMap));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean remove(Wrapper<T> wrapper) { 
   
        return SqlHelper.delBool(baseMapper.delete(wrapper));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean removeByIds(Collection<? extends Serializable> idList) { 
   
        return SqlHelper.delBool(baseMapper.deleteBatchIds(idList));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean updateById(T entity) { 
   
        return retBool(baseMapper.updateById(entity));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean update(T entity, Wrapper<T> updateWrapper) { 
   
        return retBool(baseMapper.update(entity, updateWrapper));
    }
@Transactional(rollbackFor = Exception.class)
    @Override
    public boolean updateBatchById(Collection<T> entityList, int batchSize) { 
   
        if (CollectionUtils.isEmpty(entityList)) { 
   
            throw new IllegalArgumentException("Error: entityList must not be empty");
        }
        int i = 0;
        String sqlStatement = sqlStatement(SqlMethod.UPDATE_BY_ID);
        try (SqlSession batchSqlSession = sqlSessionBatch()) { 
   
            for (T anEntityList : entityList) { 
   
                MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
                param.put(Constants.ENTITY, anEntityList);
                batchSqlSession.update(sqlStatement, param);
                if (i >= 1 && i % batchSize == 0) { 
   
                    batchSqlSession.flushStatements();
                }
                i++;
            }
            batchSqlSession.flushStatements();
        }
        return true;
    }

    @Override
    public T getById(Serializable id) { 
   
        return baseMapper.selectById(id);
    }

    @Override
    public Collection<T> listByIds(Collection<? extends Serializable> idList) { 
   
        return baseMapper.selectBatchIds(idList);
    }

    @Override
    public Collection<T> listByMap(Map<String, Object> columnMap) { 
   
        return baseMapper.selectByMap(columnMap);
    }

    @Override
    public T getOne(Wrapper<T> queryWrapper, boolean throwEx) { 
   
        if (throwEx) { 
   
            return baseMapper.selectOne(queryWrapper);
        }
        return SqlHelper.getObject(baseMapper.selectList(queryWrapper));
    }

    @Override
    public Map<String, Object> getMap(Wrapper<T> queryWrapper) { 
   
        return SqlHelper.getObject(baseMapper.selectMaps(queryWrapper));
    }

    @Override
    public Object getObj(Wrapper<T> queryWrapper) { 
   
        return SqlHelper.getObject(baseMapper.selectObjs(queryWrapper));
    }

    @Override
    public int count(Wrapper<T> queryWrapper) { 
   
        return SqlHelper.retCount(baseMapper.selectCount(queryWrapper));
    }

    @Override
    public List<T> list(Wrapper<T> queryWrapper) { 
   
        return baseMapper.selectList(queryWrapper);
    }

    @Override
    public IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper) { 
   
        return baseMapper.selectPage(page, queryWrapper);
    }

    @Override
    public List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) { 
   
        return baseMapper.selectMaps(queryWrapper);
    }

    @Override
    public List<Object> listObjs(Wrapper<T> queryWrapper) { 
   
        return baseMapper.selectObjs(queryWrapper).stream().filter(Objects::nonNull).collect(Collectors.toList());
    }

    @Override
    public IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper) { 
   
        return baseMapper.selectMapsPage(page, queryWrapper);
    }
}

Mybatis-plus提供了2个接口1个类：

BaseMapper 针对dao层的方法封装 CRUD
IService<M,T> 针对业务逻辑层的封装需要指定Dao层类和对应的实体类是在BaseMapper基础上的加强
ServiceImpl 针对业务逻辑层的实现
两者提供的方法略有不同
对比这两个接口，操作都差不多，名字有一点点改变，比如 BaseMapper 里面叫 insert() 的方法，在 IService 里面叫 save()。但是两者确实有区别，就是 IService 提供批处理操作，BaseMapper 没有。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/126325.html原文链接：https://javaforall.net