Java中的Pretty-Print JSON

Question

我正在使用json-simple，我需要漂亮地打印JSON数据（使其更具人性化）。

我无法在该库中找到此功能。 这通常是如何实现的？

Answer 1

GSON可以很好地做到这一点：

Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJSONString);
String prettyJsonString = gson.toJson(je);

Answer 2

我使用org.json内置方法来打印数据。

JSONObject json = new JSONObject(jsonString); // Convert text to object
System.out.println(json.toString(4)); // Print it with specified indentation

JSON中字段的顺序是每个定义随机的。特定订单需要解析器实现。

Answer 3

似乎GSON支持此功能，但我不知道您是否要从正在使用的库中切换。

来自用户指南：

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonOutput = gson.toJson(someObject);

Answer 4

如果您正在使用Java API进行JSON处理（JSR-353）实现，那么您可以在创建JsonGenerator.PRETTY_PRINTING时指定JsonGeneratorFactory属性。

以下示例最初发布在我的blog post。

import java.util.*;
import javax.json.Json;
import javax.json.stream.*;

Map<String, Object> properties = new HashMap<String, Object>(1);
properties.put(JsonGenerator.PRETTY_PRINTING, true);
JsonGeneratorFactory jgf = Json.createGeneratorFactory(properties);
JsonGenerator jg = jgf.createGenerator(System.out);

jg.writeStartObject()                    // {
    .write("name", "Jane Doe")           //    "name":"Jane Doe",
    .writeStartObject("address")         //    "address":{
        .write("type", 1)                //        "type":1,
        .write("street", "1 A Street")   //        "street":"1 A Street",
        .writeNull("city")               //        "city":null,
        .write("verified", false)        //        "verified":false
    .writeEnd()                          //    },
    .writeStartArray("phone-numbers")    //    "phone-numbers":[
        .writeStartObject()              //        {
            .write("number", "555-1111") //            "number":"555-1111",
            .write("extension", "123")   //            "extension":"123"
        .writeEnd()                      //        },
        .writeStartObject()              //        {
            .write("number", "555-2222") //            "number":"555-2222",
            .writeNull("extension")      //            "extension":null
        .writeEnd()                      //        }
    .writeEnd()                          //    ]
.writeEnd()                              // }
.close();

Answer 5

在一行中使用GSON进行漂亮打印：

System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(new JsonParser().parse(jsonString)));

除了内联之外，这相当于the accepted answer。

Answer 6

我的情况是我的项目使用了不支持漂亮打印的遗留（非JSR）JSON解析器。但是，我需要生成漂亮的JSON样本;只要您使用的是Java 7及更高版本，就可以实现这一点，而无需添加任何额外的库：

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine scriptEngine = manager.getEngineByName("JavaScript");
scriptEngine.put("jsonString", jsonStringNoWhitespace);
scriptEngine.eval("result = JSON.stringify(JSON.parse(jsonString), null, 2)");
String prettyPrintedJson = (String) scriptEngine.get("result");

Answer 7

杰克逊（com.fasterxml.jackson.core）：

ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonObject))

来自：How to enable pretty print JSON output (Jackson)

我知道这已经在答案中了，但是我想在这里单独写一下，因为很有可能，你已经将杰克逊作为一个依赖，所以你需要的只是额外的一行代码

Answer 8

使用org json。参考link

JSONObject jsonObject = new JSONObject(obj);
String prettyJson = jsonObject.toString(4);

使用Gson。参考link

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String json = gson.toJson(obj);

使用杰克逊。参考link

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);
String json = mapper.writeValueAsString(obj);

使用Genson。参考link。

Genson prettyGenson = new GensonBuilder().useIndentation(true).create();
String prettyJson = prettyGenson.serialize(obj);

Answer 9

在JSONLib中，您可以使用：

String jsonTxt = JSONUtils.valueToString(json, 8, 4);

来自Javadoc：

Answer 10

大多数现有答案要么依赖于某些外部库，要么需要特殊的Java版本。这是一个简单的代码，用于打印JSON字符串，仅使用通用Java API（Java 7中提供更高版本;尽管没有尝试旧版本）。

基本思想是根据JSON中的特殊字符触发格式化。例如，如果观察到'{'或'['，则代码将创建一个新行并增加缩进级别。

免责声明：我仅针对一些简单的JSON案例（基本键值对，列表，嵌套JSON）对此进行了测试，因此可能需要对更一般的JSON文本进行一些工作，例如带引号的字符串值或特殊字符（\ n，\ t等。）。

/**
 * A simple implementation to pretty-print JSON file.
 *
 * @param unformattedJsonString
 * @return
 */
public static String prettyPrintJSON(String unformattedJsonString) {
  StringBuilder prettyJSONBuilder = new StringBuilder();
  int indentLevel = 0;
  boolean inQuote = false;
  for(char charFromUnformattedJson : unformattedJsonString.toCharArray()) {
    switch(charFromUnformattedJson) {
      case '"':
        // switch the quoting status
        inQuote = !inQuote;
        prettyJSONBuilder.append(charFromUnformattedJson);
        break;
      case ' ':
        // For space: ignore the space if it is not being quoted.
        if(inQuote) {
          prettyJSONBuilder.append(charFromUnformattedJson);
        }
        break;
      case '{':
      case '[':
        // Starting a new block: increase the indent level
        prettyJSONBuilder.append(charFromUnformattedJson);
        indentLevel++;
        appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        break;
      case '}':
      case ']':
        // Ending a new block; decrese the indent level
        indentLevel--;
        appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        prettyJSONBuilder.append(charFromUnformattedJson);
        break;
      case ',':
        // Ending a json item; create a new line after
        prettyJSONBuilder.append(charFromUnformattedJson);
        if(!inQuote) {
          appendIndentedNewLine(indentLevel, prettyJSONBuilder);
        }
        break;
      default:
        prettyJSONBuilder.append(charFromUnformattedJson);
    }
  }
  return prettyJSONBuilder.toString();
}

/**
 * Print a new line with indention at the beginning of the new line.
 * @param indentLevel
 * @param stringBuilder
 */
private static void appendIndentedNewLine(int indentLevel, StringBuilder stringBuilder) {
  stringBuilder.append("\n");
  for(int i = 0; i < indentLevel; i++) {
    // Assuming indention using 2 spaces
    stringBuilder.append("  ");
  }
}

Answer 11

现在可以使用JSONLib库实现：

http://json-lib.sourceforge.net/apidocs/net/sf/json/JSONObject.html

如果（且仅当）您使用重载的toString(int indentationFactor)方法而不是标准的toString()方法。

我已在以下版本的API上验证了这一点：

<dependency>
  <groupId>org.json</groupId>
  <artifactId>json</artifactId>
  <version>20140107</version>
</dependency>

Answer 12

在一行中：

String niceFormattedJson = JsonWriter.formatJson(jsonString)

json-io libray（https://github.com/jdereg/json-io）是一个小型（75K）库，除了JDK之外没有其他依赖项。

除了漂亮打印JSON之外，您还可以将Java对象（带有循环的整个Java对象图）序列化为JSON，并将其读入。

Answer 13

遵循JSON-P 1.0规范（JSR-353），针对给定JsonStructure（JsonObject或JsonArray）的更新解决方案可能如下所示：

import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;

import javax.json.Json;
import javax.json.JsonStructure;
import javax.json.JsonWriter;
import javax.json.JsonWriterFactory;
import javax.json.stream.JsonGenerator;

public class PrettyJson {

    private static JsonWriterFactory FACTORY_INSTANCE;

    public static String toString(final JsonStructure status) {

        final StringWriter stringWriter = new StringWriter();

        final JsonWriter jsonWriter = getPrettyJsonWriterFactory()
                .createWriter(stringWriter);

        jsonWriter.write(status);
        jsonWriter.close();

        return stringWriter.toString();
    }

    private static JsonWriterFactory getPrettyJsonWriterFactory() {
        if (null == FACTORY_INSTANCE) {
            final Map<String, Object> properties = new HashMap<>(1);
            properties.put(JsonGenerator.PRETTY_PRINTING, true);
            FACTORY_INSTANCE = Json.createWriterFactory(properties);
        }
        return FACTORY_INSTANCE;
    }

}

Answer 14

您可以使用Gson，如下所示

Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonString = gson.toJson(object);

来自帖子JSON pretty print using Gson

或者，你可以像下面那样使用杰克逊

ObjectMapper mapper = new ObjectMapper();
String perttyStr = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);

来自帖子Pretty print JSON in Java (Jackson)

希望这有帮助！

Answer 15

更新：new JsonParser().parse(...)是@deprecated

---

基于 Gson 2.8.6 的Javadoc：

无需实例化此类，请改用静态方法。

JsonParser 静态方法：

JsonParser.parseString​(jsonString);
JsonParser.parseReader​(reader);

---

包装：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParser;

示例：

private Gson GSON = new GsonBuilder().setPrettyPrinting().create();
public static String getPerfectJSON(String unformattedJSON) {
    String perfectJSON = GSON.toJson(JsonParser.parseString(unformattedJSON));
    return perfectJSON;
}

---

使用Maven的

Google Gson 依赖项：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

---

参考：

• JsonParser is deprecated

Answer 16

这对我有用，使用杰克逊：

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)

Answer 17

您可以使用小型json库

String jsonstring = ....;
JsonValue json = JsonParser.parse(jsonstring);
String jsonIndendedByTwoSpaces = json.toPrettyString("  ");

Answer 18

Underscore-java具有静态方法U.formatJson（jsonstring）。我是该项目的维护者。 Live example

import com.github.underscore.lodash.U;

public class MyClass {

    public static void main(String args[]) {
        String json = "{\"Price\": {"
        + "    \"LineItems\": {"
        + "        \"LineItem\": {"
        + "            \"UnitOfMeasure\": \"EACH\", \"Quantity\": 2, \"ItemID\": \"ItemID\""
        + "        }"
        + "    },"
        + "    \"Currency\": \"USD\","
        + "    \"EnterpriseCode\": \"EnterpriseCode\""
        + "}}";
        System.out.println(U.formatJson(json)); 
    }
}

输出：

{
   "Price": {
      "LineItems": {
         "LineItem": {
            "UnitOfMeasure": "EACH",
            "Quantity": 2,
            "ItemID": "ItemID"
         }
      },
      "Currency": "USD",
      "EnterpriseCode": "EnterpriseCode"
   }
}