Android
Gson

परिचय

वाक्य - विन्यास

• बहिष्कृत बहिष्करण ()
• FieldNamingStrategy फ़ील्डNamingStrategy ()
• <टी> जेसन से (JsonElement json, Class <T> classOfT)
• <टी> जेसन से (JsonElement json, टाइप टाइपऑफ)
• <T> TJJson (JsonReader रीडर, टाइप टाइपऑफ़)
• जैसन से <टी> टी (रीडर जोंस, क्लास <टी> क्लासऑफटी)
• <टी> टीजॉन से (रीडर जोंस, टाइप टाइप ओएफटी)
• <टी> टीजॉन से (स्ट्रिंग जसन, क्लास <टी> क्लासऑफटी)
• <टी> टीजॉन से (स्ट्रिंग जसन, टाइप टाइप ओएफटी)
• <T> टाइप-एडॉप्टर <T> getAdapter (कक्षा <T> प्रकार)
• <T> टाइप एडेप्टर <टी> getAdapter (टाइपटोकन <टी> टाइप)
• <T> टाइप-एडॉप्टर <T> getDelegateAdapter (टाइप-एडेप्टरफ़ैक्टरी SkipPast, TypeToken <<> टाइप करें)
• JsonReader newJsonReader (रीडर रीडर)
• JsonWriter newJsonWriter (लेखक लेखक)
• JsonElement toJsonTree (ऑब्जेक्ट src)
• JsonElement tojsonTree (ऑब्जेक्ट src, टाइप typeOfSrc)
• बूलियन क्रमबद्धनुल्स ()
• बूलियन htmlSafe ()
• स्ट्रिंग toson (JsonElement jsonElement)
• स्ट्रिंग toson (ऑब्जेक्ट src)
• स्ट्रिंग toson (ऑब्जेक्ट src, टाइप typeOfSrc)
• स्ट्रिंग toString ()
• शून्य toJson (ऑब्जेक्ट src, प्रकार typeOfSrc, प्रशंसनीय लेखक)
• शून्य toJson (ऑब्जेक्ट src, प्रकार typeOfSrc, JsonWriter लेखक)
• शून्य toJson (JsonElement jsonElement, परिशिष्ट लेखक)
• शून्य toJson (JsonElement jsonElement, JsonWriter लेखक)
• शून्य toJson (ऑब्जेक्ट src, प्रशंसनीय लेखक)

GSON के साथ JSON पार्स करना

उदाहरण Google से Gson लाइब्रेरी का उपयोग करके एक JSON ऑब्जेक्ट को पार्स करना दिखाता है।

पार्सिंग ऑब्जेक्ट:

class Robot {
    //OPTIONAL - this annotation allows for the key to be different from the field name, and can be omitted if key and field name are same . Also this is good coding practice as it decouple your variable names with server keys name 
    @SerializedName("version") 
    private String version;

    @SerializedName("age")
    private int age;
    
    @SerializedName("robotName")
    private String name;
    
    // optional : Benefit it allows to set default values and retain them, even if key is missing from Json response. Not required for primitive data types. 

    public Robot{
       version = "";
       name = "";
    }


}

तब जहां पार्सिंग होने की जरूरत है, निम्नलिखित का उपयोग करें:

String robotJson = "{
                        \"version\": \"JellyBean\",
                        \"age\": 3,
                        \"robotName\": \"Droid\"
                   }";

Gson gson = new Gson();
Robot robot = gson.fromJson(robotJson, Robot.class);

एक सूची पार्स करना:

जब JSON ऑब्जेक्ट्स की एक सूची प्राप्त करते हैं, तो अक्सर आप उन्हें पार्स करना चाहेंगे और उन्हें जावा ऑब्जेक्ट में परिवर्तित करेंगे।

JSON स्ट्रिंग जिसे हम बदलने की कोशिश करेंगे वह निम्नलिखित है:

{
  "owned_dogs": [
    {
      "name": "Ron",
      "age": 12,
      "breed": "terrier"
    },
    {
      "name": "Bob",
      "age": 4,
      "breed": "bulldog"
    },
    {
      "name": "Johny",
      "age": 3,
      "breed": "golden retriever"
    }
  ]
}

इस विशेष JSON सरणी में तीन ऑब्जेक्ट हैं। हमारे जावा कोड में हम इन ऑब्जेक्ट्स को Dog ऑब्जेक्ट्स में मैप करना चाहते हैं। डॉग ऑब्जेक्ट इस तरह दिखेगा:

private class Dog {
    public String name;
    public int age;

    @SerializedName("breed")
    public String breedName;
}

JSON सरणी को Dog[] बदलने के लिए Dog[] :

Dog[] arrayOfDogs = gson.fromJson(jsonArrayString, Dog[].class);

एक Dog[] को JSON स्ट्रिंग में परिवर्तित करना:

String jsonArray = gson.toJson(arrayOfDogs, Dog[].class);

JSON सरणी को ArrayList<Dog> बदलने के लिए हम निम्नलिखित कार्य कर सकते हैं:

Type typeListOfDogs = new TypeToken<List<Dog>>(){}.getType();
List<Dog> listOfDogs = gson.fromJson(jsonArrayString, typeListOfDogs);

टाइप ऑब्जेक्ट टाइप typeListOfDogs परिभाषित करता है कि Dog ऑब्जेक्ट्स की सूची क्या दिखती है। जीएसओएन सरणी को सही मानों में मैप करने के लिए जीएसओएन इस प्रकार की वस्तु का उपयोग कर सकता है।

वैकल्पिक रूप से, List<Dog> को JSON सरणी में परिवर्तित करना समान तरीके से किया जा सकता है।

String jsonArray = gson.toJson(listOfDogs, typeListOfDogs);

GSON के साथ एनाम करने के लिए पार्सिंग JSON गुण

यदि आप गॉन के साथ एक स्ट्रिंग को पार्स करना चाहते हैं:

{"स्थिति": "खुला"}

public enum Status {
    @SerializedName("open")
    OPEN,
    @SerializedName("waiting")
    WAITING,
    @SerializedName("confirm")
    CONFIRM,
    @SerializedName("ready")
    READY
}

एक सूची पार्स करना Gson के साथ

विधि 1

Gson gson = new Gson();
String json = "[ \"Adam\", \"John\", \"Mary\" ]";

Type type = new TypeToken<List<String>>(){}.getType();
List<String> members = gson.fromJson(json, type);
Log.v("Members", members.toString());

यह अधिकांश जेनेरिक कंटेनर वर्गों के लिए उपयोगी है, क्योंकि आप एक पैरामीटर प्रकार के वर्ग को प्राप्त नहीं कर सकते हैं (यानी: आप List<String>.class नहीं कह सकते।

विधि 2

public class StringList extends ArrayList<String> { }

...

List<String> members = gson.fromJson(json, StringList.class);

वैकल्पिक रूप से, आप हमेशा अपने इच्छित प्रकार को उप-वर्ग कर सकते हैं, और फिर उस कक्षा में उत्तीर्ण हो सकते हैं। हालांकि यह हमेशा सबसे अच्छा अभ्यास नहीं है, क्योंकि यह आपके लिए एक प्रकार की StringList वापस आ जाएगा;

JSON सीरियलाइज़ेशन / स्व-सत्यापन और ऑटोवैल्यूसन के साथ विवरण

अपने ग्रेडेल रूट फ़ाइल में आयात करें

classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'

अपने ग्रेड ऐप फ़ाइल में आयात करें

apt 'com.google.auto.value:auto-value:1.2'  
apt 'com.ryanharter.auto.value:auto-value-gson:0.3.1'  
provided 'com.jakewharton.auto.value:auto-value-annotations:1.2-update1'  
provided 'org.glassfish:javax.annotation:10.0-b28'

आटोवल्यू के साथ ऑब्जेक्ट बनाएं:

@AutoValue public abstract class SignIn {    
    @SerializedName("signin_token") public abstract String signinToken();
    public abstract String username();

    public static TypeAdapter<SignIn> typeAdapter(Gson gson) {
        return new AutoValue_SignIn.GsonTypeAdapter(gson);
    }

    public static SignIn create(String signin, String username) {
        return new AutoValue_SignIn(signin, username);
    }
}

अपने GsonBuilder के साथ अपने Gson कनवर्टर बनाएँ

Gson gson = new GsonBuilder()
                .registerTypeAdapterFactory(
                    new AutoValueGsonTypeAdapterFactory())
                .create());

deserialize

String myJsonData = "{
    \"signin_token\": \"mySigninToken\",
    \"username\": \"myUsername\" }";
SignIn signInData = gson.fromJson(myJsonData, Signin.class);

क्रमबद्ध करें

Signin myData = SignIn.create("myTokenData", "myUsername");
String myJsonData = gson.toJson(myData);

GJ का उपयोग POJO ऑब्जेक्ट्स का उपयोग करके Serialization और Deserialization कोड को सरल बनाने का एक शानदार तरीका है। साइड इफेक्ट यह है कि प्रतिबिंब महंगा प्रदर्शन बुद्धिमान है। इसीलिए CustomTypeAdapter उत्पन्न करने के लिए AutoValue-Gson का उपयोग करने से इस प्रतिबिंब की लागत से बचना होगा, जबकि एपीआई परिवर्तन होने पर अद्यतन करने के लिए बहुत सरल रहना चाहिए।

GSON के साथ जेनेरिक क्लास ऑब्जेक्ट के लिए पार्सिंग JSON

मान लीजिए हमारे पास JSON स्ट्रिंग है J

["first","second","third"]

हम इस JSON स्ट्रिंग को String ऐरे में पार्स कर सकते हैं:

Gson gson = new Gson();
String jsonArray = "[\"first\",\"second\",\"third\"]";
String[] strings = gson.fromJson(jsonArray, String[].class);

लेकिन अगर हम इसे एक List<String> ऑब्जेक्ट में पार्स करना चाहते हैं, तो हमें TypeToken उपयोग करना चाहिए।

यहाँ नमूना है:

Gson gson = new Gson();
String jsonArray = "[\"first\",\"second\",\"third\"]";
List<String> stringList = gson.fromJson(jsonArray, new TypeToken<List<String>>() {}.getType());

मान लीजिए कि हमारे पास दो वर्ग हैं:

public class Outer<T> {
    public int index;
    public T data;
}

public class Person {
    public String firstName;
    public String lastName;
}

और हमारे पास एक JSON स्ट्रिंग है जिसे Outer<Person> ऑब्जेक्ट पर पार्स किया जाना चाहिए।

यह उदाहरण दिखाता है कि इस JSON स्ट्रिंग को संबंधित सामान्य वर्ग ऑब्जेक्ट में पार्स कैसे करें:

String json = "......";
Type userType = new TypeToken<Outer<Person>>(){}.getType();
Result<User> userResult = gson.fromJson(json,userType);

यदि JSON स्ट्रिंग को एक Outer<List<Person>> ऑब्जेक्ट पर पार्स किया जाना चाहिए:

Type userListType = new TypeToken<Outer<List<Person>>>(){}.getType();
Result<List<User>> userListResult = gson.fromJson(json,userListType); 

अपने प्रोजेक्ट में Gson जोड़ना

dependencies {
    compile 'com.google.code.gson:gson:2.8.1'
}

Gson के नवीनतम संस्करण का उपयोग करने के लिए

नीचे दी गई पंक्ति हर बार आपके द्वारा संकलित किए जाने वाले गन्स लाइब्रेरी के नवीनतम संस्करण को संकलित करेगी, आपको संस्करण बदलने की आवश्यकता नहीं है।

पेशेवरों: आप नवीनतम सुविधाओं, गति और कम बग का उपयोग कर सकते हैं।
विपक्ष: यह आपके कोड के साथ संगतता को तोड़ सकता है।

compile 'com.google.code.gson:gson:+'

डिस्क से JSON फ़ाइल लोड करने के लिए Gson का उपयोग करना।

यह एक JSON फ़ाइल को डिस्क से लोड करेगा और इसे दिए गए प्रकार में बदल देगा।

public static <T> T getFile(String fileName, Class<T> type) throws FileNotFoundException {
    Gson gson = new GsonBuilder()
            .create();
    FileReader json = new FileReader(fileName);
    return gson.fromJson(json, type);
}

Gson में एक कस्टम कनवर्टर जोड़ना

कभी-कभी आपको कुछ फ़ील्ड को वांछित प्रारूप में क्रमबद्ध या डिस्क्राइब करने की आवश्यकता होती है, उदाहरण के लिए आपकी बैकेंड तिथियों के लिए "YYYY-MM-dd HH: mm" प्रारूप का उपयोग कर सकती है और आप चाहते हैं कि आपका POJOS Joda Time में DateTime क्लास का उपयोग करे।

स्वचालित रूप से DateTimes ऑब्जेक्ट में इन स्ट्रिंग्स को कनवर्ट करने के लिए, आप एक कस्टम कनवर्टर का उपयोग कर सकते हैं।

/**
 * Gson serialiser/deserialiser for converting Joda {@link DateTime} objects.
 */
public class DateTimeConverter implements JsonSerializer<DateTime>, JsonDeserializer<DateTime> {

    private final DateTimeFormatter dateTimeFormatter;

    @Inject
    public DateTimeConverter() {
        this.dateTimeFormatter = DateTimeFormat.forPattern("YYYY-MM-dd HH:mm");
    }

    @Override
    public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(dateTimeFormatter.print(src));
    }

    @Override
    public DateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        
        if (json.getAsString() == null || json.getAsString().isEmpty()) {
            return null;
        }

        return dateTimeFormatter.parseDateTime(json.getAsString());
    }
}

Gson को नए ऑब्जेक्ट को बनाने के लिए उपयोग करने के लिए आपको Gson ऑब्जेक्ट बनाते समय इसे असाइन करना होगा:

    DateTimeConverter dateTimeConverter = new DateTimeConverter();
    Gson gson = new GsonBuilder().registerTypeAdapter(DateTime.class, dateTimeConverter)
            .create();

    String s = gson.toJson(DateTime.now());
    // this will show the date in the desired format

उस प्रारूप में दिनांक का विवरण देने के लिए आपको केवल दिनांक समय प्रारूप में एक क्षेत्र को परिभाषित करना होगा:

public class SomePojo {
    private DateTime someDate;    
} 

जब Gson एक प्रकार के डेटटाइम के क्षेत्र का सामना करता है, तो यह आपके कनवर्टर को फ़ील्ड को डिसेर्बलाइज़ करने के लिए कॉल करेगा।

रिट्रोफिट के साथ सीरियल के रूप में Gson का उपयोग करना

सबसे पहले आपको अपनी बिल्ड.ग्रेड फ़ाइल में GsonConverterFactory जोड़ना होगा

compile 'com.squareup.retrofit2:converter-gson:2.1.0'

फिर, आपको रेट्रोफ़िट सेवा बनाते समय कनवर्टर फ़ैक्टरी को जोड़ना होगा:

Gson gson = new GsonBuilder().create();
new Retrofit.Builder()
        .baseUrl(someUrl)
        .addConverterFactory(GsonConverterFactory.create(gson))
        .build()
        .create(RetrofitService.class);

आप कस्टम कन्वर्टर्स जोड़ सकते हैं जब आप उस गॉसन ऑब्जेक्ट को बनाते हैं जो आप कारखाने में पास कर रहे हैं। आपको कस्टम प्रकार रूपांतरण बनाने की अनुमति है।

Gson का उपयोग कर सामान्य वर्ग के लिए पार्सिंग json सरणी

मान लीजिए कि हमारे पास एक j है

{
  "total_count": 132,
  "page_size": 2,
  "page_index": 1,
  "twitter_posts": [
    {
      "created_on": 1465935152,
      "tweet_id": 210462857140252672,
      "tweet": "Along with our new #Twitterbird, we've also updated our Display Guidelines",
      "url": "https://twitter.com/twitterapi/status/210462857140252672"
    },
    {
      "created_on": 1465995741,
      "tweet_id": 735128881808691200,
      "tweet": "Information on the upcoming changes to Tweets is now on the developer site",
      "url": "https://twitter.com/twitterapi/status/735128881808691200"
    }
  ]
}

हम इस सरणी को कस्टम ट्वीट्स (ट्वीट्स लिस्ट कंटेनर) ऑब्जेक्ट में मैन्युअल रूप से पार्स कर सकते हैं, लेकिन इसे fromJson साथ करना आसान है:

Gson gson = new Gson();
String jsonArray = "....";
Tweets tweets = gson.fromJson(jsonArray, Tweets.class);

मान लीजिए कि हमारे पास दो वर्ग हैं:

class Tweets {
    @SerializedName("total_count")
    int totalCount;
    @SerializedName("page_size")
    int pageSize;
    @SerializedName("page_index")
    int pageIndex;
    // all you need to do it is just define List variable with correct name 
    @SerializedName("twitter_posts")
    List<Tweet> tweets;
}

class Tweet {
    @SerializedName("created_on")
    long createdOn;
    @SerializedName("tweet_id")
    String tweetId;
    @SerializedName("tweet")
    String tweetBody;
    @SerializedName("url")
    String url;
}

और यदि आपको सिर्फ एक json सरणी की जरूरत है तो आप इस कोड का उपयोग अपने पार्सिंग में कर सकते हैं:

String tweetsJsonArray = "[{.....},{.....}]"
List<Tweet> tweets = gson.fromJson(tweetsJsonArray, new TypeToken<List<Tweet>>() {}.getType());

GSON का उपयोग करते हुए कस्टम JSON Deserializer

कल्पना करें कि आपके पास सभी रीति-रिवाजों में सभी तिथियां हैं, उदाहरण के लिए /Date(1465935152)/ और आप java Date उदाहरणों के लिए सभी Json तिथियों के विवरण के लिए सामान्य नियम लागू करना चाहते हैं। इस मामले में आपको कस्टम Json Deserializer को लागू करने की आवश्यकता है।

Json का उदाहरण:

{
  "id": 1,
  "created_on": "Date(1465935152)",
  "updated_on": "Date(1465968945)",
  "name": "Oleksandr"
}

मान लीजिए कि हमारे पास यह वर्ग है:

class User {
    @SerializedName("id")
    long id;
    @SerializedName("created_on")
    Date createdOn;
    @SerializedName("updated_on")
    Date updatedOn;
    @SerializedName("name")
    String name;
}

कस्टम deserializer:

class DateDeSerializer implements JsonDeserializer<Date> {
    private static final String DATE_PREFIX = "/Date(";
    private static final String DATE_SUFFIX = ")/";

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        String dateString = json.getAsString();
        if (dateString.startsWith(DATE_PREFIX) && dateString.endsWith(DATE_SUFFIX)) {
            dateString = dateString.substring(DATE_PREFIX.length(), dateString.length() - DATE_SUFFIX.length());
        } else {
            throw new JsonParseException("Wrong date format: " + dateString);
        }
        return new Date(Long.parseLong(dateString) - TimeZone.getDefault().getRawOffset());
    }
}

और उपयोग:

Gson gson = new GsonBuilder()
                .registerTypeAdapter(Date.class, new DateDeSerializer())
                .create();
String json = "....";
User user = gson.fromJson(json, User.class);

तिथि प्रकार के साथ जैक्सन JSON तार को सीरियलाइज़ और डिसेर्बलाइज़ करें

यह उस मामले पर भी लागू होता है, जहां आप जैक्सन के साथ Gson Date रूपांतरण को संगत बनाना चाहते हैं, उदाहरण के लिए।

जैक्सन आमतौर पर तिथि को "युगों से मिलीसेकंड" में क्रमबद्ध करता है जबकि ग्सन दिनांक को Aug 31, 2016 10:26:17 लिए Aug 31, 2016 10:26:17 जैसे पठनीय प्रारूप का उपयोग करता है। जब आप एक जैक्सन प्रारूप तिथि को डीरियलाइज़ करने की कोशिश करते हैं तो यह Gson में JsonSyntaxException की ओर जाता है।

इसे दरकिनार करने के लिए, आप एक कस्टम धारावाहिक और एक कस्टम deserializer जोड़ सकते हैं:

JsonSerializer<Date> ser = new JsonSerializer<Date>() {
    @Override
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext
                context) {
        return src == null ? null : new JsonPrimitive(src.getTime());
    }
};

JsonDeserializer<Date> deser = new JsonDeserializer<Date>() {
    @Override
    public Date deserialize(JsonElement json, Type typeOfT,
                JsonDeserializationContext context) throws JsonParseException {
        return json == null ? null : new Date(json.getAsLong());
    }
};

Gson gson = new GsonBuilder()
                .registerTypeAdapter(Date.class, ser)
                .registerTypeAdapter(Date.class, deser)
                .create();

विरासत के साथ Gson का उपयोग करना

Gson बॉक्स से बाहर वंशानुक्रम का समर्थन नहीं करता है।

मान लें कि हमारे पास निम्न वर्ग पदानुक्रम है:

public class BaseClass {
    int a;
 
    public int getInt() {
        return a;
   }
}
 
public class DerivedClass1 extends BaseClass {
     int b;
 
     @Override
     public int getInt() {
         return b;
     }
 }
 
public class DerivedClass2 extends BaseClass {
    int c;
 
    @Override
    public int getInt() {
        return c;
    }
}

और अब हम एक JSON स्ट्रिंग के लिए DerivedClass1 का उदाहरण देना चाहते हैं

DerivedClass1 derivedClass1 = new DerivedClass1();
derivedClass1.b = 5;
derivedClass1.a = 10;
 
Gson gson = new Gson();
String derivedClass1Json = gson.toJson(derivedClass1);

अब, एक अन्य स्थान पर, हम इस जस स्ट्रिंग को प्राप्त करते हैं और इसे डिसेर्बलाइज करना चाहते हैं - लेकिन संकलन समय में हम केवल यह जानते हैं कि यह BaseClass का एक उदाहरण माना जाता है:

BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
System.out.println(maybeDerivedClass1.getInt());

लेकिन GSON पता नहीं है derivedClass1Json मूल का एक उदाहरण था DerivedClass1 , तो यह 10 से बाहर प्रिंट होगा।

इसे कैसे हल करें?

आपको अपना स्वयं का JsonDeserializer बनाने की आवश्यकता है, जो ऐसे मामलों को संभालता है। समाधान पूरी तरह से साफ नहीं है, लेकिन मैं एक बेहतर के साथ नहीं आ सका।

सबसे पहले, निम्न फ़ील्ड को अपने आधार वर्ग में जोड़ें

@SerializedName("type")
private String typeName;

और बेस क्लास कंस्ट्रक्टर में इसे इनिशियलाइज़ करें

public BaseClass() {
    typeName = getClass().getName();
}

अब निम्नलिखित वर्ग जोड़ें:

public class JsonDeserializerWithInheritance<T> implements JsonDeserializer<T> {
 
 @Override
 public T deserialize(
     JsonElement json, Type typeOfT, JsonDeserializationContext context)
     throws JsonParseException {
     JsonObject jsonObject = json.getAsJsonObject();
     JsonPrimitive classNamePrimitive = (JsonPrimitive) jsonObject.get("type");
 
     String className = classNamePrimitive.getAsString();
 
     Class<?> clazz;
     try {
     clazz = Class.forName(className);
     } catch (ClassNotFoundException e) {
     throw new JsonParseException(e.getMessage());
     }
     return context.deserialize(jsonObject, clazz);
 }
}

सब कुछ करना बाकी है -

GsonBuilder builder = new GsonBuilder();
 builder
 .registerTypeAdapter(BaseClass.class, new JsonDeserializerWithInheritance<BaseClass>());
 Gson gson = builder.create();

और अब, निम्न कोड चला रहा है-

 DerivedClass1 derivedClass1 = new DerivedClass1();
 derivedClass1.b = 5;
 derivedClass1.a = 10;
 String derivedClass1Json = gson.toJson(derivedClass1);
 
 BaseClass maybeDerivedClass1 = gson.fromJson(derivedClass1Json, BaseClass.class);
 System.out.println(maybeDerivedClass1.getInt());

5 का प्रिंट निकालेंगे।