金堆成同步字典服务

zhaowenxuan

2025-02-21 aa93e512a60379c6373d10023f49dae4403b51c4

金堆成同步字典服务

 src/main/java/com/example/factory/ServiceFactory.java

@@ -45,6 +45,8 @@
                return "ShanXiQinXiAnMeiJi"; // 对应的业务 Bean 名称
            case "shanxiqinpbkwyy":
                return "ShanXiQinPbkwyy";
            case "shanxiqinjdczgzyy":
                return "ShanXiQinJdczgzyy";
            default:
                throw new RuntimeException("找不到对应的医院服务配置：" + hospName);
        }

 src/main/java/com/example/scheudleds/DictSyncCommon.java

@@ -23,11 +23,11 @@
        this.serviceFactory = serviceFactory;
    }

    private final ExecutorService executorService = Executors.newFixedThreadPool(4);
    private final ExecutorService executorService = Executors.newFixedThreadPool(40);

    @Scheduled(cron = "0 0 22 * * ?")
    public void executeTasks() {
        List<String> list = Arrays.asList("shanxiqinxamjyy","shanxiqinpbkwyy");
        List<String> list = Arrays.asList("shanxiqinxamjyy","shanxiqinpbkwyy","shanxiqinjdczgzyy");
        log.info("开始执行定时任务：{}", System.currentTimeMillis());
        try {
            for (String hosp : list) {
@@ -46,4 +46,4 @@
            log.error("定时任务执行异常：", e);
        }
    }
}
}

 src/main/java/com/example/service/shanxiqin/weinan/JdczgzyyHisService.java

New file
@@ -0,0 +1,590 @@
package com.example.service.shanxiqin.weinan;

import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.example.config.ConfigValue;
import com.example.constant.ApiParamsConstants;
import com.example.domain.HisSyncDict;
import com.example.domain.TjFlowingWaterHis;
import com.example.service.HisService;
import com.example.utils.AjaxResult;
import com.example.utils.FieldNameConverter;
import com.example.utils.HttpClientUtils;
import com.example.utils.synczd.DictionaryUtilShanXiWeiNanJdczgzyy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Instant;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @Company: 西安路泰科技有限公司
 * @Author: zhaowenxuan
 * @Date: 2025/2/19 17:00
 */
@Slf4j
@Service("ShanXiQinJdczgzyy")
public class JdczgzyyHisService implements HisService {
    @Autowired
    private DictionaryUtilShanXiWeiNanJdczgzyy syncZd;
    @Autowired
    private ConfigValue configValue;

//    http://oapi.xamjyy.com/OAPI/oauth/token
//    grant_type:client_credentials
//    client_id:XFZZQEfXTZ7exhhi
//    client_secret:05a192176c21edfcc9cf5fa26fc5a9e0c5b131ad
//    http://oapi.xamjyy.com/OAPI

    @Autowired
    public JdczgzyyHisService(ApplicationContext applicationContext, ConfigValue configValue) {
        this.applicationContext = applicationContext;
        this.configValue = configValue;
        HIS_URL = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.his_api_url") + ":" + configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.his_api_port") + configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.hisapiappend");
        TJ_URL = configValue.getConfigValue("tjUrl");
        CZY = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.czy");
    }

    @Autowired
    private RedisTemplate<Object ,Object> redisTemplate;

    private final ApplicationContext applicationContext;

    private final String HIS_URL;
    private final String TJ_URL;
    private final String CZY;

    //获取token
    private JSONObject getToken () {
        String GRANT_TYPE = "client_credentials";
        String CLIENT_ID = "XFZZQEfXTZ7exhhi";
        String CLIENT_SECRET = "05a192176c21edfcc9cf5fa26fc5a9e0c5b131ad";

        Map<String, Object> map = new HashMap<>();
        map.put("grant_type", GRANT_TYPE);
        map.put("client_id", CLIENT_ID);
        map.put("client_secret", CLIENT_SECRET);
//        map.put("scope",SCOP);
//        String post = sendPostTokenFormUrlencoded (HIS_URL+"/oauth/token", map);
        String post = HttpClientUtils.sendPostTokenFormUrlencoded(HIS_URL + "/oauth/token", map, null);
        if (StrUtil.isBlank(post)) return null;
        return JSONUtil.parseObj(post);
    }

    @Override
    public String jianDang(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("jiuZhenKh", params.get(ApiParamsConstants.CARD_ID));
        map.put ("kaiLeiXing","4");
        map.put ("xingMing", params.get(ApiParamsConstants.CUS_NAME));
        long cusSex = Long.parseLong(params.get(ApiParamsConstants.CUS_SEX).toString());
        if(cusSex==0L){
            map.put ("xingBie","男");
        }else if(cusSex==1L){
            map.put ("xingBie","女");
        }else {
            map.put ("xingBie","未知");
        }
        map.put ("shenFenZh", params.get(ApiParamsConstants.CUS_ID_CARD));
        map.put ("danWeiBh",params.get(ApiParamsConstants.COMP_ID));
        map.put ("chuShengRq", params.get(ApiParamsConstants.CUS_BRITHDAY));
        map.put ("lianXiDz", params.get(ApiParamsConstants.CUS_ADDR));
        map.put ("lianXiDh", params.get(ApiParamsConstants.CUS_PHONE));
        map.put ("feiYongLb","");
        map.put ("feiYongXz","");
        map.put ("jiLuLy","3");
        map.put ("caoZuoYuan",CZY);
        map.put ("chongZhiJe","");
        map.put ("yiBaoKh","");
        map.put ("geRenBh","");
        map.put ("yiBaoBrXx","");
        map.put ("gongZuoDw",params.get(ApiParamsConstants.COMP_NAME));
        map.put ("canBaoXzMc","");
        map.put ("muLuBlLb","");
        map.put ("kunNanJzDj","");
        map.put ("yiLiaoLb","");
        map.put ("minZuDm","");
        map.put ("minZuMc","");
//        职业编码
        String post = sendPost(HIS_URL + "/menZhenJz/jianDang", map);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        if (jsonObject.getStr("returnCode").equals("1")) {
            JSONObject obj = JSONUtil.createObj();
            obj.putOpt("code","200");
            obj.putOpt("data",jsonObject.getJSONObject("returnData"));
            return JSONUtil.toJsonStr(obj);
        }else {
            JSONObject obj = JSONUtil.createObj();
            obj.putOpt("code","500");
            return JSONUtil.toJsonStr(obj);
        }
    }

    @Override
    public String getBingRenXxByShengFenZheng(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("caoZuoYuan",CZY);
        map.put ("shenFenZh", params.get(ApiParamsConstants.CUS_ID_CARD));
        map.put ("danWeiBh",params.get(ApiParamsConstants.COMP_ID));
        //职业编码
        String string = sendPostTokenFormUrlencoded(HIS_URL + "/menZhenJz/getBingRenXxByShengFenZheng", map);
        JSONObject object = JSONUtil.createObj();
        if (StrUtil.isBlank(string)){
            object.putOpt("code",500);
            return JSONUtil.toJsonStr(object);
        }
        JSONObject entries = JSONUtil.parseObj(string);
        log.info("获取病人信息返回数据 ->{}", entries);
        Object returnData = entries.get("returnData");
        if (null != returnData && !returnData.toString().equals("null")) {
            HashMap<String, String> hashMap = new HashMap<>();
            JSONArray returnData1 = entries.getJSONArray("returnData");
            JSONObject jsonObject = (JSONObject) returnData1.get(0);
            hashMap.put(ApiParamsConstants.CARD_ID,jsonObject.getStr("jiuZhenKh"));
            hashMap.put(ApiParamsConstants.PATIONID,jsonObject.getStr("bingRenId"));
            object.putOpt("code",200);
            object.putOpt("data",hashMap);
            return JSONUtil.toJsonStr(object);
        }else {
            object.putOpt("code",404);
        }
        return JSONUtil.toJsonStr(object);
    }

    @Override
    public String saveBingRenXx(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("bingRenId", params.get(ApiParamsConstants.PATIONID));
        map.put ("kaiLeiXing","4");
        map.put("jiuZhenKh",params.get(ApiParamsConstants.CARD_ID));
        map.put ("xingMing", params.get(ApiParamsConstants.CUS_NAME));
        Long cusSex = Long.parseLong(params.get(ApiParamsConstants.CUS_SEX).toString());
        if (cusSex == 0L) {
            map.put("xingBie", "男");
        } else if (cusSex == 1L) {
            map.put("xingBie", "女");
        } else {
            map.put("xingBie", "未知");
        }

        map.put ("shenFenZh", params.get(ApiParamsConstants.CUS_ID_CARD));
        map.put ("danWeiBh","");
        map.put ("chuShengRq", params.get(ApiParamsConstants.CUS_BRITHDAY));
        map.put ("lianXiDz", params.get(ApiParamsConstants.CUS_ADDR));
        map.put ("lianXiDh", params.get(ApiParamsConstants.CUS_PHONE));
        map.put ("feiYongLb","");
        map.put ("feiYongXz","");
        map.put ("jiLuLy","3");
        map.put ("caoZuoYuan",CZY);
        //职业编码
        return sendPost(HIS_URL+"/menZhenJz/saveBingRenXx", map);
    }

    @Override
    public String getListDaiShouFei(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("bingRenId",params.get(ApiParamsConstants.PATIONID));
        map.put ("jiuZhenKh",params.get(ApiParamsConstants.CARD_ID));
        map.put ("yuanQuId","1");
        //职业编码
        String post = sendPost(HIS_URL + "/shouFei/getListDaiShouFei", map);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        if (jsonObject.getStr("returnCode").equals("1")) {
            JSONObject data = jsonObject.getJSONObject("returnData");
            JSONArray list = data.getJSONArray("dtoMzFeiyong1List");
            JSONArray list1 = data.getJSONArray("dtoMzFeiYong2List");
            JSONObject result = JSONUtil.createObj();
            result.putOpt("list1",list);
            result.putOpt("list2",list1);
            return AjaxResult.success(result);
        }else {
            return AjaxResult.error(post);
        }
    }

    @Override
    public String createMenZhenFy(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("bingRenId",params.get(ApiParamsConstants.PATIONID));
        map.put ("jiuZhenKh",params.get(ApiParamsConstants.CARD_ID));
        map.put ("caoZuoYuan",CZY);
        map.put ("yuanQuId","1");
        map.put ("yingYongId","870101");
        map.put ("kaiDanKs",params.get(ApiParamsConstants.kaiDanKeShi));
        map.put ("dengJiLsh",params.get(ApiParamsConstants.Tj_NUM));
        map.put ("shouTuiBz",params.get(ApiParamsConstants.SHOU_TUI_STATUS));
        map.put ("feiYongMxList",params.get(ApiParamsConstants.FEI_YONG_INFO_LIST));
        //职业编码
        String post = sendPost(HIS_URL + "/shouFei/createMenZhenFy", map);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        if (jsonObject.getInt("returnCode") != 1) return AjaxResult.error(post);
        JSONObject data = jsonObject.getJSONObject("returnData");
        JSONObject result = JSONUtil.createObj();
        result.putOpt(ApiParamsConstants.PATIONID,data.getStr(ApiParamsConstants.PATIONID));
        result.putOpt(ApiParamsConstants.FEI_YONG_ID,data.getStr(ApiParamsConstants.FEI_YONG_ID));

        JSONArray feiYongMxList = data.getJSONArray("feiYongMxList");

        ArrayList<TjFlowingWaterHis> tjFlowingWaterHis = new ArrayList<>();
        for (Object o : feiYongMxList) {
            JSONObject entries = (JSONObject) o;
            TjFlowingWaterHis waterHis = new TjFlowingWaterHis();
            waterHis.setId(IdUtil.getSnowflakeNextId());
            waterHis.setParentId(data.getStr(ApiParamsConstants.FEI_YONG_ID));
            waterHis.setCurrentId(entries.getStr("feiYongMxId"));
            waterHis.setXmId(entries.getStr("xiangMuId"));
            tjFlowingWaterHis.add(waterHis);
        }
        result.putOpt("mxList",tjFlowingWaterHis);
        return AjaxResult.success(result);
    }

    @Override
    public String cheXiaoMzFy(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("bingRenId",params.get(ApiParamsConstants.PATIONID));
        map.put ("jiuZhenKh",params.get(ApiParamsConstants.CARD_ID));
        ArrayList<JSONObject> ids = new ArrayList<>();
        String string = params.get(ApiParamsConstants.FEI_YONG_ID_LIST).toString();
        String[] split = string.split(",");
        Arrays.stream(split).forEach(i -> {
            JSONObject object = JSONUtil.createObj();
            object.putOpt("feiYongId",i);
            ids.add(object);
        });
        map.put ("feiYongIdList",ids);
        //职业编码
        String post = sendPost(HIS_URL + "/shouFei/cheXiaoMzFy", map);
        JSONObject entries = JSONUtil.parseObj(post);
        if (entries.getStr("returnCode").equals("1"))
            return AjaxResult.success();
        else return AjaxResult.error(post);
    }

    @Override
    public String getKeShi(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("yuanQuId","1");
        map.put ("keShiMc",params.get(ApiParamsConstants.DEPT_NAME));
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getKeShi", map);
    }

    @Override
    public String getListYiShengZd(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("yuanQuId","1");
        map.put ("keShiMc",params.get(ApiParamsConstants.DEPT_NAME));
        map.put ("bianGengSj","");
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getListYiShengZd", map);
    }

    @Override
    public String getShouFeiXm(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("queryString",params.get(ApiParamsConstants.COMMON_QUERY_KEY));
        map.put ("bianGengSj","");
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getShouFeiXm", map);
    }

    @Override
    public String getKeShiByConditions(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("xingZhiSx","");
        map.put ("queryString",params.get(ApiParamsConstants.COMMON_QUERY_KEY));
        map.put ("zuoFeiBz",params.get(ApiParamsConstants.DEPT_ZUOFEI_STATUS));
        map.put ("yuanQuId","1");
        map.put ("keShiIds",params.get(ApiParamsConstants.DEPT_IDS));
        map.put ("ifPlus","");
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getKeShiByConditions", map);
    }

    @Override
    public String getYangBen(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("queryString",params.get(ApiParamsConstants.COMMON_QUERY_KEY));
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getYangBen", map);
    }

    @Override
    public String getListBingQuZd(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("yuanQuId",params.get(ApiParamsConstants.YUANQU_ID));
        map.put ("keShiId",params.get(ApiParamsConstants.DEPT_ID));
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getListBingQuZd", map);
    }

    @Override
    public String getZhiGongPage(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("bianGengSj","");
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getZhiGongPage", map);
    }

    @Override
    public String getJianChaXm(Map<String, Object> params) {
        Map<String, Object> map = new HashMap<> ();
        map.put ("queryString",params.get(ApiParamsConstants.COMMON_QUERY_KEY));
        map.put ("bianGengSj","");
        map.put ("pageIndex",params.get(ApiParamsConstants.PAGE_INDEX));
        map.put ("pageSize",params.get(ApiParamsConstants.PAGE_SIZE));
        //职业编码
        return sendPost(HIS_URL+"/zhuShuJu/getJianChaXm", map);
    }

    @Override
    public String getJianYanXm(Map<String, Object> map) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("queryCode",map.get(ApiParamsConstants.COMMON_QUERY_KEY));
        hashMap.put("page",map.get(ApiParamsConstants.PAGE_INDEX));
        hashMap.put("size",map.get(ApiParamsConstants.PAGE_SIZE));
        return sendPost(HIS_URL+"/zhuShuJu/getJianYanXm", hashMap);
    }

    @Override
    public String getShouFeiXmJg(Map<String, Object> map) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("shouFeiXmId",map.get(ApiParamsConstants.COMMON_QUERY_KEY));
        hashMap.put("jiaGeTx",map.get(ApiParamsConstants.COMMON_QUERY_KEY2));
        return sendPost(HIS_URL+"/zhuShuJu/getShouFeiXmJg", hashMap);
    }

    @Override
    public String getRongQi(Map<String, Object> map) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("queryString",map.get(ApiParamsConstants.COMMON_QUERY_KEY));
        hashMap.put("pageIndex",map.get(ApiParamsConstants.PAGE_INDEX));
        hashMap.put("pageSize",map.get(ApiParamsConstants.PAGE_SIZE));
        return sendPost(HIS_URL+"/zhuShuJu/getRongQi", hashMap);
    }

    @Override
    public String getJyYangBen(Map<String, Object> map) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("queryString",map.get(ApiParamsConstants.COMMON_QUERY_KEY));
        hashMap.put("pageIndex",map.get(ApiParamsConstants.PAGE_INDEX));
        hashMap.put("pageSize",map.get(ApiParamsConstants.PAGE_SIZE));
        return sendPost(HIS_URL+"/zhuShuJu/getYangBen", hashMap);
    }

    @Override
    public String pushZhiFuMsg(String hospName,Map<String, Object> params) {
        log.info("回调触发 ->{}",params);
        configValue.refresh();
        Map<String, Object> map = new HashMap<> ();
        map.put ("feiYongId",params.get("feiyongid"));
        String string = params.get("status").toString();
        if (!string.equals("1"))
            string = "2";
        map.put ("yeWuLx",string);
        // 参数类型区分
        map.put("type","1");
        HashMap<String, Object> headers = new HashMap<>();
        headers.put("hospId","jdczgzyy");
        String post = HttpClientUtils.sendPost(TJ_URL + "/callBack/pushZhiFuMsg", map,headers);
        JSONObject jsonObject = JSONUtil.parseObj(post);
        JSONObject obj = JSONUtil.createObj();
        if (jsonObject.getStr("code").equals("200")) {
            obj.putOpt("returnCode",1);
            obj.putOpt("exceptionContent","");
            obj.putOpt("returnData",null);
        }else {
            obj.putOpt("returnCode",0);
            obj.putOpt("exceptionContent",jsonObject.getStr("msg"));
            obj.putOpt("returnData",null);
        }
        return JSONUtil.toJsonStr(obj);
    }


    private String sendPost(String url, Map<String, Object> hashMap){
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("token:his:shanxiwnjdczgzyy");
        if (entries != null && !entries.isEmpty()) {
            String timeStr = entries.get("time").toString();
            String expiresInStr = entries.get("expires_in").toString();
            long time = Long.parseLong(timeStr);
            long expiresIn = Long.parseLong(expiresInStr);
            Instant tokenExpirationTime = Instant.ofEpochSecond(time).plusSeconds(expiresIn);
            Instant now = Instant.now();
            if (now.isAfter(tokenExpirationTime)){
                return refreshToken(url,hashMap,"json");
            }else {
                String accessToken = entries.get("access_token").toString();
                String tokenType = entries.get("token_type").toString();
                String string = HttpClientUtils.sendPostToken(url, hashMap, tokenType + " " + accessToken);

                if(StrUtil.isNotBlank(string)){
                    JSON json = FieldNameConverter.convertFieldNames(JSONUtil.parse(string));
                    return JSONUtil.toJsonStr(json);
                } else return JSONUtil.createObj().toString();
            }
        }else {
            return refreshToken(url, hashMap,"json");
        }
    }

    private String sendPostTokenFormUrlencoded(String url, Map<String, Object> hashMap){
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("token:his:shanxiwnjdczgzyy");
        if (!entries.isEmpty()) {
            String timeStr = entries.get("time").toString();
            String expiresInStr = entries.get("expires_in").toString();
            long time = Long.parseLong(timeStr);
            long expiresIn = Long.parseLong(expiresInStr);
            Instant tokenExpirationTime = Instant.ofEpochSecond(time).plusSeconds(expiresIn);
            Instant now = Instant.now();
            if (now.isAfter(tokenExpirationTime)){
                return refreshToken(url,hashMap,"url");
            }else {
                String accessToken = entries.get("access_token").toString();
                String tokenType = entries.get("token_type").toString();
                String string = HttpClientUtils.sendPostTokenFormUrlencoded(url, hashMap, tokenType + " " + accessToken);
                return StrUtil.isNotBlank(string) ? string : JSONUtil.createObj().toString();
            }
        }else {
            return refreshToken(url, hashMap,"url");
        }
    }

    private String sendPostTokenFormData(String url, Map<String, Object> hashMap){
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("token:his:shanxiwnjdczgzyy");
        if (entries != null && !entries.isEmpty()) {
            String timeStr = entries.get("time").toString();
            String expiresInStr = entries.get("expires_in").toString();
            long time = Long.parseLong(timeStr);
            long expiresIn = Long.parseLong(expiresInStr);
            Instant tokenExpirationTime = Instant.ofEpochSecond(time).plusSeconds(expiresIn);
            Instant now = Instant.now();
            if (now.isAfter(tokenExpirationTime)){
                return refreshToken(url,hashMap,"form");
            }else {
                String accessToken = entries.get("access_token").toString();
                String tokenType = entries.get("token_type").toString();
                String string = HttpClientUtils.sendPostTokenFormData(url, hashMap, tokenType + " " + accessToken);
                if(StrUtil.isNotBlank(string)){
                    JSON json = FieldNameConverter.convertFieldNames(JSONUtil.parse(string));
                    return JSONUtil.toJsonStr(json);
                }else return JSONUtil.createObj().toString();
            }
        }else {
            return refreshToken(url, hashMap,"form");
        }
    }

    private String refreshToken(String url, Map<String, Object> hashMap,String type) {
        JSONObject parseObj = getToken();
        if (parseObj != null) {
            Integer expiresIn = parseObj.getInt("expires_in");
            if (expiresIn != null) {
                parseObj.putOpt("time", Instant.now().getEpochSecond());
                redisTemplate.opsForHash().putAll("token:his:shanxiwnjdczgzyy", parseObj);
                redisTemplate.expire("token:his:shanxiwnjdczgzyy", expiresIn - 10, TimeUnit.SECONDS);

                String accessToken = parseObj.getStr("access_token");
                String tokenType = parseObj.getStr("token_type");
                switch (type){
                    case "json":
                        String string = HttpClientUtils.sendPostToken(url, hashMap, tokenType + " " + accessToken);
                        if(StrUtil.isNotBlank(string)){
                            JSON json = FieldNameConverter.convertFieldNames(JSONUtil.parse(string));
                            return JSONUtil.toJsonStr(json);
                        } else return JSONUtil.createObj().toString();
                    case "form":
                        String string1 = HttpClientUtils.sendPostTokenFormData(url, hashMap, tokenType + " " + accessToken);
                        if(StrUtil.isNotBlank(string1)){
                            JSON json = FieldNameConverter.convertFieldNames(JSONUtil.parse(string1));
                            return JSONUtil.toJsonStr(json);
                        } else return JSONUtil.createObj().toString();
                    case "url":
                        String string2 = HttpClientUtils.sendPostTokenFormUrlencoded(url, hashMap, tokenType + " " + accessToken);
                        if(StrUtil.isNotBlank(string2)){
                            JSON json = FieldNameConverter.convertFieldNames(JSONUtil.parse(string2));
                            return JSONUtil.toJsonStr(json);
                        } else return JSONUtil.createObj().toString();
                }
            }
        }
        return JSONUtil.createObj().toString();
    }

    @Override
    public void syncDict(String hospName) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("hosp","shanxiqinjdczgzyy");
        HashMap<String, Object> headers = new HashMap<>();
        headers.put("hospId","jdczgzyy");
        String post = HttpClientUtils.sendPost(TJ_URL + "/callBack/getZdList", map,headers);
        JSONArray jsonArray = JSONUtil.parseObj(post).getJSONArray("data");
        if (jsonArray != null && !jsonArray.isEmpty()) {
            List<HisSyncDict> list = jsonArray.toList(HisSyncDict.class);
            String token = "";
            Map<Object, Object> entries = redisTemplate.opsForHash().entries("token:his:shanxiwnjdczgzyy");
            if (!entries.isEmpty()) {
                String timeStr = entries.get("time").toString();
                String expiresInStr = entries.get("expires_in").toString();
                long time = Long.parseLong(timeStr);
                Long expiresIn = Long.parseLong(expiresInStr);
                Instant tokenExpirationTime = Instant.ofEpochSecond(time).plusSeconds(expiresIn);
                Instant now = Instant.now();
                if (now.isAfter(tokenExpirationTime)){
                    JSONObject parseObj = getToken();
                    if (parseObj != null) {
                        expiresIn = parseObj.getLong("expires_in");
                        if (expiresIn != null) {
                            parseObj.putOpt("time", Instant.now().getEpochSecond());
                            redisTemplate.opsForHash().putAll("token:his:shanxiwnjdczgzyy", parseObj);
                            redisTemplate.expire("token:his:shanxiwnjdczgzyy", expiresIn - 10, TimeUnit.SECONDS);
                            String accessToken = parseObj.getStr("access_token");
                            String tokenType = parseObj.getStr("token_type");
                            token = tokenType + " " + accessToken;
                        }
                    }
                }else {
                    String accessToken = entries.get("access_token").toString();
                    String tokenType = entries.get("token_type").toString();
                    token = tokenType + " " + accessToken;
                }
            }else {
                JSONObject parseObj = getToken();
                if (parseObj != null) {
                    Integer expiresIn = parseObj.getInt("expires_in");
                    if (expiresIn != null) {
                        parseObj.putOpt("time", Instant.now().getEpochSecond());
                        redisTemplate.opsForHash().putAll("token:his:shanxiwnjdczgzyy", parseObj);
                        redisTemplate.expire("token:his:shanxiwnjdczgzyy", expiresIn - 10, TimeUnit.SECONDS);
                        String accessToken = parseObj.getStr("access_token");
                        String tokenType = parseObj.getStr("token_type");
                        token = tokenType + " " + accessToken;
                    }
                }
            }
            if (StrUtil.isNotBlank(token))
                syncZd.exec(list, token);
        }
    }
}

 src/main/java/com/example/utils/synczd/DictionaryUtilShanXiWeiNanJdczgzyy.java

New file
@@ -0,0 +1,479 @@
package com.example.utils.synczd;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.example.config.ConfigValue;
import com.example.domain.HisSyncDict;
import com.example.mapper.HisSyncDictMapper;
import com.example.service.HisSyncDictService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @Company: 西安路泰科技有限公司
 * @Author: zhaowenxuan
 * @Date: 2025/1/13 11:19
 */
@Slf4j
@Component
public class DictionaryUtilShanXiWeiNanJdczgzyy {

    @Autowired
    private HisSyncDictService hisSyncDictService;
    @Autowired
    private ConfigValue configValue;
    @Autowired
    private HisSyncDictMapper hisSyncDictMapper;

    private static String CONFIG_PATH;
    private static String BASE_API_URL = "";
    private static final int SIZE = 100;
    private static String USER = "";
    private static String PASSWORD = "";
    private static String URL = "";
    private static String NAME = "";
    @Value("${config.path}")
    public void setConfigPath(String configPath) {
        CONFIG_PATH = configPath;
        NAME = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.name");
        URL = "jdbc:mysql://" + configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.ip") + ":" + configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.prot") + "/" + NAME +
                "?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=GMT%2B8";
        USER = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.username");
        PASSWORD = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.password");
        String apiUrl = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.his_api_url");
        String apiPort = configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.his_api_port");
        BASE_API_URL = apiUrl+":"+apiPort+configValue.getConfigValue("ShanXi_Qin_WeiNan_Jdczgzyy.hisapiappend");
    }


    /**
     * 暂时不做
     * 1.90 门诊明细计费及组合计费项目 MZJFZHMXXM
     *
     */

// 分页每次1000条
    static {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (Exception e) {
            System.out.println("静态代码块异常 ->"+e.getMessage());
        }
    }

    /**
     * 进行同步
     */
    public void exec(List<HisSyncDict> hisSyncDicts, String token){
        log.info("开始执行同步");
        Connection connection = getConnection();
        if (connection == null)
            return;
        for (HisSyncDict hisSyncDict : hisSyncDicts) {
            boolean isFormatJson = false;
            if (hisSyncDict.getDictName().equals("getKeShizd")
                    || hisSyncDict.getDictName().equals("getKeShiByConditionszd")
                    || hisSyncDict.getDictName().equals("getShouFeiXmzd")
                    || hisSyncDict.getDictName().equals("getListYiShengZd")
            )
                isFormatJson = true;
            hisSyncDict.setDictName(hisSyncDict.getHospId()+"_"+hisSyncDict.getDictName());
            extracted(NAME, connection, hisSyncDict,token,isFormatJson);
        }
        try {
            connection.close();
        } catch (SQLException ignored) { }
        hisSyncDictMapper.proSyncCommonDict();
        log.info("执行同步完毕");
    }

    private void extracted(String name, Connection connection, HisSyncDict hisSyncDict,String token,Boolean isFormatJson) {
        String method = hisSyncDict.getDictName();
        log.info("开始请求代码 ->{}", method);
        String tabName = "ltkj_" + method.toLowerCase();
        boolean isLimit = false;
        int page = 1;
        int maxPage = 1;
        String params = hisSyncDict.getParams();
        params = params.replace("${pageIndex}",String.valueOf(page));
        params = params.replace("${pageSize}",String.valueOf(SIZE));
        JSONObject object = JSONUtil.parseObj(params);
        if (hisSyncDict.getIsLimit() == 1) {
            isLimit = true;
        }
        log.info("请求接口 ->{}, 请求参数 ->{}", BASE_API_URL+hisSyncDict.getUrl(), object);
        JSONObject entries = execRequest(object.toString(),hisSyncDict,token);
        log.info("请求返回 ->{}", entries.toString());
        if (isFormatJson){
            if ("1".equals(entries.getStr("returnCode"))) {
                JSONObject response = entries.getJSONObject("returnData");
                try {
                    dropTable(tabName, connection);
                } catch (SQLException e) {
                    log.error("删除表异常 ->{}", e.getMessage());
                }
                if (isLimit) {
                    maxPage = LimitInsertData(connection, tabName, response, name, page);
                    log.info("计算页码为 ->{}", maxPage);
                    if (maxPage > 1) {
                        for (page = 2; page <= maxPage; page++) {
                            params = hisSyncDict.getParams();
                            params = params.replace("${pageIndex}",String.valueOf(page));
                            params = params.replace("${pageSize}",String.valueOf(SIZE));
                            object = JSONUtil.parseObj(params);
                            log.info("请求接口 ->{}, 请求参数 ->{}", BASE_API_URL+hisSyncDict.getUrl(), object.toString());
                            entries = execRequest(object.toString(),hisSyncDict,token);
                            log.info("请求返回 ->{}", entries.toString());
                            response = entries.getJSONObject("returnData");
                            if ("1".equals(entries.getStr("returnCode"))) {
                                LimitInsertData(connection, tabName, response, name, page);
                            } else {
                                log.error("{} 请求失败：{}", method, object.toString());
                            }
                        }
                    }
                } else {
                    JSONArray resultData = response.getJSONArray("list");
                    List<JSONObject> list = JSONUtil.toList(resultData, JSONObject.class);
                    for (JSONObject jsonObject : list) {
                        editDataBase(connection, tabName, jsonObject, name);
                    }
                }
            }
        }else {
            if ("1".equals(entries.getStr("returnCode"))) {
                Object returnData = entries.get("returnData");
                if (returnData instanceof JSONObject){
                    JSONObject response = entries.getJSONObject("returnData");
                    try {
                        dropTable(tabName, connection);
                    } catch (SQLException e) {
                        log.error("删除表异常 ->{}", e.getMessage());
                    }
                    editDataBase(connection, tabName, response, name);
                }else {
                    JSONArray response = entries.getJSONArray("returnData");
                    try {
                        dropTable(tabName, connection);
                        List<JSONObject> list = JSONUtil.toList(response, JSONObject.class);
                        for (JSONObject jsonObject : list) {
                            editDataBase(connection, tabName, jsonObject, name);
                        }
                    } catch (SQLException e) {
                        log.error("删除表异常 ->{}", e.getMessage());
                    }
                }
                if (isLimit) {
                    JSONArray response = entries.getJSONArray("returnData");
                    if (tabName.contains("_getjianchaxmzd")) maxPage = 10000;
                    log.info("计算页码为 ->{}", maxPage);
                    if (maxPage > 1) {
                        for (page = 2; page <= maxPage; page++) {
                            params = hisSyncDict.getParams();
                            params = params.replace("${pageIndex}",String.valueOf(page));
                            params = params.replace("${pageSize}",String.valueOf(SIZE));
                            object = JSONUtil.parseObj(params);
                            log.info("请求接口 ->{}, 请求参数 ->{}", BASE_API_URL+hisSyncDict.getUrl(), object.toString());
                            entries = execRequest(object.toString(),hisSyncDict,token);
                            log.info("请求返回 ->{}", entries.toString());
                            response = entries.getJSONArray("returnData");
                            if (response.isEmpty())
                                break;
                            List<JSONObject> list = JSONUtil.toList(response, JSONObject.class);
                            for (JSONObject jsonObject : list) {
                                editDataBase(connection, tabName, jsonObject, name);
                            }
                        }
                    }
                } else {
                    JSONArray response = entries.getJSONArray("returnData");
                    List<JSONObject> list = JSONUtil.toList(response, JSONObject.class);
                    for (JSONObject jsonObject : list) {
                        editDataBase(connection, tabName, jsonObject, name);
                    }
                }
            }
        }

    }

    /**
     * 针对于分页接口 创建表、插入数据
     *
     * @param connection
     * @param tabName
     * @param response
     * @return
     */
    private int LimitInsertData(Connection connection, String tabName, JSONObject response,String name,Integer page) {
        JSONArray jsonArray = response.getJSONArray("list");
        JSONObject entries = (JSONObject) jsonArray.get(0);
        int maxPage;
        // 行数 数据返回的第几行
        Integer rowNumber = response.getInt("RowNumber");
        // 总条数
        Integer totalCount = response.getInt("totalRows");
        Integer pageCount = response.getInt("pageCount");
        maxPage = (totalCount + 100 - 1) / 100;
        log.info("请求返回总条数 ->{},当前页 ->{},总页数 ->{}",totalCount,page,maxPage);
        jsonArray.forEach(obj -> {
            editDataBase(connection, tabName, (JSONObject) obj,name);
        });
        return pageCount;
    }

    /**
     * 操作数据库
     *
     * @param connection
     * @param tabName
     * @param obj
     */
    private void editDataBase(Connection connection, String tabName, JSONObject obj,String name) {
        try {
            if (!tabIsExists(connection, tabName,name)) {
                // 创建表
                creatTable(obj, tabName, connection);
            }
        } catch (SQLException throwables) {
            log.error("创建表异常");
            log.error(throwables.getSQLState());
            log.error(throwables.getMessage());
        }
        // 对比字段 并插入数据
        try {
            operationTable(obj, tabName, connection);
        } catch (SQLException e) {
            log.error("对比字段插入数据异常");
            log.error(e.getSQLState());
            log.error(e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 执行post请求
     *
     * @param params 请求参数 例如： param1=val1&param2=val2
     * @return 请求返回的json转换后的JSONObject对象
     */
    private JSONObject execRequest(String params,HisSyncDict hisSyncDict,String token) {
        java.net.URL url = null;
        HttpURLConnection connection = null;
        OutputStreamWriter writer = null;
        BufferedReader reader = null;
        StringBuilder response = new StringBuilder();
        try {
            url = new URL(BASE_API_URL+hisSyncDict.getUrl());
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            connection.setRequestProperty("Authorization", token);
            log.info("请求接口 ->{}", hisSyncDict.getUrl());
            if (hisSyncDict.getUrl().equals("/zhuShuJu/getListYiShengZd") || hisSyncDict.getUrl().equals("/zhuShuJu/getZhiGongPage") || hisSyncDict.getUrl().equals("/zhuShuJu/getJianChaXm")){
                connection.setRequestProperty("dangQianYhId","DBA");
                if (hisSyncDict.getUrl().equals("/zhuShuJu/getJianChaXm"))
                    connection.setRequestProperty("yuanQuId","1");
            }
            connection.setDoOutput(true);
            StringBuilder postData = new StringBuilder();
            JSONObject jsonObject = JSONUtil.parseObj(params);
            for (String key : jsonObject.keySet()) {
                if (postData.length() > 0) {
                    postData.append("&");
                }
                String encode = URLEncoder.encode(key, "UTF-8");
                String encode1 = URLEncoder.encode(String.valueOf(jsonObject.get(key)), "UTF-8");
                postData.append(encode).append("=").append(encode1);
            }

            writer = new OutputStreamWriter(connection.getOutputStream());
            writer.write(postData.toString());
            writer.flush();
            reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            return JSONUtil.parseObj(response);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
        return null;
    }

    public Connection getConnection() {
        try {
            log.info("数据库信息 ->{},{},{}",USER,PASSWORD,URL);
            return DriverManager.getConnection(URL,USER,PASSWORD);
        } catch (Exception throwables) {
            log.error("获取sql连接失败");
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 表是否存在
     *
     * @param connection
     * @param tableName
     * @return
     * @throws SQLException
     */
    private Boolean tabIsExists(Connection connection, String tableName,String name) throws SQLException {
        String tabSql = "SELECT table_name FROM information_schema.tables WHERE table_schema = ? AND table_name = ?";
        PreparedStatement statement = connection.prepareStatement(tabSql);
        statement.setString(1, name);
        statement.setString(2, tableName);
//        log.info("判断表是否存在 sql-> {}", statement.toString());
        ResultSet resultSet = statement.executeQuery();
        boolean next = resultSet.next();
        statement.close();
        return next;
    }

    /**
     * 操作表
     *
     * @param tabName
     * @param connection
     * @throws SQLException
     */
    private void operationTable(JSONObject jsonObject, String tabName, Connection connection) throws SQLException {
        List<String> columns = getColumns(tabName, connection);
//        log.info("当前表字段为 ->{}", columns);
        ArrayList<String> responseColums = new ArrayList<>();
        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
            String key = entry.getKey().trim().toLowerCase();
            responseColums.add(key);
        }
//        log.info("请求返回的字段为 ->{}", responseColums);
        responseColums.removeAll(columns);
//        log.info("需要增加的字段 ->{}",responseColums);
        if (!responseColums.isEmpty()) {
            // 需要增加字段 并插入数据
            for (String colum : responseColums) {
                String sql = "alter table " + tabName + " add column " + colum + " VARCHAR(200) null";
//                log.info("修改字段 ->{}",sql.toString());
                Statement statement = connection.createStatement();
                statement.executeUpdate(sql);
                statement.close();
            }
            insertData(tabName, connection, jsonObject);
        } else {
            insertData(tabName, connection, jsonObject);
        }
    }

    /**
     * 插入数据
     *
     * @param tabName
     * @param connection
     * @param jsonObject
     * @throws SQLException
     */
    private void insertData(String tabName, Connection connection, JSONObject jsonObject) throws SQLException {
        // 插入数据前 先查询数据是否存在
        StringBuilder insertSqlBuilder = new StringBuilder();
        StringBuilder valueBuilder = new StringBuilder();
        insertSqlBuilder.append("insert into ").append(tabName).append(" (");
        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
            String defaultVal = entry.getValue().toString();
            String key = entry.getKey().trim().toLowerCase();
            if (StrUtil.isBlank(defaultVal) || defaultVal.equals("null"))
                continue;
            String val = defaultVal.trim().replaceAll("\\s+", "").replace("\\","");
            insertSqlBuilder.append(key).append(", ");
            valueBuilder.append("'").append(val.replaceAll("'","‘")).append("', ");
        }
        insertSqlBuilder.append("insert_time, ");
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        valueBuilder.append("'").append(time).append("'").append(", ");
        insertSqlBuilder.delete(insertSqlBuilder.length() - 2, insertSqlBuilder.length());
        valueBuilder.delete(valueBuilder.length() - 2, valueBuilder.length());
        insertSqlBuilder.append(") values (").append(valueBuilder).append(")");
        // 插入数据
        Statement statement = connection.createStatement();
        log.info("插入数据 sql-> {}", insertSqlBuilder.toString());
        statement.execute(insertSqlBuilder.toString());
        statement.close();
    }

    /**
     * 获取表的列
     *
     * @param tabName
     * @param connection
     * @return
     * @throws SQLException
     */
    private List<String> getColumns(String tabName, Connection connection) throws SQLException {
        DatabaseMetaData metaData = connection.getMetaData();
        ResultSet columns = metaData.getColumns(null, null, tabName, null);
        ArrayList<String> tabColumns = new ArrayList<>();
        while (columns.next()) {
            String columnName = columns.getString("column_name");
            tabColumns.add(columnName);
        }
        return tabColumns;
    }

    /**
     * 创建表
     *
     * @param resultDataIndex1 返回数据中的第一个参数
     * @param tabName
     * @param connection
     * @throws SQLException
     */
    private void creatTable(JSONObject resultDataIndex1, String tabName, Connection connection) throws SQLException {
        StringBuilder sql = new StringBuilder("CREATE TABLE " + tabName + " (");
        for (Map.Entry<String, Object> entry : resultDataIndex1.entrySet()) {
            String key = entry.getKey().trim().toLowerCase();
            sql.append(key).append(" VARCHAR(200) null,");
        }
        sql.append("insert_time").append(" VARCHAR(100) null,");
        sql = new StringBuilder(sql.substring(0, sql.length() - 1));
        sql.append(");");
        log.info("创建表格 -> {}",sql.toString());
        Statement statement = connection.createStatement();
        statement.execute(sql.toString());
    }

    /**
     * 删除表
     * @param tabName
     * @param connection
     * @throws SQLException
     */
    private void dropTable(String tabName,Connection connection) throws SQLException {
        String sql = "DROP TABLE IF EXISTS " + tabName;
        Statement statement = connection.createStatement();
        statement.executeUpdate(sql);
        statement.close();
    }
}