yui.comn.mybatisx.extension.mgr.IMgr Maven / Gradle / Ivy
package yui.comn.mybatisx.extension.mgr;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.springframework.transaction.annotation.Transactional;
import com.baomidou.mybatisplus.core.metadata.IPage;
import yui.comn.mybatisx.core.conditions.Wrapper;
import yui.comn.mybatisx.core.mapper.BaseDao;
import yui.comn.mybatisx.core.toolkit.EntityUtils;
import yui.comn.mybatisx.core.toolkit.SoftConstants;
import yui.comn.mybatisx.extension.node.TreeNode;
/**
*
* 基础服务类
*
*
* @author yuyi ([email protected])
*/
@SuppressWarnings("unchecked")
public interface IMgr {
/**
* 默认批次提交数量
*/
int DEFAULT_BATCH_SIZE = 1000;
/**
*
* 获取对应BaseDao
*
* @return BaseDao
*/
BaseDao getBaseDao();
/**
* 获取 entity 的 class
*
* @return {@link Class}
*/
Class getEntityClass();
default IPage getPage(Wrapper wrapper) {
return EntityUtils.getPage(wrapper);
}
/**
*
* 插入一条记录
*
*
* @param entity 实体对象
*/
default T add(T entity) {
getBaseDao().insert(entity);
return entity;
}
/**
*
* 插入（真正批量）
*
*
* @param entityList 实体对象集合
*/
@Transactional(rollbackFor = Exception.class)
default Collection addBatch(Collection entityList) {
addBatch(entityList, DEFAULT_BATCH_SIZE);
return entityList;
}
/**
*
* 插入（真正批量）
*
*
* @param entityList 实体对象集合
* @param batchSize 插入批次数量
*/
Collection addBatch(Collection entityList, int batchSize);
/**
*
* 批量修改插入
*
*
* @param entity 实体对象
*/
@Transactional(rollbackFor = Exception.class)
default T addOrUpdate(T entity) {
List entityList = new ArrayList<>();
entityList.add(entity);
addOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
return entity;
}
/**
*
* 批量修改插入
*
*
* @param entityList 实体对象集合
*/
@Transactional(rollbackFor = Exception.class)
default Collection addOrUpdateBatch(Collection entityList) {
addOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
return entityList;
}
/**
*
* 批量修改插入
*
*
* @param entityList 实体对象集合
* @param batchSize 每次的数量
*/
Collection addOrUpdateBatch(Collection entityList, int batchSize);
/**
*
* 根据 ID 批量修改
*
*
* @param entityList 查询对象列表
* @param args 更新字段列表
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatch(Collection entityList, String... args) {
return updateBatch(entityList, DEFAULT_BATCH_SIZE, args);
}
/**
*
* 根据 ID 批量修改
*
*
* @param entityList 查询对象列表
* @param batchSize 更新批次数量
* @param args 更新字段列表
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatch(Collection entityList, int batchSize, String... args) {
return updateBatch(EntityUtils.getUpdateWrapperList(entityList, args), batchSize);
}
/**
*
* 根据 ID 批量修改
*
*
* @param wrapperList 查询对象列表
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatch(Collection> wrapperList) {
return updateBatch(wrapperList, DEFAULT_BATCH_SIZE);
}
/**
*
* 根据 ID 批量修改
*
*
* @param wrapperList 查询对象列表
* @param batchSize 更新批次数量
*/
int updateBatch(Collection> wrapperList, int batchSize);
/**
*
* 根据ID 批量更新
*
*
* @param entityList 实体对象集合
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatchById(Collection entityList) {
return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
}
/**
*
* 根据ID 批量更新
*
*
* @param entityList 实体对象集合
* @param batchSize 更新批次数量
*/
int updateBatchById(Collection entityList, int batchSize);
/**
*
* 根据ID 批量更新
*
*
* @param dtoList 实体封装对象集合
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatchByDtoId(Collection dtoList) {
return updateBatchByDtoId(dtoList, DEFAULT_BATCH_SIZE);
}
/**
*
* 根据ID 批量更新
*
*
* @param dtoList 实体封装对象集合
* @param batchSize 更新批次数量
*/
@Transactional(rollbackFor = Exception.class)
default int updateBatchByDtoId(Collection dtoList, int batchSize) {
return updateBatchById((Collection) EntityUtils.listVo(dtoList), batchSize);
}
/**
*
* 根据ID 批量更新所有值
*
*
* @param entityList 实体对象集合
*/
@Transactional(rollbackFor = Exception.class)
default int updateAllBatchById(Collection entityList) {
return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
}
/**
*
* 根据ID 批量更新所有值
*
*
* @param entityList 实体对象集合
* @param batchSize 更新批次数量
*/
int updateAllBatchById(Collection entityList, int batchSize);
/**
*
* 根据ID 批量更新所有值
*
*
* @param dtoList 实体封装对象集合
* @param batchSize 更新批次数量
*/
@Transactional(rollbackFor = Exception.class)
default int updateAllBatchByDtoId(Collection dtoList, int batchSize) {
return updateAllBatchById((Collection) EntityUtils.listVo(dtoList), batchSize);
}
/**
*
* 根据ID 批量更新所有值
*
*
* @param dtoList 实体封装对象集合
*/
@Transactional(rollbackFor = Exception.class)
default int updateAllBatchByDtoId(Collection dtoList) {
return updateBatchByDtoId(dtoList, DEFAULT_BATCH_SIZE);
}
/**
*
* 根据 ID 修改实体对象
*
*
* @param entity 实体对象
* @param args 过滤字段
*/
default int update(T entity, String... args) {
return update(null, EntityUtils.getUpdateWrapper(entity, args));
}
/**
*
* 根据 ID 修改实体对象
*
*
* @param entity 实体对象
* @param wrapper 实体对象封装操作类
*/
int update(T entity, Wrapper wrapper);
/**
*
* 根据 ID 修改有值的
*
*
* @param entity 实体对象
*/
int update(T entity);
/**
*
* 根据 ID 修改所有
*
*
* @param entity 实体对象
*/
int updateAll(T entity);
/**
* 根据 entity 强制删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int defunct(Wrapper wrapper);
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int delete(Wrapper wrapper);
/**
*
* 根据 ID 删除
*
*
* @param id 主键ID
*/
int deleteById(Serializable id);
/**
*
* 删除（根据ID 批量删除）
*
*
* @param idList 主键ID列表(不能为 null 以及 empty)
* @param batchSize 删除批次数量
*/
int deleteByIds(Collection idList, int batchSize);
/**
*
* 删除（根据ID 批量删除）
*
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
@Transactional(rollbackFor = Exception.class)
default int deleteByIds(Collection idList) {
return deleteByIds(idList, DEFAULT_BATCH_SIZE);
}
/**
*
* 删除（根据对象ID 批量删除）
*
*
* @param entityList 主键ID列表(不能为 null 以及 empty)
* @param batchSize 删除批次数量
*/
@Transactional(rollbackFor = Exception.class)
default int deleteBatchVoIds(Collection entityList, int batchSize) {
return deleteByIds(EntityUtils.listPrimaryKeyValueByVos(entityList), batchSize);
}
/**
*
* 删除（根据对象ID 批量删除）
*
*
* @param entityList 主键ID列表(不能为 null 以及 empty)
*/
@Transactional(rollbackFor = Exception.class)
default int deleteBatchVoIds(Collection entityList) {
return deleteBatchVoIds(entityList, DEFAULT_BATCH_SIZE);
}
/**
*
* 删除（根据对象ID 批量删除）
*
*
* @param dtoList 实体封装对象集合
* @param batchSize 删除批次数量
*/
@Transactional(rollbackFor = Exception.class)
default int deleteBatchDtoIds(Collection dtoList, int batchSize) {
return deleteBatchVoIds((Collection) EntityUtils.listVo(dtoList), batchSize);
}
/**
*
* 删除（根据对象ID 批量删除）
*
*
* @param dtoList 实体封装对象集合
*/
@Transactional(rollbackFor = Exception.class)
default int deleteBatchDtoIds(Collection dtoList) {
return deleteBatchDtoIds(dtoList, DEFAULT_BATCH_SIZE);
}
/**
*
* 删除（根据ID 删除树形结构数据）
*
*
* @param id 主键ID
* @param pidColumn 父节点主键
*/
void deleteTreeById(Serializable id, String pidColumn);
/**
*
* 删除（根据ID 批量删除树形结构数据）
*
*
* @param idList 主键ID列表(不能为 null 以及 empty)
* @param pidColumn 父节点主键
*/
@Transactional(rollbackFor = Exception.class)
default void deleteTreeByIds(Collection idList, String pidColumn) {
for (Serializable id : idList) {
deleteTreeById(id, pidColumn);
}
}
/**
*
* 查询树形结构列表
*
* @param wrapper 实体对象封装操作类（可以为 null）
* @param treeNodeClass 返回树形结构类型
*/
default > List listTreeNode(Wrapper wrapper, Class treeNodeClass) {
return listTreeNode(wrapper, treeNodeClass, null);
}
/**
*
* 查询树形结构列表
*
* @param wrapper 实体对象封装操作类（可以为 null）
* @param treeNodeClass 返回树形结构类型
*/
> List listTreeNode(Wrapper wrapper, Class treeNodeClass, Long pid);
/**
*
* 根据 ID 查询
*
*
* @param id 主键ID
*/
D getById(Serializable id);
/**
*
* 根据 ID 查询
*
*
* @param id 主键ID
*/
default T getVoById(Serializable id) {
return (T) EntityUtils.getVo(getById(id));
}
/**
*
* 根据 entity 条件，查询一条记录
*
*
* @param wrapper 实体对象封装类
*/
default D get(Wrapper wrapper) {
return get(wrapper, true);
}
/**
*
* 根据 entity 条件，查询一条记录
*
*
* @param wrapper 实体对象封装类
*/
default T getVo(Wrapper wrapper) {
return (T) EntityUtils.getVo(get(wrapper));
}
/**
*
* 根据 entity 条件，查询一条记录
*
*
* @param wrapper 实体对象封装类
* @param throwEx 是否 抛出异常
*/
D get(Wrapper wrapper, boolean throwEx);
/**
*
* 根据 entity 条件，查询一条记录
*
*
* @param wrapper 实体对象封装类
* @param throwEx 是否 抛出异常
*/
default T getVo(Wrapper wrapper, boolean throwEx) {
return (T) EntityUtils.getVo(get(wrapper, throwEx));
}
/**
*
* 查询（根据 columnMap 条件）
*
*
* @param columnMap 表字段 map 对象
*/
D getByMap(Map columnMap);
/**
*
* 查询（根据 columnMap 条件）
*
*
* @param columnMap 表字段 map 对象
*/
default T getVoByMap(Map columnMap) {
return (T) EntityUtils.getVo(getByMap(columnMap));
}
/**
*
* 根据字段条件，查询一条记录
*
*
* @param colomns 多个列逗号隔开
* @param values 多个值对应多个colomn
*/
D get(String colomns, Object... values);
/**
*
* 根据字段条件，查询一条记录
*
*
* @param colomns 多个列逗号隔开
* @param values 多个值对应多个colomn
*/
default T getVo(String colomns, Object... values) {
return (T) EntityUtils.getVo(get(colomns, values));
}
/**
*
* 根据 Wrapper 条件，查询总记录数
*
*
* @param wrapper 实体对象封装类
*/
Integer count(Wrapper wrapper);
/**
*
* 查询全部记录
*
*/
default List list() {
return list(null);
}
/**
*
* 查询全部记录
*
*/
default List listVo() {
return (List) EntityUtils.listVo(list());
}
/**
*
* 根据 entity 条件，查询全部记录
*
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
List list(Wrapper wrapper);
/**
*
* 根据 entity 条件，查询全部记录
*
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
default List listVo(Wrapper wrapper) {
return (List) EntityUtils.listVo(list(wrapper));
}
/**
*
* 查询（根据ID 批量查询）
*
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List listByIds(Collection idList);
/**
*
* 查询（根据ID 批量查询）
*
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
default List listVoByIds(Collection idList) {
return (List) EntityUtils.listVo(listByIds(idList));
}
/**
*
* 查询（根据 columnMap 条件）
*
*
* @param columnMap 表字段 map 对象
*/
List listByMap(Map columnMap);
/**
*
* 查询（根据 columnMap 条件）
*
*
* @param columnMap 表字段 map 对象
*/
default List listVoByMap(Map columnMap) {
return (List) EntityUtils.listVo(listByMap(columnMap));
}
/**
*
* 根据字段条件，查询全部记录
*
*
* @param colomns 多个列逗号隔开
* @param values 多个值对应多个colomn
*/
default List list(String colomns, Object... values) {
return listByMap(EntityUtils.getMap(colomns, values));
}
/**
*
* 根据字段条件，查询全部记录
*
*
* @param colomns 多个列逗号隔开
* @param values 多个值对应多个colomn
*/
default List listVo(String colomns, Object... values) {
return (List) EntityUtils.listVo(list(colomns, values));
}
/**
*
* 根据 Wrapper 条件，查询全部记录
*
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
List> listMaps(Wrapper wrapper);
/**
*
* 根据 columnMap 条件，查询全部记录
*
*
*@param columnMap 表字段 map 对象
*/
List> listMapsByMap(Map columnMap);
/**
*
* 根据 Wrapper 条件，查询全部记录
* 注意： 只返回第一个字段的值
*
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
List