`

google Gson学习笔记及与json-lib的比较

阅读更多

因为gson网上的帮助文档打开时比较慢,所以把帮助文档摘录如此,方便查看:

1. 基本类型转化

public static void main(String[] args) {
		Gson gson = new Gson();
		System.out.println(gson.toJson(1)); // ==> prints 1
		System.out.println(gson.toJson("abcd"));// ==> prints "abcd"
		System.out.println(gson.toJson(new Long(10)));// ==> prints 10
		int[] values = { 1 };
		System.out.println(gson.toJson(values));// ==> prints [1]
		System.out.println("============");

		int one = gson.fromJson("1", int.class);
		Integer one1 = gson.fromJson("1", Integer.class);
		Long one2 = gson.fromJson("1", Long.class);
		String str = gson.fromJson("\"abc\"", String.class);
		String anotherStr = gson.fromJson("[\"abc\"]", String.class);
		int[] ints = gson.fromJson("[1,2,3,4,5]", int[].class);
		Boolean b = gson.fromJson("false", Boolean.class);
		System.out.println(b == false); //==> prints true
	}

 2.对象转化

public class BagOfPrimitives {

	private int	          value1	= 1;
	private String	      value2	= "abc";
//是用于声明变量在序列化的时候不被存储
	private transient int	value3	= 3;

	BagOfPrimitives() {
		// no-args constructor
	}

	public static void main(String[] args) {
		BagOfPrimitives obj = new BagOfPrimitives();
		Gson gson = new Gson();
		String json = gson.toJson(obj);  
		System.out.println(json); //==> json is {"value1":1,"value2":"abc"}
		
		BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class); 
		System.out.println(obj2.value1);
		System.out.println(obj2.value2);
		System.out.println(obj2.value3);//==>3
		
		String json1 = "{'value1':1,'value2':'abc','value3':4}";
		BagOfPrimitives obj3 = gson.fromJson(json1, BagOfPrimitives.class); 
		System.out.println(obj3.value1);
		System.out.println(obj3.value2);
		System.out.println(obj3.value3); //==>3
    }
}

Note that you can not serialize objects with circular references since that will result in infinite recursion

如果要是用json lib的话,上面的代码可以写成如下所示:

String json1 = "{'value1':1,'value2':'abc','value3':4}";
JSONObject jsonObj = JSONObject.fromObject( json1 ); 
BagOfPrimitives obj3 = (BagOfPrimitives) JSONObject.toBean( jsonObj, BagOfPrimitives.class );

 Finer Points with Objects

  • It is perfectly fine (and recommended) to use private fields
  • There is no need to use any annotations to indicate a field is to be included for serialization and deserialization. All fields in the current class (and from all super classes) are included by default.
  • If a field is marked transient, (by default) it is ignored and not included in the JSON serialization or deserialization.
  • This implementation handles nulls correctly
    • While serialization, a null field is skipped from the output
    • While deserialization, a missing entry in JSON results in setting the corresponding field in the object to null
  • If a field is synthetic , it is ignored and not included in JSON serialization or deserialization
  • Fields corresponding to the outer classes in  inner classes, anonymous classes, and local classes are ignored and not included in serialization or deserialization

Nested Classes (including Inner Classes)

Gson can serialize static nested classes quite easily. 

Gson can also deserialize static nested classes. However, Gson can not automatically deserialize the pure inner classes since their no-args constructor also need a reference to the containing Object which is not available at the time of deserialization. You can address this problem by either making the inner class static or by providing a custom InstanceCreator for it. Here is an example: 
public class A {
  public String a;

  class B {

    public String b;

    public B() {
      // No args constructor for B
    }
  }
}

 NOTE : The above class B can not (by default) be serialized with Gson.

G s o n   c a n   n o t   d e serialize {"b":"abc"} into an instance of B since the class B is an inner class. if it was defined as static class B then Gson would have been able to deserialize the string. Another solution is to write a custom instance creator for B.

public class InstanceCreatorForB implements InstanceCreator<A.B> {
  private final A a;
  public InstanceCreatorForB(A a)  {
    this.a = a;
  }
  public A.B createInstance(Type type) {
    return a.new B();
  }
}

The above is possible, but not recommended.

 

数组例子:

Gson gson = new Gson();
int[] ints = {1, 2, 3, 4, 5};
String[] strings = {"abc", "def", "ghi"};

(Serialization)
gson.toJson(ints);     ==> prints [1,2,3,4,5]
gson.toJson(strings);  ==> prints ["abc", "def", "ghi"]

(Deserialization)
int[] ints2 = gson.fromJson("[1,2,3,4,5]", int[].class);
==> ints2 will be same as ints

 We also support multi-dimensional arrays, with arbitrarily complex element types

综合实例1:

public class ExampleBean {
	private String	name;
	private String	id;
	private int	   age;
	private boolean isOk;
	
    public ExampleBean(String name, String id, int age, boolean isOk) {
	    super();
	    this.name = name;
	    this.id = id;
	    this.age = age;
	    this.isOk = isOk;
    }

	public ExampleBean() {
	}
//setter和getter方法
}

 测试:

public static void main(String[] args) {
		Gson gson = new Gson();
		List<ExampleBean> list = new ArrayList<ExampleBean>();
		for (int i = 0; i < 5; i++) {
			String name = "xxlong" + i;
			int age = 20 + i;
			ExampleBean bean = new ExampleBean(name, i + "", age);
			list.add(bean);
		}
		Type listType = new TypeToken<List<ExampleBean>>() {
		}.getType();
		//将list转化成json字符串
		String json = gson.toJson(list);
		System.out.println(json);
		//将json字符串还原成list
		List<ExampleBean> list2 = gson.fromJson(json, listType);
	}

 输出如下:[{"name":"xxlong0","id":"0","age":20,"isOk":false},{"name":"xxlong1","id":"1","age":21,"isOk":false},{"name":"xxlong2","id":"2","age":22,"isOk":false},{"name":"xxlong3","id":"3","age":23,"isOk":false},{"name":"xxlong4","id":"4","age":24,"isOk":false}]

 

综合实例2:

需求:想将字符串{'tableName' :'ys_index_y','year': '2008','params':'[z_expense,z_expense_profit,z_main_margin]','isOperAll':'false','copyToYear':''}还原成对象OpeerConditions,OpeerConditions对象代码如下所示:

public class OperConditions {

	private String	 tableName;
	private String	 year;
	private String[]	params;
	private boolean	 isOperALl;
	private String	 copyToYear;

	public OperConditions() {
	}

	public OperConditions(String tableName, String year, String[] params,
	                boolean isOperALl, String copyToYear) {
		super();
		this.tableName = tableName;
		this.year = year;
		this.params = params;
		this.setOperALl(isOperALl);
		this.copyToYear = copyToYear;
	}
//getter和setter方法
}

 因为OperConditions中有属性params,它是一个数组,所以无论是用json lib还是gson都不能直接将上面的字符串还原成OperCondtions对象,可以直接将params分离出来,单独处理,我这里选用此种方法来处理:

json-lib代码如下:

public static void main(String[] args) {
		
		String json = "{'tableName' :'ys_index_y','year': '2008','isOperAll':'false','copyToYear':''}";
		JSONObject jsonObj = JSONObject.fromObject( json ); 
		OperConditions conditions = (OperConditions) JSONObject.toBean( jsonObj, OperConditions.class );
		System.out.println(conditions.isOperALl() == false); //==>输出为true
		
		String json1 = "['z_expense','z_expense_profit','z_main_margin']";
		JSONArray jsonArray = JSONArray.fromObject(json1);
		//List<String> list = jsonArray.toList(jsonArray); //这个方法也可以
		List<String> list = jsonArray.toList(jsonArray,String.class);
		conditions.setParams(list.toArray(new String[0]));
		System.out.println(conditions.getParams()[0]); //==>输出为z_expense
	}

 因为JSONArray的toArray()方法返回的是一个Object[]数组,所以先将它转化成list,再转化到String数组。

当然由JSONArray转化成list时也可以使用subList方法,如下所示:

List<String> list = jsonArray.subList(0, jsonArray.size());

 或者可以直接使用JSONArray的iterator() 方法迭代它本身直接得到需要的String数组。

 

如果使用Gson来完成这一需求,个人感觉更简单,代码如下所示:

public static void main(String[] args) {

		String json = "{'tableName' :'ys_index_y','year': '2008','isOperAll':'false','copyToYear':''}";
		Gson gson = new Gson();
		OperConditions conditions = gson.fromJson(json, OperConditions.class);
		System.out.println(conditions.isOperALl() == false); // ==>输出为true

		String json1 = "['z_expense','z_expense_profit','z_main_margin']";
		String[] params = gson.fromJson(json1,String[].class);
		conditions.setParams(params);
		System.out.println(conditions.getParams()[0]); // ==>输出为z_expense
	}

 Gson可以直接转化成String[]数组,同时转化OperConditions时也比json-lib简单。

还有一点是非常值得注意的,就是你的bean中有boolean属性值时,强烈建议你别像我这个例子中一样命名为以is开头的属性名,这可能给你带来意想不到的错误,关于这一点的详细解说请参看我的文章json lib 学习笔记

 

 

 

 

分享到:
评论

相关推荐

    json-lib-2.4-jdk15.jar

    然而,随着技术的发展,虽然json-lib在当时是一个流行的JSON处理库,但现在已有其他更先进的替代品,如Gson、Jackson和Fastjson等,它们在性能、易用性和功能上都有所提升。因此,对于新项目来说,选择这些更新的库...

    json-lib-2.2.3-jdk15.jar

    JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,被广泛用于Web应用...尽管现在有更现代的替代品如Gson、Jackson等,但在某些场景下,JSON-lib仍然是一个可靠的选择,特别是对于需要向后兼容的老项目。

    Java四大json库gson+fastjson+jackson+json-lib

    为了方便地处理JSON数据,Java社区提供了多个优秀的JSON库,包括Gson、Fastjson、Jackson和json-lib。这四大JSON库各有特点,适应不同的使用场景。 1. Gson: Gson是Google提供的一个开源库,它能够将Java对象转换...

    json-lib-2.2.2-jdk15.jar

    4. **性能优化**:虽然json-lib是一个强大的库,但在处理大量数据时,其性能可能不如其他更现代的库如Jackson或Gson。然而,对于小型项目或对性能要求不高的场景,json-lib仍是一个可行的选择。 在Android开发中,...

    json-lib jar和所有依赖的jar

    在文件列表中的"jsonlib需要jar包",这可能是指包含了`json-lib`库及其所有依赖的JAR文件。在实际项目中,将这些JAR文件添加到项目的类路径(classpath)中,就可以使用`json-lib`提供的功能,而无需通过Maven或其他...

    json-lib-2.4-jdk15和全部依赖jar包

    在处理复杂的Java对象和大量的数据时,`json-lib`提供了一套完整的解决方案,但随着技术的发展,还有其他更现代的JSON库如Gson、Jackson和Fastjson等,它们在性能和易用性上可能更有优势。因此,在选择JSON库时,应...

    json-lib-2.4和相应的依赖包

    JSON库如json-lib-2.4是Java开发者在处理JSON数据时的重要工具,它提供了一系列API,使得JSON与Java对象之间的转换变得更加简单。本文将深入探讨json-lib-2.4及其在Java开发中的应用。 首先,json-lib-2.4是一个...

    json-lib-2.3-jdk15开发包和所有依赖包

    4. **XML与JSON互转**:除了基本的JSON操作,`json-lib`还提供了XML与JSON之间的转换功能,这对于需要在XML和JSON之间进行数据交换的应用非常有用。 5. **依赖包的集成**:`json-lib-2.3-jdk15`开发包包含了所有...

    json-lib-2.4-jdk15.jar及其相关依赖

    `json-lib`库的使用使得Java开发者在处理JSON数据时更加便捷,但需要注意的是,随着Java生态的发展,现在更流行的是使用Jackson、Gson或Google的AutoValue库来处理JSON,它们提供了更多特性和更好的性能。...

    json-lib 2.4 的 jar 包

    在Java中,JSON库如json-lib 2.4可以帮助开发者有效地处理JSON数据,进行数据的序列化与反序列化操作。本文将深入探讨json-lib 2.4这个jar包在Java开发中的应用。 json-lib是一个Java库,它提供了多种Java集合(如...

    json-lib-2.4 jar 程序文件

    7. **性能优化**:虽然JSON-Lib功能强大,但相比其他更现代的JSON库(如Jackson或Gson),其性能可能略低。因此,在性能敏感的应用中,可能需要权衡其便利性和效率。 总之,`json-lib-2.4 jar`为Java开发者提供了一...

    gson,fastJson,json-lib实例

    Gson是Google提供的一个开源库,它可以直接将Java对象转换成JSON字符串,也可以将JSON字符串反序列化为Java对象。Gson的强大之处在于其灵活性和丰富的功能,例如支持自定义类型适配器、处理日期时间、以及支持泛型...

    json-lib-2.4-jdk15所需要的jar包

    JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,被广泛用于Web服务和服务器端...在现代的Java开发中,虽然有其他更现代的JSON库如Gson和Jackson,但`json-lib`仍然在一些遗留系统或特定场景下被使用。

    json-lib-2.2.2-jdk15及其所依赖的jar包

    jar包如下:commons-beanutils-1.7,commons-collections,commons-lang,commons-logging-1.1.1,ezmorph, gson-2.2.1,gson-2.2.1-sources,json-lib-2.2.2-jdk15

    json-lib-2.4-jdk15.jar所需全部JAR包_JSON_

    1. **Jackson或Gson库**:这两个是其他流行的JSON库,可能会被`json-lib`用作底层实现的一部分,提供JSON序列化和反序列化的功能。 2. **Eclipse Collections**:可能用于提供高效的数据结构,如集合和映射,用于...

    json-lib 学习笔记 分享下

    这个学习笔记主要围绕`json-lib`的使用方法和关键特性进行阐述。 首先,`json-lib`支持多种Java对象到JSON的转换,包括基本类型、数组、集合、Map以及自定义的Java类。例如,你可以通过以下方式将一个HashMap转换为...

    json-lib 需要的所有jar包

    通常,这样的集合可能包括json-lib自身的jar,以及它依赖的其他库,如Jackson、Gson、org.json等,因为Json-lib可能利用了这些库的功能来实现其功能。 具体到这个压缩包,文件名为“json.jar”,这很可能是json-lib...

    json-lib-jdk.jar

    需要注意的是,虽然`json-lib`在过去被广泛应用,但随着技术的发展,现在更推荐使用如Gson、Jackson或Fastjson这样的现代JSON库,它们通常具有更好的性能和更丰富的功能。然而,对于一些老旧的项目或者需要与旧系统...

    json-lib-2.1-jdk15.jar

    然而,随着时间的发展,json-lib的更新相对较慢,社区支持可能不如其他更现代的JSON库如Gson或Jackson活跃。这些新库提供了更多特性,比如类型安全的转换、注解支持以及更高效的性能。 总的来说,"json-lib-2.1-jdk...

    json-lib及依赖包

    JSON(JavaScript ...然而,随着技术的发展,现在有许多其他流行的JSON库,如Gson、Jackson和Fastjson,它们在性能和易用性方面可能更具优势。在选择JSON库时,开发者应根据项目需求、性能要求和团队熟悉度来决定。

Global site tag (gtag.js) - Google Analytics