मैं की तरह कुछ के बारे में सोच रहा हूँ:जावा में जेएसओएन को स्पष्ट रूप से कैसे बनाया जाए?
String json = new JsonBuilder()
.add("key1", "value1")
.add("key2", "value2")
.add("key3", new JsonBuilder()
.add("innerKey1", "value3"))
.toJson();
कौन सा जावा JSON पुस्तकालय धाराप्रवाह इमारत के इस प्रकार के लिए सबसे अच्छा है?
अद्यतन: मैंने जीएसओएन लपेट लिया और लगभग वांछित परिणाम प्राप्त किया ... with one hitch।
मैं org.json पुस्तकालय का उपयोग कर रहा है और यह अच्छा और अनुकूल हो पाया।
उदाहरण:
String jsonString = new JSONObject()
.put("JSON1", "Hello World!")
.put("JSON2", "Hello my World!")
.put("JSON3", new JSONObject()
.put("key1", "value1")).toString();
System.out.println(jsonString);
उत्पादन:
{"JSON2":"Hello my World!","JSON3":{"key1":"value1"},"JSON1":"Hello World!"}
यह बहुत अधिक धाराप्रवाह नहीं है। – Vlad
आपके द्वारा प्रदान किया गया वेब अब और काम नहीं करता है। क्या आप इसे अपडेट करना चाहते हैं? –
ऐसा लगता है कि आप शायद json-लिब के ahold प्राप्त करना चाहते हैं की तरह:
http://json-lib.sourceforge.net/
डगलस Crockford पुरुष जो JSON का आविष्कार किया है, अपने जावा पुस्तकालय यहाँ है:
यह json-lib में लोग तरह लगता है उठाया जहां Crockford रोका गया था। दोनों जेएसओएन का पूरी तरह से समर्थन करते हैं, दोनों उपयोग (संगत, जहां तक मैं कह सकता हूं) JSONObject, JSONArray और JSONFunction constructs।
'होप कि मदद करता है ..
मैं हाल ही में Gson बनाने के लिए एक पुस्तकालय बनाया धाराप्रवाह वस्तुओं:
यह इस तरह काम करता है:
JsonObject jsonObject = JsonBuilderFactory.buildObject() //Create a new builder for an object
.addNull("nullKey") //1. Add a null to the object
.add("stringKey", "Hello") //2. Add a string to the object
.add("stringNullKey", (String) null) //3. Add a null string to the object
.add("numberKey", 2) //4. Add a number to the object
.add("numberNullKey", (Float) null) //5. Add a null number to the object
.add("booleanKey", true) //6. Add a boolean to the object
.add("booleanNullKey", (Boolean) null) //7. Add a null boolean to the object
.add("characterKey", 'c') //8. Add a character to the object
.add("characterNullKey", (Character) null) //9. Add a null character to the object
.addObject("objKey") //10. Add a nested object
.add("nestedPropertyKey", 4) //11. Add a nested property to the nested object
.end() //12. End nested object and return to the parent builder
.addArray("arrayKey") //13. Add an array to the object
.addObject() //14. Add a nested object to the array
.end() //15. End the nested object
.add("arrayElement") //16. Add a string to the array
.end() //17. End the array
.getJson(); //Get the JsonObject
String json = jsonObject.toString();
और जेनरिक के जादू यह कि यदि आप एक संपत्ति नाम के बिना एक संपत्ति कुंजी या किसी वस्तु के लिए एक तत्व के साथ एक सरणी के लिए एक तत्व को जोड़ने का प्रयास त्रुटियों संकलन उत्पन्न करता है के माध्यम से:
JsonObject jsonArray = JsonBuilderFactory.buildArray().addObject().end().add("foo", "bar").getJson(); //Error: tried to add a string with property key to array.
JsonObject jsonObject = JsonBuilderFactory.buildObject().addArray().end().add("foo").getJson(); //Error: tried to add a string without property key to an object.
JsonArray jsonArray = JsonBuilderFactory.buildObject().addArray("foo").getJson(); //Error: tried to assign an object to an array.
JsonObject jsonObject = JsonBuilderFactory.buildArray().addObject().getJson(); //Error: tried to assign an object to an array.
अन्त में एपीआई में मैपिंग समर्थन है जो आपको अपने डोमेन ऑब्जेक्ट्स को JSON पर मैप करने की अनुमति देता है। लक्ष्य किया जा रहा है जब Java8 जारी की है आप इस तरह कुछ करने के लिए सक्षम हो जाएगा:
Collection<User> users = ...;
JsonArray jsonArray = JsonBuilderFactory.buildArray(users, { u-> buildObject()
.add("userName", u.getName())
.add("ageInYears", u.getAge()) })
.getJson();
json.org पर संदर्भ कार्यान्वयन एक धाराप्रवाह इंटरफ़ेस भी शामिल है। JSONWriter और इसके टूस्ट्रिंग-कार्यान्वयन उपclass JSONStringer
Java Json specification देखें।
String json = Json.createObjectBuilder()
.add("key1", "value1")
.add("key2", "value2")
.build()
.toString();
String json = new JsonBuilder(new GsonAdapter())
.object("key1", "value1")
.object("key2", "value2")
.object("key3")
.object("innerKey1", "value3")
.build().toString();
अगर आपको लगता है ऊपर समाधान सुरुचिपूर्ण है, तो मेरी JsonBuilder lib बाहर का प्रयास करें: यह सही तरीका है। यह कई प्रकार के जेसन पुस्तकालयों के लिए जेसन संरचनाओं के निर्माण के एक तरीके की अनुमति देने के लिए बनाया गया था। वर्तमान कार्यान्वयन में जीसन, जैक्सन और मोंगोडीबी शामिल हैं। यानी के लिए।जैक्सन बस स्वैप:
String json = new JsonBuilder(new JacksonAdapter()).
मैं खुशी से दूसरों को अनुरोध पर जोड़ दूंगा, यह भी स्वयं को लागू करने में काफी आसान है।
यदि आप जैक्सन का उपयोग कर रहे हैं तो कोड में JsonNode बिल्डिंग करें, तो आप उपयोगिता के निम्नलिखित सेट में दिलचस्प हो सकते हैं। उनका उपयोग करने का लाभ यह है कि वे एक और प्राकृतिक चेनिंग शैली का समर्थन करते हैं जो निर्माण के तहत जेएसओएन की संरचना को बेहतर ढंग से दिखाता है।
import static JsonNodeBuilders.array;
import static JsonNodeBuilders.object;
...
val request = object("x", "1").with("y", array(object("z", "2"))).end();
निम्नलिखित में से कौन JSON के बराबर है:
यहाँ एक उदाहरण उपयोग है
{"x":"1", "y": [{"z": "2"}]}
यहाँ वर्ग हैं: कार्यान्वयन का उपयोग करता
import static lombok.AccessLevel.PRIVATE;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.val;
/**
* Convenience {@link JsonNode} builder.
*/
@NoArgsConstructor(access = PRIVATE)
public final class JsonNodeBuilders {
/**
* Factory methods for an {@link ObjectNode} builder.
*/
public static ObjectNodeBuilder object() {
return object(JsonNodeFactory.instance);
}
public static ObjectNodeBuilder object(@NonNull String k1, boolean v1) {
return object().with(k1, v1);
}
public static ObjectNodeBuilder object(@NonNull String k1, int v1) {
return object().with(k1, v1);
}
public static ObjectNodeBuilder object(@NonNull String k1, float v1) {
return object().with(k1, v1);
}
public static ObjectNodeBuilder object(@NonNull String k1, String v1) {
return object().with(k1, v1);
}
public static ObjectNodeBuilder object(@NonNull String k1, String v1, @NonNull String k2, String v2) {
return object(k1, v1).with(k2, v2);
}
public static ObjectNodeBuilder object(@NonNull String k1, String v1, @NonNull String k2, String v2,
@NonNull String k3, String v3) {
return object(k1, v1, k2, v2).with(k3, v3);
}
public static ObjectNodeBuilder object(@NonNull String k1, JsonNodeBuilder<?> builder) {
return object().with(k1, builder);
}
public static ObjectNodeBuilder object(JsonNodeFactory factory) {
return new ObjectNodeBuilder(factory);
}
/**
* Factory methods for an {@link ArrayNode} builder.
*/
public static ArrayNodeBuilder array() {
return array(JsonNodeFactory.instance);
}
public static ArrayNodeBuilder array(@NonNull boolean... values) {
return array().with(values);
}
public static ArrayNodeBuilder array(@NonNull int... values) {
return array().with(values);
}
public static ArrayNodeBuilder array(@NonNull String... values) {
return array().with(values);
}
public static ArrayNodeBuilder array(@NonNull JsonNodeBuilder<?>... builders) {
return array().with(builders);
}
public static ArrayNodeBuilder array(JsonNodeFactory factory) {
return new ArrayNodeBuilder(factory);
}
public interface JsonNodeBuilder<T extends JsonNode> {
/**
* Construct and return the {@link JsonNode} instance.
*/
T end();
}
@RequiredArgsConstructor
private static abstract class AbstractNodeBuilder<T extends JsonNode> implements JsonNodeBuilder<T> {
/**
* The source of values.
*/
@NonNull
protected final JsonNodeFactory factory;
/**
* The value under construction.
*/
@NonNull
protected final T node;
/**
* Returns a valid JSON string, so long as {@code POJONode}s not used.
*/
@Override
public String toString() {
return node.toString();
}
}
public final static class ObjectNodeBuilder extends AbstractNodeBuilder<ObjectNode> {
private ObjectNodeBuilder(JsonNodeFactory factory) {
super(factory, factory.objectNode());
}
public ObjectNodeBuilder withNull(@NonNull String field) {
return with(field, factory.nullNode());
}
public ObjectNodeBuilder with(@NonNull String field, int value) {
return with(field, factory.numberNode(value));
}
public ObjectNodeBuilder with(@NonNull String field, float value) {
return with(field, factory.numberNode(value));
}
public ObjectNodeBuilder with(@NonNull String field, boolean value) {
return with(field, factory.booleanNode(value));
}
public ObjectNodeBuilder with(@NonNull String field, String value) {
return with(field, factory.textNode(value));
}
public ObjectNodeBuilder with(@NonNull String field, JsonNode value) {
node.set(field, value);
return this;
}
public ObjectNodeBuilder with(@NonNull String field, @NonNull JsonNodeBuilder<?> builder) {
return with(field, builder.end());
}
public ObjectNodeBuilder withPOJO(@NonNull String field, @NonNull Object pojo) {
return with(field, factory.pojoNode(pojo));
}
@Override
public ObjectNode end() {
return node;
}
}
public final static class ArrayNodeBuilder extends AbstractNodeBuilder<ArrayNode> {
private ArrayNodeBuilder(JsonNodeFactory factory) {
super(factory, factory.arrayNode());
}
public ArrayNodeBuilder with(boolean value) {
node.add(value);
return this;
}
public ArrayNodeBuilder with(@NonNull boolean... values) {
for (val value : values)
with(value);
return this;
}
public ArrayNodeBuilder with(int value) {
node.add(value);
return this;
}
public ArrayNodeBuilder with(@NonNull int... values) {
for (val value : values)
with(value);
return this;
}
public ArrayNodeBuilder with(float value) {
node.add(value);
return this;
}
public ArrayNodeBuilder with(String value) {
node.add(value);
return this;
}
public ArrayNodeBuilder with(@NonNull String... values) {
for (val value : values)
with(value);
return this;
}
public ArrayNodeBuilder with(@NonNull Iterable<String> values) {
for (val value : values)
with(value);
return this;
}
public ArrayNodeBuilder with(JsonNode value) {
node.add(value);
return this;
}
public ArrayNodeBuilder with(@NonNull JsonNode... values) {
for (val value : values)
with(value);
return this;
}
public ArrayNodeBuilder with(JsonNodeBuilder<?> value) {
return with(value.end());
}
public ArrayNodeBuilder with(@NonNull JsonNodeBuilder<?>... builders) {
for (val builder : builders)
with(builder);
return this;
}
@Override
public ArrayNode end() {
return node;
}
}
}
ध्यान दें कि Lombok , लेकिन आप आसानी से जावा बॉयलरप्लेट भरने के लिए इसे डिगगर कर सकते हैं।
यह तो तुम सब करने की है बहुत आसान से आप अपने खुद के लिखने के लिए, बस एक विधि string toJson(), और एक अमूर्त वर्ग AbstractJsonElement कि इंटरफ़ेस को लागू करने के साथ JsonElementInterface के लिए एक इंटरफेस का उपयोग लगता है,
है के लिए एक वर्ग है JSONProperty कि इंटरफ़ेस को लागू करता है, और JSONValue (किसी भी टोकन), JSONArray ([...]), और JSONObject ({...}) है कि अमूर्त वर्ग
JSONObjectJSONProperty के
की एक सूची है विस्तार JSONArray में ली है AbstractJsonElement के के सेंट
प्रत्येक में अपने ऐड समारोह उस प्रकार के vararg सूची लेना चाहिए, और अब this
वापसी अगर आप कुछ पसंद नहीं है तो आप सिर्फ यह ठीक कर सकते हैं
के लाभ इंटीफेस और अमूर्त वर्ग यह है कि JSONArray गुणों को स्वीकार नहीं कर सकता है, लेकिन JSONProperty ऑब्जेक्ट्स या सरणी स्वीकार कर सकते हैं
मुझे नहीं लगता कि मैंने उस शैली का अनुसरण करने वाले किसी भी JSON लाइब्रेरी को देखा है। शायद आप जो चाहते हैं उसे करने के लिए मौजूदा पुस्तकालय का विस्तार कर सकते हैं? – aroth
@aroth - जैसा कि हम बोलते हैं मैं com.google.gson के चारों ओर एक रैपर लिख रहा हूं। – ripper234
लगभग तैयार - http://stackoverflow.com/questions/8876271/how-to-serialize-a-jsonobject-without-too-much-quotes – ripper234