Map数据验证

背景： 当用Map list 嵌套为数据配置时，存在一个数据验证问题。本文原创，没有深度测试

 

代码：

import com.fyh.utils.mapt.Mapt;

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

public class BValidt {
    private String nameSpace;
    private String separator = "\\.";
    private boolean friendsKeyBL = false;

    /**
     * 对由List,map进行嵌套的对象进行数据检验，本质是他们与json相对应。
     *
     * @param ds
     * @param std
     * @return code =1,成功; code =0，失败
     */
    public Map<String, Object> validByPath(Object ds, Map<String, String> std, boolean isStdValid) {

        Map<String, Object> rst = new LinkedHashMap<>();
        rst.put("code", 1);
        if (std == null) {
            return rst;
        } else if (std != null && ds == null) {
            rst.put("code", 0);
            return rst;
        }

        Map<String, String> resultMap = new LinkedHashMap<>();
        rst.put("result", resultMap);

        Map<String, String> ruleMap = null;
        if (isStdValid) {
            ruleMap = new LinkedHashMap<>();
            for (Map.Entry<String, String> kv : std.entrySet()) {
                String ruleStr = kv.getKey().trim();
                Map<String, String> tmpPathMap = getPaths(ds, ruleStr);
                for (String tmpstr : tmpPathMap.keySet()) {
                    ruleMap.put(tmpstr, kv.getValue());
                }
            }
        } else {
            ruleMap = std;
        }

        for (Map.Entry<String, String> kv : ruleMap.entrySet()) {
            Object dsObj = Mapt.get(ds, kv.getKey());
            String ruleStr = kv.getKey().trim();
            Entity rstEntity = doValid(dsObj, kv.getValue());
            resultMap = doReturn(resultMap, ruleStr, rstEntity);
        }
        resultMap=resultMap.entrySet().stream()
                .sorted( Map.Entry.comparingByKey())
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (oldVal, newVal) -> oldVal,
                                LinkedHashMap::new
                        )
                );

        return rst;

    }

    private Map<String, String> getPaths(Object ds, String ruleStr) {
        Map<String, String> pathMap = new LinkedHashMap<>();//只存储对数组计算的规则的路径
        if (ds == null || ruleStr == null) return pathMap;

        if (friendsKeyBL) {
            ruleStr = ruleStr.replaceAll("(?<=[A-Z|a-z|0-9|\\]])(\\[)", ".[");
        }
        String[] strs = ruleStr.split(separator);
        String prePath = "";
        for (String str : strs) {
            if (str.substring(0, 1).equals("[")) {
                pathMap.put(prePath, "0");
                List tmpList = null;
                if (prePath.equals("") && List.class.isAssignableFrom(ds.getClass())) {
                    tmpList = (List) ds;
                } else {
                    tmpList = Mapt.getList(ds, prePath);
                }
                int count = tmpList.size();
                Map<String, String> newPathMap = new LinkedHashMap<>();
                for (int i = 0; i < count; i++) {
                    for (String k : pathMap.keySet()) {
                        String tmpStr = "[" + Integer.toString(i) + "]";
                        if (k.equals("")) {
                            newPathMap.put(tmpStr, "0");
                        } else {
                            newPathMap.put(k + "." + tmpStr, "0");
                        }
                    }
                }

                pathMap = newPathMap;

            } else if (pathMap.isEmpty()) {
                prePath = prePath.equals("") ? str : prePath + "." + str;
            } else {
                Map<String, String> newPathMap = new LinkedHashMap<>();
                for (String k : pathMap.keySet()) {
                    String tmpstr = k.equals("") ? str : k + "." + str;
                    newPathMap.put(tmpstr, "0");
                }
                pathMap = newPathMap;
            }
        }
        if (pathMap.isEmpty()) pathMap.put(ruleStr, "0");
        return pathMap;
    }

    private Map<String, String> doReturn(Map<String, String> resultMap, String key, Entity rstEntity) {
        if (rstEntity == null) return resultMap;
        if (rstEntity.rst && rstEntity.sonRst != null) {
            resultMap.put(key, rstEntity.sonRst.toString());
        }
        return resultMap;
    }

    /**
     * 对由List,map进行嵌套的对象进行数据检验，本质是他们与json相对应。
     *
     * @param ds  被验证的数据源，由List,map进行嵌套嵌套构
     * @param std 由由List,map进行嵌套构成的验证规则
     * @return code =1,成功; code =0，失败
     */
    public Map<String, Object> valid(Object ds, Object std) {

        Map<String, Object> rst = new LinkedHashMap<>();
        rst.put("code", 1);
        if (std == null) {
            return rst;
        } else if (std != null && ds == null) {
            rst.put("code", 0);
            return rst;
        }

        Queue<Object> stdQueue = new LinkedList<>();
        stdQueue.offer(std);
        Queue<Object> dsQueue = new LinkedList<>();
        dsQueue.offer(ds);
        Queue<Object> rstQueue = new LinkedList<>();
        if (List.class.isAssignableFrom(ds.getClass())) {
            List list = new ArrayList();
            rst.put("result", list);
            rstQueue.offer(list);
        } else if (Map.class.isAssignableFrom(ds.getClass())) {
            Map<String, Object> map = new LinkedHashMap<>();
            rst.put("result", map);
            rstQueue.offer(map);
        }
        while (!dsQueue.isEmpty()) {
            Object stdObj = stdQueue.poll();
            Object dsObj = dsQueue.poll();
            Object rstObj = rstQueue.poll();
            if (stdObj == null) break;
            if (List.class.isAssignableFrom(dsObj.getClass())
                    && List.class.isAssignableFrom(stdObj.getClass())
            ) {

                List dsList = (List) dsObj;
                List stdList = (List) stdObj;
                List rstList = (List) rstObj;
                Object sunStdObj = stdList.get(0);
                for (int i = 0; i < dsList.size(); i++) {
                    Object son = dsList.get(i);
                    Entity rstEntity = doValid(son, sunStdObj); //开始验证
                    if (rstEntity.rst) {
                        if (rstEntity.sonRst != null) {
                            rst.put("code", 0);
                            rstList.add(rstEntity.sonRst);
                        }
                    } else if (List.class.isAssignableFrom(son.getClass())) {
                        List tmpList = new ArrayList<>();
                        rstList.add(tmpList);
                        dsQueue.offer(son);
                        if (i < stdList.size()) {
                            stdQueue.offer(stdList.get(i));
                        } else {
                            stdQueue.offer(stdList.get(0));
                        }
                        rstQueue.offer(tmpList);
                    } else if (Map.class.isAssignableFrom(son.getClass())) {
                        Map<String, Object> tmpMap = new LinkedHashMap<>();
                        rstList.add(tmpMap);
                        dsQueue.offer(son);
                        if (i < stdList.size()) {
                            stdQueue.offer(stdList.get(i));
                        } else {
                            stdQueue.offer(stdList.get(0));
                        }

                        rstQueue.offer(tmpMap);
                    }
                }
            } else if (Map.class.isAssignableFrom(dsObj.getClass())
                    && Map.class.isAssignableFrom(stdObj.getClass())
            ) {
                Map<String, Object> dsMap = (Map<String, Object>) dsObj;
                Map<String, Object> stdMap = (Map<String, Object>) stdObj;
                Map<String, Object> rstMap = (Map<String, Object>) rstObj;
                for (Map.Entry<String, Object> en1 : dsMap.entrySet()) {
                    Object son = en1.getValue();
                    Object sunStdObj = stdMap.get(en1.getKey());
                    Entity rstEntity = doValid(son, sunStdObj);//开始验证
                    if (rstEntity.rst) {
                        if (rstEntity.sonRst != null) {
                            rst.put("code", 0);
                            rstMap.put(en1.getKey(), rstEntity.sonRst);
                        }
                    } else if (List.class.isAssignableFrom(son.getClass())) {
                        List tmpList = new ArrayList<>();
                        rstMap.put(en1.getKey(), tmpList);
                        dsQueue.offer(son);
                        stdQueue.offer(stdMap.get(en1.getKey()));
                        rstQueue.offer(tmpList);
                    } else if (Map.class.isAssignableFrom(son.getClass())) {
                        Map<String, Object> tmpMap = new LinkedHashMap<>();
                        rstMap.put(en1.getKey(), tmpMap);
                        dsQueue.offer(son);
                        stdQueue.offer(stdMap.get(en1.getKey()));
                        rstQueue.offer(tmpMap);
                    }
                }
            }
        }

        return rst;
    }

    /**
     * @param son
     * @param sonStdObj
     * @return Entity.rst 为false-没到底，需要进步处理，true--已经到底并检验了
     */
    private Entity doValid(Object son, Object sonStdObj) {
        Entity rst = new Entity(son, sonStdObj);
        if (son == null || sonStdObj == null) {
            rst.rst = true;
            return rst;
        }
        if (String.class.isAssignableFrom(sonStdObj.getClass())) {
            rst.rst = true;
            // "aa;dd;xx;;;yy".split(";(?!;)") 分割符为分号，如果有连续分号，只有最后一个分号会分割
            String[] strs = sonStdObj.toString().split(";(?!;)");
            String[] params = Arrays.copyOfRange(strs, 1, strs.length - 1);
            int lastIndex = strs.length - 1;
            if (strs[0].toLowerCase().equals("type") && strs[1] == null) {
                rst.sonRst = "验证类型出错";
                if (rst.sonRst != null) rst.sonRst = rst.sonRst + ". 原值为：" + son.toString();
            } else if (strs[0].toLowerCase().equals("type") && strs[1] != null) {
                strs[1] = strs[1].trim();
                try {
                    if (!strs[1].contains("java.lang") && (
                            strs[1].equals("String") || strs[1].equals("Integer") ||
                                    strs[1].equals("Boolean") || strs[1].equals("String") ||
                                    strs[1].equals("Double") || strs[1].equals("Long") ||
                                    strs[1].equals("String")
                    )
                    ) {
                        strs[1] = "java.lang." + strs[1];
                    }
                    if (strs[1].equals("Date")) {
                        strs[1] = "java.util.Date";
                    }

                    if (this.nameSpace != null && !strs[1].contains(".")) {
                        strs[1] = this.nameSpace + "." + strs[1];
                    }
                    Class cls = Class.forName(strs[1]);
                    if (cls.isAssignableFrom(son.getClass())) {
                        return rst;
                    } else {
                        rst.sonRst = strs[2] != null ? strs[2] : "不是指定类型";
                        if (rst.sonRst != null) rst.sonRst = rst.sonRst + ". 原值为：" + son.toString();
                    }
                } catch (ClassNotFoundException e) {
                    rst.sonRst = strs[2] != null ? strs[2] : "验证类型出错";
                    if (rst.sonRst != null) rst.sonRst = rst.sonRst + ". 原值为：" + son.toString();
                    return rst;
                }

            }
            if (Validt.valid(strs[0], son.toString(), params)) {
                return rst;
            } else {
                rst.sonRst = strs[lastIndex] != null ? strs[lastIndex] : "验证" + strs[0] + "出错";
                if (rst.sonRst != null) rst.sonRst = rst.sonRst + ". 原值为：" + son.toString();
                return rst;
            }


        }
        return rst;
    }


    public String getNameSpace() {
        return nameSpace;
    }

    public void setNameSpace(String nameSpace) {
        this.nameSpace = nameSpace;
    }

    class Entity {
        protected boolean rst = false;
        protected Object son;
        protected Object sonRst;
        protected Object sonStdObj;

        public Entity() {
        }

        public Entity(Object son, Object sonStdObj) {
            this.son = son;
            this.sonStdObj = sonStdObj;
        }

        public boolean isRst() {
            return rst;
        }

        public void setRst(boolean rst) {
            this.rst = rst;
        }

        public Object getSon() {
            return son;
        }

        public void setSon(Object son) {
            this.son = son;
        }

        public Object getSonStdObj() {
            return sonStdObj;
        }

        public void setSonStdObj(Object sonStdObj) {
            this.sonStdObj = sonStdObj;
        }


        public Object getSonRst() {
            return sonRst;
        }

        public void setSonRst(Object sonRst) {
            this.sonRst = sonRst;
        }
    }


}

 

 

测试与使用

 

import com.fyh.utils.JackJsonUtils;
import org.junit.jupiter.api.Test;

import java.util.*;

import static org.junit.jupiter.api.Assertions.*;

class BValidtTest {
    private BValidt bValidt = new BValidt();
    @Test
    void validByPath(){
        Arrays.asList("a", "b", "c").forEach(i->{System.out.println(i);});
        Arrays.asList("a", "b", "c").forEach(System.out::println);

        String dsStr = JackJsonUtils.getStdJsonStr("{no:1,name:'a'}");
        Map<String, Object> dsMap = JackJsonUtils.fromJson(dsStr, Map.class);

        Map<String,String> ruleMap=new LinkedHashMap<>();
        ruleMap.put("no","num;3;不是数或小数位数出错");
        ruleMap.put("name","required; 不能为空");
        Map<String, Object> rst = bValidt.validByPath(dsMap, ruleMap,true);

        List<Map<String,Object>> dsList=new ArrayList<>() ;
        Map<String,Object> dsMapA=new LinkedHashMap<>();
        dsList.add(dsMapA);
        dsMapA.put("no","11");
        dsMapA.put("name","");
        dsMapA=new LinkedHashMap<>();
        dsList.add(dsMapA);
        dsMapA.put("no","22");
        dsMapA.put("name","");


        Map<String,String> stdMapA=new LinkedHashMap<>();
        stdMapA.put("[0].no","num;3;不是指定类型");
        stdMapA.put("[0].name","required;不能为空");
        Map<String, Object> rstList = bValidt.validByPath(dsList, stdMapA,true);

        String dsStr1 = JackJsonUtils.getStdJsonStr("" +
                "{\n" +
                "    items:[\n" +
                "        {\n" +
                "            no:1,\n" +
                "            name:\"wang\",        \n" +
                "            son:{" +
                "               xx:12"+
                "            }"+
                "        },\n" +
                "        {\n" +
                "            no:'11',\n" +
                "            name:\"wang\",\n" +
                "            son:{" +
                "               xx:55"+
                "            }"+
                "        }\n" +
                "    ]\n" +
                "}" +
                "");
        Map<String, Object> dsMap1 = JackJsonUtils.fromJson(dsStr1, Map.class);

        Map<String,String> ruleMap1=new LinkedHashMap<>();
        ruleMap1.put("items.[0].no","num;3;不是数或小数位数出错");
        ruleMap1.put("items.[0].son.xx","num;3;不是数或小数位数出错");
        ruleMap1.put("items.[0].name","required; 不能为空");
        Map<String, Object> rst1 = bValidt.validByPath(dsMap1, ruleMap1,true);

        String dsStr2 = JackJsonUtils.getStdJsonStr("" +
                "{\n" +
                "    items:[\n" +
                "        {\n" +
                "            no:1,\n" +
                "            name:\"wang\",        \n" +
                "            son:[{" +
                "               xx:12"+
                "            }," +
                "            {" +
                "               xx:13"+
                "             }] "+
                "        },\n" +
                "        {\n" +
                "            no:'11',\n" +
                "            name:\"wang\",\n" +
                "            son:[{" +
                "               xx:22"+
                "            }," +
                "            {" +
                "               xx:23"+
                "             }] "+
                "        }\n" +
                "    ]\n" +
                "}" +
                "");
        Map<String, Object> dsMap2 = JackJsonUtils.fromJson(dsStr2, Map.class);

        Map<String,String> ruleMap2=new LinkedHashMap<>();
        ruleMap2.put("items.[0].no","num;3;不是数或小数位数出错");
        ruleMap2.put("items.[0].son.[0].xx","num;3;不是数或小数位数出错");
        ruleMap2.put("items.[0].name","required; 不能为空");
        Map<String, Object> rst2 = bValidt.validByPath(dsMap2, ruleMap2,true);

        System.out.println();
    }
//    @Test
    void valid() {
        //展示通过js对象转标准JSON字符串，再转成Map实例
        String dsStr = JackJsonUtils.getStdJsonStr("{no:1,name:''}");
        Map<String, Object> dsMap = JackJsonUtils.fromJson(dsStr, Map.class);

        String stdStr = JackJsonUtils.getStdJsonStr("{\n" +
                "    name:\"required; 不能为空 \",\n" +
                "    no: \"num;3;不是数或小数位数出错\"\n" +
                "}");
        Map<String, Object> stdMap = JackJsonUtils.fromJson(stdStr, Map.class);


        Map<String, Object> rst = bValidt.valid(dsMap, stdMap);


        String dsStr1 = JackJsonUtils.getStdJsonStr(
                "" +
                        "{\n" +
                        "    items:[\n" +
                        "        {\n" +
                        "            no:1,\n" +
                        "            name:\"wang\",        \n" +
                        "        },\n" +
                        "        {\n" +
                        "            no:'11',\n" +
                        "            name:\"wang\",\n" +
                        "        }\n" +
                        "    ]\n" +
                        "}" +
                        "");
        Map<String, Object> dsMap1 = JackJsonUtils.fromJson(dsStr1, Map.class);

        String stdStr1 = JackJsonUtils.getStdJsonStr("" +
                "{\n" +
                "    items:[\n" +
                "        {\n" +
                "            name:\"required; 不能为空 \",\n" +
                "            no: \"num;2;不是数或小数\"\n" +
                "        },\n" +
                "        {\n" +
                "            name:\"required; 不能为空 \",\n" +
                "            no: \"num;不是数或小数\"\n" +
                "        }\n" +
                "    ]\n" +
                "}" +
                "");
        Map<String, Object> stdMap1 = JackJsonUtils.fromJson(stdStr1, Map.class);
        Map<String, Object> rst1 = bValidt.valid(dsMap1, stdMap1);

        String dsStr2 = JackJsonUtils.getStdJsonStr(
                "" +
                        "{\n" +
                        "    no:'11',\n" +
                        "    name:'name11',\n" +
                        "    items:[\n" +
                        "        {\n" +
                        "            no:1,\n" +
                        "            name:\"wang\",\n" +
                        "            son:[\n" +
                        "                'dd','ee'\n" +
                        "            ],\n" +
                        "        },\n" +
                        "        {\n" +
                        "            no:11,\n" +
                        "            name:\"wang\",\n" +
                        "        }\n" +
                        "    ]\n" +
                        "}" +
                        "");
        Map<String, Object> dsMap2 = JackJsonUtils.fromJson(dsStr2, Map.class);

        String stdStr2 = JackJsonUtils.getStdJsonStr("" +
                "{\n" +
                "    no:'num;3;不是数或小数',\n" +
                "    items:[\n" +
                "        {\n" +
                "            name:\"required; 不能为空 \",\n" +
                "            no: \"num;3;不是数或小数\",\n" +
                "            son:[\n" +
                "                \"num;不是数或小数\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ]\n" +
                "}" +
                "");
        Map<String, Object> stdMap2 = JackJsonUtils.fromJson(stdStr2, Map.class);
        Map<String, Object> rst2 = bValidt.valid(dsMap2, stdMap2);


        List<Map<String,Object>> dsList=new ArrayList<>() ;
        Map<String,Object> dsMapA=new LinkedHashMap<>();
        dsList.add(dsMapA);
        dsMapA.put("no","11");
        dsMapA.put("name","name11");
        dsMapA=new LinkedHashMap<>();
        dsList.add(dsMapA);
        dsMapA.put("no","22");
        dsMapA.put("name","name22");

        List<Map<String,Object>> stdList=new ArrayList<>() ;
        Map<String,Object> stdMapA=new LinkedHashMap<>();
        stdList.add(stdMapA);

//        stdMapA.put("no","num;不是数字");
        stdMapA.put("no","type;String;不是指定类型");
        stdMapA.put("name","required;不能为空");
        Map<String, Object> rst3 = bValidt.valid(dsList, stdList);


        System.out.println();

    }
}