Redis + CAS，配置自增单号

import lombok.Data;

import javax.persistence.*;
import java.util.Date;

/**
 * @Author: DengJia
 * @Date: 2022/2/14 10:44
 * @Description: 业务单号配置
 */

@Data
public class YwdhConfig {
    /**
     * 药库单号设置自增主键
     */
    private Integer pkywdhconfig;
    /**
     * 社区编码
     */
    private String sqbm;
    /**
     * 单号类型（1药库采购、2药库入库、3药库出库...）
     */
    private Integer lx;
    /**
     * 科室类型（对应zd_ks科室的主键id）
     */
    private Integer kslx;
    /**
     * 具体类型（将单号类型进一步细分的具体类型）
     */
    private Integer jtlx;
    /**
     * 操作人员id
     */
    private Integer czryid;
    /**
     * 单号前缀
     */
    private String dhqz;
    /**
     * 单号长度（不含前缀）
     */
    private Integer dhcd;
    /**
     * 单号起始号
     */
    private Integer dhqsh;
    /**
     * 单号步长
     */
    private Integer dhbc;
    /**
     * 是否开启（1开启为递增序列，0不开启为时间戳随机序列）
     */
    private Integer isopen;
    /**
     * 时间戳
     */
    private String currenttime;

    private Date createdAt;
    private Date updatedAt;
}

import lombok.Data;

import javax.persistence.*;

/**
 * @Author: DengJia
 * @Date: 2022/2/17 9:25
 * @Description: redis键值对
 */

@Data
public class YwdhRedisPair {
    private Integer pkpair;
    private String currenttime;
    private String sqbm;
    private String keyname;
    private String value;

    public YwdhRedisPair() {
    }

    public YwdhRedisPair(String sqbm, String currenttime) {
        this.currenttime = currenttime;
        this.sqbm = sqbm;
    }

    public YwdhRedisPair(Integer pkpair, String currenttime, String sqbm, String keyname, String value) {
        this.pkpair = pkpair;
        this.currenttime = currenttime;
        this.sqbm = sqbm;
        this.keyname = keyname;
        this.value = value;
    }
}

import com.yuanbo.common.util.G3GlobalNames;

import java.util.Objects;
import java.util.stream.Stream;

/**
 * @Author: DengJia
 * @Date: 2022/2/10 11:31
 * @Description: 业务单号操作，枚举类
 */

public enum YwdhOpsEnum {
    // 药库采购
    PURCHASE(G3GlobalNames.YK_CGD0, 1),
    // 药库验收
    ACCEPTANCE(G3GlobalNames.YK_YSD0, 4),
    // 药库入库
    INBOUND(G3GlobalNames.YK_RKD0, 2),
    // 药库出库
    OUTBOUND(G3GlobalNames.YK_CKD0, 3);
    // ...

    private Long opcode;
    private Integer lx;

    /**
     * 获取对应类型的操作码
     *
     * @param lx 类型值
     * @return 操作码
     */
    public static Long getOpcode(Integer lx) {
        return Stream.of(YwdhOpsEnum.values())
                .filter(e -> Objects.equals(e.getLx(), lx))
                .findFirst().map(e -> e.opcode)
                // 如果lx不存在，opcode返回无效值：-1L
                .orElse(-1L);
    }

    /**
     * 获取操作码的类型
     *
     * @param opcode 药库操作的编码
     * @return 类型值
     */
    public static Integer getLx(long opcode) {
        return Stream.of(YwdhOpsEnum.values())
                .filter(e -> Objects.equals(e.getOpcode(), opcode))
                .findFirst().map(e -> e.lx)
                // 如果opcode不存在，lx返回无效值：-1
                .orElse(-1);
    }

    YwdhOpsEnum(Long opcode, Integer lx) {
        this.opcode = opcode;
        this.lx = lx;
    }

    public Long getOpcode() {
        return opcode;
    }

    public void setOpcode(Long opcode) {
        this.opcode = opcode;
    }

    public Integer getLx() {
        return lx;
    }

    public void setLx(Integer lx) {
        this.lx = lx;
    }
}

import com.yuanbo.chss.domain.business.YwdhConfig;

import java.util.List;
import java.util.Map;

/**
 * @Author: DengJia
 * @Date: 2022/2/14 14:30
 * @Description: 药库单号配置 Repository
 */
public interface YwdhConfigRepository {

    /**
     * 查询业务单号配置，入参含主键则通过主键查询，否则按条件查询。
     *
     * @param dataMap 过滤条件
     * @return 配置信息
     */
    List<Map<String, Object>> selectYwdhConfig(Map<String, Object> dataMap);

    /**
     * 用户自定义配置业务单号格式
     *
     * @param dbBean    原值
     * @param paramBean 修改值
     */
    void updateYwdhConfig(YwdhConfig dbBean, YwdhConfig paramBean);

    /**
     * 删除单号配置
     * @param ids 待删除单号主键ids
     */
    void deleteBusinessNumConfigByIds(List<Integer> ids);

}

import com.yuanbo.chss.domain.business.YwdhConfig;
import com.yuanbo.common.util.LoginHelper;
import com.yuanbo.hap.util.DBAgent;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.yuanbo.hap.util.ParamUtil.beanToMap;
import static com.yuanbo.hap.util.ParamUtil.mapToBean;

/**
 * @Author: DengJia
 * @Date: 2022/2/14 14:39
 * @Description: 业务单号配置 RepositoryImpl
 */

@Repository("YwdhConfigRepository")
public class YwdhConfigRepositoryImpl implements YwdhConfigRepository {
    private static final DBAgent DBA = DBAgent.getInstance();

    @Override
    public List<Map<String, Object>> selectYwdhConfig(Map<String, Object> dataMap) {
        StringBuilder querySql = new StringBuilder("select * from ywdh_config where sqbm = ::SQBM ");
        if (dataMap.get("PKYWDHCONFIG") != null) {
            querySql.append("and pkywdhconfig = ::PKYWDHCONFIG ");
        } else {
            if (dataMap.get("LX") != null) {
                querySql.append("and lx = ::LX ");
            }
            if (dataMap.get("KSLX") != null) {
                querySql.append("and kslx = ::KSLX ");
            }
            if (dataMap.get("JTLX") != null) {
                querySql.append("and jtlx = ::JTLX ");
            }
//            if (dataMap.get("CZRYID") != null) {
//                querySql.append("and czryid = ::CZRYID ");
//            }
            if (dataMap.get("DHQZ") != null) {
                querySql.append("and dhqz = :DHQZ ");
            }
            if (dataMap.get("DHCD") != null) {
                querySql.append("and dhcd = ::DHCD ");
            }
            if (dataMap.get("DHQSH") != null) {
                querySql.append("and dhqsh = ::DHQSH ");
            }
            if (dataMap.get("DHBC") != null) {
                querySql.append("and dhbc = ::DHBC ");
            }
            if (dataMap.get("ISOPEN") != null) {
                querySql.append("and isopen = ::ISOPEN ");
            }
            if (dataMap.get("CURRENTTIME") != null) {
                querySql.append("and currenttime = ::CURRENTTIME ");
            }
        }
        return DBA.querySQL(querySql.toString(), dataMap, null);
    }

    @Override
    public void updateYwdhConfig(YwdhConfig dbBean, YwdhConfig paramBean) {
        YwdhConfig config = new YwdhConfig();
        // 浅拷贝
        BeanUtils.copyProperties(paramBean, config);
        if (config.getLx() == null) {
            config.setLx(dbBean.getLx());
        }
        if (config.getKslx() == null) {
            config.setKslx(dbBean.getKslx());
        }
        if (config.getJtlx() == null) {
            config.setJtlx(dbBean.getJtlx());
        }
        if (config.getCzryid() == null) {
            config.setCzryid(dbBean.getCzryid());
        }
        if (config.getDhqz() == null) {
            config.setDhqz(dbBean.getDhqz());
        }
        if (config.getDhcd() == null) {
            config.setDhcd(dbBean.getDhcd());
        }
        if (config.getDhqsh() == null) {
            config.setDhqsh(dbBean.getDhqsh());
        }
        if (config.getDhbc() == null) {
            config.setDhbc(dbBean.getDhbc());
        }
        if (config.getIsopen() == null) {
            config.setIsopen(dbBean.getIsopen());
        }
        if (config.getCurrenttime() == null) {
            config.setCurrenttime(dbBean.getCurrenttime());
        }
        config.setCreatedAt(dbBean.getCreatedAt());
        DBA.update(null, config);
    }

    @Override
    public void deleteBusinessNumConfigByIds(List<Integer> ids) {
        // 去掉字符串前后中括号
        String strIds = org.apache.commons.lang3.StringUtils.strip(ids.toString(), "[]");
        DBA.executeProcSql("delete from ywdh_config where pkywdhconfig in ( " + strIds + " )", null);
    }
}

import com.yuanbo.chss.domain.business.YwdhRedisPair;

import java.util.List;

public interface YwdhRedisPairRepository {

    List<YwdhRedisPair> selectYwdhKeyConfig(YwdhRedisPair ywdhRedisPair);

    void insertYwdhRedisPair(YwdhRedisPair ywdhRedisPair);

    void updateYwdhKeyConfig(YwdhRedisPair ywdhRedisPair);

    void deleteYwdhKeyConfig(YwdhRedisPair ywdhRedisPair);
}

import com.yuanbo.chss.domain.business.YwdhRedisPair;
import com.yuanbo.hap.util.DBAgent;
import com.yuanbo.hap.util.ParamUtil;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: DengJia
 * @Date: 2022/2/17 11:28
 * @Description:
 */

@Repository("YwdhRedisPairRepository")
public class YwdhRedisPairRepositoryImpl implements YwdhRedisPairRepository {
    private static final DBAgent DBA = DBAgent.getInstance();

    @Override
    public List<YwdhRedisPair> selectYwdhKeyConfig(YwdhRedisPair ywdhRedisPair) {
        HashMap<String, Object> dataMap = new HashMap<>(4);
        ParamUtil.beanToMap(ywdhRedisPair, dataMap, true);
        StringBuilder querySql = new StringBuilder("select * from ywdh_redis_pair where sqbm = :sqbm ");
        if (dataMap.get("pkpair") != null) {
            querySql.append("and pkpair = :pkpair ");
        } else {
            if (dataMap.get("fkywdhconfig") != null) {
                querySql.append("and fkywdhconfig = :fkywdhconfig ");
            }
            if (dataMap.get("currenttime") != null) {
                querySql.append("and currenttime = :currenttime ");
            }
            if (dataMap.get("keyname") != null) {
                querySql.append("and keyname = :keyname ");
            }
            if (dataMap.get("value") != null) {
                querySql.append("and value = :value ");
            }
        }

        List<Map<String, Object>> list = DBA.querySQL(querySql.toString(), dataMap, null);
        return ParamUtil.mapsToBeans(list, YwdhRedisPair.class, true);
    }

    @Override
    public void insertYwdhRedisPair(YwdhRedisPair ywdhRedisPair) {
        DBA.save(null, ywdhRedisPair);
    }

    @Override
    public void updateYwdhKeyConfig(YwdhRedisPair ywdhRedisPair) {
//        Map<String, Object> map = new HashMap<>();
//        map.put("SQBM", ywdhRedisPair.getSqbm());
//        map.put("KEYNAME", ywdhRedisPair.getKeyname());
//        if (ywdhRedisPair.getValue() != null) {
//            map.put("VALUE", ywdhRedisPair.getValue());
//        }
//
//        StringBuilder sb = new StringBuilder("update ywdh_redis_pair set value = 3 ");
//
//        sb.append("where sqbm = ::SQBM and keyname = ::KEYNAME");
//
//        DBA.executeSQL(sb.toString(), );
        DBA.update(null, ywdhRedisPair);
    }

    @Override
    public void deleteYwdhKeyConfig(YwdhRedisPair ywdhRedisPair) {
        DBA.delete(null, ywdhRedisPair);
    }
}

import com.yuanbo.chss.domain.business.YwdhConfig;
import com.yuanbo.hap.webservice.function.FuncResult;

import java.util.Map;

/**
 * his业务单号配置 业务接口
 */
public interface YwdhConfigBS {

    /**
     * 创建单号生成规则的时候，也生成redis键，由于redis未进行持久化配置，同时需要将key记录进mysql。
     * 客户端传入的JTLX，代表多条具体类型，以 ',' 逗号分割，分别存储。
     *
     * @param dataMap 配置信息
     * @return 添加成功
     */
    FuncResult createBusinessNumConfig(Map<String, Object> dataMap);

    /**
     * 条件查询业务单号配置
     *
     * @param dataMap 查询条件
     * @return 按条件过滤后的配置信息
     */
    FuncResult queryBusinessNumConfig(Map<String, Object> dataMap);


    /**
     * 按入参TYPE分别进行修改、新增、删除
     * 通过时间戳字段(CURRENTTIME)实现乐观锁机制（修改之前查出来的时间戳与数据库的时间戳进行对比，一致方可进行本次修改）
     *
     * @param dataMap 入参
     * @return 修改成功
     */
    FuncResult updateBusinessNumConfigByType(Map<String, Object> dataMap);

    /**
     * 删除业务单号配置
     *
     * @param dataMap 待删除的配置主键
     * @return 删除成功
     */
    FuncResult deleteBusinessNumConfigByType(Map<String, Object> dataMap);
}

import com.yuanbo.chss.domain.business.YwdhConfig;
import com.yuanbo.chss.domain.business.YwdhRedisPair;
import com.yuanbo.chss.domain.log.LogCzrz;
import com.yuanbo.chss.domain.yk.YwdhOpsEnum;
import com.yuanbo.chss.repository.YwdhConfigRepository;
import com.yuanbo.chss.repository.YwdhRedisPairRepository;
import com.yuanbo.common.util.DateTransUtil;
import com.yuanbo.common.util.LoginHelper;
import com.yuanbo.hap.core.exception.AppException;
import com.yuanbo.hap.util.DBAgent;
import com.yuanbo.hap.util.WebServiceUtils;
import com.yuanbo.hap.webservice.function.FuncResult;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.*;
import java.util.stream.Collectors;

import static com.yuanbo.hap.util.ParamUtil.*;
import static com.yuanbo.hap.util.ParamUtil.mapToBean;

/**
 * @Author: DengJia
 * @Date: 2022/2/14 14:30
 * @Description: 业务单号配置 业务类
 */
@Service("YwdhConfigBS")
@Transactional
public class YwdhConfigBSImpl implements YwdhConfigBS {
    @Autowired
    private YwdhConfigRepository ywdhConfigRepository;
    @Autowired
    private YwdhRedisPairRepository ywdhRedisPairRepository;
    @Resource
    private RedisTemplate<Object, Object> redisTemplate;

    private static final String PREFIX = "INCR";
    private static final DBAgent DBA = DBAgent.getInstance();

    /**
     * 乐观锁机制下执行数据的改动（UPDATE、DELETE）
     */
    public static final String OPTIMISTIC_LOCK_UPDATE = "UPDATE";
    public static final String OPTIMISTIC_LOCK_DELETE = "DELETE";

    @Override
    public FuncResult createBusinessNumConfig(Map<String, Object> dataMap) {
        // 入参校验
        if (dataMap.get("SQBM") == null) {
            dataMap.put("SQBM", LoginHelper.getLoginerSQBM());
        }
        if (dataMap.get("CZRYID") == null) {
            dataMap.put("CZRYID", LoginHelper.getLoginerId());
        }
        if (dataMap.get("LX") == null) {
            throw new AppException("LX不可为空！");
        }
        if (dataMap.get("KSLX") == null) {
            throw new AppException("KSLX不可为空！");
        }
        List<YwdhConfig> configs = new ArrayList<>();
        StringBuilder rklxString = new StringBuilder();
        List<Integer> rklxList = new ArrayList<>();

        if (dataMap.get("JTLX") != null) {
            try {
                String jtlxString = dataMap.get("JTLX").toString();
                if (StringUtils.isNotBlank(jtlxString)) {
                    String[] jtlxs = jtlxString.split(",");
                    configs = new ArrayList<>();
                    for (String jtlx : jtlxs) {
                        int i = Integer.parseInt(jtlx.trim());
                        dataMap.put("JTLX", i);
                        configs.add(getBean(dataMap));
                        rklxList.add(i);
                    }
                }
            } catch (Exception e) {
                throw new AppException("请将JTLX以逗号分割传入！");
            }
        } else {
            configs.add(getBean(dataMap));
        }

        // 检查可行性，及后续操作
        configs.forEach(this::checkAvailability);

        // 为多个具体类型设置同一套规则（一次添加一套规则）
        String nowTimeString = String.valueOf(System.currentTimeMillis());
        System.currentTimeMillis();
        for (YwdhConfig config : configs) {
            config.setCurrenttime(nowTimeString);
            // mysql保存自定义的规则
            DBA.save(null, config);
        }

        // 生成key
        StringBuilder keyName = new StringBuilder(PREFIX + "_" + dataMap.get("SQBM"));
        if (dataMap.get("LX") != null) {
            Long dhlx = YwdhOpsEnum.getOpcode(Integer.parseInt(dataMap.get("LX").toString()));
            keyName.append("_").append(dhlx);
        }
        if (dataMap.get("KSLX") != null) {
            Integer kslx = Integer.parseInt(dataMap.get("KSLX").toString());
            keyName.append("_").append(kslx);
        }
        if (!rklxList.isEmpty()) {
            Collections.sort(rklxList);
            rklxList.forEach(rklxString::append);
            keyName.append("_").append(rklxString);
        }

        // mysql保存键
        YwdhRedisPair pair = new YwdhRedisPair();
        pair.setCurrenttime(nowTimeString);
        pair.setSqbm(dataMap.get("SQBM").toString());
        pair.setKeyname(keyName.toString());
        pair.setValue(dataMap.get("DHQSH").toString());
        ywdhRedisPairRepository.insertYwdhRedisPair(pair);

        // redis设置键
        callRedisToSetKeyAndExpiration(keyName.toString(), Integer.parseInt(dataMap.get("DHQSH").toString()));

        return new FuncResult().setMsg("添加成功");
    }

    @Override
    public FuncResult queryBusinessNumConfig(Map<String, Object> dataMap) {
        if (dataMap.get("SQBM") == null) {
            dataMap.put("SQBM", LoginHelper.getLoginerSQBM());
        }
        List<Map<String, Object>> list = ywdhConfigRepository.selectYwdhConfig(dataMap);
        return new FuncResult().addDataSet("YWDHCONFIG", list);
    }

    @Override
    @Transactional
    public FuncResult updateBusinessNumConfigByType(Map<String, Object> dataMap) {
        final String currentTimeMillis = String.valueOf(System.currentTimeMillis());
        String sqbm = LoginHelper.getLoginerSQBM();
        Integer czryid = Integer.parseInt(LoginHelper.getLoginerId().toString());
        List[] listArray = (List[]) dataMap.get("YWDHCONFIG");
        List<Map<String, Object>> configMapList = listArray[0];
        List<String> flagList = listArray[1];
        List<YwdhConfig> configBeanList = mapsToBeans(configMapList, YwdhConfig.class, true);
        final int dataSize = configMapList.size();

        // 设置操作人员
        configBeanList.forEach(b -> b.setCzryid(czryid));

        List<Integer>
                // 之前的具体类型列表
                jtlxList0 = new ArrayList<>(),
                // 现在的具体类型列表
                jtlxList1 = new ArrayList<>();
        StringBuilder
                // 之前的redis后缀
                jtlxStr0 = new StringBuilder(),
                // 现在的redis后缀
                jtlxStr1 = new StringBuilder();

        int addSize = 0, updateSize = 0, deleteSize = 0, unChangedSize = 0;

        final String rowOp_unchange = "UnChanged";
        for (String flag : flagList) {
            switch (flag) {
                case WebServiceUtils.rowOp_add:
                    addSize++;
                    break;
                case WebServiceUtils.rowOp_delete:
                    deleteSize++;
                    break;
                case WebServiceUtils.rowOp_update:
                    updateSize++;
                    break;
                case rowOp_unchange:
                    unChangedSize++;
                    break;
                default:
                    break;
            }
        }

        boolean
                onlyAdd = addSize == dataSize,
                onlyDelete = deleteSize == dataSize,
                onlyUpdate = updateSize == dataSize,
                unChange = unChangedSize == dataSize;

        if (unChange) {
            return new FuncResult().setMsg("修改成功");
        }
        if (onlyAdd) {
            doOnlyAddAction(configBeanList, jtlxList0, jtlxList1, currentTimeMillis);
        } else if (onlyDelete) {
            doOnlyDeleteAction(configBeanList, jtlxList0, jtlxList1, currentTimeMillis);
        } else {
            doElseAction(listArray, jtlxList0, jtlxList1, onlyUpdate, currentTimeMillis);
        }

        Collections.sort(jtlxList0);
        Collections.sort(jtlxList1);

        jtlxList0.forEach(jtlxStr0::append);
        jtlxList1.forEach(jtlxStr1::append);

        // 做好Redis的同步以及MySQL的数据备份
        syncAndBackup(configBeanList, jtlxStr0, jtlxStr1, currentTimeMillis);

        return new FuncResult().setMsg("修改成功");
    }

    @Override
    public FuncResult deleteBusinessNumConfigByType(Map<String, Object> dataMap) {
        if (dataMap.get("YWDHCONFIG") == null) {
            throw new AppException("YWDHCONFIG不可为空！");
        }
        List[] lists = (List[]) dataMap.get("YWDHCONFIG");
        List<Map<String, Object>> ywdhConfigs = lists[0];
        for (Map<String, Object> ywdhConfigMap : ywdhConfigs) {
            // 条件校验
            if (ywdhConfigMap.get("SQBM") == null) {
                ywdhConfigMap.put("SQBM", LoginHelper.getLoginerSQBM());
            }
            if (ywdhConfigMap.get("CZRYID") == null) {
                ywdhConfigMap.put("CZRYID", LoginHelper.getLoginerId());
            }
            if (ywdhConfigMap.get("PKYWDHCONFIG") == null) {
                throw new AppException("PKYWDHCONFIG不可为空！");
            }
        }

        StringBuilder rklxString = new StringBuilder();
        List<Integer> rklxList = new ArrayList<>();
        for (Map<String, Object> ywdhConfigMap : ywdhConfigs) {
            Map<String, Object> dbYwdhConfigMap = ywdhConfigRepository.selectYwdhConfig(ywdhConfigMap).get(0);
            YwdhConfig dbYwdhConfig = getBean(dbYwdhConfigMap);
            // 删除配置规则
            DBA.delete(null, dbYwdhConfig);
            // 记录日志
            doLogAction(dbYwdhConfig, null);

            if (dbYwdhConfigMap.get("JTLX") != null) {
                int jtlx = Integer.parseInt(dbYwdhConfigMap.get("JTLX").toString());
                rklxList.add(jtlx);
            }
        }

        // 获取key
        Map<String, Object> ywdhConfig = ywdhConfigs.get(0);
        StringBuilder keyName = new StringBuilder(PREFIX + "_" + ywdhConfig.get("SQBM"));
        if (ywdhConfig.get("LX") != null) {
            Long dhlx = YwdhOpsEnum.getOpcode(Integer.parseInt(ywdhConfig.get("LX").toString()));
            keyName.append("_").append(dhlx);
        }
        if (ywdhConfig.get("KSLX") != null) {
            Integer kslx = Integer.parseInt(ywdhConfig.get("KSLX").toString());
            keyName.append("_").append(kslx);
        }

        if (!rklxList.isEmpty()) {
            List<Integer> sorted = rklxList.stream().sorted().collect(Collectors.toList());
            sorted.forEach(rklxString::append);
            keyName.append("_").append(rklxString);
        }

        // 删除redis
        redisTemplate.delete(keyName.toString());
        // 删除mysql键值
        YwdhRedisPair pairCondition = new YwdhRedisPair();
        pairCondition.setSqbm(ywdhConfig.get("SQBM").toString());
        pairCondition.setKeyname(keyName.toString());
        List<YwdhRedisPair> queryResult = ywdhRedisPairRepository.selectYwdhKeyConfig(pairCondition);
        if (!queryResult.isEmpty()) {
            ywdhRedisPairRepository.deleteYwdhKeyConfig(queryResult.get(0));
        }

        return new FuncResult().setMsg("删除成功");
    }

    /**
     * 获取Map类型数据的实体类对象
     *
     * @param dataMap 入参配置信息
     * @return 类对象
     */
    private YwdhConfig getBean(Map<String, Object> dataMap) {
        YwdhConfig bean = new YwdhConfig();
        mapToBean(dataMap, bean, true);
        return bean;
    }

    /**
     * 针对一次UPDATE里面仅有新增的操作
     *
     * @param configBeanList    入参配置
     * @param jtlxList0         改之前的具体类型列表
     * @param jtlxList1         现在的具体类型列表
     * @param currentTimeMillis 系统当前时间戳
     */
    private void doOnlyAddAction(List<YwdhConfig> configBeanList, List<Integer> jtlxList0, List<Integer> jtlxList1, String currentTimeMillis) {
        /*
            currenttimeVersion（乐观锁标识），
            以时间戳实现乐观锁，只有每次修改前从数据库查出来的时间戳和修改时数据库的数据仍然为此值时，才允许修改数据，
            否则已经发生了并行操作，不允许修改。
         */
        String currenttimeVersion = "";

        YwdhConfig param = configBeanList.get(0);
        Map<String, Object> condi = new HashMap<>(4);
        condi.put("sqbm", param.getSqbm());
        condi.put("dhqz", param.getDhqz());
        condi.put("lx", param.getLx());
        condi.put("kslx", param.getKslx());

        // 记录具体类型id值并且修改时间戳
        List<YwdhConfig> queryConfigBeanList = DBA.find(YwdhConfig.class, condi, null);
        for (YwdhConfig config : queryConfigBeanList) {
            currenttimeVersion = config.getCurrenttime();
            jtlxList0.add(config.getJtlx());
            config.setCurrenttime(currentTimeMillis);
        }
        for (YwdhConfig config : configBeanList) {
            jtlxList1.add(config.getJtlx());
            config.setCurrenttime(currentTimeMillis);
        }
        jtlxList1.addAll(jtlxList0);

        // 乐观锁机制下执行数据修改保存操作
        optimisticLockingDataChange(currenttimeVersion, queryConfigBeanList, OPTIMISTIC_LOCK_UPDATE);
        DBA.save(null, configBeanList);
    }

    /**
     * 针对一次UPDATE里面仅有删除的操作
     *
     * @param configBeanList    入参配置
     * @param jtlxList0         改之前的具体类型列表
     * @param jtlxList1         现在的具体类型列表
     * @param currentTimeMillis 系统当前时间戳
     */
    private void doOnlyDeleteAction(List<YwdhConfig> configBeanList, List<Integer> jtlxList0, List<Integer> jtlxList1, String currentTimeMillis) {
        /*
            currenttimeVersion（乐观锁标识），
            以时间戳实现乐观锁，只有每次修改前从数据库查出来的时间戳和修改时数据库的数据仍然为此值时，才允许修改数据，
            否则已经发生了并行操作，不允许修改。
         */
        String currenttimeVersion = "";
        YwdhConfig param = configBeanList.get(0);
        Map<String, Object> condi = new HashMap<>(4);
        condi.put("sqbm", param.getSqbm());
        condi.put("dhqz", param.getDhqz());
        condi.put("lx", param.getLx());
        condi.put("kslx", param.getKslx());

        List<YwdhConfig> queryConfigBeanList = DBA.find(YwdhConfig.class, condi, null);
        currenttimeVersion = queryConfigBeanList.get(0).getCurrenttime();

        // 记录具体类型id值并且修改时间戳
        for (YwdhConfig config : queryConfigBeanList) {
            jtlxList0.add(config.getJtlx());
        }

        List<Integer> needDel = configBeanList.stream().map(YwdhConfig::getJtlx).collect(Collectors.toList());
        List<YwdhConfig> retainConfigList = queryConfigBeanList.stream().filter(jtlx -> !needDel.contains(jtlx.getJtlx())).collect(Collectors.toList());
        List<Integer> retain = retainConfigList.stream().map(YwdhConfig::getJtlx).collect(Collectors.toList());
        jtlxList1.addAll(retain);

        for (YwdhConfig config : retainConfigList) {
            config.setCurrenttime(currentTimeMillis);
        }

        List<Integer> pkids = configBeanList.stream().map(YwdhConfig::getPkywdhconfig).collect(Collectors.toList());
        ywdhConfigRepository.deleteBusinessNumConfigByIds(pkids);

        // 乐观锁执行修改
        optimisticLockingDataChange(currenttimeVersion, retainConfigList, OPTIMISTIC_LOCK_UPDATE);

        // 记录批量删除日志
        List<YwdhConfig> deleteSet = queryConfigBeanList.stream().filter(b -> pkids.contains(b.getPkywdhconfig())).collect(Collectors.toList());
        deleteSet.forEach(config -> doLogAction(config, null));
    }

    /**
     * 针对一次UPDATE里面不是仅有增加操作或不是仅有删除操作的其他操作
     *
     * @param listArray         原生列表数组
     * @param jtlxList0         改之前的具体类型列表
     * @param jtlxList1         现在的具体类型列表
     * @param onlyUpdate        仅有修改的操作
     * @param currentTimeMillis 系统当前时间戳
     */
    private void doElseAction(List[] listArray, List<Integer> jtlxList0, List<Integer> jtlxList1, boolean onlyUpdate, String currentTimeMillis) {
        List<Map<String, Object>> configMapList = listArray[0];
        List<String> flagList = listArray[1];
        List<YwdhConfig> configBeanList = mapsToBeans(configMapList, YwdhConfig.class, true);
        final int dataSize = configMapList.size();
        Integer czryid = Integer.parseInt(LoginHelper.getLoginerId().toString());
        List<YwdhConfig> allDbConfigBeans = new ArrayList<>();

        if (!onlyUpdate) {
            // 获取所涉及到的所有具体类型的数据库记录
            allDbConfigBeans = getYwdhConfigs(configMapList, flagList);
        }

        // 通过flag类型来进行相应的操作，日志记录等
        for (int i = 0; i < dataSize; i++) {
            String flag = flagList.get(i);
            Map<String, Object> map = configMapList.get(i);
            YwdhConfig bean = configBeanList.get(i);

            if (WebServiceUtils.rowOp_add.equalsIgnoreCase(flag)) {
                bean.setCurrenttime(currentTimeMillis);
                bean.setCzryid(czryid);
                // 新增
                DBA.save(null, bean);
                // 记录具体类型id值
                jtlxList1.add(bean.getJtlx());

            } else if (WebServiceUtils.rowOp_delete.equalsIgnoreCase(flag)) {
                YwdhConfig
                        paramConfig = getBean(map),
                        dbConfig = getBean(ywdhConfigRepository.selectYwdhConfig(map).get(0));
                // 乐观锁机制执行删除
                List<YwdhConfig> deleteConfigBeanList = new ArrayList<>();
                deleteConfigBeanList.add(paramConfig);
                optimisticLockingDataChange(dbConfig.getCurrenttime(), deleteConfigBeanList, OPTIMISTIC_LOCK_DELETE);

                // 记录删除日志
                doLogAction(dbConfig, null);
                // 记录具体类型id值
                jtlxList0.add(dbConfig.getJtlx());

            } else if (WebServiceUtils.rowOp_update.equalsIgnoreCase(flag)) {
                YwdhConfig
                        paramConfig = getBean(map),
                        dbConfig = getBean(ywdhConfigRepository.selectYwdhConfig(map).get(0));
                paramConfig.setCurrenttime(currentTimeMillis);
                paramConfig.setCzryid(czryid);
                // 乐观锁机制执行修改
                List<YwdhConfig> updateConfigBeanList = new ArrayList<>();
                updateConfigBeanList.add(paramConfig);
                optimisticLockingDataChange(dbConfig.getCurrenttime(), updateConfigBeanList, OPTIMISTIC_LOCK_UPDATE);
                // 记录修改日志
                doLogAction(dbConfig, paramConfig);
                // 记录具体类型id值
                jtlxList0.add(dbConfig.getJtlx());
                jtlxList1.add(dbConfig.getJtlx());
            }
        }

        if (!onlyUpdate) {
            // 可能有增删和未修改的数据，需要对未修改的数据执行相关操作
            doMoreAction(allDbConfigBeans, jtlxList0, jtlxList1, currentTimeMillis);
        }
    }

    /**
     * 乐观锁机制执行数据改动（UPDATE、DELETE）
     *
     * @param currenttimeVersion 乐观锁标识
     * @param changeDataList     需要进行改动的数据列表
     * @param flag               UPDATE or DELETE
     */
    private void optimisticLockingDataChange(String currenttimeVersion, List<YwdhConfig> changeDataList, String flag) {
        if (OPTIMISTIC_LOCK_UPDATE.equalsIgnoreCase(flag)) {
            for (YwdhConfig config : changeDataList) {
                StringBuilder spliceSQL = new StringBuilder(" ");
                Class<YwdhConfig> c = YwdhConfig.class;
                Field[] fields = c.getDeclaredFields();
                // 反射拼接更新语句的SET项
                for (Field field : fields) {
                    field.setAccessible(true);
                    Class<?> type = field.getType();
                    String name = field.getName();
                    if ("createdAt".equalsIgnoreCase(name) || "updatedAt".equalsIgnoreCase(name)) {
                        continue;
                    }
                    Object value = null;
                    try {
                        value = field.get(config);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }

                    if (type == String.class) {
                        spliceSQL.append(name).append("='").append(value).append("',");
                    } else {
                        spliceSQL.append(name).append("=").append(value).append(",");
                    }
                }
                String sqlToString = spliceSQL.substring(0, spliceSQL.length() - 1);
                String updateSQL = "update ywdh_config set " + sqlToString + " where PKYWDHCONFIG=" + config.getPkywdhconfig() + " and CURRENTTIME=" + currenttimeVersion;
                if (DBA.executeSQL(updateSQL, null) != 1) {
                    throw new AppException("当前页面数据已被更改，请刷新页面后再试！");
                }
            }
        } else if (OPTIMISTIC_LOCK_DELETE.equalsIgnoreCase(flag)) {
            for (YwdhConfig config : changeDataList) {
                String deleteSQL = "delete from ywdh_config where PKYWDHCONFIG=" + config.getPkywdhconfig() + " and CURRENTTIME=" + currenttimeVersion;
                if (DBA.executeSQL(deleteSQL, null) != 1) {
                    throw new AppException("当前页面数据已被更改，请刷新页面后再试！");
                }
            }
        }
    }

    /**
     * 获取所涉及到的所有具体类型的数据库记录
     *
     * @param configMapList 入参配置集合
     * @param flagList      入参标志集合
     * @return 所有相关的配置项（即每一个具体类型的数据记录）
     */
    private List<YwdhConfig> getYwdhConfigs(List<Map<String, Object>> configMapList, List<String> flagList) {
        int dataSize = configMapList.size();
        List<YwdhConfig> allDbConfigBeans;
        Map<String, Object> oneMap = null;
        for (int i = 0; i < dataSize; i++) {
            // 随便选择一个修改的或者删除的（为了获取时间戳），通过时间戳查询数据库里的所有config
            boolean deleteOrUpdate = WebServiceUtils.rowOp_delete.equalsIgnoreCase(flagList.get(i))
                    || WebServiceUtils.rowOp_update.equalsIgnoreCase(flagList.get(i));
            if (deleteOrUpdate) {
                oneMap = configMapList.get(i);
                break;
            }
        }
        String dbTime =
                ywdhConfigRepository.selectYwdhConfig(oneMap)
                        .get(0).get("CURRENTTIME").toString();

        Map<String, Object> condi = new HashMap<>(2);
        condi.put("SQBM", LoginHelper.getLoginerSQBM());
        condi.put("CURRENTTIME", dbTime);
        allDbConfigBeans = mapsToBeans(ywdhConfigRepository.selectYwdhConfig(condi),
                YwdhConfig.class, true);
        return allDbConfigBeans;
    }

    /**
     * 可能有增删和未修改的数据，需要对未修改的数据执行相关操作
     *
     * @param allDbConfigBeans  涉及到的所有具体类型的业务配置
     * @param jtlxList0         改之前的具体类型列表
     * @param jtlxList1         现在的具体类型列表
     * @param currentTimeMillis 系统当前时间戳
     */
    private void doMoreAction(List<YwdhConfig> allDbConfigBeans, List<Integer> jtlxList0, List<Integer> jtlxList1, String currentTimeMillis) {
        List<YwdhConfig> unchangedList =
                allDbConfigBeans.stream()
                        .filter(b -> !jtlxList0.contains(b.getJtlx()) && !jtlxList1.contains(b.getJtlx()))
                        .collect(Collectors.toList());

        List<Integer> unchangedJtlxs =
                unchangedList.stream()
                        .map(YwdhConfig::getJtlx).collect(Collectors.toList());

        jtlxList0.addAll(unchangedJtlxs);
        jtlxList1.addAll(unchangedJtlxs);

        unchangedList.forEach(b -> b.setCurrenttime(currentTimeMillis));
        DBA.update(null, unchangedList);
    }

    /**
     * 执行Redis的单号起始号改动以及在MySQL做好备份（用作在Redis数据丢失之后通过MySQL找回数据）
     *
     * @param configBeanList    入参配置
     * @param jtlxStr0          改之前的具体类型
     * @param jtlxStr1          现在的具体类型
     * @param currentTimeMillis 系统当前时间戳
     */
    private void syncAndBackup(List<YwdhConfig> configBeanList, StringBuilder jtlxStr0, StringBuilder jtlxStr1, String currentTimeMillis) {
        String sqbm = LoginHelper.getLoginerSQBM();
        YwdhConfig config = configBeanList.get(0);

        // 获取keyName
        StringBuilder
                keyName0 = new StringBuilder(PREFIX + "_" + sqbm),
                keyName1 = new StringBuilder(PREFIX + "_" + sqbm);
        if (config.getLx() != null) {
            Long dhlx = YwdhOpsEnum.getOpcode(config.getLx());
            keyName0.append("_").append(dhlx);
            keyName1.append("_").append(dhlx);
        }
        if (config.getKslx() != null) {
            keyName0.append("_").append(config.getKslx());
            keyName1.append("_").append(config.getKslx());
        }
        if (StringUtils.isNotBlank(jtlxStr0) && !Objects.equals("null", jtlxStr0.toString())) {
            keyName0.append("_").append(jtlxStr0);
        }
        if (StringUtils.isNotBlank(jtlxStr1) && !Objects.equals("null", jtlxStr1.toString())) {
            keyName1.append("_").append(jtlxStr1);
        }

        // 删除mysql旧键值
        YwdhRedisPair pair0 = new YwdhRedisPair(null, null, sqbm, keyName0.toString(), null);
        List<YwdhRedisPair> pairQueryResult = ywdhRedisPairRepository.selectYwdhKeyConfig(pair0);
        DBA.delete(null, pairQueryResult);

        // 添加mysql新键值
        YwdhRedisPair pair1 = new YwdhRedisPair(null, currentTimeMillis, sqbm, keyName1.toString(), config.getDhqsh().toString());
        DBA.save(null, pair1);

        // 删除旧redis
        redisTemplate.delete(keyName0.toString());
        // 添加新redis
        callRedisToSetKeyAndExpiration(keyName1.toString(), Integer.parseInt(config.getDhqsh().toString()));
    }

    /**
     * 通过反射记录日志
     *
     * @param from 从什么
     * @param to   变成了什么
     */
    private void doLogAction(YwdhConfig from, YwdhConfig to) {
        boolean
                del = from != null && to == null,
                mod = from != null && to != null;

        DBAgent dba = DBAgent.getInstance();
        // 获取所有字段
        Field[] fields = YwdhConfig.class.getDeclaredFields();
        LogCzrz rz = new LogCzrz();
        StringBuilder tableColumn = new StringBuilder();
        StringBuilder xgxx = new StringBuilder();
        for (Field field : fields) {
            // 获取属性名
            String attrName = field.getName();
            // 将属性名的首字母变为大写，为set/get方法做准备
            String methodName = attrName.substring(0, 1).toUpperCase() + attrName.substring(1);
            Object result = null;
            Object dbObj = null;
            try {
                // 获取类当前属性的set/getXXX方法（只获取公有方法）
                Method method = YwdhConfig.class.getMethod("get" + methodName);
                // 执行该方法
                if (mod) {
                    result = method.invoke(to);
                }
                dbObj = method.invoke(from);
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                try {
                    result = field.get(to);
                    dbObj = field.get(from);
                } catch (IllegalAccessException illegalAccessException) {
                    illegalAccessException.printStackTrace();
                }
                e.printStackTrace();
            }

            // 修改又是字段给的null，这种情况不记录日志，其他都记录
            if (!mod || result != null) {
                // 判断字段并进行日志记录
                if (!Objects.equals(dbObj, result)) {
                    tableColumn.append(attrName).append(", ");
                    xgxx.append(attrName).append(": ").append(dbObj).append(" -> ").append(result).append(" | ");
                }
            }
        }
        if (tableColumn.length() > 0) {
            rz.setTableName("ywdh_config");
            rz.setTableId(from.getPkywdhconfig().toString());
            rz.setSqbm(LoginHelper.getLoginerSQBM());
            rz.setXgysbm(LoginHelper.getLoginerBm());
            rz.setXgysmc(LoginHelper.getLoginerName());
            rz.setTableColumn(tableColumn.toString());
            rz.setXgxx(xgxx.toString());
            Map<String, Integer> m = DateTransUtil.getOLEDateFromDate(new Date());
            rz.setXgrq(m.get("days"));
            rz.setXgsj(m.get("second"));
            try {
                InetAddress host = InetAddress.getLocalHost();
                rz.setMachineIp(host.getHostAddress());
                rz.setMachineName(host.getHostName());
            } catch (UnknownHostException e) {
                rz.setMachineName(null);
                rz.setMachineIp(null);
            }
            dba.save("LogCzrz", rz);
        }
    }

    /**
     * 已经进行了业务单号配置的科室将不允许再次设置
     * 一个用户不可对同一社区，同一单号类型，同一药库，同一具体操作设置两套不同的规则
     *
     * @param config 业务单号配置
     */
    private void checkAvailability(YwdhConfig config) {
        String sqbm = config.getSqbm() == null ? LoginHelper.getLoginerSQBM() : config.getSqbm();
        HashMap<String, Object> condition = new HashMap<>(4);
        condition.put("SQBM", sqbm);
        if (config.getLx() != null) {
            condition.put("LX", config.getLx());
        }
        if (config.getKslx() != null) {
            condition.put("KSLX", config.getKslx());
        }
        if (config.getJtlx() != null) {
            condition.put("JTLX", config.getJtlx());
        }

        List<Map<String, Object>> queryResult = ywdhConfigRepository.selectYwdhConfig(condition);

        if (!queryResult.isEmpty()) {
            throw new AppException("配置 lx:" + config.getLx() + " kslx:" + config.getKslx() + " jtlx:" + config.getJtlx() + " 已存在！");
        }
    }

    /**
     * 设置redis键的同时也设置他的时效性(默认采用当天有效)
     *
     * @param key   键
     * @param value 值
     */
    private void callRedisToSetKeyAndExpiration(String key, Object value) {
        Calendar calendar = new GregorianCalendar();
        // 时
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        // 分
        calendar.set(Calendar.MINUTE, 50);
        // 秒
        calendar.set(Calendar.SECOND, 0);
        // 毫秒
        calendar.set(Calendar.MILLISECOND, 0);

        redisTemplate.opsForValue().set(key, value);
        redisTemplate.expireAt(key, calendar.getTime());
    }
}

public interface NumberHelper {

    /**
     * 生成药库增序单号
     *
     * @param ywdhConfig 业务单号生成规则
     * @param keyName    Redis唯一键：前缀（INCR） + opcode + "_" + sqbm
     * @return 业务单号
     */
    String generateIncrementSequenceNumber(YwdhConfig ywdhConfig, String keyName);

}

@Service("NumberHelper")
public class NumberHelperImpl implements NumberHelper {

    @Override
    public String generateIncrementSequenceNumber(YwdhConfig config, String keyName) {
        DBAgent dbAgent = DBAgent.getInstance();

        // 单号起始号
        long dhqsh = Long.parseLong(config.getDhqsh().toString());
        if (redisTemplate.hasKey(keyName)) {
            // 单号步长
            long dhbc = Long.parseLong(config.getDhbc().toString());
            dhqsh = redisTemplate.opsForValue().increment(keyName, dhbc);
        } else {
            redisTemplate.opsForValue().set(keyName, dhqsh);
        }

        // 单号长度
        Integer dhcd = config.getDhcd();
        // 前补零操作
        String str = IntStream.range(0, dhcd).mapToObj(i -> "0").collect(Collectors.joining());
        DecimalFormat df = new DecimalFormat(str);
        String format = df.format(dhqsh);

        String s = "select BM from zd_ks where sqbm = ::SQBM and sysid = ::SYSID";
        Map<String, Object> map = new HashMap<>();
        map.put("SQBM", config.getSqbm());
        map.put("SYSID", config.getKslx());
        List<Map<String, Object>> result = dbAgent.querySQL(s, map, null);
        Object bm = result.get(0).get("BM");
        // 拼接单号，比如首单入库将可拼接为：RK0380000000000001
        return config.getDhqz() + bm + format;
    }
}