精华内容
下载资源
问答
  • 我的json数据是这样的: {"@timestamp":"2020-06-04T06:23:12.343Z","beat":{"hostname":"node01","name":"192.168.199.34","version":"5.5.2"},"host":"192.168.199.34","input_type":"log","message":"{\...
  • 开发过程中遇到解析JSON的时候解析出来的字符串数组带有双层引号,导致数据不匹配,例如下面JSON list数组的第一个元素 "232ed6e1878e456cb990d496c282badd",解析出来为""232ed6e1878e456cb990d496c282badd""。...

    解决解析字符串数组多层引号问题

    问题描述:

    开发过程中遇到解析JSON的时候解析出来的字符串数组带有双层引号,导致数据不匹配,例如下面JSON list数组的第一个元素 "232ed6e1878e456cb990d496c282badd",解析出来为""232ed6e1878e456cb990d496c282badd""

    待解析的JSON参数:

    {
        "list": [
            "232ed6e1878e456cb990d496c282badd",
            "8a082bca79304ce78330c492370f8974",
            "d3860bb1da284d96a34550ebbff1fe81",
            "c4f3a4878c8a45abb333b9f8577eeca7"
        ]
    }
    

    解决方法

    利用 fastjson JSONArray.getString()方法解决,解析出来就是正常的想要的字符串了。

    // 解析JSON参数jsonParams
    JSONObject jsonObject = JSON.parseObject(jsonParams);
    // 从JSONObject获取JSONArray类型的元素
    JSONArray array = jsonObject.getJSONArray("list");
    // 获取数组中下标 i +1的字符串
    String inboxId = array.getString(i);
    
    展开全文
  • - Json解析成关系型数据表结构 - MapReduce多文件输出 - 消除MapReduce默认文件输出格式 (1)FileOutputFormat package com.leboop.www.json; import org.apache.hadoop.fs.Path; import org.apache.hadoop....

    直接上代码。涉及技术点:

    - Json解析成关系型数据表结构

    - MapReduce多文件输出

    - 消除MapReduce默认文件输出格式

    configuration.set("mapreduce.fileoutputcommitter.marksuccessfuljobs", "false");

    控制_SUCCESS文件生成。

    (1)FileOutputFormat

    package com.leboop.www.json;
    
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.TaskAttemptContext;
    import org.apache.hadoop.mapreduce.lib.output.FileOutputCommitter;
    import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
    
    import java.io.IOException;
    
    /**
     * Created by leboop on 2020/7/18.
     */
    class FileOutputFormat extends TextOutputFormat<NullWritable, Text> {
        @Override
        public Path getDefaultWorkFile(TaskAttemptContext context, String extension) throws IOException {
            // TODO Auto-generated method stub
            FileOutputCommitter committer = (FileOutputCommitter) getOutputCommitter(context);
            return new Path(committer.getWorkPath(), getOutputName(context));
        }
    }

    自定义FileOutputFormat取消生成的文件后缀r-0000等,比如需要生成file1,如果没有实现该类,会生成file1-r-0000。

     

    (2)JsonParser

    package com.leboop.www.json;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
    import org.apache.hadoop.mapreduce.lib.output.LazyOutputFormat;
    import org.apache.hadoop.mapreduce.lib.output.MultipleOutputs;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * Created by leboop on 2020/7/18.
     */
    public class JsonParser {
        public static void parse(Path path) throws Exception {
            Configuration configuration = new Configuration();
            configuration.set("fs.defaultFS", "hdfs://192.168.128.11:9000");
            System.setProperty("HADOOP_USER_NAME", "root");
            Job job = Job.getInstance(configuration, "JsonParser");
            job.setJarByClass(Main.class);
            job.setMapperClass(JsonMapper.class);
            job.setOutputKeyClass(NullWritable.class);
            job.setOutputValueClass(Text.class);
            job.setOutputFormatClass(FileOutputFormat.class);
            job.setNumReduceTasks(0);
            FileInputFormat.setInputPaths(job, path);
            Map<String, List<String>> saveFileMap = Utils.readSaveFile();
            for (Map.Entry<String, List<String>> entry : saveFileMap.entrySet()) {
                System.out.println(entry.getKey());
                MultipleOutputs.addNamedOutput(job, entry.getKey(), FileOutputFormat.class, NullWritable.class, Text.class);
            }
            FileOutputFormat.setOutputPath(job, new Path("/output/json"));
            LazyOutputFormat.setOutputFormatClass(job, FileOutputFormat.class);
            job.waitForCompletion(true);
        }
    }
    

    LazyOutputFormat.setOutputFormatClass(job, FileOutputFormat.class);可以取消多余的文件part-r-0000.

     

    这里的setOutputPath是设置所有文件相同的基目录,比如生成的文件分别在如下目录

    /output/json/d1/file1

    /output/json/d2/file2

    /output/json/d3/file1

    基目录设置为/output/json即可。

    (3)JsonMapper

    package com.leboop.www.json;
    
    import com.google.gson.JsonArray;
    import com.google.gson.JsonElement;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Mapper;
    import org.apache.hadoop.mapreduce.lib.output.MultipleOutputs;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.*;
    
    /**
     * Created by leboop on 2020/7/18.
     */
    public class JsonMapper extends Mapper<LongWritable, Text, NullWritable, Text> {
        private MultipleOutputs<NullWritable, Text> multipleOutputs = null;
        /**
         * 保存字段名和字段值(字段值可能多个)
         */
        private Map<String, List<String>> map = new HashMap<String, List<String>>();
        /**
         * 保存文件名,一个文件名相当于一个关系型数据库表
         */
        private Map<String, List<String>> saveFileMap = new HashMap<String, List<String>>();
    
        @Override
        protected void setup(Context context) throws IOException, InterruptedException {
            multipleOutputs = new MultipleOutputs<>(context);
            saveFileMap = Utils.readSaveFile();
        }
    
        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {
            multipleOutputs.close();
        }
    
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String jsonStr = value.toString();
    
            // 使用gson包,将json字符串转换成json对象
            com.google.gson.JsonParser jsonParser = new com.google.gson.JsonParser();
            JsonElement e = jsonParser.parse(jsonStr);
            System.out.println("读取到的json字符串:");
            System.out.println(e);
    
            // 解析json
            StringBuilder keySb = new StringBuilder();
            jsonTree(e, keySb);
            System.out.println("解析后的json数据:");
            for (Map.Entry<String, List<String>> entry : map.entrySet()) {
                System.out.println(entry.getKey() + "  =  " + entry.getValue());
            }
    
    
            //
            for (Map.Entry<String, List<String>> entry : saveFileMap.entrySet()) { // 遍历文件
                int maxSize = 0;
                List<List<String>> tmp = new ArrayList<List<String>>();
                for (String fieldName : entry.getValue()) {//遍历字段
                    List<String> fieldValueList = map.get(fieldName); //字段可能不存在
                    if (fieldValueList != null) {
                        if (fieldValueList.size() > maxSize) {
                            maxSize = fieldValueList.size();
                        }
                        tmp.add(fieldValueList);
                    } else {
                        tmp.add(Arrays.asList(""));
                    }
    
                }
                // 填充数组
                String[][] arr = fill(tmp, maxSize);
                //数组转换成字符串
                String resultStr = arrToStr(arr);
                //写入保存文件
                System.out.println("保存文件" + entry.getKey() + ":");
                System.out.println(resultStr);
                System.out.println("++++++++++++++++++++++++++++++++++++++++++");
    
                multipleOutputs.write(entry.getKey(), null, new Text(resultStr),String.valueOf(Time.now())+"/"+entry.getKey());
            }
        }
    
    
        /**
         * 数组转换成可写入文件的字符串
         *
         * @param arr
         * @return
         */
        private String arrToStr(String[][] arr) {
            StringBuilder resultSb = new StringBuilder();
            for (int r = 0; r < arr.length; r++) {
                for (int c = 0; c < arr[r].length; c++) {
                    resultSb.append(arr[r][c]).append("|");
                }
                resultSb.append("\n");
            }
            return resultSb.toString();
        }
    
        /**
         * 数据填充
         *
         * @param tmp
         * @param maxSize
         * @return
         */
        private String[][] fill(List<List<String>> tmp, int maxSize) {
            String[][] arr = new String[maxSize][tmp.size()];
            if (tmp.size() > 0) { //数据填充
                for (int c = 0; c < tmp.size(); c++) {
                    List<String> curr = tmp.get(c);
                    if (maxSize % curr.size() != 0) { // 异常数据
                        break;
                    } else {
                        int rep = maxSize / curr.size(); //副本数
                        for (int k = 0; k < curr.size(); k++) { // 行数 =k*r
                            for (int r = 0; r < rep; r++) {
                                arr[k * rep + r][c] = curr.get(k);
                            }
                        }
    
                    }
                }
            }
    
    
            return arr;
        }
    
    
        /**
         * 递归解析json
         *
         * @param e
         * @param key
         */
        private void jsonTree(JsonElement e, StringBuilder key) {
            // 原始数据类型
            if (e.isJsonNull() || e.isJsonPrimitive()) {
                String keyStr = key.toString();
                if (map.containsKey(keyStr)) {
                    List<String> list = map.get(keyStr);
                    list.add(e.toString());
                    map.put(keyStr, list);
                } else {
                    List<String> list = new ArrayList<String>();
                    list.add(e.toString());
                    map.put(keyStr, list);
                }
                key.setLength(0);
                return;
            }
            // 对象数组,注:对象数组不一定是OA,反之OA一定是对象数组
            if (e.isJsonArray()) {
                JsonArray jsonArr = e.getAsJsonArray();
                if (null != jsonArr) {
                    for (JsonElement je : jsonArr) {
                        if (je.isJsonNull() || je.isJsonPrimitive()) { // 数组中元素依然是原始数据类型
                            String keyStr = key.toString();
                            if (map.containsKey(keyStr)) {
                                List<String> list = map.get(keyStr);
                                list.set(0, map.get(keyStr).get(0) + "," + je.toString());
                                map.put(keyStr, list);
                            } else {
                                List<String> list = new ArrayList<String>();
                                list.add(je.toString());
                                map.put(keyStr, list);
                            }
                        } else { // 不是原始数据类型继续递归
                            jsonTree(je, key);  //递归
                        }
                    }
    
                }
            }
            // json对象
            if (e.isJsonObject()) {
                // json的所有key=value对
                Set<Map.Entry<String, JsonElement>> es = e.getAsJsonObject().entrySet();
                String pKey = key.toString(); // 存储父节点
                for (Map.Entry<String, JsonElement> en : es) {
                    if (pKey.length() > 0) { //连接符拼接
                        key = new StringBuilder(pKey + "-->" + en.getKey());
                    } else {
                        key = new StringBuilder(en.getKey());
                    }
                    JsonElement element = en.getValue();
                    jsonTree(element, key); //递归
                }
            }
        }
    }
    

    multipleOutputs.write(entry.getKey(), null, new Text(resultStr),String.valueOf(Time.now())+"/"+entry.getKey());

    设置多个目录多个文件输出,注意String.valueOf(Time.now())+"/"+entry.getKey()

    "/"左边的是目录,右边必须与第一项相同entry.getKey(),表示最终保存的文件名。也可以如下写:

    multipleOutputs.write(NullWritable.get(), new Text(resultStr), String.valueOf(Time.now()) + "/" + entry.getKey());

    (4)Utils

    package com.leboop.www.json;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Created by leboop on 2020/7/18.
     */
    public class Utils {
        /**
         * 从文件中读取字段保存的文件(文件可以理解成一张数据库表)
         */
        public static Map<String, List<String>> readSaveFile() {
            Map<String, List<String>> saveFileMap = new HashMap<String, List<String>>();
            try {
                BufferedReader metaBR = new BufferedReader(new FileReader(
                        new File("G:\\idea_workspace\\MapReduce\\data\\meta")));
                String line;
                while ((line = metaBR.readLine()) != null) {
                    String k = line.split(":")[0];
                    String[] vs = line.split(":")[1].split("\\|");
                    List<String> list = new ArrayList<String>();
                    for (String v : vs) {
                        list.add(v);
                    }
                    saveFileMap.put(k, list);
                }
                System.out.println("保存文件名:");
                for (Map.Entry<String, List<String>> entry : saveFileMap.entrySet()) {
                    System.out.println(entry.getKey() + " = " + entry.getValue());
                }
                System.out.println("+++++++++++++++++++++++++++++++");
            } catch (Exception e1) {
    
            }
    
            return saveFileMap;
        }
    }
    

    (5)Main

    package com.leboop.www.json;
    
    import org.apache.hadoop.fs.Path;
    
    /**
     * Created by leboop on 2020/7/18.
     */
    public class Main {
        public static void main(String[] args) throws Exception {
            Path path = new Path("/json/data.json");
            JsonParser.parse(path);
        }
    }
    

    (6)data.json

    {"OA":[{"rd":1,"rn":"s"},{"rd":2,"rn":"d"}],"OOA":[{"a":1,"b":[{"c":1,"d":[{"e":1},{"e":2}]},{"c":2,"d":[{"e":2},{"e":2}]}]},{"a":2,"b":[{"c":1,"d":[{"e":1},{"e":1}]},{"c":2,"d":[{"e":2},{"e":2}]}]}],"name":{"c":"RickandMorty","d":"dd"},"hobby":["t","m",{"s":true}],"id":"kladu8yak8asdha8","boolean":true,"number":3,"k":null,"ARRAY":[{"FIRST":"Rick","SEC":"tt"},{"LAST":"Morty"}]}

    (7)meta

    file1:name-->c|name-->d|hobby|hobby-->s|id|boolean|number|k|ARRAY-->FIRST|ARRAY-->SEC|ARRAY-->LAST
    file2:id|OA-->rd|OA-->rn
    file3:id|OOA-->a
    file4:OOA-->a|OOA-->b-->c|OOA-->b-->d-->e

     

    展开全文
  • 首先需要设计Json解析后保存的关系型数据库表结构,包括主表,附表,各表的主键和外键; 解析详细代码如下: package jsonparser; import com.google.gson.JsonArray; import com.google.gson.JsonElement; ...

     首先需要设计Json解析后保存的关系型数据库表结构,包括主表,附表,各表的主键和外键;

    解析详细代码如下:

    package jsonparser;
    
    import com.google.gson.JsonArray;
    import com.google.gson.JsonElement;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.util.*;
    
    /**
     * Created by leboop on 2020/7/18.
     * 将一个json转换成关系型数据库表
     */
    public class JsonParser {
        /**
         * 保存字段名和字段值(字段值可能多个)
         */
        private static Map<String, List<String>> map = new HashMap<String, List<String>>();
        /**
         * 保存文件名,一个文件名相当于一个关系型数据库表
         */
        private static Map<String, List<String>> saveFileMap = new HashMap<String, List<String>>();
    
        /**
         * 从文件中读取json字符串
         *
         * @return
         */
        private static String readJson() {
            StringBuilder sb = new StringBuilder();
            try {
                BufferedReader br = new BufferedReader(new FileReader(
                        new File("G:\\idea_workspace\\oozie\\data\\data.json")));
                String line;
                while ((line = br.readLine()) != null) {
                    sb.append(line);
                }
            } catch (Exception e) {
    
            }
            return sb.toString();
        }
    
        /**
         * 从文件中读取字段保存的文件(文件可以理解成一张数据库表)
         */
        private static void readSaveFile() {
            try {
                BufferedReader metaBR = new BufferedReader(new FileReader(
                        new File("G:\\idea_workspace\\oozie\\data\\meta")));
                String line;
                while ((line = metaBR.readLine()) != null) {
                    String k = line.split(":")[0];
                    String[] vs = line.split(":")[1].split("\\|");
                    List<String> list = new ArrayList<String>();
                    for (String v : vs) {
                        list.add(v);
                    }
                    saveFileMap.put(k, list);
                }
                System.out.println("保存文件名:");
                for (Map.Entry<String, List<String>> entry : saveFileMap.entrySet()) {
                    System.out.println(entry.getKey() + " = " + entry.getValue());
                }
                System.out.println("+++++++++++++++++++++++++++++++");
            } catch (Exception e1) {
    
            }
        }
    
        public static void main(String[] args) {
            String jsonStr = readJson(); //读取json数据
            // 使用gson包,将json字符串转换成json对象
            com.google.gson.JsonParser jsonParser = new com.google.gson.JsonParser();
            JsonElement e = jsonParser.parse(jsonStr);
            System.out.println("读取到的json字符串:");
            System.out.println(e);
    
            // 解析json
            StringBuilder key = new StringBuilder();
            jsonTree(e, key);
            System.out.println("解析后的json数据:");
            for (Map.Entry<String, List<String>> entry : map.entrySet()) {
                System.out.println(entry.getKey() + "  =  " + entry.getValue());
            }
    
            //读取保存文件
            readSaveFile();
    
            //
            for (Map.Entry<String, List<String>> entry : saveFileMap.entrySet()) { // 遍历文件
                int maxSize = 0;
                List<List<String>> tmp = new ArrayList<List<String>>();
                for (String fieldName : entry.getValue()) {//遍历字段
                    List<String> fieldValueList = map.get(fieldName); //字段可能不存在
                    if (fieldValueList != null) {
                        if (fieldValueList.size() > maxSize) {
                            maxSize = fieldValueList.size();
                        }
                        tmp.add(fieldValueList);
                    } else {
                        tmp.add(Arrays.asList(""));
                    }
    
                }
                // 填充数组
                String[][] arr = fill(tmp, maxSize);
                //数组转换成字符串
                String resultStr = arrToStr(arr);
                //写入保存文件
                System.out.println("保存文件"+entry.getKey() + ":");
                System.out.println(resultStr);
                System.out.println("++++++++++++++++++++++++++++++++++++++++++");
            }
        }
    
    
        /**
         * 数组转换成可写入文件的字符串
         *
         * @param arr
         * @return
         */
        private static String arrToStr(String[][] arr) {
            StringBuilder resultSb = new StringBuilder();
            for (int r = 0; r < arr.length; r++) {
                for (int c = 0; c < arr[r].length; c++) {
                    resultSb.append(arr[r][c]).append("|");
                }
                resultSb.append("\n");
            }
            return resultSb.toString();
        }
    
        /**
         * 数据填充
         *
         * @param tmp
         * @param maxSize
         * @return
         */
        private static String[][] fill(List<List<String>> tmp, int maxSize) {
            String[][] arr = new String[maxSize][tmp.size()];
            if (tmp.size() > 0) { //数据填充
                for (int c = 0; c < tmp.size(); c++) {
                    List<String> curr = tmp.get(c);
                    if (maxSize % curr.size() != 0) { // 异常数据
                        break;
                    } else {
                        int rep = maxSize / curr.size(); //副本数
                        for (int k = 0; k < curr.size(); k++) { // 行数 =k*r
                            for (int r = 0; r < rep; r++) {
                                arr[k * rep + r][c] = curr.get(k);
                            }
                        }
    
                    }
                }
            }
    
    
            return arr;
        }
    
    
        /**
         * 递归解析json
         *
         * @param e
         * @param key
         */
        private static void jsonTree(JsonElement e, StringBuilder key) {
            // 原始数据类型
            if (e.isJsonNull() || e.isJsonPrimitive()) {
                String keyStr = key.toString();
                if (map.containsKey(keyStr)) {
                    List<String> list = map.get(keyStr);
                    list.add(e.toString());
                    map.put(keyStr, list);
                } else {
                    List<String> list = new ArrayList<String>();
                    list.add(e.toString());
                    map.put(keyStr, list);
                }
                key.setLength(0);
                return;
            }
            // 对象数组,注:对象数组不一定是OA,反之OA一定是对象数组
            if (e.isJsonArray()) {
                JsonArray jsonArr = e.getAsJsonArray();
                if (null != jsonArr) {
                    for (JsonElement je : jsonArr) {
                        if (je.isJsonNull() || je.isJsonPrimitive()) { // 数组中元素依然是原始数据类型
                            String keyStr = key.toString();
                            if (map.containsKey(keyStr)) {
                                List<String> list = map.get(keyStr);
                                list.set(0, map.get(keyStr).get(0) + "," + je.toString());
                                map.put(keyStr, list);
                            } else {
                                List<String> list = new ArrayList<String>();
                                list.add(je.toString());
                                map.put(keyStr, list);
                            }
                        } else { // 不是原始数据类型继续递归
                            jsonTree(je, key);  //递归
                        }
                    }
    
                }
            }
            // json对象
            if (e.isJsonObject()) {
                // json的所有key=value对
                Set<Map.Entry<String, JsonElement>> es = e.getAsJsonObject().entrySet();
                String pKey = key.toString(); // 存储父节点
                for (Map.Entry<String, JsonElement> en : es) {
                    if (pKey.length() > 0) { //连接符拼接
                        key = new StringBuilder(pKey + "-->" + en.getKey());
                    } else {
                        key = new StringBuilder(en.getKey());
                    }
                    JsonElement element = en.getValue();
                    jsonTree(element, key); //递归
                }
            }
        }
    }
    

    代码中涉及到的文件如下:

    (1)data.json

    {
      "OA": [
        {
          "rd": 1,
          "rn": "s"
        },
        {
          "rd": 2,
          "rn": "d"
        }
      ],
      "OOA": [
        {
          "a": 1,
          "b": [
            {
              "c": 1,
              "d": [
                {
                  "e": 1
                },
                {
                  "e": 2
                }
              ]
            },
            {
              "c": 2,
              "d": [
                {
                  "e": 2
                },
                {
                  "e": 2
                }
              ]
            }
          ]
        },
        {
          "a": 2,
          "b": [
            {
              "c": 1,
              "d": [
                {
                  "e": 1
                },
                {
                  "e": 1
                }
              ]
            },
            {
              "c": 2,
              "d": [
                {
                  "e": 2
                },
                {
                  "e": 2
                }
              ]
            }
          ]
        }
      ],
      "name": {
        "c": "Rick and Morty",
        "d": "dd"
      },
      "hobby":["t","m",{"s":true}],
      "id": "kladu8yak8asdha8",
      "boolean": true,
      "number": 3,
      "k": null,
      "ARRAY": [
        {
          "FIRST": "Rick",
          "SEC": "tt"
        },
        {
          "LAST": "Morty"
        }
      ]
    }

    (2)meta

    file_1:name-->c|name-->d|hobby|hobby-->s|id|boolean|number|k|ARRAY-->FIRST|ARRAY-->SEC|ARRAY-->LAST
    file_2:id|OA-->rd|OA-->rn
    file_3:id|OOA-->a
    file_4:OOA-->a|OOA-->b-->c|OOA-->b-->d-->e

    输出结果如下:

    读取到的json字符串:
    {"OA":[{"rd":1,"rn":"s"},{"rd":2,"rn":"d"}],"OOA":[{"a":1,"b":[{"c":1,"d":[{"e":1},{"e":2}]},{"c":2,"d":[{"e":2},{"e":2}]}]},{"a":2,"b":[{"c":1,"d":[{"e":1},{"e":1}]},{"c":2,"d":[{"e":2},{"e":2}]}]}],"name":{"c":"Rick and Morty","d":"dd"},"hobby":["t","m",{"s":true}],"id":"kladu8yak8asdha8","boolean":true,"number":3,"k":null,"ARRAY":[{"FIRST":"Rick","SEC":"tt"},{"LAST":"Morty"}]}
    解析后的json数据:
    OOA-->a  =  [1, 2]
    ARRAY-->LAST  =  ["Morty"]
    k  =  [null]
    hobby-->s  =  [true]
    OA-->rn  =  ["s", "d"]
    number  =  [3]
    name-->c  =  ["Rick and Morty"]
    name-->d  =  ["dd"]
    boolean  =  [true]
    OOA-->b-->d-->e  =  [1, 2, 2, 2, 1, 1, 2, 2]
    ARRAY-->SEC  =  ["tt"]
    OA-->rd  =  [1, 2]
    ARRAY-->FIRST  =  ["Rick"]
    OOA-->b-->c  =  [1, 2, 1, 2]
    id  =  ["kladu8yak8asdha8"]
    hobby  =  ["t","m"]
    保存文件名:
    file_1 = [name-->c, name-->d, hobby, hobby-->s, id, boolean, number, k, ARRAY-->FIRST, ARRAY-->SEC, ARRAY-->LAST]
    file_2 = [id, OA-->rd, OA-->rn]
    file_3 = [id, OOA-->a]
    file_4 = [OOA-->a, OOA-->b-->c, OOA-->b-->d-->e]
    +++++++++++++++++++++++++++++++
    保存文件file_1:
    "Rick and Morty"|"dd"|"t","m"|true|"kladu8yak8asdha8"|true|3|null|"Rick"|"tt"|"Morty"|
    
    ++++++++++++++++++++++++++++++++++++++++++
    保存文件file_2:
    "kladu8yak8asdha8"|1|"s"|
    "kladu8yak8asdha8"|2|"d"|
    
    ++++++++++++++++++++++++++++++++++++++++++
    保存文件file_3:
    "kladu8yak8asdha8"|1|
    "kladu8yak8asdha8"|2|
    
    ++++++++++++++++++++++++++++++++++++++++++
    保存文件file_4:
    1|1|1|
    1|1|2|
    1|2|2|
    1|2|2|
    2|1|1|
    2|1|1|
    2|2|2|
    2|2|2|
    
    ++++++++++++++++++++++++++++++++++++++++++

     

    展开全文
  • 一、解析接口请求返回json中含数组的一层对象的简单结构 1> 数据结构如下: { “data”: [ { “cpid”: “20190904162049UyPhgiTkUAoQ8w0i70BdnqQybmB4”, “dbServerName”: “192.168.31.11” }, { “cpid”: ...

    一、解析接口请求返回json中含数组的一层对象的简单结构

    1 数据结构如下:

      {
        "data": [
            {
                "cpid": "20190904162049UyPhgiTkUAoQ8w0i70BdnqQybmB4",
                "dbServerName": "192.168.31.11"
            },
            {
                "cpid": "20190906113836wyzwnK9IWdfYhI2kwxNoTPGbv8W6",
                "dbServerName": "172.15.103.27"
            }
        ],
        "pageIndex": 0,
        "pageNo": 1,
        "pageSize": 10
    }
    

    2. 如解析1中的数据,指定ip为192.168.31.11的cpid,代码如下:

    import org.json.JSONObject;       //需要jmeter的lib/ext中放入 json.jar包
    import org.json.JSONArray;
    
    //获取jmeter接口请求返回值。此处获取到String类型;
    String response_data = prev.getResponseDataAsString(); 
    //log.info("response_data------>"+response_data);  //jmeter beanshell打印出返回的结果
    
    JSONObject data_obj = new JSONObject(response_data);    //将接口响应结果转换为jsonobject对象
    JSONArray data_array = data_obj.getJSONArray("data"); //获取响应结果中参数data值; data为数组
    //log.info("data_array------>"+data_array.toString()); 
    
    int len = data_array.length(); //获取data数组的长度
    
    String strlen = Integer.toString(len);
    String cpidR="";
    //循环data数据中的数据找到要获取的指定数据
    for(int i = 0;i <len;i++){
        JSONObject jsonTemp = (JSONObject)data_array.getJSONObject(i); 
        //log.info("jsonTemp------>"+jsonTemp.toString());
        String dbServerName = jsonTemp.get("dbServerName").toString(); //获取data中的dbServerName
        //log.info("dbServerName"+i+"------>"+dbServerNameR);
        
        if(dbServerName.equals("192.168.31.11") )
        {
        	    cpidR = jsonTemp.get("cpid").toString();  //将满足条件的数据获取赋值给全局变量cpidR
            break;
        }else{
            continue;
        }
    }
     log.info("cpidR------>"+cpidR); 
     vars.put("orcl_cpid",cpidR);  //将获取的满足条件的cpidR值存为jmeter变量,提供下个接口使用,下个接口直接使用此处的${orcl_cpid}即可
     return "成功返回cpid";
    

    二、解析接口请求返回json中含数组的多层对象的复杂结构

    1. json数据结构

    {
        "data": [
            {
                "cpid": "20190904162049UyPhgiTkUAoQ8w0i70BdnqQybmB4",
                "dbServerName": "192.168.31.11"
                 “coonpool”:
                  {
                     “poolid”:“123456789”,
                     “poolname”:“nametest”
                  }==  //第二层对象
            },
            {
                "cpid": "20190906113836wyzwnK9IWdfYhI2kwxNoTPGbv8W6",
                "dbServerName": "172.15.103.27"
                 “coonpool”:
                  {
                     “poolid”:“A123456789”,
                     “poolname”:“nametest”
                  }
            }
        ],
        "pageIndex": 0,
        "pageNo": 1,
        "pageSize": 10
    }
    

    2. jmeter使用beanshell解析的java代码如下:
    需求:获取poolid为123456789的poolname与cpid

    import org.json.JSONObject; 
    import org.json.JSONArray;
    
    //获取请求返回值。此处获取到String类型;
    String response_data = prev.getResponseDataAsString(); 
    log.info("response_data------>"+response_data);
    
    JSONObject data_obj = new JSONObject(response_data);
    JSONArray data_array = data_obj.getJSONArray("data"); //获取响应结果中参数data值; data为数组
    
    log.info("data_array------>"+data_array.toString()); 
    int len = data_array.length(); //获取data数组的长度
    
    String strlen = Integer.toString(len);
    String cpid ="";
    String poolname="";
    
    for(int i = 0;i <len;i++){
        JSONObject responseRunVo1 = (JSONObject)data_array.getJSONObject(i); 
        JSONObject responseRunVo2 = (JSONObject)jsonTemp.getJSONObject("connpool");
        
      //  log.info("获取数组的第二层对象元素:"+responseRunVo);
      
        String poolidR= responseRunVo2.getString("poolid");
        if (poolidR.equals("123456789") )
        {
        	   cpid =responseRunVo1.getString("cpid");   //第一层对象的数据
        	   poolname= responseRunVo2.getString("poolname");  //第二层对象的数据    	   
            break;
        }else{
            continue;
        }
    }
     log.info("cpid------>"+cpid); 
     log.info("poolname------>"+poolname); 
    
     vars.put("orcl_cpid",cpid);
     vars.put("orcl_poolname",poolname);
    //下个接口可以直接使用变量orcl_cpid与orcl_poolname获取结果值
     return "成功返回";
    
    展开全文
  • 使用轻量级开源的cJSON库,快速实现对json文本的解析,本例程通过详细的步骤,一步一步的对复杂JSON数据的解析。仅供大家参考和学习,严禁用于商业用途!
  • 写项目的时候,请求了一个接口,发现返回的json数据,多层嵌套的,而且嵌套的第二层data是数组,第三层的news也是数组所以需要写多个嵌套json进行解析,使用json.Unmarshal 进行嵌套结构体的解析json截图为:代码...
  • Gson多层嵌套Json解析

    2015-06-16 08:28:42
    多层嵌套Json解析 采用静态内部类的形式实现多层嵌套 对于数组采用List成员实现   { "mp3list": [  {  "name": "爱我别走",  "artist": "张震岳",  "size": "2.8M",  "url": "http://127.0.0.1"
  • 无限级json数组动态根据层级生成id,先贴出原始数据 { "project_name": "项目名称", "project_remark": "test", "Project_tree_node": [ { "label": "造价入口", "children": [ { "label": "变更" },
  • Gson解析多层嵌套的数组出现的问题

    千次阅读 2015-06-25 23:16:01
    首先,Gson是可以完美的解析N层夹套的数组的。解析一个两层嵌套的数组,一直出现如下错误:6-25 22:04:55.596 17974-17974/cn.usmaker.hm.pai E/AndroidRuntime﹕ FATAL EXCEPTION: main Process: ...
  • JSONObject 解析多层json数据

    万次阅读 2018-08-30 21:57:41
    多层嵌套时,只需要解析多层嵌套次数-1,解析完成后可直接取出数据。 相同数据需要使用for循环。 JSONArray是数组,JSONObject是单条数据。 JSONObject jsonObject = new JSONObject(responseText); JSONObject...
  • android解析多层json经验

    千次阅读 2016-10-09 10:31:03
    多层嵌套时,只需要解析多层嵌套次数-1,解析完成后可直接取出数据。 相同数据需要使用for循环。 JSONArray是数组,JSONObject是单条数据。
  • 多层嵌套json类型数据解析

    千次阅读 2019-09-29 02:28:03
    前段时间写了一个多层嵌套json数据对象,费了半天劲,记录一下 前端数据类似淘宝多条件搜索,json数据类型为key-value嵌套数组 前端为ajax传值 function searfunc(arr) { //arr为查询按钮之后输出的搜索...
  • 向那种单层的数组我就会解析,向这种多层的我就不会了,都说是一层一层往下解析,就是不会,求大神指点,不要用Gson之类的框架,那些我会,谢谢 { "OK": 0, "obj": { "list": [ { "id": "8005285", "tour...
  • * key 必须是字符串,value 可以是合法的 JSON 数据类型(字符串, 数字, 对象, 数组, 布尔值或 null) * value如果是字符串,用jsonobj.getString("key")获取 * value如果是数 字,用jsonobj.getIntValue("ke...
  • 1.解析json数据代码: //获取body中返回的所有参数 varjsonData=JSON.parse(responseBody); //获取其中data的值,jsonData是一个json格式 vardata=jsonData.data;//data //解析data的key值(businessSubjectDtos...
  • 支持多层嵌套的JSON数据解析。 支持包含多重嵌套的数组JSON数据解析。 在需要对同一个JSON字符串多次解析的情况下,相比于多次调用GET_JSON_OBJECT,JSON_TUPLE可以一次输入多个Key,且JSON字符串只被解析一次,...
  • C# Newtonsoft.Json 解析多嵌套json 进行反序列化 ... C# 生成多层嵌套JSON数组中(树结构JSON) https://blog.csdn.net/kongwei521/article/details/52522632 ...
  • 有一段Json数据,该Json数据中所有key对应的value值有各种类型,包括:数字、字符(串)、布尔值,以及由这些简单类型组成的对象,数组等,并且是多层嵌套的。前端将该Json解析后根据不同的key,将对应的value内容以...
  • json解析

    2013-05-05 23:19:49
    该小项目完整全面整理了java解析json各中写法,以及json的生成、遍历。 该项目收集整理json所需的jar包,使用文档。 /** * json的生成、遍历 */ import java.util.*; import net.sf.json.JSONArray; import ...
  • Oracle:解析复杂类型json

    千次阅读 2018-07-26 15:04:51
    工作中常遇到用oracle解析复杂类型的json多层对象并且包含数组等)情况,本人在开发中,采用将复杂json逐层解析到表,随后再提取方法。  例:解析如下的json数据,某平台国内机票订购单据 {  "data&...
  • Hive里面使用 get_json_object函数来解析 json 格式数据 读取数组内容 读取对象内容:获取单层值,获取多层值,获取内部的数组
  • 火山视窗JSON合成与解析 一、JSON介绍与模块配置 ...1、JSON介绍。...2、JSON目前共有两个对象,“JSON对象类”和“JSON数组类”。 3、JSON对象类标准格式为以“{”开始,最终以“}”结尾。 ...
  • 火山安卓JSON合成与解析 一、JSON介绍与模块配置 1、JSON介绍。...2、JSON共有两个对象,“JSON对象类”和“JSON数组类”。 3、JSON对象类标准格式为以“{”开始,最终以“}”结尾。 键名...
  • 使用python对json解析

    2019-08-02 00:39:31
    最近在工作中遇到了嵌套多层json串,不仅包括类似于python字典的嵌套,里面还有数组的嵌套。 具体的例子如下,在这里列举了三个例子,其实处理了大约500万条,虽然嵌套也挺多,但相对于专业的爬虫工程师来说,这...

空空如也

空空如也

1 2 3
收藏数 43
精华内容 17
关键字:

多层数组解析json