जावा में सुंदर-प्रिंट JSON
जवाबों:
GSON एक अच्छे तरीके से कर सकता है:
Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonParser jp = new JsonParser();
JsonElement je = jp.parse(uglyJSONString);
String prettyJsonString = gson.toJson(je);scriptEngine.eval("result = JSON.stringify(JSON.parse(jsonString), null, 2)");
GsonBuilder, के बाद से मैं का उपयोग कर रहा था gson.toJson(object)मैं बस से मेरी इन्स्टेन्शियशन बदलना पड़ा Gson gson = new Gson();करने के लिए Gson gson = new GsonBuilder().setPrettyPrinting().create(); और मेरे कोड काम करने के लिए जारी रखा, लेकिन बहुत एक पंक्ति के बजाय वस्तु छपी।
मैंने डेटा को सुंदर रूप से प्रिंट करने के लिए org.json अंतर्निहित विधियों का उपयोग किया ।
JSONObject json = new JSONObject(jsonString); // Convert text to object
System.out.println(json.toString(4)); // Print it with specified indentationJSON में खेतों का क्रम प्रति परिभाषा यादृच्छिक है। एक विशिष्ट आदेश पार्सर कार्यान्वयन के अधीन है।
ऐसा लगता है कि जीएसओएन इसका समर्थन करता है, हालांकि मुझे नहीं पता कि क्या आप उस लाइब्रेरी से स्विच करना चाहते हैं जिसका आप उपयोग कर रहे हैं।
उपयोगकर्ता गाइड से:
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 आउटपुट (जैक्सन) कैसे सक्षम करें
मुझे पता है कि यह पहले से ही उत्तर में है, लेकिन मैं इसे अलग से यहां लिखना चाहता हूं क्योंकि संभावना है, आपके पास पहले से ही एक निर्भरता के रूप में जैक्सन है और इसलिए आपको आवश्यकता होगी कोड की एक अतिरिक्त पंक्ति होगी
यदि आप JSON प्रसंस्करण (JSR-353) कार्यान्वयन के लिए जावा एपीआई का उपयोग कर रहे हैं, तो आप 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();मेरी स्थिति यह है कि मेरी परियोजना एक विरासत (गैर-जेएसआर) JSON पार्सर का उपयोग करती है जो सुंदर मुद्रण का समर्थन नहीं करती है। हालांकि, मुझे सुंदर मुद्रित JSON नमूने का उत्पादन करने की आवश्यकता थी; जब तक आप जावा 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)));इनलाइनिंग के अलावा, यह स्वीकृत उत्तर के बराबर है ।
मौजूदा जवाबों में से अधिकांश या तो कुछ बाहरी पुस्तकालय पर निर्भर करते हैं, या एक विशेष जावा संस्करण की आवश्यकता होती है। यहाँ एक JSON स्ट्रिंग को सुंदर रूप से प्रिंट करने के लिए एक सरल कोड है, केवल सामान्य जावा एपीआई (उच्चतर के लिए जावा 7 में उपलब्ध) का उपयोग करके (हालांकि पुराने संस्करण की कोशिश नहीं की गई है)।
मूल विचार JSON में विशेष वर्णों के आधार पर स्वरूपण को छोटा करना है। उदाहरण के लिए, यदि कोई '{' या '[' देखा जाता है, तो कोड एक नई लाइन बनाएगा और इंडेंट स्तर को बढ़ाएगा।
डिस्क्लेमर: मैंने केवल कुछ साधारण JSON मामलों (बेसिक की-वैल्यू पेयर, लिस्ट, नेस्टेड JSON) के लिए यह परीक्षण किया है, इसलिए इसे और अधिक सामान्य JSON टेक्स्ट के लिए कुछ काम करने की आवश्यकता हो सकती है, जैसे कि उद्धरण के अंदर स्ट्रिंग मान, या विशेष वर्ण (\ n, \) टी आदि)।
/**
* 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 ) एक छोटी (75K) लाइब्रेरी है जिसमें JDK के अलावा कोई अन्य निर्भरता नहीं है।
सुंदर मुद्रण JSON के अलावा, आप जावा ऑब्जेक्ट (साइकिल के साथ पूरे जावा ऑब्जेक्ट ग्राफ़) को JSON में अनुक्रमित कर सकते हैं, साथ ही साथ उन्हें पढ़ भी सकते हैं।
अब इसे JSONLib लाइब्रेरी के साथ प्राप्त किया जा सकता है:
http://json-lib.sourceforge.net/apidocs/net/sf/json/JSONObject.html
यदि (और केवल यदि) आप ओवरलोड toString(int indentationFactor)विधि का उपयोग करते हैं, तो मानक toString()विधि का नहीं।
मैंने एपीआई के निम्नलिखित संस्करण पर इसे सत्यापित किया है:
<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);पोस्ट से JSON सुंदर प्रिंट Gson का उपयोग कर
वैकल्पिक रूप से, आप नीचे दिए गए जैक्सन का उपयोग कर सकते हैं
ObjectMapper mapper = new ObjectMapper();
String perttyStr = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);जावा (जैक्सन) में सुंदर प्रिंट JSON पोस्ट से
उममीद है कि इससे मदद मिलेगी!
Org 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);जैक्सन का उपयोग करते हुए इसने मेरे लिए काम किया:
mapper.writerWithDefaultPrettyPrinter().writeValueAsString(JSONString)mapperसे आया?
आप छोटे json पुस्तकालय का उपयोग कर सकते हैं
String jsonstring = ....;
JsonValue json = JsonParser.parse(jsonstring);
String jsonIndendedByTwoSpaces = json.toPrettyString(" ");अंडरस्कोर-जावा में स्थिर विधि है U.formatJson(json)। पांच प्रारूप प्रकार समर्थित हैं: 2, 3, 4, टैब और कॉम्पैक्ट। मैं परियोजना का अनुरक्षक हूं। जीवंत उदाहरण
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"
}
}