Pretty-Print JSON w Javie

używam json-simple i muszę dość wydrukować dane JSON (aby były bardziej czytelne dla człowieka).

Nie udało mi się znaleźć tej funkcji w tej bibliotece. Jak to się zwykle osiąga?

GSON może to zrobić w przyjemny sposób:

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

Kiedyś org.json wbudowanej metody pretty wydrukować dane.

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

Kolejność pól w JSON jest losowa według definicji. Konkretne zamówienie podlega implementacji parsera.

Wygląda na to, że GSON obsługuje to, chociaż nie wiem, czy chcesz przełączyć się z używanej biblioteki.

Z instrukcji obsługi:

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

Z Jacksonem ( com.fasterxml.jackson.databind):

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

Od: Jak włączyć ładny wydruk JSON (Jackson)

Wiem, że jest to już w odpowiedziach, ale chcę napisać to tutaj osobno, ponieważ są szanse, że masz już Jackson jako zależność, więc wszystko, czego potrzebujesz, to dodatkowy wiersz kodu

Jeśli używasz interfejsu API języka Java do implementacji przetwarzania JSON (JSR-353), możesz określić JsonGenerator.PRETTY_PRINTINGwłaściwość podczas tworzenia JsonGeneratorFactory.

Poniższy przykład został pierwotnie opublikowany na moim blogu .

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

Moja sytuacja jest taka, że ​​mój projekt korzysta ze starszego parsera JSON (nie JSR), który nie obsługuje ładnego drukowania. Musiałem jednak wyprodukować ładnie wydrukowane próbki JSON; jest to możliwe bez konieczności dodawania dodatkowych bibliotek, o ile używasz Java 7 i nowszych wersji:

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

Ładne drukowanie z GSON w jednej linii:

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

Oprócz wstawiania jest to równoważne z przyjętą odpowiedzią .

Większość istniejących odpowiedzi albo zależy od biblioteki zewnętrznej, albo wymaga specjalnej wersji Java. Oto prosty kod do wydrukowania łańcucha JSON, tylko przy użyciu ogólnych interfejsów API Java (dostępny w Javie 7 dla wyższych wersji; chociaż nie wypróbowałem starszej wersji).

Podstawową ideą jest przełączanie formatowania na podstawie znaków specjalnych w JSON. Na przykład, jeśli zostanie zaobserwowane „{” lub „[”, kod utworzy nowy wiersz i zwiększy poziom wcięcia.

Oświadczenie: Testowałem to tylko dla niektórych prostych przypadków JSON (podstawowa para klucz-wartość, lista, zagnieżdżony JSON), więc może potrzebować trochę pracy dla bardziej ogólnego tekstu JSON, takiego jak wartość ciągu z cudzysłowami lub znaki specjalne (\ n, \ t itp.).

/**
 * 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("  ");
  }
}

W jednej linii:

String niceFormattedJson = JsonWriter.formatJson(jsonString)

Biblioteka json-io ( https://github.com/jdereg/json-io ) to mała biblioteka (75 KB ) bez żadnych innych zależności niż JDK.

Oprócz ładnego drukowania JSON, możesz serializować obiekty Java (całe wykresy obiektów Java z cyklami) do JSON, a także wczytywać je.

Teraz można to osiągnąć dzięki bibliotece JSONLib:

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

Jeśli (i tylko jeśli) używasz toString(int indentationFactor)metody przeciążonej , a nie standardowej toString().

Zweryfikowałem to w następującej wersji interfejsu API:

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

Zgodnie ze specyfikacjami JSON-P 1.0 ( JSR-353 ) bardziej aktualne rozwiązanie dla danego JsonStructure( JsonObjectlub JsonArray) mogłoby wyglądać następująco:

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

}

W JSONLib możesz użyć tego:

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

Z Javadoc :

Możesz użyć Gson jak poniżej

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

Z postu ładny wydruk JSON za pomocą Gsona

Alternatywnie możesz użyć Jacksona jak poniżej

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

Z postu Ładny druk JSON w Javie (Jackson)

Mam nadzieję, że to pomoże!

Za pomocą org json. Link referencyjny

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

Korzystanie z Gson. Link referencyjny

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

Korzystanie z Jacksona. Link referencyjny

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

Korzystanie z Genson. Link referencyjny .

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

To zadziałało dla mnie przy użyciu Jacksona:

mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)

Możesz użyć małej biblioteki json

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

Underscore-java ma metodę statyczną U.formatJson(json). Obsługiwanych jest pięć typów formatów: 2, 3, 4, tabulatory i compact. Jestem opiekunem projektu. Przykład na żywo

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

Wynik:

{
  "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"
    }
}