根据规则生成假数据

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import java.util.*;

/**
 * Created by hongcq on 15/12/24.
 */
public class UTest {

    public static void main(String[] args) {

        String ruleList = "[{\"field\":\"data.companyID\",\"params\":{\"length\":\"1\",\"username\":\"2\"},\"ruleID\":4},{\"field\":\"data.companyName\",\"params\":{\"length\":\"12\",\"ruleID\":5}}]";
        String response = "{\"error\":{\"returnCode\":0,\"returnMessage\":\"success\",\"returnUserMessage\":\"success\"},\"data\":{\"companyID\":\"434325435435\",\"companyName\":\"\\u4eba\\u4eba\\u884c\\u79d1\\u6280\",\"companyAbbrName\":\"\\u4eba\\u4eba\\u884c\"}}";
        UTest test = new UTest();

        ArrayList<FieldNode> headers = test.genHeader(ruleList);
        JSONObject object = JSON.parseObject(response);
        test.genResponse(object, headers);

        System.out.println(JSON.toJSONString(object));
    }

    /**
     * 构造返回信息
     *
     * @param obj
     * @param nextObjList
     * @return String
     */
    private void genResponse(JSONObject obj, ArrayList<FieldNode> nextObjList) {
        Set<String> set = obj.keySet();
        for (String k : set) {
            for (FieldNode node : nextObjList) {
                if (!k.equals(node.getKey())) {
                    continue;
                }
                // 叶子节点,需要构造假数据
                if (node.getNextObjList().size() == 0 && node.getObj() != null) {
                    obj.put(k, genData(node.getObj()));
                    continue;
                }
                // 非叶子节点继续遍历
                genResponse(obj.getJSONObject(k), node.getNextObjList());
            }
        }
    }

    /**
     * 生成假数据
     *
     * @param object
     * @return
     */
    private Object genData(JSONObject object) {
        return "xxxx";
    }

    /**
     * 构建链表规则信息
     *
     * @param rules
     * @return list
     */
    private ArrayList<FieldNode> genHeader(String rules) {
        JSONArray ruleList = JSON.parseArray(rules);

        JSONObject obj = null;
        FieldNode parent = null;
        FieldNode node = null;
        ArrayList<FieldNode> header = new ArrayList<>();

        for (int i = 0; i < ruleList.size(); i++) {

            obj = ruleList.getJSONObject(i);
            String field = obj.getString("field");
            if (null == field || "".equals(field)) {
                continue;
            }

            // field String以"."分隔成array,并以链表形式存储
            String[] fields = field.split("\\.");
            parent = null;

            // 构建链表
            for (String key : fields) {
                if (key == null || "".equals(key)) {
                    continue;
                }
                // 如果没有表头节点,就增加一个
                if (parent == null) {
                    parent = getParent(header, key);
                    if (parent == null) {
                        node = new FieldNode();
                        node.setKey(key);
                        addParent(header, node);
                    } else {
                        continue;
                    }
                } else {
                    node = new FieldNode();
                    node.setKey(key);
                    parent.addChild(node);
                }
                parent = node;
            }
            if (parent != null) {
                parent.setObj(obj);
            }
        }

        return header;
    }

    /**
     * 增加链表头节点
     *
     * @param list
     * @param node
     * @return void
     */
    private void addParent(ArrayList<FieldNode> list, FieldNode node) {
        list.add(node);
    }

    /**
     * 获取表头节点
     *
     * @param list
     * @param key
     * @return
     */
    private FieldNode getParent(ArrayList<FieldNode> list, String key) {
        for (FieldNode child : list) {
            if (child.getKey().equals(key)) {
                return child;
            }
        }
        return null;
    }

    class FieldNode {

        private String key;
        private JSONObject obj;
        private ArrayList<FieldNode> nextObjList = new ArrayList<>();

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public JSONObject getObj() {
            return obj;
        }

        public void setObj(JSONObject obj) {
            this.obj = obj;
        }

        public ArrayList<FieldNode> getNextObjList() {
            return nextObjList;
        }

        public void setNextObjList(ArrayList<FieldNode> list) {
            this.nextObjList = list;
        }

        /**
         * 增加子节点
         *
         * @param node
         * @return void
         */
        public void addChild(FieldNode node) {
            if (!hasChild(node)) {
                nextObjList.add(node);
            }
        }

        /**
         * 是否包含某个子节点
         *
         * @param node
         * @return boolean
         */
        public boolean hasChild(FieldNode node) {
            for (FieldNode n : nextObjList) {
                if (n.getKey().equals(node.getKey())) {
                    return true;
                }
            }
            return false;
        }
    }

}

转载于:https://my.oschina.net/qinglive/blog/857539