redis之缓存码表

前言

本篇是一个简单的将常用的码表缓存进redis的代码, 防止频繁访问数据库.

说明

1. 由于是小系统内部使用, 没有对redis做防止雪崩的处理.

2. 加入了页面动态控制:
   

3. 可随配置项动态更新redis的内容

4. 提供了6中访问数据的键值对格式

5. 可同步所有数据, 也可监测redis和数据库的差异数据. 均对代码做了优化处理. 其中查重数据的算法值得推荐一下, 利用map的key非重复做的查询
   相关代码:

    /**
     * 两个list取不同
     */
    private static StringBuffer getDiffrent(List<String> listRedis, List<String> listSql) {
        Map<String,Integer> map = new HashMap<String,Integer>(listRedis.size()+listSql.size());
        StringBuffer diff = new StringBuffer();
        for (String string : listSql) {
            map.put(string, 1);
        }
        for (String string : listRedis) {
            Integer cc = map.get(string);
            if (cc != null) {
                map.put(string, ++cc);
                continue;
            }
            diff.append("redis- ").append(string).append("</br>");
        }
        for(Map.Entry<String, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                diff.append("sql- ").append(entry.getKey()).append("</br>");
            }
        }
        return diff;
    }

所有代码

/**
 * VMasterUtils
 */
public class VMasterUtils {

    private static final Logger logger = Logger.getLogger(VMasterUtils.class);
    public static final String Master_PREFIX = "ccrv:md:";
    public static final String ListByKey_PREFIX = "ccrv:md:ListByKey:";
    public static final String IdValByKeyPy_PREFIX = "ccrv:md:IdValByKeyPy:";
    public static final String IdByKeyPy_PREFIX = "ccrv:md:IdByKeyPy:";
    public static final String IdByKeyVal_PREFIX = "ccrv:md:IdByKeyVal:";
    public static final String PyByKeyVal_PREFIX = "ccrv:md:PyByKeyVal:";
    public static final String ValById_PREFIX = "ccrv:md:ValById:";

    private static IVMasterService getVMasterService() {
        return (IVMasterService) Action.ctx.getBean("vMasterService");
    }

    /**
     * 2 -> 3 + 5
     * 1.通过 select_key 查找列表 master_detail_id, master_value, py
     */
    public static List getListByKey(String selectKey) {
        if (isInvalid(selectKey)) {
            return new ArrayList();
        }
        List redisResult = new ArrayList();
        try {
            redisResult = RedisUtil.getList(ListByKey_PREFIX + selectKey);
            if (redisResult == null || redisResult.size() == 0) {
                throw new Exception(selectKey + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getListByKey: " + e.getMessage());
            redisResult = getListByKeyFromSql(selectKey, new Boolean[]{true});
            return redisResult == null ? new ArrayList() : redisResult;
        }
    }

    public static List getListByKeyFromSql(String selectKey, Boolean[] setRedis) {
        List list = new ArrayList();
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectListByKey(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                String value = ClobToString((Clob) ((Map) listFromSql.get(0)).get("CONCATVALUE"));
                list = new Gson().fromJson(value, list.getClass());
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(ListByKey_PREFIX, selectKey, value);
                }
                return list;
            } else {
                saveErrorLog(selectKey + " sql_no_data ");
                setRedis[0] = false;
                return new ArrayList();
            }
        } catch (Exception e) {
            saveErrorLog(" getListByKeyFromSql: " + e.getMessage());
            setRedis[0] = false;
            return list;
        }
    }

    /**
     * 2 + 4 -> 3 + 5
     * 2.通过 select_key, py(非空) 查找 master_detail_id, master_value, py
     */
    public static List getIdValByKeyPy(String selectKey, String py) {
        if (isInvalid(selectKey, py)) {
            return new ArrayList();
        }
        List redisResult = new ArrayList();
        try {
            redisResult = RedisUtil.getList(IdValByKeyPy_PREFIX + selectKey + ":" + py);
            if (redisResult == null || redisResult.size() == 0) {
                throw new Exception(selectKey + ":" + py + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getIdValByKeyPy: " + e.getMessage());
            redisResult = getIdValByKeyPyFromSql(selectKey, py, new Boolean[]{true});
            return redisResult == null ? new ArrayList() : redisResult;
        }
    }

    public static List getIdValByKeyPyFromSql(String selectKey, String py, Boolean[] setRedis) {
        List list = new ArrayList();
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            mapParam.put("py", py);
            mapParam.put("pyChanged", true);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectIdValByKeyPy(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                String value = (String) ((Map) listFromSql.get(0)).get("CONCATVALUE");
                list = new Gson().fromJson(value, list.getClass());
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(IdValByKeyPy_PREFIX, selectKey + ":" + py, value);
                }
                return list;
            } else {
                saveErrorLog(selectKey + ":" + py + " sql_no_data ");
                setRedis[0] = false;
                return new ArrayList();
            }
        } catch (Exception e) {
            saveErrorLog(" getIdValByKeyPyFromSql: " + e.getMessage());
            setRedis[0] = false;
            return list;
        }
    }

    /**
     * 2 + 4 -> 3
     * 3.通过 select_key, py(非空) 查找 master_detail_id
     */
    public static String getIdByKeyPy(String selectKey, String py) {
        if (isInvalid(selectKey, py)) {
            return "";
        }
        String redisResult = "";
        try {
            redisResult = RedisUtil.get(IdByKeyPy_PREFIX + selectKey + ":" + py);
            if (redisResult == null || redisResult.equals("null") || redisResult.equals("")) {
                throw new Exception(selectKey + ":" + py + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getIdByKeyPy: " + e.getMessage());
            redisResult = getIdByKeyPyFromSql(selectKey, py, new Boolean[]{true});
            return redisResult == null ? "" : redisResult;
        }
    }

    public static String getIdByKeyPyFromSql(String selectKey, String py, Boolean[] setRedis) {
        String value = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            mapParam.put("py", py);
            mapParam.put("pyChanged", true);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectIdByKeyPy(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                value = (String) ((Map) listFromSql.get(0)).get("CONCATVALUE");
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(IdByKeyPy_PREFIX, selectKey + ":" + py, value);
                }
                return value;
            } else {
                saveErrorLog(selectKey + ":" + py + " sql_no_data ");
                setRedis[0] = false;
                return "";
            }
        } catch (Exception e) {
            saveErrorLog(" getIdByKeyPyFromSql: " + e.getMessage());
            setRedis[0] = false;
            return value;
        }
    }

    /**
     * 2 + 5 -> 3
     * 4.通过 select_key, master_value 查找 master_detail_id
     */
    public static String getIdByKeyVal(String selectKey, String masterValue) {
        if (isInvalid(selectKey, masterValue)) {
            return "";
        }
        String redisResult = "";
        try {
            redisResult = RedisUtil.get(IdByKeyVal_PREFIX + selectKey + ":" + masterValue);
            if (redisResult == null || redisResult.equals("null") || redisResult.equals("")) {
                throw new Exception(selectKey + ":" + masterValue + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getIdByKeyVal: " + e.getMessage());
            redisResult = getIdByKeyValFromSql(selectKey, masterValue, new Boolean[]{true});
            return redisResult == null ? "" : redisResult;
        }
    }

    public static String getIdByKeyValFromSql(String selectKey, String masterValue, Boolean[] setRedis) {
        String value = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            mapParam.put("masterValue", masterValue);
            mapParam.put("masterValueChanged", true);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectIdByKeyVal(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                value = (String) ((Map) listFromSql.get(0)).get("CONCATVALUE");
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(IdByKeyVal_PREFIX, selectKey + ":" + masterValue, value);
                }
                return value;
            } else {
                saveErrorLog(selectKey + ":" + masterValue + " sql_no_data ");
                setRedis[0] = false;
                return "";
            }
        } catch (Exception e) {
            saveErrorLog(" getIdByKeyValFromSql: " + e.getMessage());
            setRedis[0] = false;
            return value;
        }
    }

    /**
     * 2 + 5 -> 4
     * 5.通过 select_key, master_value 查找 py
     */
    public static String getPyByKeyVal(String selectKey, String masterValue) {
        if (isInvalid(selectKey, masterValue)) {
            return "";
        }
        String redisResult = "";
        try {
            redisResult = RedisUtil.get(PyByKeyVal_PREFIX + selectKey + ":" + masterValue);
            if (redisResult == null || redisResult.equals("null") || redisResult.equals("")) {
                throw new Exception(selectKey + ":" + masterValue + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getPyByKeyVal: " + e.getMessage());
            redisResult = getPyByKeyValFromSql(selectKey, masterValue, new Boolean[]{true});
            return redisResult == null ? "" : redisResult;
        }
    }

    public static String getPyByKeyValFromSql(String selectKey, String masterValue, Boolean[] setRedis) {
        String value = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            mapParam.put("masterValue", masterValue);
            mapParam.put("masterValueChanged", true);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectPyByKeyVal(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                value = (String) ((Map) listFromSql.get(0)).get("CONCATVALUE");
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(PyByKeyVal_PREFIX, selectKey + ":" + masterValue, value);
                }
                return value;
            } else {
                saveErrorLog(selectKey + ":" + masterValue + " sql_no_data ");
                setRedis[0] = false;
                return "";
            }
        } catch (Exception e) {
            saveErrorLog(" getPyByKeyValFromSql: " + e.getMessage());
            setRedis[0] = false;
            return value;
        }
    }

    /**
     * 3 -> 5
     * 6.通过 master_detail_id 查找 master_value
     */
    public static String getValById(String masterDetailId) {
        if(!StringUtils.isNotEmpty(masterDetailId) || "null".equals(masterDetailId)){
            return "";
        }
        String redisResult = "";
        try {
            redisResult = RedisUtil.get(ValById_PREFIX + masterDetailId);
            if (redisResult == null || redisResult.equals("null") || redisResult.equals("")) {
                throw new Exception(masterDetailId + " redis_no_data ");
            }
            return redisResult;
        } catch (Exception e) {
            saveErrorLog(" getValById: " + e.getMessage());
            redisResult = getValByIdFromSql(masterDetailId, new Boolean[]{true});
            return redisResult == null ? "" : redisResult;
        }
    }

    public static String getValByIdFromSql(String masterDetailId, Boolean[] setRedis) {
        String value = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("masterDetailId", masterDetailId);
            mapParam.put("masterDetailIdChanged", true);
            mapParam.put("selectKeyChanged", false);
            IdentityBean identityBean = new IdentityBean();
            List listFromSql = vMasterService.selectValById(identityBean, mapParam);
            if (listFromSql != null && listFromSql.size() > 0) {
                value = (String) ((Map) listFromSql.get(0)).get("CONCATVALUE");
                if (setRedis[0]) {
                    setRedis[0] = saveOneToRedis(ValById_PREFIX, masterDetailId, value);
                }
                return value;
            } else {
                saveErrorLog(masterDetailId + " sql_no_data ");
                setRedis[0] = false;
                return "";
            }
        } catch (Exception e) {
            saveErrorLog(" getValByIdFromSql: " + e.getMessage());
            setRedis[0] = false;
            return value;
        }
    }

    /**
     * 检查全部数据
     */
    public static String checkAllData() {
        StringBuffer returnMsg = new StringBuffer();
        String msgPrefix = "**************************</br>**************************</br>";

        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean ident = new IdentityBean();
            Map map = new HashMap();

            List<Map<String, String>> listByKeyListRedis = RedisUtil.getListLike(ListByKey_PREFIX + "*");
            List<Map<String, String>> idValByKeyPyListRedis = RedisUtil.getListLike(IdValByKeyPy_PREFIX + "*");
            List<Map<String, String>> idByKeyPyListRedis = RedisUtil.getListLike(IdByKeyPy_PREFIX + "*");
            List<Map<String, String>> idByKeyValListRedis = RedisUtil.getListLike(IdByKeyVal_PREFIX + "*");
            List<Map<String, String>> pyByKeyValListRedis = RedisUtil.getListLike(PyByKeyVal_PREFIX + "*");
            List<Map<String, String>> valByIdListRedis = RedisUtil.getListLike(ValById_PREFIX + "*");

            List<Map<String, Object>> listByKeyList = vMasterService.selectListByKey(ident, map);
            List<Map<String, Object>> idValByKeyPyList = vMasterService.selectIdValByKeyPy(ident, map);
            List<Map<String, Object>> idByKeyPyList = vMasterService.selectIdByKeyPy(ident, map);
            List<Map<String, Object>> idByKeyValList = vMasterService.selectIdByKeyVal(ident, map);
            List<Map<String, Object>> pyByKeyValList = vMasterService.selectPyByKeyVal(ident, map);
            List<Map<String, Object>> valByIdList = vMasterService.selectValById(ident, map);

            returnMsg.append(msgPrefix).append(ListByKey_PREFIX).append(" 的差异数据:</br>").append(check2List(listByKeyListRedis, listByKeyList, ListByKey_PREFIX)).append("</br>");
            returnMsg.append(msgPrefix).append(IdValByKeyPy_PREFIX).append(" 的差异数据:</br>").append(check2List(idValByKeyPyListRedis, idValByKeyPyList, IdValByKeyPy_PREFIX)).append("</br>");
            returnMsg.append(msgPrefix).append(IdByKeyPy_PREFIX).append(" 的差异数据:</br>").append(check2List(idByKeyPyListRedis, idByKeyPyList, IdByKeyPy_PREFIX)).append("</br>");
            returnMsg.append(msgPrefix).append(IdByKeyVal_PREFIX).append(" 的差异数据:</br>").append(check2List(idByKeyValListRedis, idByKeyValList, IdByKeyVal_PREFIX)).append("</br>");
            returnMsg.append(msgPrefix).append(PyByKeyVal_PREFIX).append(" 的差异数据:</br>").append(check2List(pyByKeyValListRedis, pyByKeyValList, PyByKeyVal_PREFIX)).append("</br>");
            returnMsg.append(msgPrefix).append(ValById_PREFIX).append(" 的差异数据:</br>").append(check2List(valByIdListRedis, valByIdList, ValById_PREFIX)).append("</br>");

            return returnMsg.toString();
        } catch (Exception e) {
            saveErrorLog(" checkAllData: " + e.getMessage());
            returnMsg.append(" </br> checkAllData error! ");
            return returnMsg.toString();
        }
    }

    /**
     * 检查两个list各自差集
     */
    private static StringBuffer check2List(List<Map<String, String>> listRedis, List<Map<String, Object>> listSql, String prefix) throws Exception {
        List<String> listRedis2 = new ArrayList<String>();
        for (Map<String, String> listRedisMap : listRedis) {
            listRedis2.add(listRedisMap.get("SELECTKEY") + listRedisMap.get("CONCATVALUE"));
        }
        List<String> listSql2 = new ArrayList<String>();
        if (prefix.equals(ListByKey_PREFIX)) {
            for (Map<String, Object> listSqlMap : listSql) {
                listSql2.add(prefix + listSqlMap.get("SELECTKEY") + ClobToString((Clob) listSqlMap.get("CONCATVALUE")));
            }
        } else {
            for (Map<String, Object> listSqlMap : listSql) {
                listSql2.add(prefix + listSqlMap.get("SELECTKEY") + (String) listSqlMap.get("CONCATVALUE"));
            }
        }
        return getDiffrent(listRedis2, listSql2);
    }

    /**
     * 保存全部数据
     */
    public static String saveAllData() {
        String returnMsg = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean ident = new IdentityBean();
            Map map = new HashMap();
            List listByKeyList = vMasterService.selectListByKey(ident, map);
            returnMsg += ListByKey_PREFIX + saveCloblistToRedis(listByKeyList, ListByKey_PREFIX) + "</br>";
            List idValByKeyPyList = vMasterService.selectIdValByKeyPy(ident, map);
            returnMsg += IdValByKeyPy_PREFIX + saveStringlistToRedis(idValByKeyPyList, IdValByKeyPy_PREFIX) + "</br>";
            List idByKeyPyList = vMasterService.selectIdByKeyPy(ident, map);
            returnMsg += IdByKeyPy_PREFIX + saveStringlistToRedis(idByKeyPyList, IdByKeyPy_PREFIX) + "</br>";
            List idByKeyValList = vMasterService.selectIdByKeyVal(ident, map);
            returnMsg += IdByKeyVal_PREFIX + saveStringlistToRedis(idByKeyValList, IdByKeyVal_PREFIX) + "</br>";
            List pyByKeyValList = vMasterService.selectPyByKeyVal(ident, map);
            returnMsg += PyByKeyVal_PREFIX + saveStringlistToRedis(pyByKeyValList, PyByKeyVal_PREFIX) + "</br>";
            List valByIdList = vMasterService.selectValById(ident, map);
            returnMsg += ValById_PREFIX + saveStringlistToRedis(valByIdList, ValById_PREFIX) + "</br>";
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" saveAllDataToRedisError: " + e.getMessage());
            returnMsg += " saveAllDataToRedisError error! ";
            return returnMsg;
        }
    }

    /**
     * 根据selectKey保存一个selectKey相关全部数据
     */
    public static String saveOneData(String selectKey) throws Exception {
        String returnMsg = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean identityBean = new IdentityBean();
            returnMsg += saveOneDataByKey(vMasterService, identityBean, ListByKey_PREFIX, selectKey);
            returnMsg += saveOneDataByKey(vMasterService, identityBean, IdValByKeyPy_PREFIX, selectKey);
            returnMsg += saveOneDataByKey(vMasterService, identityBean, IdByKeyPy_PREFIX, selectKey);
            returnMsg += saveOneDataByKey(vMasterService, identityBean, IdByKeyVal_PREFIX, selectKey);
            returnMsg += saveOneDataByKey(vMasterService, identityBean, PyByKeyVal_PREFIX, selectKey);
            returnMsg += saveOneDataByKey(vMasterService, identityBean, ValById_PREFIX, selectKey);
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" saveOneDataToRedisError: " + e.getMessage());
            returnMsg += " saveOneData error! ";
            return returnMsg;
        }
    }

    private static String saveOneDataByKey(IVMasterService vMasterService, IdentityBean identityBean, String prefix, String selectKey) {
        String returnMsg = "";
        try {
            Map<String, Object> mapParam = new HashMap<String, Object>();
            mapParam.put("selectKey", selectKey);
            mapParam.put("selectKeyChanged", true);
            List listFromSql = new ArrayList();
            String resultSave = "";
            if (prefix.equals(ListByKey_PREFIX)) {
                listFromSql = vMasterService.selectListByKey(identityBean, mapParam);
                resultSave = saveCloblistToRedis(listFromSql, ListByKey_PREFIX);
            } else if (prefix.equals(IdValByKeyPy_PREFIX)) {
                listFromSql = vMasterService.selectIdValByKeyPy(identityBean, mapParam);
                resultSave = saveStringlistToRedis(listFromSql, IdValByKeyPy_PREFIX);
            } else if (prefix.equals(IdByKeyPy_PREFIX)) {
                listFromSql = vMasterService.selectIdByKeyPy(identityBean, mapParam);
                resultSave = saveStringlistToRedis(listFromSql, IdByKeyPy_PREFIX);
            } else if (prefix.equals(IdByKeyVal_PREFIX)) {
                listFromSql = vMasterService.selectIdByKeyVal(identityBean, mapParam);
                resultSave = saveStringlistToRedis(listFromSql, IdByKeyVal_PREFIX);
            } else if (prefix.equals(PyByKeyVal_PREFIX)) {
                listFromSql = vMasterService.selectPyByKeyVal(identityBean, mapParam);
                resultSave = saveStringlistToRedis(listFromSql, PyByKeyVal_PREFIX);
            } else if (prefix.equals(ValById_PREFIX)) {
                mapParam.put("masterDetailIdChanged", false);
                listFromSql = vMasterService.selectValById(identityBean, mapParam);
                resultSave = saveStringlistToRedis(listFromSql, ValById_PREFIX);
            }
            returnMsg += "OK".equals(resultSave) ? "" : resultSave;
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" saveOneDataByKeyToRedisError: " + e.getMessage());
            returnMsg += " saveOneDataByKeyToRedisError error! ";
            return returnMsg;
        }
    }

    /**
     * 添加或更新多条数据进redis(string)
     */
    private static String saveStringlistToRedis(List list, String prefixStr) throws Exception {
        if (list.size() == 0) {
            return " saveStringlistToRedis " + prefixStr + " sql_no_data ";
        }
        String[] data = new String[list.size() * 2];
        for (int i = 0, j = list.size(); i < j; i++) {
            Map<String, String> mapTemp = (Map<String, String>) list.get(i);
            data[i * 2] = prefixStr + mapTemp.get("SELECTKEY");
            data[i * 2 + 1] = mapTemp.get("CONCATVALUE");
        }
        String result = RedisUtil.mset(data);
        return "OK".equals(result) ? "OK" : " saveStringlistToRedis " + prefixStr + " error ";
    }

    /**
     * 添加或更新多条数据进redis(clob)
     */
    private static String saveCloblistToRedis(List list, String prefixStr) throws Exception {
        if (list.size() == 0) {
            return " saveCloblistToRedis " + prefixStr + " sql_no_data ";
        }
        String[] data = new String[list.size() * 2];
        for (int i = 0, j = list.size(); i < j; i++) {
            Map<String, Object> mapTemp = (Map<String, Object>) list.get(i);
            data[i * 2] = prefixStr + mapTemp.get("SELECTKEY");
            data[i * 2 + 1] = ClobToString((Clob) mapTemp.get("CONCATVALUE"));
        }
        String result = RedisUtil.mset(data);
        return "OK".equals(result) ? "OK" : " saveCloblistToRedis " + prefixStr + " error ";
    }

    /**
     * 添加或更新一条数据进redis(string)
     */
    public static boolean saveOneToRedis(String prefix, String key, String value) {
        try {
            String result = RedisUtil.set(prefix + key, value);
            if (!"OK".equals(result)) {
                throw new Exception(prefix + key + " redis_not_save ");
            }
            return true;
        } catch (Exception e) {
            saveErrorLog(" saveOneDataToRedisError: " + e.getMessage());
            return false;
        }
    }

    /**
     * 物理删除一条或多条记录
     */
    public static Long deleteData(String... keys) {
        try {
            return RedisUtil.del(keys);
        } catch (Exception e) {
            saveErrorLog(" deleteDataRedisError: " + e.getMessage());
            return 0L;
        }
    }

    /**
     * 清空vmaster所有数据缓存
     */
    public static String delAllMasterData() {
        try {
            return " ClearAllMasterCache: " + RedisUtil.deleteByPrex(Master_PREFIX);
        } catch (Exception e) {
            saveErrorLog(" delAllMasterDataRedisError: " + e.getMessage());
            return " ClearAllMasterCache: error ";
        }
    }

    /**
     * 基础数据类型维护页面用
     * 修改基础数据类型同步到Redis
     * 1.Redis删除指定selectKey所有相关数据
     * 2.替换key后查询数据库插入Redis
     */
    public static String updateRedisByKey(String oldSelectKey, String newSelectKey) {
        String returnMsg = "";
        try {
            // 1
            String oldListByKey = ListByKey_PREFIX + oldSelectKey;
            Boolean[] flag1 = new Boolean[]{true};
            getListByKeyFromSql(newSelectKey, flag1);
            Long delCount1 = 0L;
            if (RedisUtil.hasKey(oldListByKey)) {
                delCount1 = RedisUtil.del(oldListByKey) - 1L;
            }
            if (!(delCount1 == 0L)) {
                returnMsg += " ListByKey update: Redis Error ";
            }
            // 2
            String oldIdValByKeyPy = IdValByKeyPy_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdValByKeyPySet = RedisUtil.keys(oldIdValByKeyPy);
            if (oldIdValByKeyPySet.size() > 0) {
                int addCount2 = 0;
                for (String str : oldIdValByKeyPySet) {
                    String py = str.substring(str.lastIndexOf(":") + 1, str.length());
                    Boolean[] flag = new Boolean[]{true};
                    getIdValByKeyPyFromSql(newSelectKey, py, flag);
                    if (flag[0]) {
                        addCount2++;
                    }
                }
                String[] oldIdValByKeyPyArray = oldIdValByKeyPySet.toArray(new String[0]);
                Long delCount2 = RedisUtil.del(oldIdValByKeyPyArray);
                if (addCount2 != delCount2) {
                    returnMsg += " IdValByKeyPy update: Redis Error ";
                }
            }
            // 3
            String oldIdByKeyPy = IdByKeyPy_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdByKeyPySet = RedisUtil.keys(oldIdByKeyPy);
            if (oldIdByKeyPySet.size() > 0) {
                int addCount3 = 0;
                for (String str : oldIdByKeyPySet) {
                    String py = str.substring(str.lastIndexOf(":") + 1, str.length());
                    Boolean[] flag = new Boolean[]{true};
                    getIdByKeyPyFromSql(newSelectKey, py, flag);
                    if (flag[0]) {
                        addCount3++;
                    }
                }
                String[] oldIdByKeyPyArray = oldIdByKeyPySet.toArray(new String[0]);
                Long delCount3 = RedisUtil.del(oldIdByKeyPyArray);
                if (addCount3 != delCount3) {
                    returnMsg += " IdByKeyPy update: Redis Error ";
                }
            }
            // 4
            String oldIdByKeyVal = IdByKeyVal_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdByKeyValSet = RedisUtil.keys(oldIdByKeyVal);
            if (oldIdByKeyValSet.size() > 0) {
                int addCount4 = 0;
                for (String str : oldIdByKeyValSet) {
                    String masterValue = str.substring(str.lastIndexOf(":") + 1, str.length());
                    Boolean[] flag = new Boolean[]{true};
                    getIdByKeyValFromSql(newSelectKey, masterValue, flag);
                    if (flag[0]) {
                        addCount4++;
                    }
                }
                String[] oldIdByKeyValArray = oldIdByKeyValSet.toArray(new String[0]);
                Long delCount4 = RedisUtil.del(oldIdByKeyValArray);
                if (addCount4 != delCount4) {
                    returnMsg += " IdByKeyVal update: Redis Error ";
                }
            }
            // 5
            String oldPyByKeyVal = PyByKeyVal_PREFIX + oldSelectKey + ":*";
            Set<String> oldPyByKeyValSet = RedisUtil.keys(oldPyByKeyVal);
            if (oldPyByKeyValSet.size() > 0) {
                int addCount5 = 0;
                for (String str : oldPyByKeyValSet) {
                    String masterValue = str.substring(str.lastIndexOf(":") + 1, str.length());
                    Boolean[] flag = new Boolean[]{true};
                    getPyByKeyValFromSql(newSelectKey, masterValue, flag);
                    if (flag[0]) {
                        addCount5++;
                    }
                }
                String[] oldPyByKeyValArray = oldPyByKeyValSet.toArray(new String[0]);
                Long delCount5 = RedisUtil.del(oldPyByKeyValArray);
                if (addCount5 != delCount5) {
                    returnMsg += " PyByKeyVal update: Redis Error ";
                }
            }
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" UpdateRedisByKey Error: " + e.getMessage());
            returnMsg += " UpdateRedisByKey Error ";
            return returnMsg;
        }
    }

    /**
     * 基础数据类型维护页面用
     * 基础数据值维护页面用
     * 删除基础数据类型同步到Redis
     * 1.Redis删除指定selectKey所有相关数据
     */
    public static String deleteRedisByKey(String oldSelectKey) {
        String returnMsg = "";
        try {
            // 1
            String oldListByKey = ListByKey_PREFIX + oldSelectKey;
            Long delCount1 = 0L;
            if (RedisUtil.hasKey(oldListByKey)) {
                // 6 删除时同时删掉ValById的数据***********************
                List<String> tempList = new ArrayList<String>();
                List ListByKey = RedisUtil.getList(oldListByKey);
                for (Object o : ListByKey) {
                    Map<String, String> tempMap = (Map<String, String>) o;
                    tempList.add(ValById_PREFIX + tempMap.get("masterDetailId"));
                }
                String[] idArray = tempList.toArray(new String[0]);
                Long delCount6 = RedisUtil.del(idArray);
                if (!(idArray.length == delCount6)) {
                    returnMsg += " ValById delete: Redis Error ";
                }
                // **************************************************
                delCount1 = RedisUtil.del(oldListByKey) - 1L;
            }
            if (!(delCount1 == 0L)) {
                returnMsg += " ListByKey delete: Redis Error ";
            }
            // 2
            String oldIdValByKeyPy = IdValByKeyPy_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdValByKeyPySet = RedisUtil.keys(oldIdValByKeyPy);
            if (oldIdValByKeyPySet.size() > 0) {
                String[] oldIdValByKeyPyArray = oldIdValByKeyPySet.toArray(new String[0]);
                Long delCount2 = RedisUtil.del(oldIdValByKeyPyArray);
                if (oldIdValByKeyPySet.size() != delCount2) {
                    returnMsg += " IdValByKeyPy delete: Redis Error ";
                }
            }
            // 3
            String oldIdByKeyPy = IdByKeyPy_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdByKeyPySet = RedisUtil.keys(oldIdByKeyPy);
            if (oldIdByKeyPySet.size() > 0) {
                String[] oldIdByKeyPyArray = oldIdByKeyPySet.toArray(new String[0]);
                Long delCount3 = RedisUtil.del(oldIdByKeyPyArray);
                if (oldIdByKeyPySet.size() != delCount3) {
                    returnMsg += " IdByKeyPy delete: Redis Error ";
                }
            }
            // 4
            String oldIdByKeyVal = IdByKeyVal_PREFIX + oldSelectKey + ":*";
            Set<String> oldIdByKeyValSet = RedisUtil.keys(oldIdByKeyVal);
            if (oldIdByKeyValSet.size() > 0) {
                String[] oldIdByKeyValArray = oldIdByKeyValSet.toArray(new String[0]);
                Long delCount4 = RedisUtil.del(oldIdByKeyValArray);
                if (oldIdByKeyValSet.size() != delCount4) {
                    returnMsg += " IdByKeyVal delete: Redis Error ";
                }
            }
            // 5
            String oldPyByKeyVal = PyByKeyVal_PREFIX + oldSelectKey + ":*";
            Set<String> oldPyByKeyValSet = RedisUtil.keys(oldPyByKeyVal);
            if (oldPyByKeyValSet.size() > 0) {
                String[] oldPyByKeyValArray = oldPyByKeyValSet.toArray(new String[0]);
                Long delCount5 = RedisUtil.del(oldPyByKeyValArray);
                if (oldPyByKeyValSet.size() != delCount5) {
                    returnMsg += " PyByKeyVal delete: Redis Error ";
                }
            }
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" DeleteRedisByKey Error: " + e.getMessage());
            returnMsg += " DeleteRedisByKey Error ";
            return returnMsg;
        }
    }

    /**
     * 基础数据值维护页面专用
     * 新增
     */
    public static String BaseDataForInsertRedis(String masterTypeId) {
        String returnMsg = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean ident = new IdentityBean();
            Map mapParam = new HashMap();
            mapParam.put("masterTypeId", masterTypeId);
            String selectKey = vMasterService.selectKeyByTypeId(ident, mapParam);
            if (selectKey != null && !"".equals(selectKey)) {
                returnMsg += deleteRedisByKey(selectKey);
                returnMsg += saveOneData(selectKey);
            } else {
                returnMsg += " BaseDataForInsertRedis : " + masterTypeId + " error ";
            }
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" BaseDataForInsertRedis error " + e.getMessage());
            returnMsg += " BaseDataForInsertRedis error ";
            return returnMsg;
        }
    }

    /**
     * 基础数据值维护页面专用
     * 修改
     */
    public static String BaseDataForUpdateRedis(String newMasterTypeId) {
        String returnMsg = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean ident = new IdentityBean();
            Map newMapParam = new HashMap();
            newMapParam.put("masterTypeId", newMasterTypeId);
            String newSelectKey = vMasterService.selectKeyByTypeId(ident, newMapParam);
            if (newSelectKey != null && !"".equals(newSelectKey)) {
                returnMsg += deleteRedisByKey(newSelectKey);
                returnMsg += saveOneData(newSelectKey);
            } else {
                returnMsg += " BaseDataForUpdateRedis : " + newMasterTypeId + " error ";
            }
            return returnMsg;
        } catch (Exception e) {
            saveErrorLog(" BaseDataForUpdateRedis error " + e.getMessage());
            returnMsg += " BaseDataForUpdateRedis error ";
            return returnMsg;
        }
    }

    /**
     * 基础数据值维护页面专用
     * 删除
     */
    public static String BaseDataForDeleteRedis(String masterDetailId) {
        String selectKey = "";
        try {
            IVMasterService vMasterService = getVMasterService();
            IdentityBean ident = new IdentityBean();
            Map mapParam = new HashMap();
            mapParam.put("masterDetailId", masterDetailId);
            selectKey = vMasterService.selectKeyById(ident, mapParam);
            if (selectKey != null && !"".equals(selectKey)) {
                deleteRedisByKey(selectKey);
            } else {
                logger.error(" BaseDataForDeleteRedis :" + masterDetailId + " error ");
            }
            return selectKey;
        } catch (Exception e) {
            saveErrorLog(" BaseDataForDeleteRedis error " + e.getMessage());
            return selectKey;
        }
    }

    /**
     * ClobToString
     */
    private static String ClobToString(Clob sc) throws SQLException, IOException {
        String reString = "";
        Reader is = sc.getCharacterStream();
        BufferedReader br = new BufferedReader(is);
        String s = br.readLine();
        StringBuffer sb = new StringBuffer();
        while (s != null) {
            sb.append(s);
            s = br.readLine();
        }
        reString = sb.toString();
        return reString;
    }

    /**
     * VMaster异常log记录
     */
    public static void saveErrorLog(String log) {
        logger.error(log);
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd_HH:mm:ss_");
            String dateKey = sdf.format(new Date()) + UUID.randomUUID();
            RedisUtil.hset("vmaster:errorlog", dateKey, log);
        } catch (Exception e) {
            logger.error(log + e.getMessage());
        }
    }

//    /**
//     * 设置Gset
//     */
//    public static String goGset(String str) {
//        IVMasterService vMasterService = getVMasterService();
//        IdentityBean identityBean = new IdentityBean();
//        String result = "";
//        Map map = new HashMap();
//        map.put("sql", str);
//        try {
//            result = String.valueOf(vMasterService.goGset(identityBean, map));
//        } catch (Exception e) {
//            saveErrorLog("gset error" + e.getMessage());
//            result = e.getMessage();
//        }
//        return result;
//    }

    /**
     * 两个list取不同
     */
    private static StringBuffer getDiffrent(List<String> listRedis, List<String> listSql) {
        Map<String,Integer> map = new HashMap<String,Integer>(listRedis.size()+listSql.size());
        StringBuffer diff = new StringBuffer();
        for (String string : listSql) {
            map.put(string, 1);
        }
        for (String string : listRedis) {
            Integer cc = map.get(string);
            if (cc != null) {
                map.put(string, ++cc);
                continue;
            }
            diff.append("redis- ").append(string).append("</br>");
        }
        for(Map.Entry<String, Integer> entry : map.entrySet()) {
            if (entry.getValue() == 1) {
                diff.append("sql- ").append(entry.getKey()).append("</br>");
            }
        }
        return diff;
    }

    /**
     * 用于判断入参是否无效
     */
    private static boolean isInvalid(String... params) {
        for (String param : params) {
            if (StringUtils.isBlank(param) || param.equals("null")) {
                return true;
            }
        }
        return false;
    }
}