n Java world, JSON is becoming de facto standard for data exchange format over XML because of its ease of use and efficiency in terms of transferring it.
If you don’t know about JSON, it is Javascript object notation, a text based data exchange format which is collection of name-value where name is strictly of string type and value can be int, boolean, array or another json object.
GSON is open source Java library developed by Google. It is an API for converting a Java object to/from json representation.
Why should you use it ?
- Converts any Java object i.e new object or any existing/legacy object, to JSON and vice-versa.
- Finest support for generic objects
- Simple, convenient methods for conversions
- No need of any annotation for fields for conversions
- All the fields by default are included in conversions even private fields
- If don’t want to include the field in conversion, use transient modifier for that field
- It handles the null fields gracefully, by not including them in serialization output but during deserialization it is initialized back to null
How do you add it to project ?
Add it as dependency using one of following way
Using Maven
Add the following dependency to project’s pom.xml
2 |
< groupId >com.google.code.gson</ groupId >
|
3 |
< artifactId >gson</ artifactId >
|
4 |
< version >2.2.4</ version >
|
Using Gradle
Add following to project’s build.gradle
6 |
compile 'com.google.code.gson:gson:2.2.4'
|
Use as unmanaged dependency
If you are not using any build tool, you can add gson jar to directly classpath or build path.
Download the latest jar from GSON project’s downloads page. The downloaded zip file contains 3 jar files – the binary, the source code and the javadoc. Grab the binary jar file and add it to your project classpath.
How to use it ?
For conversion of an object to/from json, you need to use the Gson class and its following 2 methods.
toJson() => converts an object provided to json string, takes object to be converted as argument and returns the json representation string
fromJSon() => converts the json string to object, takes first param as json string as object and class literal of destination object and returns the destination object
You can use Gson instance/object multiple times as it does not maintain any state.
Following are few examples stating the use of GSON API.
Example 1 : For simple object
Consider the following model object for conversion purpose, but remember that you can convert any object
ModelObject.java
01 |
package in.ajduke.ap012;
|
03 |
* An model for gson demo |
07 |
public class ModelObject {
|
13 |
public ModelObject(String name, int val,
|
14 |
boolean status, double f) {
|
23 |
public String toString() {
|
24 |
return "ModelObject [name=" + name + ",
|
25 |
val= " + val + " , status="
|
26 |
+ status + ", f=" + f + "]" ;
|
Following is listing for conversion object to json representation,
Example1.java
01 |
final Gson gson = new Gson();
|
03 |
ModelObject modelObject = new ModelObject( "myname" , 12 , true , 2.3 );
|
04 |
System.out.println( "toJson ---" );
|
05 |
System.out.println( "Original Java object : " + modelObject);
|
07 |
String json = gson.toJson(modelObject); |
08 |
System.out.println( "Converted JSON string is : " + json);
|
10 |
System.out.println( "fromJson----" );
|
12 |
System.out.println( "Original JSON string is : " + json);
|
14 |
ModelObject modelObject1 = gson.fromJson(json, ModelObject. class );
|
15 |
System.out.println( "Converted Java object : " + modelObject1);
|
Note the signature of fromJson() it takes second argument as the class literal of destination object.
Output as follows,
Example-1-output
toJson ---
Original Java object : ModelObject [name=myname, val=12, status=true, f=2.3]
Converted JSON string is : {"name":"myname","val":12,"status":true,"f":2.3}
fromJson----
Original JSON string is : {"name":"myname","val":12,"status":true,"f":2.3}
Converted Java object : ModelObject [name=myname, val=12, status=true, f=2.3]
Example 2 : For generic objects
For converting back the generic object to java object from json representation, we need to use use extra object as shown in follows
Type collectionType =new TypeToken<{ generic-object-with-type-information }>(){}.getType();
You need to provide the destination class type to TypeToken type parameter information as shown above. This is to form the Type instance and this we need to pass it to fromJson() method as second argument.
Following listing shows example for conversion of generic classes or the classes from collections framework to/from json
GenericModel.java
01 |
package in.ajduke.ap012;
|
03 |
* An generified model for demo of gson conversion |
06 |
public class GenericModel<T> {
|
09 |
public GenericModel(T value) {
|
15 |
public String toString() {
|
16 |
return "Model2 [value=" + value + "]" ;
|
Example2.java
01 |
Gson gson = new Gson();
|
03 |
System.out.println( "A generic object demo" );
|
05 |
GenericModel<Integer> model = new GenericModel<>( 12 );
|
08 |
String json = gson.toJson(model); |
09 |
System.out.println( "json representation :" + json);
|
12 |
Type collectionType = new TypeToken<GenericModel<Integer>>() {
|
14 |
GenericModel<Integer> modelObj = |
15 |
gson.fromJson(json, collectionType);
|
16 |
System.out.println( "converted object representation: " + modelObj);
|
18 |
System.out.println( "\nA object from collection framework\n" );
|
20 |
List<String> listOfString = new ArrayList<>();
|
21 |
listOfString.add( "ajduke" );
|
22 |
listOfString.add( "ajduchess" );
|
25 |
String jsonStr = gson.toJson(listOfString); |
26 |
System.out.println( "json representation :" + jsonStr);
|
28 |
Type collectionType2 = new TypeToken<List<String>>() {
|
30 |
List<String> listObj = gson.fromJson(jsonStr, collectionType2); |
31 |
System.out.println( "converted object representation: " + listObj);
|
Output as follows
Example2-output
A generic object demo
json representation :{"value":12}
converted object representation: Model2 [value=12]
A object from collection framework
json representation :["ajduke","ajduchess"]
converted object representation: [ajduke, ajduchess]
Example 3 : using transient
If you don’t want to include some field in json representation, you can use transient modifier to an variable declaration, then while converting it to json representation, GSON ignores that variable. But when converting back to an object from json string it initializes itsdefault value depending on variable type.
Consider our ModelObject and lets skip the integer val from json representation so, modify the its declaration to transient as in following listing
ModelObject2.java
01 |
package in.ajduke.ap012;
|
03 |
* An model for demo of gson conversion |
07 |
public class ModelObject {
|
13 |
public ModelObject(String name, int val,
|
14 |
boolean status, double f) {
|
23 |
public String toString() {
|
24 |
return "ModelObject [name=" + name + ",
|
25 |
val= " + val + " , status="
|
26 |
+ status + ", f=" + f + "]" ;
|
Following is listing
Example3.java
01 |
Gson gson = new Gson();
|
03 |
ModelObject modelObject = new ModelObject( "namesake" , 50 , true , 4.3 );
|
04 |
System.out.print( "Original Java object : " );
|
05 |
System.out.println(modelObject); |
08 |
String json = gson.toJson(modelObject); |
09 |
System.out.print( "Converted JSON string is : " );
|
10 |
System.out.println(json); |
13 |
ModelObject modelObject3 = gson.fromJson(json, ModelObject. class );
|
14 |
System.out.print( "Converted Java object : " );
|
15 |
System.out.println(modelObject3); |
So, while converting it GSON ignores and output of above as follows
example3-output
Original Java object : ModelObject [name=namesake, val=50, status=true, f=4.3]
Converted JSON string is : {"name":"namesake","status":true,"f":4.3}
Converted Java object : ModelObject [name=namesake, val=0, status=true, f=4.3]
Thats all folks, for GSON introduction !!
Note: I had given small code snippet for all examples, to access full length listing go to this gist on github
相关推荐
包含以下java源文件: com.google.gson.DefaultDateTypeAdapter.class com.google.gson.ExclusionStrategy.class com.google.gson.FieldAttributes.class com.google.gson.FieldNamingPolicy.class ...
google Gson 的最基本的运用和基本的类型
谷歌开发的 JSON 解析依赖包,2.8.0版本,包含依赖包、文档以及源码
google gson post 简单例子,利用gson实例化实体类,异步请求网络。
Google gson库能够实现定制化的序列化和反序列操作,能够简化Java序列化和反序列化操作
利用Google Gson实现JSON字符串和对象之间相互转换,内含源码和jar包
Google Gson解析Json数据应用实例
google的Gson 包括jar包,gson-2.2.4-javadoc,gson-2.2.4-sources。
android google gson json解析
Eclipse下使用Google Gson解析Json数据示例,挺好用的,亲测
Android Studio下使用Google Gson解析Json数据示例
用于复杂的Json 转换 例 Json 转 List<Bean>
Eclipse下使用Google Gson解析Json数据示例
GoogleGson-vs-SpringJackson
Gson 是 Google 提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库,可以快速的将一个 Json 字符转成一个 Java 对象,或者将一个 Java 对象转化为 Json 字符串。
om.google.code.gson/gson/2.6.2 Gson maven依赖 java 开发包
android google gson jar包及文档
json我们在网络请求中经常用到,最近最火的微信小程序开发中... 就会报错,因为对于嵌套类型的json它是解释不出来的,这时就需要用到com.google.gson.Gson.jar了。资源中提供了jar包与代码示例,一句代码解决您的问题。
基于googleGson的Json工具类,支持List,Object与Json互转,简单易用,Java与Android通用
com.google.gson.Gson 2.8.1 2.8.2 jar包 gson,直接解压到maven仓库,或者提取里面的jar包都可以使用