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 没有。

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

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...