将json转换为键值对中的文本的java代码

我是Java新手，我想写一段代码，将传入的json文件转换为键值对中的文本，键值对将被管道分隔。json文件中的模式往往会发生变化。因此，我无法基于每个值编写程序（我之前尝试过）

有人能帮忙吗

该文件是：

[{"type_id":4102,"id":0,"product_name":"ATP:Endpoint","feature_name":"ATP:Endpoint",
"feature_ver":"2014.2.0","atpProtocol":"av","device_uid":"D00A9450ABD85ACD2B0125968FEABBF9","device_ip":"10.75.81.205","device_name":"10.75.81.205","file":{"name":"CSIDL_PROFILE\\desktop\\av ping\\malheur_34_0\\malheur_34_0 - copy (4)","folder":"CSIDL_PROFILE\\desktop\\aving\\malheur_34_0","sha2":"BC44F53958886E6B220CA6C634D78703220139
E968719A7459B859954CAA4A77","md5":null,"version":null,"size":null,"date_created":null,"date_modified":null,"date_accessed":null},"platform":{"processor":"x86 Family 6 Model 45 Stepping 7","country":"1","language":"English","system":"Windows 7 build 7601 Service Pack 1","scanner":"Symantec Endpoint Protection 12.1.3.0"},"scan":{"signatures_version":"20141112.002","technology":"AV Engine"}]

---

我已经编写了一些将json字符串解析为map/list对象的方法

public static Map<String,Object> parseJSONObjectToMap(JSONObject jsonObject) throws JSONException{
    Map<String, Object> mapData = new HashMap<String, Object>();
    Iterator<String> keysItr = jsonObject.keys();
        while(keysItr.hasNext()) {
            String key = keysItr.next();
            Object value = jsonObject.get(key);

            if(value instanceof JSONArray) {
                value = parseJSONArrayToList((JSONArray) value);
            }else if(value instanceof JSONObject) {
                value = parseJSONObjectToMap((JSONObject) value);
            }
            mapData.put(key, value);
        }
    return mapData;
}

public static List<Object> parseJSONArrayToList(JSONArray array) throws JSONException {
    List<Object> list = new ArrayList<Object>();
    for(int i = 0; i < array.length(); i++) {
        Object value = array.get(i);
        if(value instanceof JSONArray) {
            value = parseJSONArrayToList((JSONArray) value);
        }else if(value instanceof JSONObject) {
            value = parseJSONObjectToMap((JSONObject) value);
        }
        list.add(value);
    }
    return list;
}

publicstaticmap parseJSONObjectToMap（jsonobjectjsonobject）抛出JSONException{
Map mapData=new HashMap（）；
迭代器keysItr=jsonObject.keys（）；
while（keysItr.hasNext（））{
String key=keysItr.next（）；
Object value=jsonObject.get（key）；
if（JSONArray的值实例）{
value=parseJSONArrayToList（（JSONArray）值）；
}else if（JSONObject的值实例）{
value=parseJSONObjectToMap（（JSONObject）值）；
}
mapData.put（键、值）；
}
返回地图数据；
}
公共静态列表parseJSONArrayList（JSONArray数组）抛出JSONException{
列表=新的ArrayList（）；
对于（int i=0；i

因此，我编写了一些通用代码，用于将每个json文件输入转换为管道。这也将读取子节点和。。。请看一下，测试一下你自己。我认为这将对其他人有用

package test;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.Iterator;
import java.util.Map;

import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;

public class ParseSEPEvents {

String endTime;
long latestLiveVisitStartTime;
boolean foundLatestVisitEndTime = false;

public ParseSEPEvents() {
}

public static void main(String args[]) throws Exception{
    ParseSEPEvents obj = new ParseSEPEvents();
    String contents = new String(Files.readAllBytes(Paths.get("<FileLocation>")));

    int idx = contents.indexOf("json");
    String jsonStr = contents.substring(idx+5);
    String header = contents.substring(0, idx+5);
    StringBuilder returnStr = obj.logParser(jsonStr);
    StringBuilder fnlStr = new StringBuilder(header).append(returnStr);

    System.out.println(fnlStr);
}

private StringBuilder parseToken( JsonNode node) {
    StringBuilder event = new StringBuilder();

    if (node == null) {
        return event;
    }       

    Iterator<Map.Entry<String, JsonNode>> itr = node.fields();      
    while (itr.hasNext()) {
        Map.Entry<String, JsonNode> keyValue = itr.next();
        String keyStr = keyValue.getKey();
        JsonNode innerNode = node.findValue(keyStr);            

        if(innerNode.isValueNode()){
        event.append(keyValue.getKey()).append("|").append(innerNode.toString()).append("|");
        }else{
            StringBuilder eventChild = parseToken(innerNode);
            event.append(keyValue.getKey()).append("[").append(eventChild).append("]");
        }

    }

    return event;

}

public StringBuilder logParser(String jsonStr) {
    JsonParser parser = null;
    StringBuilder strBuild = new StringBuilder();

    try {
        JsonFactory factory = new MappingJsonFactory();
        System.out.println("Parsing file records.");
        parser = factory.createParser(jsonStr);

        JsonToken currentToken = parser.nextToken();
        if (currentToken != JsonToken.START_ARRAY) {
            System.out.println("Warning: root should be object. quiting.");
            return strBuild;
        }

        while ((parser.nextToken()) != JsonToken.END_ARRAY) {
            currentToken = parser.nextToken();
            JsonNode node = parser.readValueAsTree();

            StringBuilder event = new StringBuilder();
            event = parseToken(node);
            return new StringBuilder("|").append(event);
        }

    } catch (JsonParseException jpe) {
        System.out.println("Unable to parse json records."
                + jpe.getMessage());
    } catch (IOException ioe) {
        System.out.println("Error while parsing file. " + ioe.getMessage());
    } finally {
        try {
            if ((parser != null) && !(parser.isClosed())) {
                parser.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
             }
         }

    return strBuild;
     }

}

封装测试；
导入java.io.File；
导入java.io.IOException；
导入java.nio.charset.StandardCharset；
导入java.nio.file.*；
导入java.util.Iterator；
导入java.util.Map；
导入com.fasterxml.jackson.core.*；
导入com.fasterxml.jackson.databind.*；
公共类事件{
字符串结束时间；
长时间的迟到访问开始时间；
布尔值foundLatestVisitEndTime=false；
公共事件（）{
}
公共静态void main（字符串args[]）引发异常{
ParseSEPEvents obj=新的ParseSEPEvents（）；
字符串内容=新字符串（Files.readAllBytes（path.get（“”））；
int idx=contents.indexOf（“json”）；
字符串jsonStr=contents.substring（idx+5）；
字符串头=contents.substring（0，idx+5）；
StringBuilder returnStr=obj.logParser（jsonStr）；
StringBuilder fnlStr=新的StringBuilder（标头）.append（returnStr）；
系统输出打印LN（fnlStr）；
}
私有StringBuilder parseToken（JsonNode节点）{
StringBuilder事件=新建StringBuilder（）；
if（node==null）{
返回事件；
}       
迭代器itr=node.fields（）；
while（itr.hasNext（））{
Map.Entry keyValue=itr.next（）；
字符串keyStr=keyValue.getKey（）；
JsonNode innerNode=node.findValue（keyStr）；
if（innerNode.isValueNode（））{
event.append（keyValue.getKey（））.append（“|”）.append（innerNode.toString（））.append（“|”）；
}否则{
StringBuilder eventChild=parseToken（innerNode）；
append（keyValue.getKey（））.append（“[”）.append（eventChild.append（“]）；
}
}
返回事件；
}
公共StringBuilder日志解析器（字符串jsonStr）{
JsonParser=null；
StringBuilder strBuild=新建StringBuilder（）；
试一试{
JsonFactory=new-MappingJsonFactory（）；
System.out.println（“解析文件记录”）；
parser=factory.createParser（jsonStr）；
JsonToken currentToken=parser.nextToken（）；
if（currentToken！=JsonToken.START\u数组）{
System.out.println（“警告：root应该是object.quiting.”）；
返回strBuild；
}
while（（parser.nextToken（））！=JsonToken.END\u数组）{
currentToken=parser.nextToken（）；
JsonNode=parser.readValueAsTree（）；
StringBuilder事件=新建StringBuilder（）；
事件=解析令牌（节点）；
返回新的StringBuilder（“|”）。追加（事件）；
}
}捕获（JsonParseException jpe）{
System.out.println（“无法解析json记录。”
+jpe.getMessage（））；
}捕获（ioe异常ioe）{
System.out.println（“解析文件时出错。”+ioe.getMessage（））；
}最后{
试一试{
if（（parser！=null）&&&！（parser.isClosed（））{
parser.close（）；
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
返回strBuild；
}
}

您能显示您的json输入吗？您期望的输出是什么？对于数组、对象等，您将使用什么符号。如果您使用非标准库，您至少应该指出依赖项（即要使用的库）。是的，谢谢提醒您需要导入以下库