mybatis-plus mapper-locations(grbl源码分析)
mybatis-plus mapper-locations(grbl源码分析)
全栈程序员站长
发布于 2022-08-01 13:29:48
发布于 2022-08-01 13:29:48
文章被收录于专栏：全栈程序员必看
大家好，又见面了，我是你们的朋友全栈君。
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.cn/126325.html原文链接：https://javaforall.cn
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2022年4月1，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
相关产品与服务
数据库
云数据库为企业提供了完善的关系型数据库、非关系型数据库、分析型数据库和数据库生态工具。您可以通过产品选择和组合搭建，轻松实现高可靠、高可用性、高性能等数据库需求。云数据库服务也可大幅减少您的运维工作量，更专注于业务发展，让企业一站式享受数据上云及分布式架构的技术红利！
腾讯云开发者
