去掉不需要的依赖

liulin

2024-07-31 72514fab70f067c15a167a96923b678eea3c8bfd

 src/main/java/com/lunhan/xxx/repository/BasicMapperImpl.java

@@ -1,22 +1,25 @@
package com.lunhan.xxx.repository;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.lunhan.xxx.common.PagerResult;
import com.lunhan.xxx.common.enums.ELogger;
import com.lunhan.xxx.common.enums.EResultCode;
import com.lunhan.xxx.common.enums.EYesOrNo;
import com.lunhan.xxx.common.exceptions.BusinessException;
import com.lunhan.xxx.common.util.LoggerUtil;
import com.lunhan.xxx.entity.dto.SearchBasicDTO;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.session.ResultHandler;
import org.slf4j.Logger;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.Table;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
@@ -28,7 +31,7 @@
 *
 * @param <T> 数据实体
 */
public class BasicMapper<T> {
public abstract class BasicMapperImpl<T> implements BasicMapper<T> {
    protected BaseMapper<T> DB;
    protected Class<T> clazz;
    protected String tableName;
@@ -38,16 +41,17 @@
    /**
     * 构造方法
     */
    public BasicMapper(BaseMapper<T> db) {
    public BasicMapperImpl(BaseMapper<T> db) {
        this.clazz = (Class<T>) (
                (ParameterizedType) getClass().getGenericSuperclass()
        ).getActualTypeArguments()[0];
        this.DB = db;
        Table annotation = clazz.getAnnotation(Table.class);
        TableName annotation = clazz.getAnnotation(TableName.class);
        if (null == annotation) {
            this.tableName = StringUtils.camelToUnderline(clazz.getSimpleName().replace("PO", ""));
            return;
        }
        this.tableName = annotation.name();
        this.tableName = annotation.value();
    }

    public LambdaQueryWrapper<T> query() {
@@ -58,90 +62,248 @@
        return Wrappers.update();
    }

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    public int insert(T entity) {
        return DB.insert(entity);
    }

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体对象
     * @since 3.4.4
     */
    public int deleteById(T entity) {
        return DB.deleteById(entity);
    }

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    public int delete(Wrapper<T> queryWrapper) {
        return DB.delete(queryWrapper);
    }

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    public int updateById(T entity) {
        return DB.updateById(entity);
    }

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null,当entity为null时,无法进行自动填充)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    public int update(T entity, Wrapper<T> updateWrapper) {
        return DB.update(entity, updateWrapper);
    }

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    public T selectById(Serializable id) {
        return DB.selectById(id);
    }

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

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList        idList 主键ID列表(不能为 null 以及 empty)
     * @param resultHandler resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public void selectBatchIds(Collection<? extends Serializable> idList, ResultHandler<T> resultHandler) {
        DB.selectBatchIds(idList, resultHandler);
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    public Long selectCount(Wrapper<T> queryWrapper) {
        return DB.selectCount(queryWrapper);
    }

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

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper  实体对象封装操作类（可以为 null）
     * @param resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public void selectList(Wrapper<T> queryWrapper, ResultHandler<T> resultHandler) {
        DB.selectList(queryWrapper, resultHandler);
    }

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     * @since 3.5.3.2
     */
    public List<T> selectList(IPage<T> page, Wrapper<T> queryWrapper) {
        return DB.selectList(page, queryWrapper);
        return DB.selectList(queryWrapper);
    }

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page          分页查询条件
     * @param queryWrapper  实体对象封装操作类（可以为 null）
     * @param resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public void selectList(IPage<T> page, Wrapper<T> queryWrapper, ResultHandler<T> resultHandler) {
        DB.selectList(page, queryWrapper, resultHandler);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类
     */
    public List<Map<String, Object>> selectMaps(Wrapper<T> queryWrapper) {
        return DB.selectMaps(queryWrapper);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper  实体对象封装操作类
     * @param resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public void selectMaps(Wrapper<T> queryWrapper, ResultHandler<Map<String, Object>> resultHandler) {
        DB.selectMaps(queryWrapper, resultHandler);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     * @since 3.5.3.2
     */
    public List<Map<String, Object>> selectMaps(IPage<? extends Map<String, Object>> page, Wrapper<T> queryWrapper) {
        return DB.selectMaps(page, queryWrapper);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page          分页查询条件
     * @param queryWrapper  实体对象封装操作类
     * @param resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public void selectMaps(IPage<? extends Map<String, Object>> page, Wrapper<T> queryWrapper, ResultHandler<Map<String, Object>> resultHandler) {
        DB.selectMaps(page, queryWrapper, resultHandler);
    }

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

    /**
     * 根据 Wrapper 条件，查询全部记录
     * <p>注意： 只返回第一个字段的值</p>
     *
     * @param queryWrapper  实体对象封装操作类（可以为 null）
     * @param resultHandler 结果处理器 {@link ResultHandler}
     * @since 3.5.4
     */
    public <E> void selectObjs(Wrapper<T> queryWrapper, ResultHandler<E> resultHandler) {
        DB.selectObjs(queryWrapper, resultHandler);
    }


    /**
     * 批量新增
     *
     * @param list 数据实体列表
     */
    public Boolean addList(List<T> list) {
        List<BatchResult> batchResult = DB.insert(list);
        // TODO 判断成功
        return Boolean.TRUE;
    }

    /**
     * 批量更新
     *
     * @param list 数据实体列表
     */
    public Boolean modifyList(List<T> list) {
        List<BatchResult> batchResult = DB.updateById(list);
        // TODO 判断成功
        return Boolean.TRUE;
    }

    /**
     * 批量查询其他实体列表
     *
     * @param queryWrapper 查询条件
     */
    public <E> List<E> selectListObject(Wrapper<T> queryWrapper) {
        return DB.selectObjs(queryWrapper);
    }

    /**
     * 批量查询其他实体列表
     *
     * @param queryWrapper  查询条件
     * @param resultHandler 查询结果处理器
     */
    public <E> void selectListObject(Wrapper<T> queryWrapper, ResultHandler<E> resultHandler) {
        DB.selectObjs(queryWrapper, resultHandler);
    }

    /**
     * 根据条件获取数据实体列表
     * 根据主键查询单个数据实体
     *
     * @param queryWrapper 查询条件
     * @param id 主键值
     */
    @Transactional(readOnly = true)
    protected List<T> getList(Wrapper<T>... queryWrapper) {
        return DB.selectList(queryWrapper.length > 0 ? queryWrapper[0] : null);
    public T get(Serializable id) {
        return DB.selectById(id);
    }

    /**
@@ -149,8 +311,7 @@
     *
     * @param queryWrapper 查询条件
     */
    @Transactional(readOnly = true)
    protected T get(Wrapper<T> queryWrapper) {
    public T get(Wrapper<T> queryWrapper) {
        String method = "BasicDao.Wrapper<T> queryWrapper";
        try {
            return DB.selectOne(queryWrapper);
@@ -163,6 +324,20 @@
        }
    }

    /**
     * 根据主键批量获取
     * @param listId 主键列表
     */
    public <E extends Serializable> List<T> getList(List<E> listId) {
        return DB.selectBatchIds(listId);
    }

    /**
     * 获取全量数据（慎重）
     */
    public List<T> getList() {
        return DB.selectList(null);
    }

    /**
     * 根据传入sql查询数据
@@ -188,7 +363,7 @@
     * @param id 主键id
     * @return 是否成功
     */
    public Boolean remove(Long id) {
    public Boolean remove(Serializable id) {
        int rowCount = DB.deleteById(id);
        if (rowCount > 0) {
            return Boolean.TRUE;
@@ -202,7 +377,7 @@
     * @param listId id列表
     * @return 是否成功
     */
    public Boolean remove(List<Long> listId) {
    public <E extends Serializable> Boolean remove(List<E> listId) {
        int rowCount = DB.deleteByIds(listId);
        if (rowCount > 0) {
            return Boolean.TRUE;
@@ -216,7 +391,7 @@
     *
     * @param queryWrapper 查询条件
     */
    protected Boolean remove(Wrapper<T> queryWrapper) {
    public Boolean remove(Wrapper<T> queryWrapper) {
        int rowCount = DB.delete(queryWrapper);
        if (rowCount > 0) {
            return Boolean.TRUE;
@@ -230,7 +405,7 @@
     * @param id 主键id
     * @return 是否成功
     */
    public Boolean deleteLogic(Long id) {
    public Boolean deleteLogic(Serializable id) {
        UpdateWrapper<T> where = Wrappers.update();
        where.set("is_delete", EYesOrNo.YES.getValue());
        where.eq("id", id);
@@ -247,7 +422,7 @@
     * @param listId id列表
     * @return 是否成功
     */
    public Boolean deleteLogic(List<Long> listId) {
    public <E extends Serializable> Boolean deleteLogic(List<E> listId) {
        UpdateWrapper<T> where = Wrappers.update();
        where.set("is_delete", EYesOrNo.YES.getValue());
        where.in("id", listId);
@@ -257,4 +432,12 @@
        }
        return Boolean.FALSE;
    }

    /**
     * 分页查询
     *
     * @param search 查询参数
     */
    @Override
    public abstract PagerResult<T> search(SearchBasicDTO search);
}