代码记录 lamda 实战 linjinyu


转换

package com.jsh.erp.utils.array;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


/**
 * @Description: 超级前台 业务处理 StringUtils
 * @Author: linjinyu
 * @CreateDate: 5/28/20 5:58 PM
 * @UpdateUser: linjinyu
 * @UpdateDate: 5/28/20 5:58 PM
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class SuperdeskStringUtils {


    /**
     * usage : List<Long> searchVirtIds = SuperdeskStringUtils.strArrayConvertToLongList(event.getVirtIds(), ";");
     *
     * @param ids
     * @param splitChat
     * @return
     */
    public static List<Long> stringArrayConvertToLongList(String ids, String splitChat) {


        if (StringUtils.isNotBlank(ids)) {
            String[] idArray = ids.split(splitChat);
            return Arrays.stream(idArray)
                    .map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());
        } else {
            return new ArrayList<>();
        }
    }

    public static List<String> stringArrayConvertToStringList(String ids, String splitChat) {


        if (StringUtils.isNotBlank(ids)) {
            String[] idArray = ids.split(splitChat);
            return Arrays.stream(idArray)
                    .map(s -> s.trim()).collect(Collectors.toList());
        } else {
            return new ArrayList<>();
        }


    }

    /**
     * @param input
     * @return
     */
    public static String stringListConvertToString(List<String> input) {

        String output = "";

        if (CollectionUtils.isNotEmpty(input)) {
            output = input.stream().collect(Collectors.joining(","));
        }

        return output;
    }
}

累加

sampleSupTotal = dataList.stream().map(diEx -> diEx.getAllprice()).reduce(BigDecimal.ZERO, BigDecimal::add);

            if (codeCurrGroupStatistics.get("HKD") != null) {
                sampleSupTotalHKD = dataList.stream().map(diEx -> new BigDecimal(df.format(diEx.getUnitPriceCurr().multiply(diEx.getOpernumber())))).reduce(BigDecimal.ZERO, BigDecimal::add);
            } else {
                sampleSupTotalHKD = sampleSupTotal.divide(rate, 2);
            }

分组

分组统计

// 以币种 分组统计
            Map<String, Long> codeCurrGroupStatistics = dataList.stream().collect(
                    Collectors.groupingBy(
                            DepotItemVo4WithInfoEx::getCodeCurr,
                            Collectors.counting()
                    )
            );

此分组方式有 大作用 , 例程为 Bean 1 or N 字段 的 分组 , 如果以Id来分组为怎样, 很糖吧

Map<String, List<DepotItem>> groupByCodeCurr = result.parallelStream()
                .collect(Collectors.groupingBy(DepotItem::getCodeCurr, Collectors.toList()));
//                .collect(Collectors.groupingBy(e -> fetchGroupKeyByCodeCurr(e), Collectors.toList()));

分组处理 一个 生成 excel 合并数据问题

private static String fetchGroupKeyById(InvoiceApplyExportExcelForceScore invoiceApplyExportExcelForceScore) {
        return invoiceApplyExportExcelForceScore.getInvoiceApplyId() +
                "_" + invoiceApplyExportExcelForceScore.getAccountingOrderId() +
                "_" + invoiceApplyExportExcelForceScore.getUnifiedOrderGoodsId();
    }

    private static String fetchGroupKeyByName(InvoiceApplyExportExcelForceScore invoiceApplyExportExcelForceScore) {
        return invoiceApplyExportExcelForceScore.getInvoiceNo() +
                "_" + invoiceApplyExportExcelForceScore.getAccountingOrderSn() +
                "_" + invoiceApplyExportExcelForceScore.getCreditName() +
                "_" + invoiceApplyExportExcelForceScore.getGoodsName();
    }

    private static String[] fieldHeadMode1Static = {"发票申请编号", "对账单编号", "销售单据编号",
            "购方名称", "购方税号", "购方地址电话", "购方银行账号", "备注",
            "税收编码",
            "货品名称", // 侨城汇要改成 货品名称 20200826 周可军 胡军知悉
            "规格型号", "计量单位", "商品数量", "销售单价", "积分类型", "结算金额", "税率", "折扣金额",
            "供应商"

//                    "商品信息", "商品编码", "商品规格", "商品数量", "商品单价(折扣后)",
//                    "商品价格(折扣后)", "商品单位", "财务代码", "收货人姓名", "收货人手机号", "发货时间", "运费", "快递公司", "快递单号", "完成时间", "回款状态", "发票号", "开票时间", "发票状态", "开票申请编号", "开票申请备注", "发票抬头", "发票类型"
    };

    private static String[] fieldValueMode1Static = {"invoiceNo", "accountingOrderSn", "orderSn",
            "enterpriseName", "companyName", "invoiceBank", "invoiceAccount", "remark",
            "unifiedOrderGoodsTaxCode",
            "goodsName",
            "cateNameLv3", "unit", "quantity", "price", "creditName", "balance", "unifiedOrderGoodsTaxRate", "",
            "saleName"
    };

    /**
     * 可行 再合并
     *
     * @param result
     * @return
     */
    private HSSFWorkbook mergeResultByExcelDebugAndCreateWorkbook(List<InvoiceApplyExportExcelForceScore> result) {

        HSSFWorkbook workbook = new HSSFWorkbook();

        if (CollectionUtils.isEmpty(result)) {
            return workbook;
        }

        // 得出当前数据 发票申请的 id -> sn
        Map<Long, String> invoiceApplyMap = result.stream().collect(Collectors.toMap(
                /*key*/InvoiceApplyExportExcelForceScore::getInvoiceApplyId,
                /*value*/InvoiceApplyExportExcelForceScore::getInvoiceNo,
                /*key重复时*/(key1, key2) -> key2,
                LinkedHashMap::new
        ));

        // 因为是可以多选的 所以先按 发票申请Id 分组
        Map<Long, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyId = result.parallelStream()
                .collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getInvoiceApplyId, Collectors.toList()));
//                .collect(Collectors.groupingBy(e -> fetchGroupKey(e), Collectors.toList()));

        List<InvoiceApplyExportExcelForceScore> transferListBySheet      = null;
        List<InvoiceApplyExportExcelForceScore> transferListBySheetMerge = null;

        // 因为是可以多选的 所以先按 发票申请Id 分组 每个 entry 是 一份
        for (Map.Entry<Long, List<InvoiceApplyExportExcelForceScore>> entry : transferMapGrouopByInvoiceApplyId.entrySet()) {

            transferListBySheet = new ArrayList<>();
            transferListBySheetMerge = new ArrayList<>();

            Map<String, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyIdGroupBy = entry.getValue().parallelStream()
                    .collect(Collectors.groupingBy(e -> fetchGroupKeyByName(e), Collectors.toList()));

            for (Map.Entry<String, List<InvoiceApplyExportExcelForceScore>> _entry : transferMapGrouopByInvoiceApplyIdGroupBy.entrySet()) {


                log.info("_groupKey : {} _size : {}", _entry.getKey(), _entry.getValue().size());

                if (_entry.getValue().size() > 1) {
//                    log.info("\n{}", JsonUtils.toJson(_entry.getValue()));

                    // TODO 处理 合并
                    InvoiceApplyExportExcelForceScore _merge = new InvoiceApplyExportExcelForceScore();
                    BeanUtil.copyProperties(_entry.getValue().get(0), _merge);

                    // 商品数量
                    _merge.setQuantity(_entry.getValue().stream()
                            .map(item -> item.getQuantity() == null ? 0 : item.getQuantity())
                            .reduce(0, Integer::sum));
//                    // 销售单价
//                    _merge.setPrice(_entry.getValue().stream()
//                            .map(item -> item.getPrice() == null ? BigDecimal.ZERO : item.getPrice())
//                            .reduce(BigDecimal.ZERO, BigDecimal::add));
                    // 结算金额(积分)
                    _merge.setBalance(_entry.getValue().stream()
                            .map(item -> item.getBalance() == null ? BigDecimal.ZERO : item.getBalance())
                            .reduce(BigDecimal.ZERO, BigDecimal::add));

//                    累加
//                    BigDecimal::add
                    transferListBySheetMerge.add(_merge);


                } else {
                    transferListBySheetMerge.addAll(_entry.getValue());
                }

                transferListBySheet.addAll(_entry.getValue());
            }

            try {
                ExcelUtils.createSheetByWorkbook(transferListBySheet, fieldHeadMode1Static, fieldValueMode1Static, workbook, invoiceApplyMap.get(entry.getKey()).toString() + "");
                ExcelUtils.createSheetByWorkbook(transferListBySheetMerge, fieldHeadMode1Static, fieldValueMode1Static, workbook, invoiceApplyMap.get(entry.getKey()).toString() + "_合并");
            } catch (Exception e) {

            }


        }

        return workbook;

    }

    /**
     * @param result
     * @return
     */
    private List<InvoiceApplyExportExcelForceScore> mergeResultByExcelDebug(List<InvoiceApplyExportExcelForceScore> result) {

        // 因为是可以多选的 所以先按 发票申请Id 分组
        Map<Long, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyId = result.parallelStream()
                .collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getInvoiceApplyId, Collectors.toList()));
//                .collect(Collectors.groupingBy(e -> fetchGroupKey(e), Collectors.toList()));

        List<InvoiceApplyExportExcelForceScore> transferList = new ArrayList<>();

        // 因为是可以多选的 所以先按 发票申请Id 分组 每个 entry 是 一份
        for (Map.Entry<Long, List<InvoiceApplyExportExcelForceScore>> entry : transferMapGrouopByInvoiceApplyId.entrySet()) {

            Map<String, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyIdGroupBy = entry.getValue().parallelStream()
                    .collect(Collectors.groupingBy(e -> fetchGroupKeyById(e), Collectors.toList()));

            for (Map.Entry<String, List<InvoiceApplyExportExcelForceScore>> _entry : transferMapGrouopByInvoiceApplyIdGroupBy.entrySet()) {


                log.info("_groupKey : {} _size : {}", _entry.getKey(), _entry.getValue().size());

                if (_entry.getValue().size() > 1) {
                    log.info("\n{}", JsonUtils.toJson(_entry.getValue()));
                }

                transferList.addAll(_entry.getValue());
            }
        }

        return transferList;

    }

    // TODO
    private void mergeResultByExcel(List<InvoiceApplyExportExcelForceScore> result) {

        result.parallelStream()
//                .collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getUnifiedOrderGoodsId, Collectors.toList()))
                .collect(Collectors.groupingBy(e -> fetchGroupKeyById(e), Collectors.toList()))
                .forEach((groupKey, transferList) -> {


                    InvoiceApplyExportExcelForceScore mergeRow = new InvoiceApplyExportExcelForceScore();

                    log.info("\ngroupKey : {}\ntransferList : {}", groupKey, JsonUtils.toJson(transferList));

//                    authorizedStationInfo.setStationId(k);
//                    List<AuthorizedPileInfo> authorizedPileInfos = new ArrayList<>();
//                    v.parallelStream().collect(Collectors.groupingBy(CrmAuthorizedInfo::getPileId, Collectors.toList())).forEach((k1, v1) -> {
//                        AuthorizedPileInfo authorizedPileInfo = new AuthorizedPileInfo();
//                        authorizedPileInfo.setPileId(k1);
//                        authorizedPileInfo.setGunIds(v1.stream().map(CrmAuthorizedInfo::getGunId).collect(Collectors.toList()));
//                        authorizedPileInfos.add(authorizedPileInfo);
//                    });
//                    authorizedStationInfo.setPileIds(authorizedPileInfos);

//                    authorizedStationInfos.add(authorizedStationInfo);
                });

    }

分页

// 处理分页

//                方法1、   总页数 = (总记录数 + 每页数据大小  - 1) / 每页数据大小
//                方法2、 可使用Math.ceil()函数,该函数需要强类型转换(向上取整是指:浮点数取整)
//                总页数 = (int) Math.ceil(总记录数/每页大小)

                Integer pageSize = 22;

                if (midReceiptItemListUp.size() > pageSize) {

                    Integer pageTotal = (midReceiptItemListUp.size() + pageSize - 1) / pageSize;

                    for (Integer pageNum = 1; pageNum <= pageTotal; pageNum++) {

                        log.info("处理分页 pageNum {} pageTotal {} pageSize {} itemTotal {} ", pageNum, pageTotal, pageSize, midReceiptItemListUp.size());


                        MonthlySettlementReceiptVo monthlySettlementReceiptVoPage = new MonthlySettlementReceiptVo();

                        BeanUtil.copyProperties(monthlySettlementReceiptVo, monthlySettlementReceiptVoPage);

                        monthlySettlementReceiptVoPage.setPageNum(pageNum);
                        monthlySettlementReceiptVoPage.setPageSize(pageSize);
                        monthlySettlementReceiptVoPage.setPageTotal(pageTotal);

                        List<DepotHeadVo4StatementAccount> pageData = midReceiptItemListUp.stream().skip(pageSize * (pageNum - 1)).limit(pageSize).collect(Collectors.toList());

                        monthlySettlementReceiptVoPage.setList(pageData);

                        receiptVos.add(monthlySettlementReceiptVoPage);
                    }

                } else {

                    monthlySettlementReceiptVo.setPageNum(1);
                    monthlySettlementReceiptVo.setPageSize(pageSize);
                    monthlySettlementReceiptVo.setPageTotal(1);

                    receiptVos.add(monthlySettlementReceiptVo);
                }

集合 并集 交集 差集

package cn.superdesk.app.core.service;


import cn.superdesk.app.base.exception.ExceptionCode;
import cn.superdesk.app.common.dao.entity.ServiceAppMenuConfigEntity;
import cn.superdesk.app.common.dao.entity.ServiceOrgConfigEntity;
import cn.superdesk.app.common.dao.mapper.ServiceAppMenuConfigEntityMapper;
import cn.superdesk.app.common.dao.mapper.ServiceOrgConfigEntityMapper;
import cn.superdesk.app.core.constants.GlobalConstant;
import cn.superdesk.app.core.dao.entity.AppMenuEntity;
import cn.superdesk.app.core.dao.entity.AppRoleEntity;
import cn.superdesk.app.core.dao.entity.AppRoleFunctionEntity;
import cn.superdesk.app.core.dao.mapper.AppMenuEntityMapper;
import cn.superdesk.app.core.dao.mapper.AppRoleEntityMapper;
import cn.superdesk.app.core.dao.mapper.AppRoleFunctionEntityMapper;
import cn.superdesk.libs.common.SuperdeskBaseException;
import cn.superdesk.libs.common.json.JsonUtils;
import cn.superdesk.libs.common.util.CollectionUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;


/**
 * @Description: 后台用户与角色
 * 整合两个功能
 * 1. 现有业务界面 首页 -> 系统管理 -> 管理用户配置 -> 新增用户 -> 项目管理员时 会创建对映或关联项目管理员角色
 * 2. 新做业务界面 搜索出 XXX角色 批量 按照 蓝本角色数据(系统级别) 覆盖 按企业X服务X权限 插入 得出最终的 XXX角色权限
 * @Author: linjinyu
 * @CreateDate: 12/25/19 2:48 PM
 * @UpdateUser: linjinyu
 * @UpdateDate: 12/25/19 2:48 PM
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
@Slf4j
@Service
public class AppUserAppRoleSupplyService {


    @Autowired
    private AppRoleEntityMapper              appRoleEntityMapper;
    @Autowired
    private AppRoleService                   appRoleService;
    @Autowired
    private AppRoleFunctionEntityMapper      appRoleFunctionEntityMapper;
    @Autowired
    private AppMenuEntityMapper              appMenuEntityMapper;
    @Autowired
    private ServiceOrgConfigEntityMapper     serviceOrgConfigEntityMapper;
    @Autowired
    private ServiceAppMenuConfigEntityMapper serviceAppMenuConfigEntityMapper;

    private List<AppRoleFunctionEntity> appRoleXFunctionSample;

    /**
     * 初始化 蓝本
     *
     * @param sampleAppRoleId
     */
    private void initAppRoleXFunctionSample(Integer sampleAppRoleId) {

        if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
            appRoleXFunctionSample = selectAppRoleXAppMenuByAppRoleId(sampleAppRoleId);

            if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
                throw new SuperdeskBaseException(ExceptionCode.RECORD_NOT_EXIST.code, "项目管理员角色 蓝本 权限为空");
            }
        }

        // 如果 样品的数据为空 throw 出错误
    }

    /**
     * 一键 全部 项目管理员 角色 设置 权限
     * 1. 获取全部 项目管理员角色
     * 2. iterator -> 系统权限 蓝本 -> 业务权限 蓝本
     */
    public void oneKeySettingAppRoleType3OrganisationAdministrators() {

        List<AppRoleEntity> todoResult = selectAppRoleByAppRoleType3();

        todoResult.forEach(appRoleEntity -> {
            initAppRoleBySample(appRoleEntity.getId(), null);
        });


    }

    /**
     * 第一步 得到 全部 项目管理员 角色
     *
     * @return
     */
    public List<AppRoleEntity> selectAppRoleByAppRoleType3() {
        /**
         * 角色类型
         * 超级管理员=>1
         * 系统管理员=>2
         * 项目管理员=>3
         * 项目普通管理员=>4
         * 运营中心管理员=>6
         * 运营中心普通管理员=>7
         * 运营商管理员=>20
         * 渠道商管理员=>21
         * 运营商操作员=>22
         * 渠道商操作员=>23
         */
//        List<AppRoleEntity> appUserXRoleResult = appRoleEntityMapper.findAppRoleByAppUserIdAndRoleType(GlobalConstant.UserType.ORG_TYPE.type, null);
//        return appUserXRoleResult;

//        SELECT
//            id,org_id,type,sys_code,name,description,is_init,floor_repair,status,created_by,created_at,updated_by,updated_at,enabled
//        FROM tb_app_role
//        WHERE
//            org_id >0 and type = 3
//        ORDER BY `tb_app_role`.`org_id` ASC


//        AppRoleEntity conditions = new AppRoleEntity();
//        conditions.setType(GlobalConstant.UserType.ORG_TYPE.type);
//        List<AppRoleEntity> appRoleResult = appRoleEntityMapper.select(conditions);


        List<AppRoleEntity> appRoleResult = appRoleEntityMapper.selectAppRoleByAppRoleType(GlobalConstant.UserType.ORG_TYPE.type);

        return appRoleResult;
    }

    /**
     * 初始化 角色 的 权限 根据 样本 角色id(appRole.id)
     *
     * @param targetAppRoleId
     * @param sampleAppRoleId
     */
    public void initAppRoleBySample(
            /*目标要初始化的 appUserId*/Integer targetAppRoleId,
            /*样品 appUserId*/Integer sampleAppRoleId
    ) {


        // TODO 为了测试 先写死一个吧 环境 dev
        // 正式
//        * ac : quanx
//        * pw : a12345678
//        * app_user_id : 1508
//        * app_role_id : 10231

        // 测试
//        * ac : tquanx
//        * pw : a12345678
//        * app_user_id : 2920
//        * app_role_id : 5
        if (null == sampleAppRoleId) {
//            sampleAppRoleId = 5;

            AppRoleEntity sampleAppRole = appRoleService.getRoleByTypeSample(GlobalConstant.UserType.ORG_TYPE.type);
            sampleAppRoleId = sampleAppRole.getId();
        }


        if (null == sampleAppRoleId && sampleAppRoleId.intValue() > 0) {
            log.info("sampleAppRoleId:{} 不合法, 初始化失败 ", sampleAppRoleId);
        }

        if (null == targetAppRoleId && targetAppRoleId.intValue() > 0) {
            log.info("targetAppRoleId:{} 不合法, 初始化失败 ", targetAppRoleId);
        }

        if (targetAppRoleId.equals(sampleAppRoleId)) {
            log.info("targetAppRoleId:{} 不要与 sampleAppRoleId:{} 相等, 初始化失败 ", targetAppRoleId, sampleAppRoleId);
        }

        // 初始化 蓝本
        initAppRoleXFunctionSample(sampleAppRoleId);

        // 查找出 targetAppRole by Id
        AppRoleEntity appRoleEntity = appRoleEntityMapper.selectByPrimaryKey(targetAppRoleId);

        log.info("处理 app_role info\n{}", JsonUtils.toJson(appRoleEntity));

        // TODO 处理系统权限
        processSystemRole(targetAppRoleId);
        // TODO 处理业务权限
        processBusinessRole(targetAppRoleId);


    }


    /**
     * 处理系统权限
     *
     * @param targetAppRoleId
     */
    private void processSystemRole(Integer targetAppRoleId) {

        // 如果蓝本数据 为空 直接 返回 没有什么好处理的
        if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
            return;
        }


        // 原本的 app_user 对映的 app_role 的 菜单权限
        List<AppRoleFunctionEntity> appRoleXFunctionResult = selectAppRoleXAppMenuByAppRoleId(targetAppRoleId);

        log.info("当前角色权限 app_role X app_menu by app_role_id({}) => app_menu_id.size({})\n{}", targetAppRoleId, appRoleXFunctionResult.size(), JsonUtils.toJson(appRoleXFunctionResult));

        // 删除原来 app_role x app_menu
        if (CollectionUtils.isNotEmpty(appRoleXFunctionResult)) {
            // List<Integer> 转 int[]
            // deleteRoleIds.stream().mapToInt(Integer::intValue).toArray()
            List<Integer> deleteRoleIds = appRoleXFunctionResult.stream().map(e -> e.getRoleId()).collect(Collectors.toList());
            appRoleFunctionEntityMapper.deleteBatch(deleteRoleIds.toArray(new Integer[deleteRoleIds.size()]));
        }


        // TODO 处理系统级权限
        /* ---------------- 插入样本权限 start -------------- */
        List<AppRoleFunctionEntity> insertAppRoleFunction = new ArrayList<>();

        appRoleXFunctionSample.forEach(appRoleFunctionEntity -> {

            AppRoleFunctionEntity sample = new AppRoleFunctionEntity();

            sample.setRoleId(targetAppRoleId);
            sample.setFunctionId(appRoleFunctionEntity.getFunctionId());

            insertAppRoleFunction.add(sample);

        });
        /* ---------------- 插入样本权限 end   -------------- */

        appRoleFunctionEntityMapper.insertList(insertAppRoleFunction);

    }

    /**
     * TODO 处理业务权限
     *
     * @param targetAppRoleId
     * @return
     */
    private void processBusinessRole(Integer targetAppRoleId) {

        List<AppMenuEntity> result = new ArrayList<>();

        // 为了简单 没有传入 orgId
        // 根据 targetAppRoleId 查出 appRole 得到 orgId
        AppRoleEntity appRoleEntity = appRoleEntityMapper.selectByPrimaryKey(targetAppRoleId);

        log.info("处理业务权限 targetAppRoleId:{}\n{}", targetAppRoleId, JsonUtils.toJson(appRoleEntity));

        // 根据 orgId 得到 服务(上架的)
        List<ServiceOrgConfigEntity> serviceXOrgnization = selectServiceConfigByOrgnizationId(appRoleEntity.getOrgId());

        log.info("根据 orgId:{}, 得到 服务(上架的) \n {}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceXOrgnization));

        List<Integer> serviceTypeInfoIds = serviceXOrgnization.stream().map(e -> e.getServiceTypeId()).collect(Collectors.toList());

        log.info("项目:{} \n服务上线情况为:\n{}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceTypeInfoIds));

        // 如果 项目 服务上架 情况为空 直接 返回 没什么好处理的
        if (CollectionUtils.isEmpty(serviceTypeInfoIds)) {
            return;
        }

        // 根据 服务集合 -> service_type_info_ids 得到 serviceAppMenuConfig 集合
        List<ServiceAppMenuConfigEntity> serviceAppMenuConfigEntityList = serviceAppMenuConfigEntityMapper.queryByServiceTypeInfoIds(serviceTypeInfoIds);

        log.info("项目:{} \n服务上线X权限为:\n{}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceAppMenuConfigEntityList));

        // 如果 项目有 对映的 服务上线 但这个 服务对映的权限是空的 直接 返回 没什么好处理的
        if (CollectionUtils.isEmpty(serviceAppMenuConfigEntityList)) {
            return;
        }

        // 拼装成 AppMenuEntity List 返回

        // TODO 处理业务级权限 是有点多余 先接上吧
        /* ---------------- 插入业务权限 start -------------- */

        List<AppRoleFunctionEntity> insertAppRoleFunction = new ArrayList<>();

        serviceAppMenuConfigEntityList.forEach(serviceAppMenuConfigEntity -> {

            AppRoleFunctionEntity sample = new AppRoleFunctionEntity();

            sample.setRoleId(targetAppRoleId);
            sample.setFunctionId(serviceAppMenuConfigEntity.getFunctionId());

            insertAppRoleFunction.add(sample);
        });
        /* ---------------- 插入业务权限 start -------------- */

        appRoleFunctionEntityMapper.insertList(insertAppRoleFunction);

    }

//    private List<AppMenuEntity> processBusinessRole(AppRoleEntity appRoleEntity) {
//
//        // init return
//        List<AppMenuEntity> sourceAppMenuList = new ArrayList<>();
//        List<AppMenuEntity> deDuplicationAppMenuList = new ArrayList<>();
//        //        app_user -> orgnization -> service -> service2app_menu -> app_menu
//
//
////                    orgnization X service
//
//        // 查出来的数据 不是全部都有权限的
//        List<ServiceOrgConfigEntity> serviceXOrgnization = selectServiceConfigByOrgnizationId(appRoleEntity.getOrgId());
//
//        if (CollectionUtils.isNotEmpty(serviceXOrgnization)) {
//            serviceXOrgnization.forEach(serviceOrgConfigEntity -> {
//
//                // service x service2app_menu
//                if (serviceId2AppMenuId.containsKey(serviceOrgConfigEntity.getServiceTypeId())) {
//
//                    List<Integer> appMenuIdRootList = serviceId2AppMenuId.get(serviceOrgConfigEntity.getServiceTypeId());
//
//                    appMenuIdRootList.forEach(appMenuId -> {
//
//                        sourceAppMenuList.addAll(filterAppMenu2Tree(appMenuId));
//                    });
//
//                    log.info("service type id{} => app menu ids{}");
//
//                } else {
//                    log.info("service type id {} 没有后台权限");
//                }
//            });
//        }
//
////        log.info(JsonUtils.toPrettyJson(serviceId2AppMenuId));
//        log.info("到得菜单权限为 size({}) \n{}", sourceAppMenuList.size(), JsonUtils.toJson(sourceAppMenuList));
//
//
//        deDuplicationAppMenuList = filterAppRole(sourceAppMenuList);
//        log.info("过滤菜单权限为 size({}) \n{}", deDuplicationAppMenuList.size(), JsonUtils.toJson(deDuplicationAppMenuList));
//
//        return deDuplicationAppMenuList;
//
//    }

//    private List<AppMenuEntity> filterAppRole(List<AppMenuEntity> maybeRepeat) {
//
//        // 临时存储
//        List<Integer> tempIds = new ArrayList<>();
//
//        return maybeRepeat.stream().filter(entity -> {
//            boolean isExist = !tempIds.contains(entity.getId());
//            tempIds.add(entity.getId());
//            return isExist;
//        }).collect(Collectors.toList());
//
//
//    }


//    /**
//     * 第一步 得到 全部 项目管理员 角色
//     *
//     * @return
//     */
//    private List<AppRoleEntity> selectAppRoleByAppRoleType3() {
//        /**
//         * 角色类型
//         * 超级管理员=>1
//         * 系统管理员=>2
//         * 项目管理员=>3
//         * 项目普通管理员=>4
//         * 运营中心管理员=>6
//         * 运营中心普通管理员=>7
//         * 运营商管理员=>20
//         * 渠道商管理员=>21
//         * 运营商操作员=>22
//         * 渠道商操作员=>23
//         */
////        List<AppRoleEntity> appUserXRoleResult = appRoleEntityMapper.findAppRoleByAppUserIdAndRoleType(GlobalConstant.UserType.ORG_TYPE.type, null);
////        return appUserXRoleResult;
//
//
//        AppRoleEntity conditions = new AppRoleEntity();
//        conditions.setType(GlobalConstant.UserType.ORG_TYPE.type);
//        List<AppRoleEntity> appRoleResult = appRoleEntityMapper.select(conditions);
//
//        return appRoleResult;
//    }

    /**
     * 查出 app_role x app_menu
     *
     * @param appRoleId
     * @return
     */
    private List<AppRoleFunctionEntity> selectAppRoleXAppMenuByAppRoleId(Integer appRoleId) {

//        SELECT * FROM `tb_app_role_function` WHERE `role_id` = 9143 ORDER BY function_id ASC

        AppRoleFunctionEntity conditions = new AppRoleFunctionEntity();

        conditions.setRoleId(appRoleId);

        List<AppRoleFunctionEntity> appRoleXFunctionResult = appRoleFunctionEntityMapper.select(conditions);

        return appRoleXFunctionResult;
    }


//    private static List<AppMenuEntity>               appMenuTable;
//    private static Map<Integer, List<AppMenuEntity>> subAppMenuTree = new HashMap<>();
//
//    private void initAppMenuTable() {
//
//        if (CollectionUtils.isEmpty(appMenuTable)) {
//            appMenuTable = appMenuEntityMapper.selectAll();
//        }
//
//
//    }


    /**
     * 业务权限 时
     *
     * @param orgnizationId
     * @return
     */
    private List<ServiceOrgConfigEntity> selectServiceConfigByOrgnizationId(Integer orgnizationId) {

//        SELECT * FROM `tb_service_org_config`

        ServiceOrgConfigEntity conditions = new ServiceOrgConfigEntity();

        conditions.setOrgId(orgnizationId);

        /**
         * 状态:0-下线;1-上线;2-灰度
         */
        conditions.setStatus(1);
        /**
         * 类型:0-项目;1-企业
         */
        conditions.setType(0);
        conditions.setEnabled(1);

        List<ServiceOrgConfigEntity> result = serviceOrgConfigEntityMapper.select(conditions);

        return result;

    }


//    SELECT * FROM `tb_service_type_info` WHERE `link_url_type` = 0

//    SELECT soc.id,soc.service_type_id,sti.* FROM `tb_service_org_config` soc
//    LEFT JOIN tb_service_type_info sti ON  soc.`service_type_id` = sti.id AND sti.`link_url_type` = 0
//    WHERE
//    soc.`status` = 1
//    AND soc.`type` = 0
//    ORDER BY soc.org_id ASC

    /**
     * 某 app_menu 树根 的全部节点
     * @param appMenuidRoot
     * @return
     */
//    private List<AppMenuEntity> filterAppMenu2Tree(Integer appMenuidRoot) {
//
//        // 查出所有菜单放入内存
//        initAppMenuTable();
//
//        if (subAppMenuTree.containsKey(appMenuidRoot)) {
//
//            return subAppMenuTree.get(appMenuidRoot);
//
//        } else {
//
//            List<AppMenuEntity> result = new ArrayList<>();
//
//            List<AppMenuEntity> level1 = new ArrayList<>();
//            List<AppMenuEntity> level2 = new ArrayList<>();
//            List<AppMenuEntity> level3 = new ArrayList<>();
//
//            // 目录
//            level1.addAll(appMenuTable.stream().filter(e -> e.getId().equals(appMenuidRoot)).collect(Collectors.toList()));
//            // 菜单
//            level2.addAll(appMenuTable.stream().filter(e -> e.getParentCode().equals(appMenuidRoot)).collect(Collectors.toList()));
//            // 操作
//            level2.forEach(appMenuEntity -> {
//                level3.addAll(appMenuTable.stream().filter(e -> e.getParentCode().equals(appMenuEntity.getId())).collect(Collectors.toList()));
//            });
//
//            result.addAll(level1);
//            result.addAll(level2);
//            result.addAll(level3);
//
//            subAppMenuTree.put(appMenuidRoot, result);
//
//            return result;
//        }
//
//
//    }

}

过滤

package cn.superdesk.uniorder.utils.lamda;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * @Description: LamdaUtils
 * @Author: linjinyu
 * @CreateDate: 6/23/20 5:14 PM
 * @UpdateUser: linjinyu
 * @UpdateDate: 6/23/20 5:14 PM
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
public class LamdaUtils {

    /**
     * distinctByKey 自己定义 针对属性去重
     * <p>
     * usage:
     * List<InvoiceOrder> invoiceOrderList = invoiceOrderMapper.selectByExample(example);
     * <p>
     * if (CollectionUtils.isNotEmpty(invoiceOrderList)) {
     * // 得出受影响的对账单 ids
     * affectedAccountingOrderIds = invoiceOrderList.stream().filter(LamdaUtils.distinctByKey(o -> o.getDzId())).map(o -> o.getDzId()).collect(Collectors.toList());
     * }
     *
     * @param keyExtractor
     * @param <T>
     * @return
     */
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }


    public static <T extends Object> T filter(List<T> objs, Predicate<T> predicate) {
        return objs.stream()
                .filter(predicate)
                .findAny()
                .orElse(null);
    }


    /**
     * 根据多个判断条件, 对list数据按优先级排序
     * list 需要过滤的数据
     * predicates 多个判断条件
     */
    public static <T extends Object> List<T> filters(List<T> list, List<Predicate<T>> predicates) {

        List<T>   resultList = new ArrayList();
        Stream<T> stream     = list.stream();

        // 循环判断条件list
        for (int i = 0, psize = predicates.size(), lsize = list.size(); resultList.size() < lsize && i < psize; i++) {

            Predicate<T> predicate = predicates.get(i);
            // stream.filter 过滤掉 符合条件的, 同时把符合条件的添加到 待返回的list
            stream = stream.filter(e -> {
                if (predicate.test(e)) {
                    resultList.add(e);
                    return false;
                }
                return true;
            });
        }
        long count = stream.count();

        return resultList;
    }


}

package cn.superdesk.uniorder.service.base;


import cn.superdesk.libs.common.json.JsonUtils;
import cn.superdesk.libs.common.util.CollectionUtils;
import cn.superdesk.uniorder.dao.entity.base.*;
import cn.superdesk.uniorder.dao.mapper.base.UnifiedOrderCreditMapper;
import cn.superdesk.uniorder.dao.mapper.base.UnifiedOrderGoodsMapper;
import cn.superdesk.uniorder.utils.lamda.LamdaUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.function.Predicate;


/**
 * @Description: 重构 处理 合并数据 不写 interface
 * @Author: linjinyu
 * @CreateDate: 9/15/20 5:03 PM
 * @UpdateUser: linjinyu
 * @UpdateDate: 9/15/20 5:03 PM
 * @UpdateRemark: 修改内容
 * @Version: 1.0
 */
@Slf4j
@Service
public class CommonOrderProcessService {

    @Autowired
    private UnifiedOrderGoodsMapper  unifiedOrderGoodsMapper;
    @Autowired
    private UnifiedOrderCreditMapper unifiedOrderCreditMapper;

    /**
     * 处理 kdfka 重推单 问题
     *
     * @param unifiedOrderEntity
     * @param processUnifiedOrderGoodsList
     */
    public void processUnifiedOrderGoodsBykafkaPushOrderReceive(UnifiedOrder unifiedOrderEntity, List<UnifiedOrderGoods> processUnifiedOrderGoodsList) {


        // 一般订单
        // 有订单时 先删除在保存商品
//        unifiedOrderGoodsMapperEx.deleteBySn(unifiedOrder.getOrderSn());
//        for (UnifiedOrderGoods unifiedOrderGoods : unifiedOrderGoodsList) {
//            unifiedOrderGoodsMapper.insertSelective(unifiedOrderGoods);
//        }

        // 积分订单
        // 之前是先删除再 插入
//        UnifiedOrderGoodsExample scoreOrderGoodsExample4Delete = new UnifiedOrderGoodsExample();
//        scoreOrderGoodsExample4Delete.createCriteria()
//                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
//        unifiedOrderGoodsMapper.deleteByExample(scoreOrderGoodsExample4Delete);
//                processUnifiedOrderGoodsList.forEach(unifiedOrderGoods -> {
//                    unifiedOrderGoodsMapper.insert(unifiedOrderGoods);
//                });


        UnifiedOrderGoodsExample orderGoodsExample4SaveOrUpdate = new UnifiedOrderGoodsExample();
        orderGoodsExample4SaveOrUpdate.createCriteria()
                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
        List<UnifiedOrderGoods> existsUnifiedOrderGoodsList = unifiedOrderGoodsMapper.selectByExample(orderGoodsExample4SaveOrUpdate);

        log.error("\n\n\nOrderGoods: \n已存在数据 : \n{}\n过来的数据 : \n{}\n\n\n",
                JsonUtils.toJson(existsUnifiedOrderGoodsList),
                JsonUtils.toJson(processUnifiedOrderGoodsList)
        );

        List<UnifiedOrderGoods> finalUnifiedOrderGoodsList = new ArrayList<>();

        for (UnifiedOrderGoods processOrderGoods : processUnifiedOrderGoodsList) {

            /****************************************** 兼容 情况 ******************************************/

            // 新过来的数据在老的是不是存在 因为在 同一个 order_sn 下 goods_id 是唯一的 ,所以成立
            // TODO 问题点 如果有 附件 赠品 就会有问题
            UnifiedOrderGoods isExistsOrderGoods = null;

            boolean isRetry = false;

            // 逻辑是 运费 必定是不成立
            if (processOrderGoods.getOutSnapshotOrderGoodsId() != null && !processOrderGoods.getOutSnapshotOrderGoodsId().equals(0L)) {

                isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getOutSnapshotOrderGoodsId().equals(r.getOutSnapshotOrderGoodsId()));

                if (null == isExistsOrderGoods) {
                    isRetry = true;
                }

            } else {
                // 运费的补刀
                isRetry = true;
            }

            if (isRetry) {

                if(null != processOrderGoods.getGoodsId()){
                    isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getGoodsId().equals(r.getGoodsId()));
                }


                // 再补 202009151941 by linjinyu 发现 生产环境上 unified_order_goods.goods_id 是NULL  数据
                if (null == isExistsOrderGoods) {
                    isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getGoodsName().equals(r.getGoodsName()));
                }
            }

            /****************************************** 兼容 情况 ******************************************/

            // 存在
            if (null != isExistsOrderGoods) {

                // TODO 要更新什么信息 从而没问题?

                isExistsOrderGoods.setOutSnapshotOrderGoodsId(processOrderGoods.getOutSnapshotOrderGoodsId());
                isExistsOrderGoods.setGoodsId(processOrderGoods.getGoodsId());

                isExistsOrderGoods.setCateIdLv1(processOrderGoods.getCateIdLv1());
                isExistsOrderGoods.setCateIdLv1(processOrderGoods.getCateIdLv2());
                isExistsOrderGoods.setCateIdLv3(processOrderGoods.getCateIdLv3());

                isExistsOrderGoods.setCateNameLv1(processOrderGoods.getCateNameLv1());
                isExistsOrderGoods.setCateNameLv2(processOrderGoods.getCateNameLv2());
                isExistsOrderGoods.setCateNameLv3(processOrderGoods.getCateNameLv3());

                isExistsOrderGoods.setUnit(processOrderGoods.getUnit());

                isExistsOrderGoods.setTaxRate(processOrderGoods.getTaxRate());
                isExistsOrderGoods.setTaxCode(processOrderGoods.getTaxCode());
                isExistsOrderGoods.setFiscalCode(processOrderGoods.getFiscalCode());

//                unifiedOrderGoodsMapper.updateByPrimaryKeySelective(isExistsOrderGoods);

                finalUnifiedOrderGoodsList.add(isExistsOrderGoods);

            } else {

//                unifiedOrderGoodsMapper.insert(processOrderGoods);
                finalUnifiedOrderGoodsList.add(processOrderGoods);
            }


        }


        UnifiedOrderGoodsExample scoreOrderGoodsExample4Delete = new UnifiedOrderGoodsExample();
        scoreOrderGoodsExample4Delete.createCriteria()
                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
        unifiedOrderGoodsMapper.deleteByExample(scoreOrderGoodsExample4Delete);

        finalUnifiedOrderGoodsList.forEach(unifiedOrderGoods -> {
            unifiedOrderGoodsMapper.insert(unifiedOrderGoods);
        });
    }

    /**
     * 处理 kdfka 重推单 问题
     * <p>
     * 处理方法
     * kafkaUnifiedOrderReceive
     * kafkaScoreOrderReceive
     *
     * @param unifiedOrderEntity
     * @param processUnifiedOrderCreditList
     */
    public void processUnifiedOrderCreditBykafkaPushOrderReceive(UnifiedOrder unifiedOrderEntity, List<UnifiedOrderCredit> processUnifiedOrderCreditList) {

        // 积分订单
        // 之前是先删除再 插入
//        UnifiedOrderCreditExample scoreOrderCreditExample4Delete = new UnifiedOrderCreditExample();
//        scoreOrderCreditExample4Delete.createCriteria()
//                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
//        unifiedOrderCreditMapper.deleteByExample(scoreOrderCreditExample4Delete);
//        processUnifiedOrderCreditList.forEach(unifiedOrderCredit -> {
//            unifiedOrderCreditMapper.insert(unifiedOrderCredit);
//        });


        UnifiedOrderCreditExample scoreOrderCreditExample4SaveOrUpdate = new UnifiedOrderCreditExample();

        scoreOrderCreditExample4SaveOrUpdate.createCriteria()
                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
        List<UnifiedOrderCredit> existsUnifiedOrderCreditList = unifiedOrderCreditMapper.selectByExample(scoreOrderCreditExample4SaveOrUpdate);

        log.error("\n\n\nOrderCredit: \n已存在数据 : \n{}\n过来的数据 : \n{}\n\n\n",
                JsonUtils.toJson(existsUnifiedOrderCreditList),
                JsonUtils.toJson(processUnifiedOrderCreditList)
        );

        List<UnifiedOrderCredit> finalUnifiedOrderCreditList= new ArrayList<>();

        for (UnifiedOrderCredit processOrderCredit : processUnifiedOrderCreditList) {

            /****************************************** 情况1 ******************************************/


            // 新过来的数据在老的是不是存在
            List<UnifiedOrderCredit> isExistsOrderCreditList = null;
            UnifiedOrderCredit       isExistsOrderCredit     = null;


            boolean isRetry = false;

            if (processOrderCredit.getOutSnapshotOrderCreditId() != null && !processOrderCredit.getOutSnapshotOrderCreditId().equals(0L)) {

                isExistsOrderCredit = LamdaUtils.filter(existsUnifiedOrderCreditList, r -> processOrderCredit.getOutSnapshotOrderCreditId().equals(r.getOutSnapshotOrderCreditId()));

                if (null == isExistsOrderCredit) {
                    isRetry = true;
                }
            } else {
                isRetry = true;
            }

            if (isRetry) {
//                // 查询条件 如果 goods_id 为 0 条数大于 1 是会有问题 0 默认只有运费 , 如果 附件与赠品过来的情况 就会有问题,具体的问题再写吧
                List<Predicate<UnifiedOrderCredit>> predicates = new ArrayList();


                predicates.add(r -> processOrderCredit.getCreditType().equals(r.getCreditType()));
                predicates.add(r -> processOrderCredit.getCreditName().equals(r.getCreditName()));

                predicates.add(r -> processOrderCredit.getGoodsId().equals(r.getGoodsId()));

//                predicates.add(r -> processOrderCredit.getBalance().equals(r.getBalance()));
//                predicates.add(r -> NumberUtil.compare(processOrderCredit.getBalance(),r.getBalance()));
                predicates.add(r -> processOrderCredit.getBalance().compareTo(r.getBalance()) == 0);


                predicates.add(r -> processOrderCredit.getBatchs().equals(r.getBatchs()));
//
//                // 新过来的数据在老的是不是存在
                isExistsOrderCreditList = LamdaUtils.filters(existsUnifiedOrderCreditList, predicates);


//                isExistsOrderCredit = LamdaUtils.filter(existsUnifiedOrderCreditList, r -> processOrderCredit.getGoodsId().equals(r.getGoodsId()));
            }


            /****************************************** 情况1 ******************************************/

            // 存在

            if (null != isExistsOrderCredit) {

                // TODO 好像没什么好更新的
                isExistsOrderCredit.setCreditType(processOrderCredit.getCreditType());
                isExistsOrderCredit.setCreditName(processOrderCredit.getCreditName());

                isExistsOrderCredit.setOutSnapshotOrderCreditId(processOrderCredit.getOutSnapshotOrderCreditId());
                isExistsOrderCredit.setGoodsId(processOrderCredit.getGoodsId());

                isExistsOrderCredit.setDailyAccountType(processOrderCredit.getDailyAccountType());
                isExistsOrderCredit.setBatchs(processOrderCredit.getBatchs());
                isExistsOrderCredit.setBalance(processOrderCredit.getBalance());
                isExistsOrderCredit.setEnterpriseId(processOrderCredit.getEnterpriseId());
                isExistsOrderCredit.setMemberId(processOrderCredit.getMemberId());

                processOrderCredit.setPayStatus(processOrderCredit.getPayStatus());
                processOrderCredit.setPayType(processOrderCredit.getPayType());

                isExistsOrderCredit.setUpdateUserId(2L);
                isExistsOrderCredit.setUpdateTime(new Date());

//                unifiedOrderCreditMapper.updateByPrimaryKeySelective(isExistsOrderCredit);
                finalUnifiedOrderCreditList.add(isExistsOrderCredit);

            } else {
//                unifiedOrderCreditMapper.insert(processOrderCredit);
//
                finalUnifiedOrderCreditList.add(processOrderCredit);
            }

            if (CollectionUtils.isNotEmpty(isExistsOrderCreditList) && isRetry) {

                // TODO 怎样合并呢?
                if (isExistsOrderCreditList.size() > 1) {

                } else if (isExistsOrderCreditList.size() == 1){

                    isExistsOrderCredit = isExistsOrderCreditList.get(0);

                    isExistsOrderCredit.setCreditName(processOrderCredit.getCreditName());
                    isExistsOrderCredit.setOutSnapshotOrderCreditId(processOrderCredit.getOutSnapshotOrderCreditId());
                    isExistsOrderCredit.setUpdateUserId(3L);
                    isExistsOrderCredit.setUpdateTime(new Date());

//                    unifiedOrderCreditMapper.updateByPrimaryKeySelective(isExistsOrderCredit);

                    finalUnifiedOrderCreditList.add(isExistsOrderCredit);
                }

            }

        }

        UnifiedOrderCreditExample scoreOrderCreditExample4Delete = new UnifiedOrderCreditExample();
        scoreOrderCreditExample4Delete.createCriteria()
                .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
        unifiedOrderCreditMapper.deleteByExample(scoreOrderCreditExample4Delete);
        finalUnifiedOrderCreditList.forEach(unifiedOrderCredit -> {
            unifiedOrderCreditMapper.insert(unifiedOrderCredit);
        });
    }
}

请先后发表评论
  • 最新评论
  • 总共0条评论