大家好,又见面了,我是你们的朋友全栈君。
继承该接口后,无需编写 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);
}
顶级 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);
}
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