前端请求对象转化成mybatis3查询数据库条件工具类

 1.工具类

这里提供一个便捷的前端请求对象转化成mybatis3查询数据库条件工具类，方便大家拿过来就能使用

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 各种方便功能
 *
 * @author RenPL
 */
public class LambdaUtils {

    /**
     * data 不为 null 时，执行后面的 lambda 代码
     *
     * @param data 数据
     * @param func 代码
     * @param   数据类型
     * @param   返回类型
     * @return data == null，返回 empty；data != null，返回执行结果
     */
    public static  Optional callIfNotNull(T data, Function func) {
        if (data != null) {
            return Optional.ofNullable(func.apply(data));
        } else {
            return Optional.empty();
        }
    }

    /**
     * data 不为 null 时，执行后面的 lambda 代码
     *
     * @param data 数据
     * @param func 代码
     * @param   数据类型
     */
    public static  void runIfNotNull(T data, Consumer func) {
        if (data != null) {
            func.accept(data);
        }
    }

    /**
     * data 不为空时，执行后面的 lambda 代码
     *
     * @param data 数据
     * @param func 代码
     * @param   数据类型，基本就是 String
     */
    public static  void runIfNotEmpty(T data, Consumer func) {
        if (data != null && data.length() > 0) {
            func.accept(data);
        }
    }

    /**
     * data 不为 null 时，执行后面的 lambda 代码
     *
     * @param data 数据
     * @param func 代码
     * @param   数据类型
     */
    public static  void runIfStringNotNull(T data, Consumer func) {
        if (data != null&&data!="") {
            func.accept(data);
        }
    }

    /**
     * 将某种 key 翻译成对象，并塞回原列表。
     * 使用标准服务 list 方法的版本。
     * 

     * 示例用法：
     * 
     * // 将运力详情 dto 塞入调度单 dto ，使用 where capacity_no in 条件查询，并塞回
     * final List items = resp.getData().getItems();
     * LambdaUtils.translateKeyToObj(
     *     items,
     *     TspDispatchDocumentsDto::getCapacityNo,
     *     "capacity_no",
     *     tspCapacityService,
     *     TspCapacity::getCapacityNo,
     *     (origin, another) -> origin.setTspCapacityDto(TspCapacityConverter.fromEntityToDto(another))
     * );
     * 
     *
     * @param originItems           原始列表
     * @param originKeyExtractor    key 提取器，作为 in 条件
     * @param keyName               查询 in 条件
     * @param queryService          查询服务，提供详情对象
     * @param anotherKeyExtractor   详情对象 key 提取器，必须与 originKeyExtractor 的结果对应
     * @param anotherToOriginPusher 将详情对象塞回原始对象的函数
     * @param  原始对象类型
     * @param  Key 类型，大部分为 String
     * @param  详情对象类型
     */
    public static  void translateKeyToObj(
            List originItems,
            Function originKeyExtractor,
            String keyName,
            IService queryService,
            Function anotherKeyExtractor,
            BiConsumer anotherToOriginPusher
    ) {
        final List keyList = originItems.stream()
                .map(originKeyExtractor)
                .collect(Collectors.toList());

        final QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.in(keyName, keyList);
        final List list = queryService.list(queryWrapper);
        final Map capacityMap = list.stream().collect(Collectors.toMap(anotherKeyExtractor, v -> v));

        originItems.forEach(origin ->
                Optional.ofNullable(capacityMap.get(originKeyExtractor.apply(origin)))
                        .ifPresent(another -> anotherToOriginPusher.accept(origin, another))
        );
    }

    /**
     * 将某种 key 翻译成对象，并塞回原列表。
     * 使用自定义查询的版本。
     *
     * @param originItems           原始列表
     * @param originKeyExtractor    key 提取器，作为 in 条件
     * @param queryFunction         查询方法，提供详情对象
     * @param anotherKeyExtractor   详情对象 key 提取器，必须与 originKeyExtractor 的结果对应
     * @param anotherToOriginPusher 将详情对象塞回原始对象的函数
     * @param  原始对象类型
     * @param  Key 类型，大部分为 String
     * @param  详情对象类型
     */
    public static  void translateKeyToObj(
            List originItems,
            Function originKeyExtractor,
            Function, List> queryFunction,
            Function anotherKeyExtractor,
            BiConsumer anotherToOriginPusher
    ) {
        final List keyList = originItems.stream()
                .map(originKeyExtractor)
                .collect(Collectors.toList());

        final List list = queryFunction.apply(keyList);
        final Map capacityMap = list.stream().collect(Collectors.toMap(anotherKeyExtractor, v -> v));

        originItems.forEach(origin ->
                Optional.ofNullable(capacityMap.get(originKeyExtractor.apply(origin)))
                        .ifPresent(another -> anotherToOriginPusher.accept(origin, another))
        );
    }
}

2.各类对象转换工具

/**
 * 各类对象转换工具
 *
 * @author RenPL 2020-2-24
 */
public class SensitiveWordsConverter {
    /**
     * 将前端查询类转换为 MybatisPlus 查询类
     *
     * @param query 前端查询类
     * @return MybatisPlus 查询类
     */
    public static QueryWrapper fromQueryToWrapper(SensitiveWordsReq query) {
        final QueryWrapper wrapper = new QueryWrapper<>();
        // 敏感词类型
        LambdaUtils.runIfNotNull(query.getType(), v -> wrapper.eq("type", v));
        // 敏感词内容
        LambdaUtils.runIfNotEmpty(query.getContent(), v -> wrapper.eq("content", v));
        // 起始创建时间
        LambdaUtils.runIfNotNull(query.getStartCreateTime(), v -> wrapper.ge("create_time", v));
        // 结束创建时间
        LambdaUtils.runIfNotNull(query.getEndCreateTime(), v -> wrapper.le("create_time", v));
        // 起始修改时间
        LambdaUtils.runIfNotNull(query.getStartUpdateTime(), v -> wrapper.ge("update_time", v));
        // 结束修改时间
        LambdaUtils.runIfNotNull(query.getEndUpdateTime(), v -> wrapper.le("update_time", v));
        return wrapper;
    }

    /**
     * 数据库对象转换为 Rep
     *
     * @param entity 数据库对象
     * @return Rep
     */
    public static SensitiveWordsRep fromEntityToRep(SensitiveWordsEntity entity) {
        final SensitiveWordsRep dto = new SensitiveWordsRep();
        BeanUtils.copyProperties(entity, dto);
        return dto;
    }

    /**
     * 数据库对象转换为 Req
     *
     * @param req 对象
     * @return entity对象
     */
    public static SensitiveWordsEntity fromReqToEntity(SensitiveWordsReq req) {
        final SensitiveWordsEntity entity = new SensitiveWordsEntity();
        BeanUtils.copyProperties(req, entity);
        return entity;
    }
}

3.这样前端对象直接动态的转换成mybatis3查询条件了

方便吧