Collectors.groupingBy()

最新推荐文章于 2023-12-05 11:09:04 发布
最新推荐文章于 2023-12-05 11:09:04 发布
阅读量297 收藏
点赞数
文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60948956/article/details/133982832
版权 
List.stream().collect(Collectors.groupingBy(e -> e.getZshm() + e.getZszw() + e.getZszt()))

 

package org.jeecg.modules.quota.xxljob;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.annotation.XxlJob;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.quota.entity.ChuanYuan;
import org.jeecg.modules.quota.entity.ChuanYuanZhengShu;
import org.jeecg.modules.quota.entity.JcYc;
import org.jeecg.modules.quota.entity.SysCertPdf;
import org.jeecg.modules.quota.entity.cnfaidata.DsCyzsxx;
import org.jeecg.modules.quota.entity.cnfaidata.DsYcjbxx;
import org.jeecg.modules.quota.service.*;
import org.jeecg.modules.quota.utils.RequestYxeUtil;
import org.jeecg.modules.system.mapper.SysDictMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 渔船、证书、船员+证书，数据接口同步
 */
@Component
@Slf4j
public class JcYcJobHandler {
    private static final String YC_MAX_TIME = "yc_max_time";
    private static final String CYZSXX_MAX_TIME = "cyzsxx_max_time";
    private static final String CYXX_MAX_TIME = "cyxx_max_time";
    @Autowired
    private IJcYcService jcYcService;
    @Autowired
    private IDsYcjbxxService dsYcjbxxService;
    @Autowired
    private IChuanYuanZhengShuService chuanYuanZhengShuService;
    @Autowired
    private IDsCyzsxxService dsCyzsxxService;
    @Autowired
    private SysDictMapper sysDictMapper;
    @Autowired
    private IChuanYuanService chuanYuanService;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private ISysCertPdfService sysCertPdfService;
    @Value(value = "${jeecg.uploadType}")
    private String uploadType;

    /**
     * 基础渔船信息同步
     * @return
     * @throws ParseException
     */
    @XxlJob(value = "ycjbxx")
    public ReturnT<String> ycjbxx(String params) throws Exception {

        String ycMaxTime = dsYcjbxxService.queryMaxTime();
        if (redisTemplate.hasKey(YC_MAX_TIME)) {
            String redisYcTime = (String) redisTemplate.opsForValue().get(YC_MAX_TIME);
            if (redisYcTime != null && !redisYcTime.equals(ycMaxTime)) {
                ArrayList<JcYc> updateList = new ArrayList<>();
                ArrayList<JcYc> insertList = new ArrayList<>();
                //需要同步的鱼小二 数据
                QueryWrapper<DsYcjbxx> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("YCSZDQMC", "苍南县");
                List<DsYcjbxx> dsYcjbxxList = dsYcjbxxService.list(queryWrapper);
                List<JcYc> jcYcList = jcYcService.list();
                Map<String, List<JcYc>> jcYcMap = jcYcList.stream().collect(Collectors.groupingBy(JcYc::getId));
                for (DsYcjbxx dsYcjbxx : dsYcjbxxList) {
                    if (jcYcMap.get(dsYcjbxx.getId()) != null && !jcYcMap.get(dsYcjbxx.getId()).isEmpty()) {
                        JcYc jcYc = jcYcMap.get(dsYcjbxx.getId()).get(0);
                        if ("修改记录".equals(dsYcjbxx.getGxcz())) {
                            // 数据已存在，执行更新操作
                            jcYc.setYcssd(dsYcjbxx.getYcszdqdm());
                            jcYc.setCjg(dsYcjbxx.getCjgcn());
                            jcYc.setZycs(dsYcjbxx.getZycs());
                            jcYc.setSyzxm(dsYcjbxx.getCbsyrmc());
                            jcYc.setSyzdz(dsYcjbxx.getCbsyrdz());
                            jcYc.setSyzdh(dsYcjbxx.getCbsyrdh());
                            jcYc.setYzbm(dsYcjbxx.getYzbm());
                            updateList.add(jcYc);
                            System.out.println("基础渔船信息同步,数据已更新: cm=" + jcYc.getCm());
                        } else if ("删除记录".equals(dsYcjbxx.getGxcz())) {
                            jcYc.setDelFlag(1);
                            updateList.add(jcYc);
                            System.out.println("基础渔船信息同步,数据已删除: cm=" + jcYc.getCm());
                        }
                    } else {
                        // 数据不存在，执行插入操作
                        JcYc jcYcNew = new JcYc();
                        jcYcNew.setSysOrgCode("A01");
                        jcYcNew.setId(dsYcjbxx.getId());
                        jcYcNew.setCm(dsYcjbxx.getCm());
                        jcYcNew.setYcm(dsYcjbxx.getYcm());
                        jcYcNew.setYcssd(dsYcjbxx.getYcszdqdm());
                        jcYcNew.setCjg(dsYcjbxx.getCjgcn());
                        jcYcNew.setZccmc(dsYcjbxx.getZccmc());
                        jcYcNew.setZccyw(dsYcjbxx.getZccyw());
                        jcYcNew.setZccdz(dsYcjbxx.getZccdz());
                        jcYcNew.setZccdzyw(dsYcjbxx.getZccdzyw());
                        jcYcNew.setCc(dsYcjbxx.getCc());
                        jcYcNew.setXk(dsYcjbxx.getXk());
                        jcYcNew.setXs(dsYcjbxx.getXs());
                        jcYcNew.setZdw(dsYcjbxx.getZdw());
                        jcYcNew.setJdw(dsYcjbxx.getJdw());
                        jcYcNew.setZjzgl(dsYcjbxx.getZjzgl());
                        String ctcz = dsYcjbxx.getCtcz();
                        if (BeanUtil.isNotEmpty(ctcz)) {
                            //限额捕捞_渔船管理_船体材质
                            String valByText = sysDictMapper.getValByText("1682656333384515586", ctcz);
                            jcYcNew.setCtcz(Integer.valueOf(valByText));
                        }
                        String jzwgrq = dsYcjbxx.getJzwgrq();
                        if (BeanUtil.isNotEmpty(jzwgrq)) {
                            //String转Date
                            Date date = new SimpleDateFormat("yyyy-MM-dd").parse(jzwgrq);
                            jcYcNew.setJzwgrq(date);
                        }
                        jcYcNew.setCbhh(dsYcjbxx.getCbhhsbm());
                        String zylx = dsYcjbxx.getZylx();
                        if (BeanUtil.isNotEmpty(zylx)) {
                            //限额捕捞_渔船管理_作业类型
                            String valByText = sysDictMapper.getValByText("1683404442990235649", zylx);
                            jcYcNew.setZylx(Integer.valueOf(valByText));
                        }
                        jcYcNew.setZyfs(dsYcjbxx.getZyfs());
                        jcYcNew.setZyfs2(dsYcjbxx.getZyfs2());
                        jcYcNew.setZycs(dsYcjbxx.getZycs());
                        jcYcNew.setSyzxm(dsYcjbxx.getCbsyrmc());
                        jcYcNew.setSyzdz(dsYcjbxx.getCbsyrdz());
                        jcYcNew.setSyzdh(dsYcjbxx.getCbsyrdh());
                        jcYcNew.setYzbm(dsYcjbxx.getYzbm());
                        jcYcNew.setBlxkzbh(dsYcjbxx.getBlxkzbh());
                        jcYcNew.setCbjyzsbh(dsYcjbxx.getCbjyzsbh());
                        jcYcNew.setGjdjzsbh(dsYcjbxx.getGjdjzsbh());
                        jcYcNew.setSyqzsbh(dsYcjbxx.getSyqzsbh());
                        jcYcNew.setZxdjbh(dsYcjbxx.getZxdjbh());
                        jcYcNew.setCwpzsbh(dsYcjbxx.getCwgjzbpzsbh());
                        String cbzl = dsYcjbxx.getCbzl();
                        if (BeanUtil.isNotEmpty(cbzl)) {//字典
                            //限额捕捞_渔船管理_渔船种类
                            String valByText = sysDictMapper.getValByText("1683369911311855617", cbzl);
                            jcYcNew.setYclx(Integer.valueOf(valByText));
                        }
                        jcYcNew.setHh(dsYcjbxx.getHh());
                        jcYcNew.setJwm(dsYcjbxx.getCbsbm());
                        jcYcNew.setCmhzsbh(dsYcjbxx.getCmhzsbh());
                        jcYcNew.setYcbm(dsYcjbxx.getYcbm());
                        jcYcNew.setDelFlag(0);
                        jcYcNew.setSfzqybh(dsYcjbxx.getCbsyrsfzhmhqyzch());
                        jcYcNew.setYcid(dsYcjbxx.getId());
                        jcYcNew.setYyzzmc(dsYcjbxx.getYyzzmc());
                        insertList.add(jcYcNew);
                        System.out.println("基础渔船信息同步,数据已新增: cm=" + jcYcNew.getCm());
                    }
                }
                jcYcService.updateBatchById(updateList);
                jcYcService.saveBatch(insertList);
                redisTemplate.opsForValue().set(YC_MAX_TIME, ycMaxTime);

                //更新渔船照片
                List<JcYc> list = jcYcService.list();
                for (JcYc jcYc : list) {
                    ArrayList<SysCertPdf> sysCertPdfs = RequestYxeUtil.xeblCertificate(jcYc.getCm(), jcYc.getYcid(), uploadType);
                    for (SysCertPdf sysCertPdf : sysCertPdfs) {
                        SysCertPdf sysCertPdfOld = sysCertPdfService.getFileNameByValue(sysCertPdf.getModelName(), sysCertPdf.getCertId());
                        if (BeanUtil.isNotEmpty(sysCertPdfOld)){
                            BeanUtil.copyProperties(sysCertPdf,sysCertPdfOld,"id");
                            sysCertPdfService.updateById(sysCertPdfOld);
                        }else {
                            sysCertPdfService.save(sysCertPdf);
                        }
                    }
                }
            }
        } else {
            redisTemplate.opsForValue().set(YC_MAX_TIME, ycMaxTime);
        }
        return ReturnT.SUCCESS;
    }

    /**
     * 船员证书信息数据同步
     * @return
     */
    @XxlJob(value = "cyzsxx")
    public ReturnT<String> cyzsxx(String params) {

        String cyszxxMaxTime = dsCyzsxxService.queryMaxTime();
        if (redisTemplate.hasKey(CYZSXX_MAX_TIME)) {
            String redisCyzsxxTime = (String) redisTemplate.opsForValue().get(CYZSXX_MAX_TIME);
            if (redisCyzsxxTime != null && !redisCyzsxxTime.equals(cyszxxMaxTime)) {
                ArrayList<ChuanYuanZhengShu> updateList = new ArrayList<>();
                ArrayList<ChuanYuanZhengShu> insertList = new ArrayList<>();
                //鱼小二船员证书表
                List<DsCyzsxx> dsCyzsxxList = dsCyzsxxService.list();
                //本项目船员证书表
                List<ChuanYuanZhengShu> chuanYuanZhengShuList = chuanYuanZhengShuService.list();
                //将本项目船员证书表数据通过证书号码证书职务证书状态进行分组
                Map<String, List<ChuanYuanZhengShu>> chuanYuanZhengShuMap = chuanYuanZhengShuList.stream().collect(Collectors.groupingBy(e -> e.getZshm() + e.getZszw() + e.getZszt()));
                for (DsCyzsxx dsCyzsxx : dsCyzsxxList) {
                    if (chuanYuanZhengShuMap.get(dsCyzsxx.getZshm() + dsCyzsxx.getZszw() + dsCyzsxx.getZszt()) != null && !chuanYuanZhengShuMap.get(dsCyzsxx.getZshm() + dsCyzsxx.getZszw() + dsCyzsxx.getZszt()).isEmpty()) {
                        ChuanYuanZhengShu chuanYuanZhengShu = chuanYuanZhengShuMap.get(dsCyzsxx.getZshm() + dsCyzsxx.getZszw() + dsCyzsxx.getZszt()).get(0);
                        // 更新操作
                        updateList.add(chuanYuanZhengShu);
                        System.out.println("船员证书信息数据同步,数据已更新: zshm=" + chuanYuanZhengShu.getZshm());
                    } else {
                        // 新增操作
                        // 数据不存在，执行插入操作
                        ChuanYuanZhengShu cyzsNew = new ChuanYuanZhengShu();
                        cyzsNew.setSysOrgCode("A01");
                        cyzsNew.setSfzhm(dsCyzsxx.getSfzhm());
                        cyzsNew.setXm(dsCyzsxx.getXm());
                        cyzsNew.setXmpy(dsCyzsxx.getXmpy());
                        cyzsNew.setXb(dsCyzsxx.getXb());
                        cyzsNew.setCsrq(dsCyzsxx.getCsrq());
                        cyzsNew.setHjsf(dsCyzsxx.getHjsf());
                        cyzsNew.setHjcs(dsCyzsxx.getHjcs());
                        cyzsNew.setHjdz(dsCyzsxx.getHjdz());
                        cyzsNew.setZslx(dsCyzsxx.getZslx());
                        cyzsNew.setLbdm(dsCyzsxx.getLbdm());
                        cyzsNew.setZszldm(dsCyzsxx.getZszldm());
                        cyzsNew.setZsdj(dsCyzsxx.getZsdj());
                        cyzsNew.setZszw(dsCyzsxx.getZszw());
                        cyzsNew.setSycb(dsCyzsxx.getSycb());
                        cyzsNew.setZshm(dsCyzsxx.getZshm());
                        cyzsNew.setQfjg(dsCyzsxx.getQfjg());
                        cyzsNew.setQfgyxm(dsCyzsxx.getQfgyxm());
                        cyzsNew.setQfrq(dsCyzsxx.getQfrq());
                        cyzsNew.setDyrq(dsCyzsxx.getQfrq());
                        cyzsNew.setJzrq(dsCyzsxx.getJzrq());
                        cyzsNew.setZszt(dsCyzsxx.getZszt());
                        cyzsNew.setDahm(dsCyzsxx.getDahm());
                        insertList.add(cyzsNew);
                        System.out.println("船员证书信息数据同步,数据已新增: zshm=" + cyzsNew.getZshm());
                    }
                }
                chuanYuanZhengShuService.updateBatchById(updateList);
                chuanYuanZhengShuService.saveOrUpdateBatch(insertList);
                redisTemplate.opsForValue().set(CYZSXX_MAX_TIME, cyszxxMaxTime);
            }
        } else {
            redisTemplate.opsForValue().set(CYZSXX_MAX_TIME, cyszxxMaxTime);
        }
        return ReturnT.SUCCESS;
    }

    /**
     * 船员信息同步
     * @return
     */
    @XxlJob(value = "cyxx")
    public ReturnT<String> cyxx(String params) throws Exception {

        String cyxxMaxTime = dsCyzsxxService.queryMaxTime();
        if (redisTemplate.hasKey(CYXX_MAX_TIME)) {
            String redisCyxxTime = (String) redisTemplate.opsForValue().get(CYXX_MAX_TIME);
            if (redisCyxxTime != null && !redisCyxxTime.equals(cyxxMaxTime)) {
                ArrayList<ChuanYuan> updateList = new ArrayList<>();
                ArrayList<ChuanYuan> insertList = new ArrayList<>();
                QueryWrapper<DsCyzsxx> queryWrapperCy = new QueryWrapper<>();
                queryWrapperCy.groupBy("SFZHM");
                //鱼小二证书数据
                List<DsCyzsxx> dsYcjbxxesCy = dsCyzsxxService.list(queryWrapperCy);
                //船员数据
                List<ChuanYuan> chuanYuanList = chuanYuanService.list();
                Map<String, List<ChuanYuan>> ycMap = chuanYuanList.stream().collect(Collectors.groupingBy(ChuanYuan::getSfzhm));
                for (DsCyzsxx cyzsxx : dsYcjbxxesCy) {
                    if (ycMap.get(cyzsxx.getSfzhm()) != null && !ycMap.get(cyzsxx.getSfzhm()).isEmpty()) {
                        ChuanYuan chuanYuan = ycMap.get(cyzsxx.getSfzhm()).get(0);
                        // 更新操作
                        chuanYuan.setYxbz(cyzsxx.getZszt());
                        updateList.add(chuanYuan);
                        System.out.println("船员信息数据同步,数据已更新: sfzhm=" + chuanYuan.getSfzhm());
                    } else {
                        ChuanYuan cyNew = new ChuanYuan();
                        cyNew.setSysOrgCode("A01");
                        cyNew.setSfzhm(cyzsxx.getSfzhm());
                        cyNew.setXm(cyzsxx.getXm());
                        cyNew.setXmpy(cyzsxx.getXmpy());
                        cyNew.setXb(cyzsxx.getXb());
                        cyNew.setCsrq(cyzsxx.getCsrq());
                        cyNew.setHjsf(cyzsxx.getHjsf());
                        cyNew.setHjcs(cyzsxx.getHjcs());
                        cyNew.setHjqx(cyzsxx.getHjxq());
                        cyNew.setHjdz(cyzsxx.getHjdz());
                        cyNew.setYxbz(cyzsxx.getZszt());
                        insertList.add(cyNew);
                        System.out.println("船员证书信息数据同步,数据已新增: zshm=" + cyNew.getSfzhm());
                    }
                }
                chuanYuanService.updateBatchById(updateList);
                chuanYuanService.saveOrUpdateBatch(insertList);
                redisTemplate.opsForValue().set(CYXX_MAX_TIME, cyxxMaxTime);

                //一网通办获取token同步船员照片等
                List<ChuanYuan> list = chuanYuanService.list();
                for (ChuanYuan chuanYuan : list) {
                    SysCertPdf sysCertPdf = RequestYxeUtil.xeblCyzp(chuanYuan.getSfzhm(), uploadType);
                    if (BeanUtil.isNotEmpty(sysCertPdf)) {
                        SysCertPdf sysCertPdfOld = sysCertPdfService.getFileNameByValue(sysCertPdf.getModelName(), sysCertPdf.getCertId());
                        if (BeanUtil.isNotEmpty(sysCertPdfOld)){
                            BeanUtil.copyProperties(sysCertPdf,sysCertPdfOld,"id");
                            sysCertPdfService.updateById(sysCertPdfOld);
                        }else {
                            sysCertPdfService.save(sysCertPdf);
                        }
                    }
                }
            }
        } else {
            redisTemplate.opsForValue().set(CYXX_MAX_TIME, cyxxMaxTime);
        }
        return ReturnT.SUCCESS;
    }
}

package org.jeecg.modules.quota.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.util.MinioUtil;
import org.jeecg.common.util.ZOSUtil;
import org.jeecg.modules.quota.controller.DataSynchronismController;
import org.jeecg.modules.quota.entity.SysCertPdf;
import org.jeecg.modules.quota.service.ISysCertPdfService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author leitao
 * @Date 2023/9/21 15:28
 * @description: 请求鱼小二工具类
 * @Title: RequestYxeUtil
 * @Package org.jeecg.modules.quota.utils
 */
public class RequestYxeUtil {
    //    private static final String token_url = "http://2xx.x.xx.xx3:xx99/cnfai/oauth/token?clientId=2c9fb2a67c642bd2017c642bd21c0000&clientSecret=6ab3e8291b9af57c7ac4457bc60e0d2e0b08a8b9828c6e9d86250458b4de51bf82d9604abeb987d3";
    //token（线上）鱼小二
    private static final String token_url = "http://2xx.x.xx.xx3:xx99/cnfai/oauth/token?clientId=2c9fb2a67c642bd2017c642bd21c0000&clientSecret=6ab3e8291b9af57c7ac4457bc60e0d2e0b08a8b9828c6e9d86250458b4de51bf82d9604abeb987d3";
    //鱼小二获取渔船照片证据
    private static final String XeblCertificate_url = "http://2xx.x.xx.xx3:xx99/cnfai/services/certificateApi/XeblCertificate";

    //token（一网通办）
    private static final String XeblCyzp_token_url = "http://2xx.x.xx.xx3:xx99/cnfai//oauth/token";

    //获取船员照片
    private static final String XeblCyzp_url = "http://2xx.x.xx.xx3:xx99/cnfai//services/CyService/getCyPhoto";

    /**
     * 限额捕捞获取渔船证书
     *
     * @param cm
     * @param ycid
     * @throws IOException
     */
    public static ArrayList<SysCertPdf> xeblCertificate(String cm, String ycid, String uploadType) throws Exception {
        ArrayList<SysCertPdf> sysCertPdfs = new ArrayList<>();
        String requestResult = HttpRequest.post(token_url).execute().body();
        JSONObject jsonResult = JSONUtil.parseObj(requestResult);
        String code = jsonResult.getStr("code");
        if ("0".equals(code)) {
            String result = jsonResult.getStr("result");
            JSONObject resultJson = JSONUtil.parseObj(result);
            String accessToken = resultJson.getStr("accessToken");

            //限额捕捞获取渔船证书
            HashMap<String, Object> paramMap = new HashMap<>();
            paramMap.put("shipName", cm);
            paramMap.put("shipInfoId", ycid);
            String xeblCertificateResult = HttpRequest.post(XeblCertificate_url)
                    .header("X-Access-Token", accessToken)
                    .body(JSONUtil.toJsonPrettyStr(paramMap)).execute().body();
            JSONObject jsonObject = JSONUtil.parseObj(xeblCertificateResult);
            String code1 = jsonObject.getStr("code");
            if ("200".equals(code1)) {
                //将result转成JSONObject
                JSONObject json_result = jsonObject.getJSONObject("result");
                Map<String, Object> map = JSONUtil.parseObj(json_result);

                Map<String, SysCertPdf> sysCertPdfMap = new HashMap<>();

                Object pngCert = map.get("pngCert");
                if (pngCert instanceof JSONArray) {
                    JSONArray jsonArray = (JSONArray) pngCert;
                    for (Object o : jsonArray) {
                        Map<String, Object> pngCertMap = (Map<String, Object>) o;
                        for (String value : pngCertMap.keySet()) {
                            SysCertPdf sysCertPdf = new SysCertPdf();
                            String base64 = (String) pngCertMap.get(value);
                            MultipartFile pngMultipartFile = Base64ToMultipartFileConverter.convert(base64, ycid + ".png");
                            uploadFile(pngMultipartFile, value, "png", ycid, uploadType, sysCertPdf);
                            sysCertPdfMap.put(value, sysCertPdf);
                        }
                    }
                }
                Object pdfCert = map.get("pdfCert");
                if (pdfCert instanceof JSONArray) {
                    JSONArray jsonArray = (JSONArray) pdfCert;
                    for (Object o : jsonArray) {
                        Map<String, Object> pngCertMap = (Map<String, Object>) o;
                        for (String value : pngCertMap.keySet()) {
                            String base64 = (String) pngCertMap.get(value);
                            MultipartFile pdfMultipartFile = Base64ToMultipartFileConverter.convert(base64, ycid + ".pdf");
                            uploadFile(pdfMultipartFile, value, "pdf", ycid, uploadType, sysCertPdfMap.get(value));
                        }
                    }
                }
                for (String s : sysCertPdfMap.keySet()) {
                    sysCertPdfs.add(sysCertPdfMap.get(s));
                }
            }

        }
        return sysCertPdfs;
    }

    /**
     * 将文件上传到服务器
     *
     * @param multipartFile
     * @param value
     * @param type
     * @param ycid
     * @param uploadType
     * @param sysCertPdf
     * @return
     * @throws Exception
     */
    public static SysCertPdf uploadFile(MultipartFile multipartFile, String value, String type, String ycid, String uploadType, SysCertPdf sysCertPdf) throws Exception {
        String bizPath = "pdfCert" + "/" + value;
        String fileUrl = " ";
        if ("png".equals(type)) {
            if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
                fileUrl = MinioUtil.upload(multipartFile, bizPath);
                fileUrl = fileUrl.substring(1, fileUrl.length());
                //保存文件信息
                // 获取文件名
                sysCertPdf.setModelName(value);
                sysCertPdf.setPngPath(fileUrl);
                sysCertPdf.setCertId(ycid);
                sysCertPdf.setCertType(1);
                sysCertPdf.setDeleted(0);
                return sysCertPdf;
            } else if (CommonConstant.UPLOAD_TYPE_ZOS.equals(uploadType)) {
                fileUrl = ZOSUtil.upload(multipartFile, bizPath);
                sysCertPdf.setModelName(value);
                sysCertPdf.setPngPath(fileUrl);
                sysCertPdf.setCertId(ycid);
                sysCertPdf.setCertType(1);
                sysCertPdf.setDeleted(0);
                return sysCertPdf;
            }
        } else if ("pdf".equals(type)) {
            if (BeanUtil.isNotEmpty(sysCertPdf)) {
                if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
                    fileUrl = MinioUtil.upload(multipartFile, bizPath);
                    //保存文件信息
                    // 获取文件名
                    sysCertPdf.setPdfPath(fileUrl);
                    return sysCertPdf;
                } else if (CommonConstant.UPLOAD_TYPE_ZOS.equals(uploadType)) {
                    fileUrl = ZOSUtil.upload(multipartFile, bizPath);
                    sysCertPdf.setPdfPath(fileUrl);
                    return sysCertPdf;
                }
            }
        }

        return null;
    }

    /**
     * 将文件保存到本地
     *
     * @param file
     * @param type
     * @param value
     * @param ycid
     * @throws IOException
     */
    public static void saveFileToLocal(MultipartFile file, String type, String value, String ycid) throws IOException {
        String fileName = file.getOriginalFilename();
        String filePath = "E:\\workspace\\" + fileName + "." + type;
        String filePath1 = "E:\\workspace\\" + "pdfCert" + "/" + value + "/" + ycid + "." + type;
        File localFile = new File(filePath1);
        // 文件名
        if (!localFile.getParentFile().exists()) {
            localFile.getParentFile().mkdirs();// 新建目录
        }
        file.transferTo(localFile);
    }

    /**
     * 根据船只身份证查询照片
     *
     * @param sfzhm
     * @param uploadType
     * @return
     */
    public static SysCertPdf xeblCyzp(String sfzhm, String uploadType) throws Exception {
        //
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("clientId", "402881fXXXXXXXXXXc27e00001");
        paramMap.put("clientSecret", "482978cf5bcb08bc51dcec5b680ccXXXXXXXXXXXXXXXXXXXfc894ccff5ff54ceef53cfde562");

        String requestResult = HttpRequest.post(XeblCyzp_token_url).form(paramMap)
                .execute().body();
        JSONObject jsonResult = JSONUtil.parseObj(requestResult);

        String code = jsonResult.getStr("code");
        if ("0".equals(code)) {
            String result = jsonResult.getStr("result");
            JSONObject resultJson = JSONUtil.parseObj(result);
            String accessToken = resultJson.getStr("accessToken");
            String[] str = new String[]{sfzhm};
            String xeblCyzpUrlResult = HttpRequest.post(XeblCyzp_url)
                    .header("X-Access-Token", accessToken)
                    .body(Arrays.toString(str)).execute().body();
            JSONObject jsonObject = JSONUtil.parseObj(xeblCyzpUrlResult);
            String code1 = jsonObject.getStr("code");
            if ("200".equals(code1)) {
                String str_result = jsonObject.getStr("result");
                Map<String, String> collect = Arrays.stream(str_result.split(",")).collect(Collectors.toMap((e -> e.split(":")[0]), (e -> e.split(":")[1])));
                StringBuilder stringBuilder = new StringBuilder();
                StringBuilder append = stringBuilder.append("[{\"").append(sfzhm).append("\"");
                String sfzhmBase64 = collect.get(append.toString());
                String substring = sfzhmBase64.substring(1,sfzhmBase64.length()-3);
                MultipartFile jpgMultipartFile = Base64ToMultipartFileConverter.convert(substring, sfzhm + ".jpg");
                return uploadCyPhoto(jpgMultipartFile, sfzhm, uploadType);
            }
        }

        return null;
    }

    /**
     * 上传船员照片
     * @param jpgMultipartFile
     * @param sfzhm
     * @param uploadType
     * @return
     * @throws Exception
     */
    private static SysCertPdf uploadCyPhoto(MultipartFile jpgMultipartFile, String sfzhm, String uploadType) throws Exception {
        String bizPath = "cyPhoto";
        String fileUrl = " ";
        SysCertPdf sysCertPdf = new SysCertPdf();
        if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
            fileUrl = MinioUtil.upload(jpgMultipartFile, bizPath);
            fileUrl = fileUrl.substring(1);
            //保存文件信息
            // 获取文件名
            sysCertPdf.setModelName("cyPhoto");
            sysCertPdf.setPngPath(fileUrl);
            sysCertPdf.setCertId(sfzhm);
            sysCertPdf.setCertType(2);
            sysCertPdf.setDeleted(0);
            return sysCertPdf;
        }else if (CommonConstant.UPLOAD_TYPE_ZOS.equals(uploadType)) {
            fileUrl = ZOSUtil.upload(jpgMultipartFile, bizPath);
            sysCertPdf.setModelName("cyPhoto");
            sysCertPdf.setPngPath(fileUrl);
            sysCertPdf.setCertId(sfzhm);
            sysCertPdf.setCertType(2);
            sysCertPdf.setDeleted(0);
            return sysCertPdf;
        }
        return null;
    }
}

奔波霸的伶俐虫
关注
java中收集器分组函数 Collectors.groupingBy() 的用法详解
hkl_Forever的博客
01-01 3569
【2】推荐写法二，Collectors.toMap() 会使用 Function.identity() 或 o -> o 确定使用对象，BinaryOperator.minBy()或maxBy() 则用来规定比较属性，例如按分数、id等取最大或最小的那条数据。java的 stream 流是非常重要的特性，在开发中是必备的技能，这里着重分析一下 Collectors.groupingBy() 的各种用法。1、代码示例，在第六步的基础上优化。【1】以上二种写法是等效的。
java8中Collectors.groupingBy 用法
muzitian的博客
09-20 1155
多级分组：要实现多级分组，我们可以使用一个由双参数版本的Collectors.groupingBy工厂方法创 建的收集器，它除了普通的分类函数之外，还可以接受collector类型的第二个参数。"啤酒_青岛啤酒":[{"category":"啤酒","id":4,"name":"青岛啤酒","num":3,"price":10}],那么要进 行二级分组的话，我们可以把一个内层groupingBy传递给外层groupingBy，并定义一个为流 中项目分类的二级标准。//{"啤酒":2,"零食":3}
JAVA8 Collectors.groupingBy
小妖666个人笔记
12-28 1242
1.按长度对字符串进行分组 List<String> list = Arrays.asList("a", "bb", "cc", "ddd"); Map<Integer, List<String>> result = list.stream().collect(Collectors.groupingBy(String::length)); System.ou...
java中Collectors.groupingBy返回实例？
gb4215287的博客
12-05 740
java中Collectors.groupingBy返回实例？
Collectors分组groupingBy用法
weixin_45876619的博客
08-02 643
代码】Collectors分组groupingBy用法。
jdk8 streamAPI 中Collector收集器Collectors.groupingBy分组难点精解
blueboz的博客
04-01 3138
collector collector的简单场景,一般是在流处理完毕，想要收集对象的收尾工作。代码如下。 List<String> list = Stream.of("kimmy", "robin", "lisa", "lulu", "mike", "jimmy") .collect(Collectors.toList()); 这个收集器主要是把 流水...
Collectors.groupingBy方法的使用
m0_59176231的博客
11-13 5330
业务场景：现在有5个人，这些人都年龄分部在18-30岁之间。现要求把他们按照年龄进行分组key：年龄value：数据列表输出结果如下：效果相当于是，把list这个集合里面存放的100个人每个人都调用Perple的getAge方法，按照getAge方法的返回值进行分组。每个组是一个Map类型的对象。每个组，即Map，这个对象中的键是getAge的返回值，即，分组的依据。
深入探索Java 8的`Collectors.groupingBy()`：分组的艺术
最新发布
09-15
Collectors.groupingBy()作为Stream API中的一个重要组成部分，它提供了一种将流中的元素按照某个属性或条件进行分组的方法。这种方法不仅能够简化代码，还能够提高处理集合数据的效率。本文将深入探讨Collectors....
Java 8中Collectors.groupingBy方法空指针异常源码分析
m0_71777195的博客
08-03 3558
现在有这样的一个需求： 老板让把所有的员工按年龄进行分组，然后统计各个年龄的人数。这个需求，如果是在数据库中，可以直接使用一个group by语句进行统计即可，那么在 Java 中的话，可以借助于 Java 8 中Collectors类提供的方法来实现，方法返回的是一个集合，如果通过分组的属性 key 值为null，就会抛出空指针异常。...
Collectors.groupingBy() 分组、求和、统计、平均、最大（小）值
libai_vip的博客
09-25 1502
Student类 package com.zzz.test2.test; import java.math.BigDecimal;import java.sql.Timestamp; public class Student { private String name; private Integer age; private String score; private Integer gender; private BigDecimal height; private Tim
Java8 stream操作排序(Collectors.groupingBy)、统计(Collectors.counting())功能实现
yf_imiss的博客
05-23 8906
简要： 今天我们用Java8Lambda表达式实现一个经典top K 题： 给一非空的单词列表，返回前 k 个出现次数最多的单词。 返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序。 我们直接进入主题： 首先我们的有一个实现这个逻辑的方法如下： 返回结果变量list数据集合 public static List<String> getList(String[] listValue, long k) { return Array.
项目中的基础知识
早上真起不来的博客
07-15 498
yml中mytesthttps使用${添加链接描述添加链接描述​httpshttpshttpshttpshttps。
Stream - Collectors.groupingBy实现分组后，且每个分组也进行排序
qq_43842093的博客
07-02 5174
之前记录过：stream的三个常用方式（toMap,groupingBy,findFirst）。这里继续记录下groupingBy的几个高级用法。实现分组，且每个分组也进行排序这里要特别说明下：从方法上看，分组之后，是不能对每个分组进行比较的（也就无法排序）super T,?Collector
Java8新特性
晨港飞燕的专栏
05-22 7691
List集合的stream().collect()方法 Map<Byte, List<String>> levelList = bottles.stream().collect( Collectors.groupingBy( ProductBottle::getLevel, Collectors.mapping(ProductBottle::getQrcode, Co...
Java8 中Collectors详解
llianlianpay的博客
08-16 2280
参考：https://blog.csdn.net/weixin_41849346/article/details/114930096 目录 初始化数据 1.统计平均数(averagingDouble) 2.Collector收集器转换（collectingAndThen） 3.输入的数量（counting） 4.分组（groupingBy） 4.1 groupingBy(Function) 4.2 groupingBy(Function, Collector) 4.3 groupingBy
collectors排序_Collectors.groupingBy()返回排序后的结果
weixin_39977136的博客
12-30 3914
背景：数据库中查出了一个list集合，需要对该集合进行分组汇总如A:[]B:[]C:[]如此格式的mapListentity=entityService.list();Map>entityMap=entity.stream().collect(Collectors.groupingBy(TableEntity::getStringKey,Collectors.mapping(Tab...
有序集合使用Collectors.groupingBy()或Collectors.toMap()输出乱序问题
我的博客
06-17 2271
比如说将有序的订单列表（按照创建时间降序），以订单编号进行分组，返回订单列表信息使用Collectors.groupingBy最终返回给前端的数据和分组前有序的订单列表顺序不一致，产生了乱序输出。输出查看Collectors.toMap()源码发现其默认输出的Map是HashMap，而HashMap不是按顺序存的。HashMap输出乱序，和它存数据的方式有关。HashMap使用哈希表来存储，为了解决Hash冲突使用的是链地址法。
Stream——采取collect进行数据Collectors.groupingBy数据分组
专注写bug
06-16 3665
之前，针对链式编程中的几个方法做了大致的说明。详情可以参考：但实际业务中，总会存在很多复杂的思维，需要使用到，此时玩的不熟练总感觉无从下手。以几个案例的形式，展示一些使用流来实现的操作，做一个笔记的记录。因为要考虑使用集合，需要使用到自定义类对象，所以先从定义对象开始。 定义测试数据 有了数据接收对象，现在开始定义数据集合信息，有如下几组数据信息： 此时的集合数据格式如下所示： 如果再数据库中，此时的数据格式类似下面这种形式：在一般开发中，我们通常期望返回数据样式如下： 此时，通常会采取方式，进行数据的映
Collectors.groupingBy
08-11
Collectors.groupingBy 是一个 Java 8 中的收集器，它将流中的元素根据指定的分类函数分组，返回一个 Map 对象，其中键为分类函数的返回值，值为对应的元素列表。例如，可以使用 Collectors.groupingBy 将一个字符串...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值