课程表

Java 基础教程

Java 面向对象

Java 高级教程

工具箱
速查手册

Java 解析 JSON

当前位置：免费教程 » Java相关 » Java

目前Java常见的Json处理库有如下几种：

1.json-lib

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。json-lib在功能和性能上面都不能满足现在互联网化的需求。

2.开源的Jackson

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

3.Google的Gson

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。

Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

4.阿里巴巴的FastJson

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的jar，能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

综上4种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，如果只是功能要求，没有性能要求，可以使用google的Gson，如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean。

w3xue为了照顾以前的老项目，在这里简要介绍下json-lib库，但重点介绍的是阿里巴巴的FastJson库。

一、使用json-lib

Java解析JSON，可以下载json-lib.jar包支持，该jar下载地址：百度网盘

下面是使用代码：

  1. //JSON对象 JSONObject的使用
  2. String str1 = "{ 'name': 'myjsondemo', 'sex': '1' }";
  3. JSONObject obj = JSONObject.fromObject(str1);
  4. String name = obj.getString("name"); //直接返回字符串型 myjsondemo
  5. Object nameo = obj.get("name"); //直接返回对象型的myjsondemo
  6. int age = obj.getInt("sex"); //直接返回int型的sex
  7.         
  8. //JSON数组对象 JSONArray的运用
  9. String jsonArrStr = "[{ 'name': 'myjsondemo', 'sex': '1','website':'//www.w3xue.com' },{ 'name': 'Smith', 'sex': '1','website':'http://www.java.com' }]";
  10. JSONArray array = JSONArray.fromObject(jsonArrStr);
  11. int size = array.size(); //获取JSON数组大小
  12. JSONObject jo = array.getJSONObject(0);//取第一个JSON对象
  13. for(int i=0;i<size;i++){
  14.     JSONObject jo1 = array.getJSONObject(i);
  15.     System.out.println(jo1.getString("website")); //循环返回网址
  16. }
  17.  
  18. //序列化Bean对象为JSON对象
  19. User user = new User();
  20. user.setName("myjsondemo");
  21. user.setSex(1);
  22. user.setWebsite("//www.w3xue.com");
  23. JSONObject jo2 =  JSONObject.fromObject(user);
  24. System.out.println(jo2.toString()); //则会输出 { 'name': 'myjsondemo', 'sex': '1','website':'//www.w3xue.com' }

二、使用FastJson

1、Fastjson 简介

3.jpg

Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。

Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。

Fastjson 源码地址：https://github.com/alibaba/fastjson

Fastjson 中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

2、Fastjson 特性

  • 提供服务器端、安卓客户端两种解析工具，性能表现较好。

  • 提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。调用toJSONString方 法即可将对象转换成 JSON 字符串，parseObject 方法则反过来将 JSON 字符串转换成对象。

  • 允许转换预先存在的无法修改的对象（只有class、无源代码）。

  • Java泛型的广泛支持。

  • 允许对象的自定义表示、允许自定义序列化类。

  • 支持任意复杂对象（具有深厚的继承层次和广泛使用的泛型类型）。

3、下载和使用

你可以在 maven 中央仓库中直接下载：

  1. http://repo1.maven.org/maven2/com/alibaba/fastjson/

或者配置 maven 依赖:

  1. <dependency>
  2.     <groupId>com.alibaba</groupId>
  3.     <artifactId>fastjson</artifactId>
  4.     <version>x.x.x</version>
  5. </dependency>

其中 x.x.x 是版本号，根据需要使用特定版本，建议使用最新版本。

4、将 Java 对象转换为 JSON 格式

定义以下 Person JavaBean:

  1. public class Person {
  2.      
  3.     @JSONField(name = "AGE")
  4.     private int age;
  5.  
  6.     @JSONField(name = "FULL NAME")
  7.     private String fullName;
  8.  
  9.     @JSONField(name = "DATE OF BIRTH")
  10.     private Date dateOfBirth;
  11.  
  12.     public Person(int age, String fullName, Date dateOfBirth) {
  13.         super();
  14.         this.age = age;
  15.         this.fullName= fullName;
  16.         this.dateOfBirth = dateOfBirth;
  17.     }
  18.  
  19.     // 标准 getters & setters}

可以使用 JSON.toJSONString() 将 Java 对象转换换为 JSON 对象：

  1. private List<Person> listOfPersons = new ArrayList<Person>();
  2.  @Beforepublic void setUp() {
  3.     listOfPersons.add(new Person(15, "John Doe", new Date()));
  4.     listOfPersons.add(new Person(20, "Janette Doe", new Date()));}
  5.  @Testpublic void whenJavaList_thanConvertToJsonCorrect() {
  6.     String jsonOutput= JSON.toJSONString(listOfPersons);}

输出结果为：

  1. [  
  2.     {  
  3.         "AGE":15,
  4.         "DATE OF BIRTH":1468962431394,
  5.         "FULL NAME":"John Doe"
  6.     },
  7.     {  
  8.         "AGE":20,
  9.         "DATE OF BIRTH":1468962431394,
  10.         "FULL NAME":"Janette Doe"
  11.     }]

我们还可以自定义输出，并控制字段的排序，日期显示格式，序列化标记等。

接下来我们更新 bean 并添加几个字段：

  1. @JSONField(name="AGE", serialize=false)private int age;
  2.  @JSONField(name="LAST NAME", ordinal = 2)private String lastName;
  3.  @JSONField(name="FIRST NAME", ordinal = 1)private String firstName;
  4.  @JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)private Date dateOfBirth;

以上代码中我们列出了基本参数类别，并使用 @JSONField 注解，以便实现自定义转换：

  • format 参数用于格式化 date 属性。

  • 默认情况下， FastJson 库可以序列化 Java bean 实体， 但我们可以使用 serialize 指定字段不序列化。

  • 使用 ordinal 参数指定字段的顺序

这样，以上输出结果为：

  1. [
  2.     {
  3.         "FIRST NAME":"Doe",
  4.         "LAST NAME":"Jhon",
  5.         "DATE OF BIRTH":"19/07/2016"
  6.     },
  7.     {
  8.         "FIRST NAME":"Doe",
  9.         "LAST NAME":"Janette",
  10.         "DATE OF BIRTH":"19/07/2016"
  11.     }]

5、@JSONField

@JSONField 的作用对象:

  • 1） Field

  • 2）Setter 和 Getter 方法

注意：FastJson 在进行操作时，是根据 getter 和 setter 的方法进行的，并不是依据 Field 进行。

注意：若属性是私有的，必须有 set 方法。否则无法反序列化。

  1. package com.alibaba.fastjson.annotation;public @interface JSONField {
  2.     // 配置序列化和反序列化的顺序，1.1.42版本之后才支持
  3.     int ordinal() default 0;
  4.  
  5.      // 指定字段的名称
  6.     String name() default "";
  7.  
  8.     // 指定字段的格式，对日期格式有用
  9.     String format() default "";
  10.  
  11.     // 是否序列化
  12.     boolean serialize() default true;
  13.  
  14.     // 是否反序列化
  15.     boolean deserialize() default true;}

6. JSONField配置方式

FieldInfo 可以配置在 getter/setter 方法或者字段上。例如：

6.1 配置在 getter/setter 上

  1.  public class A {
  2.       private int id;
  3.  
  4.       @JSONField(name="ID")
  5.       public int getId() {return id;}
  6.       @JSONField(name="ID")
  7.       public void setId(int value) {this.id = id;}}

6.2 配置在 field 上

  1.  public class A {
  2.       @JSONField(name="ID")
  3.       private int id;
  4.  
  5.       public int getId() {return id;}
  6.       public void setId(int value) {this.id = id;}
  7.  }

7. 使用format配置日期格式化

  1.  public class A {
  2.       // 配置date序列化和反序列使用yyyyMMdd日期格式
  3.       @JSONField(format="yyyyMMdd")
  4.       public Date date;
  5.  }

8. 使用 serialize/deserialize 指定字段不序列化

  1. public class A {
  2.       @JSONField(serialize=false)
  3.       public Date date;
  4.  }
  5.  
  6.  public class A {
  7.       @JSONField(deserialize=false)
  8.       public Date date;
  9.  }

9. 使用 ordinal 指定字段的顺序

缺省 fastjson 序列化一个 java bean，是根据 fieldName 的字母序进行序列化的，你可以通过 ordinal 指定字段的顺序。这个特性需要 1.1.42 以上版本。

  1. public static class VO {
  2.     @JSONField(ordinal = 3)
  3.     private int f0;
  4.  
  5.     @JSONField(ordinal = 2)
  6.     private int f1;
  7.  
  8.     @JSONField(ordinal = 1)
  9.     private int f2;}

10、FastJson 还支持 BeanToArray 序列化功能：

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);

输出结果为：

  1. [
  2.     [
  3.         15,
  4.         1469003271063,
  5.         "John Doe"
  6.     ],
  7.     [
  8.         20,
  9.         1469003271063,
  10.         "Janette Doe"
  11.     ]]

11、创建 JSON 对象

创建 JSON 对象非常简单，只需使用 JSONObject（fastJson提供的json对象） 和 JSONArray（fastJson提供json数组对象） 对象即可。

我们可以把JSONObject 当成一个 Map<String,Object> 来看，只是 JSONObject 提供了更为丰富便捷的方法，方便我们对于对象属性的操作。我们看一下源码。

1.png

同样我们可以把 JSONArray 当做一个 List<Object>，可以把 JSONArray 看成 JSONObject 对象的一个集合。

2.png

此外，由于 JSONObject 和 JSONArray 继承了 JSON，所以说也可以直接使用两者对 JSON 格式字符串与 JSON 对象及 javaBean 之间做转换，不过为了避免混淆我们还是使用 JSON。

  1. @Testpublic void whenGenerateJson_thanGenerationCorrect() throws ParseException {
  2.     JSONArray jsonArray = new JSONArray();
  3.     for (int i = 0; i < 2; i++) {
  4.         JSONObject jsonObject = new JSONObject();
  5.         jsonObject.put("AGE", 10);
  6.         jsonObject.put("FULL NAME", "Doe " + i);
  7.         jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
  8.         jsonArray.add(jsonObject);
  9.     }
  10.     String jsonOutput = jsonArray.toJSONString();}

输出结果为：

  1. [
  2.    {
  3.       "AGE":"10",
  4.       "DATE OF BIRTH":"2016/12/12 12:12:12",
  5.       "FULL NAME":"Doe 0"
  6.    },
  7.    {
  8.       "AGE":"10",
  9.       "DATE OF BIRTH":"2016/12/12 12:12:12",
  10.       "FULL NAME":"Doe 1"
  11.    }]

12、JSON 字符串转换为 Java 对象

现在我们已经学会了如何创建 JSON 对象，以及如何将 Java 对象转换为 JSON 字符串，接下来我们就需要了解如何解析 JSON：

  1. @Testpublic void whenJson_thanConvertToObjectCorrect() {
  2.     Person person = new Person(20, "John", "Doe", new Date());
  3.     String jsonObject = JSON.toJSONString(person);
  4.     Person newPerson = JSON.parseObject(jsonObject, Person.class);
  5.      
  6.     assertEquals(newPerson.getAge(), 0); // 如果我们设置系列化为 false
  7.     assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());}

我们可以使用 JSON.parseObject() 将 JSON 字符串转换为 Java 对象。

注意反序列化时为对象时，必须要有默认无参的构造函数，否则会报异常:

  1. com.alibaba.fastjson.JSONException: default constructor not found.

以下是简单的实例测试：

  1. Person [age=20, fullName=John Doe, dateOfBirth=Wed Jul 20 08:51:12 WEST 2016]

@JSONField deserialize 可选项可以指定字段不反序列化。

  1. @JSONField(name = "DATE OF BIRTH", deserialize=false)private Date dateOfBirth;

输出结果为：

  1. Person [age=20, fullName=John Doe, dateOfBirth=null]

13、使用 ContextValueFilter 配置 JSON 转换

在某些场景下，对Value做过滤，需要获得所属JavaBean的信息，包括类型、字段、方法等。在fastjson-1.2.9中，提供了ContextValueFilter，类似于之前版本提供的ValueFilter，只是多了BeanContext参数可用。

  1. @Testpublic void givenContextFilter_whenJavaObject_thanJsonCorrect() {
  2.     ContextValueFilter valueFilter = new ContextValueFilter () {
  3.         public Object process(
  4.           BeanContext context, Object object, String name, Object value) {
  5.             if (name.equals("DATE OF BIRTH")) {
  6.                 return "NOT TO DISCLOSE";
  7.             }
  8.             if (value.equals("John")) {
  9.                 return ((String) value).toUpperCase();
  10.             } else {
  11.                 return null;
  12.             }
  13.         }
  14.     };
  15.     String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);}

以上实例中我们隐藏了 DATE OF BIRTH 字段，并过滤名字不包含 John 的字段：

  1. [
  2.     {
  3.         "FULL NAME":"JOHN DOE",
  4.         "DATE OF BIRTH":"NOT TO DISCLOSE"
  5.     }]

14、使用 NameFilter 和 SerializeConfig

NameFilter: 序列化时修改 Key。

SerializeConfig：内部是个map容器主要功能是配置并记录每种Java类型对应的序列化类。

  1. @Testpublic void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
  2.     NameFilter formatName = new NameFilter() {
  3.         public String process(Object object, String name, Object value) {
  4.             return name.toLowerCase().replace(" ", "_");
  5.         }
  6.     };
  7.      
  8.     SerializeConfig.getGlobalInstance().addFilter(Person.class,  formatName);
  9.     String jsonOutput = 
  10.       JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");}

实例中我们声明了 formatName 过滤器使用 NameFilter 匿名类来处理字段名称。 新创建的过滤器与 Person 类相关联，然后添加到全局实例，它是 SerializeConfig 类中的静态属性。

现在我们可以轻松地将对象转换为JSON格式。

注意我们使用的是 toJSONStringWithDateFormat() 而不是 toJSONString() ，它可以更快速的格式化日期。

输出结果：

  1. [  
  2.     {  
  3.         "full_name":"John Doe",
  4.         "date_of_birth":"2016-07-21"
  5.     },
  6.     {  
  7.         "full_name":"Janette Doe",
  8.         "date_of_birth":"2016-07-21"
  9.     }]


转载本站内容时，请务必注明来自W3xue，违者必究。
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
皖ICP备17017327号-2　皖公网安备34020702000426号