Java로 된 Pretty-Print JSON

나는 사용하고있다 JSON 단순 JSON 데이터를 예쁘게 인쇄해야합니다 (더 인간이 읽을 수 있도록).

해당 라이브러리에서이 기능을 찾을 수 없습니다. 이것이 일반적으로 어떻게 달성됩니까?

GSON 은이를 좋은 방법으로 수행 할 수 있습니다.

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

org.json 내장 메소드를 사용 하여 데이터를 예쁘게 인쇄했습니다.

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

JSON의 필드 순서는 정의마다 무작위입니다. 특정 순서는 파서 구현에 따라 다릅니다.

GSON 이 이것을 지원하는 것처럼 보이지만 사용중인 라이브러리에서 전환 하려는지 모르겠습니다.

사용 설명서에서 :

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

잭슨 ( com.fasterxml.jackson.databind)으로 :

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

보낸 사람 : 예쁜 인쇄 JSON 출력을 활성화하는 방법 (Jackson)

나는 이것이 이미 답변에 있음을 알고 있지만, 여기에 별도로 작성하고 싶습니다. 기회가 이미 잭슨을 가지고 있기 때문에 여분의 코드 줄이 필요할 것입니다.

JSON 처리 (JSR-353) 구현에 Java API를 사용하는 경우을 JsonGenerator.PRETTY_PRINTING작성할 때 특성을 지정할 수 있습니다 JsonGeneratorFactory.

다음 예제는 원래 블로그 게시물에 게시되었습니다 .

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();

내 상황은 내 프로젝트가 예쁜 인쇄를 지원하지 않는 기존 (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");

한 줄에 GSON을 사용 하여 인쇄하기 :

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

인라인 외에도 허용되는 답변 과 같습니다 .

기존 답변의 대부분은 일부 외부 라이브러리에 의존하거나 특수 Java 버전이 필요합니다. 다음은 일반적인 Java API를 사용하여 JSON 문자열을 예쁘게 인쇄하는 간단한 코드입니다 (Java 7 이상에서는 사용 가능하지만 이전 버전은 시도하지 않음).

기본 아이디어는 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("  ");
  }
}

한 줄로 :

String niceFormattedJson = JsonWriter.formatJson(jsonString)

json-io libray ( https://github.com/jdereg/json-io )는 JDK 이외의 다른 종속성이없는 작은 (75K) 라이브러리입니다.

예쁘게 인쇄하는 JSON 외에도 Java 객체 (사이클이있는 전체 Java 객체 그래프)를 JSON으로 직렬화하고 읽을 수 있습니다.

이제 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>

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;
    }

}

JSONLib에서는 다음을 사용할 수 있습니다.

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

로부터 자바 독 :

아래와 같이 Gson을 사용할 수 있습니다

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

Gson을 사용하여 포스트 JSON 예문에서

또는 아래처럼 Jackson을 사용할 수 있습니다

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

게시물 Pretty Java의 JSON 인쇄 (Jackson)

이 도움을 바랍니다!

조직 json 사용. 참조 링크

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

Gson 사용하기. 참조 링크

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

잭슨을 사용합니다. 참조 링크

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

젠슨 사용하기. 참조 링크 .

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

Jackson을 사용하여 나를 위해 일했습니다.

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)

작은 JSON 라이브러리를 사용할 수 있습니다

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

Underscore-java 에는 정적 메소드가 U.formatJson(json)있습니다. 2, 3, 4, 탭 및 컴팩트의 5 가지 형식 유형이 지원됩니다. 나는 프로젝트의 관리자입니다. 라이브 예

import com.github.underscore.lodash.U;

import static com.github.underscore.lodash.Json.JsonStringBuilder.Step.TABS;
import static com.github.underscore.lodash.Json.JsonStringBuilder.Step.TWO_SPACES;

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, TWO_SPACES)); 
        System.out.println(U.formatJson(json, TABS)); 
    }
}

산출:

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