编程语言
首页 > 编程语言> > [JAVA]-Java中使用JSON(整理)

[JAVA]-Java中使用JSON(整理)

作者:互联网

参考:https://www.runoob.com/w3cnote/fastjson-intro.html

一、JSON类库

Json类库选择:Java中并没有内置JSON的解析,因此使用JSON需要借助第三方类库。下面是几个常用的 JSON 解析类库:
Gson:谷歌开发的JSON库,功能十分全面。
FastJson:阿里巴巴开发的JSON库,性能十分优秀。
Jackson:社区十分活跃且更新速度很快。

二、FastJson简介

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

Fastjson 特性

FastJson使用:
可以在 maven 中央仓库中直接下载:http://repo1.maven.org/maven2/com/alibaba/fastjson/ 或 通过Maven依赖使用:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

其中 1.2.47 是版本号,根据需要使用特定版本,建议使用最新版本。

三、Fasjson中的主要类定义

FastJson类库中最长用到的两个结构定义:

1、JSON

JSON类提供了多种 Java对象<->JSON字符串 直接互相转换的方法。

JSON.parseObject():从字符串解析 JSON 对象。
JSON.parseArray():从字符串解析 JSON 数组。
JSON.toJSONString(obj/array):将 JSON 对象或 JSON 数组转化为字符串。

样例:
//从字符串解析JSON对象
JSONObject obj = JSON.parseObject("{"Test":"你好"}");
//从字符串解析JSON数组
JSONArray arr = JSON.parseArray("["Test1","Test2"]\n");
//将JSON对象转化为字符串
String objStr = JSON.toJSONString(obj);
//将JSON数组转化为字符串
String arrStr = JSON.toJSONString(arr);

JSON类中主要常用方法定义

public abstract class JSON impletements JSONStreamAware, JSONAware {
   ....   
   //parseObject()方法
   public static JSONObject parseObject(String text, Feature... features) {....}
   public static JSONObject parseObject(String text) {....}
   public static <T> T parseObject(String text, TypeReference<T> type, Feature... features) {....}
   public static <T> T parseObject(String json, Class<T> clazz, Feature... features) {....}
   public static <T> T parseObject(String text,  Class<T> clazz, ParseProcess processor, Feature... features) {....}
   public static <T> T parseObject(String json,   Type type, Feature... features) {....}
   public static <T> T parseObject(byte[] bytes, Type clazz, Feature... features) {....}
   public static <T> T parseObject(char[] input, int length, Type clazz, Feature... features) {....}
   ....
   //parseArray()方法
   public static JSONArray parseArray(String text) {....}
   public static <T> List<T> parseArray(String text, Class<T> clazz) {....}
   public static List<Object> parseArray(String text, Type[] types)  {....}
   ....

   //toJSONString()方法
   public String toJSONString() {...}
   ....
   public static String toJSONString(Object object) {....}
   public static String toJSONString(Object object, SerializerFeature... features)  {....}
   public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features)   {....}
   ....
}

2、JSONObject

public class JSONObject extern JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
  .... 
  private fianl Map<String, Object> map; //用于表示一个JSON对象的数据结构,是一个key和value的集合,Key是String类型、Value可能是基础类型或其他JSON对象
  ....
  public boolean isEmpyt() { //判断是否为对象,map为空,即没有key和value
     ....
  }

  public JSONObject getJSONObject(String key) { //指定key,对应value。如果value对象为非JSONObject类型(String、Map等),本函数会把其转换为JSONObject类型。
     ....
  }

  public JSONArray getJSONArray(String key) { //指定key,对应value。如果value对象为非JSONArray类型(String、List等),本函数会把其转换为JSONArray类型。
     ....
  }
}

3、JSONArray

public class JSONArray extern JSON implements List, Cloneable, RadomAccess, Serializable {
    .... 
    private fianl List list;
    .... 
    //构造方法
    public JSONArray() {this.list = new ArrayList(); } 
    public JSONArray(List list) {this.list = list; } 
    public JSONArray(int initialCapacity) {this.list = new ArrayList(this.list = new ArrayList();) 
    .... 
    public JSONObject getJSONObject(int index) {...} //指定索引,获取JSONObject 
    .... 
    public T getObject(int index, Class clazz) {...} //指定索引,返回指定类型的实例
    .... 
    public List toJavaList(Class clazz) {...} //转换成Java自定义结构的列表实例
}

四、Json序列化:Java对象->JSON字符串

1、通过JSONField方式

样例: public class Person { @JSONField(name = "AGE") private int age;

@JSONField(name = "FULL NAME")
private String fullName;

@JSONField(name = "DATE OF BIRTH")
private Date dateOfBirth;

public Person(int age, String fullName, Date dateOfBirth) {
super();
this.age = age;
this.fullName= fullName;
this.dateOfBirth = dateOfBirth;
}

// 标准 getters & setters
}

使用 JSON.toJSONString() 将 Java 对象转换换为 JSON 对象: private List listOfPersons = new ArrayList();

@Before public void setUp() { listOfPersons.add(new Person(15, "John Doe", new Date())); listOfPersons.add(new Person(20, "Janette Doe", new Date())); }

@Test public void whenJavaList_thanConvertToJsonCorrect() { String jsonOutput= JSON.toJSONString(listOfPersons); }

输出结果为: [
{
"AGE":15, "DATE OF BIRTH":1468962431394, "FULL NAME":"John Doe" }, {
"AGE":20, "DATE OF BIRTH":1468962431394, "FULL NAME":"Janette Doe" } ]

我们还可以自定义输出,并控制字段的排序,日期显示格式,序列化标记等。接下来我们更新 bean 并添加几个字段: @JSONField(name="AGE", serialize=false) private int age;

@JSONField(name="LAST NAME", ordinal = 2) private String lastName;

@JSONField(name="FIRST NAME", ordinal = 1) private String firstName;

@JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3) private Date dateOfBirth; 以上代码中我们列出了基本参数类别,并使用 @JSONField 注解,以便实现自定义转换:

format 参数用于格式化 date 属性。
serialize 指定字段不序列化。默认情况下,FastJson 库可以序列化 Java bean 实体,但可以使用serialize 指定字段不序列化。
使用 ordinal 参数指定字段的顺序 输出结果为: [ {
"FIRST NAME":"Doe",
"LAST NAME":"Jhon",
"DATE OF BIRTH":"19/07/2016"
}, {
"FIRST NAME":"Doe",
"LAST NAME":"Janette",
"DATE OF BIRTH":"19/07/2016"
} ]
1、JSONField作用对象详解 @JSONField 的作用对象:

Field
Setter 和 Getter 方法 注意:FastJson 在进行操作时,是根据 getter 和 setter 的方法进行的,并不是依据 Field 进行。
注意:若属性是私有的,必须有 set 方法。否则无法反序列化。 package com.alibaba.fastjson.annotation;

public @interface JSONField { // 配置序列化和反序列化的顺序,1.1.42版本之后才支持 int ordinal() default 0;

// 指定字段的名称
String name() default "";

// 指定字段的格式,对日期格式有用
String format() default "";

// 是否序列化
boolean serialize() default true;

// 是否反序列化
boolean deserialize() default true;
}

JSONField 配置方式 (1)配置在 field 上 public class A { @JSONField(name="ID") private int id;

public int getId() {return id;} public void setId(int value) {this.id = id;} }

(2)配置在 getter/setter 上 public class A { private int id;

@JSONField(name="ID") public int getId() {return id;}

@JSONField(name="ID") public void setId(int value) {this.id = id;} }

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

使用 serialize/deserialize 指定字段不序列化 public class A { @JSONField(serialize=false) public Date date; }

public class A { @JSONField(deserialize=false) public Date date; }

使用ordinal指定字段的顺序 默认 fastjson 序列化一个 java bean,是根据 fieldName 的字母序进行序列化的,你可以通过 ordinal 指定字段的顺序。这个特性需要 1.1.42 以上版本。 public static class VO { @JSONField(ordinal = 3) private int f0;

@JSONField(ordinal = 2) private int f1;

@JSONField(ordinal = 1) private int f2; }

通过JSONObject方式

使用 JSONObject(fastJson提供的json对象) 和 JSONArray(fastJson提供json数组对象) 创建 JSON 对象 JSONObject 和 JSONArray 继承了 JSON,所以可以直接使用两者对 JSON 格式字符串 与 JSON 对象 及 javaBean 之间做转换,不过为了避免混淆,我们还是*建议使用 JSON.toJSONString()。

使用继承的toJSONString()方法样例: @Test public void whenGenerateJson_thanGenerationCorrect() throws ParseException { JSONArray jsonArray = new JSONArray();

for (int i = 0; i < 2; i++) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("AGE", 10);
jsonObject.put("FULL NAME", "Doe " + i);
jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
jsonArray.add(jsonObject);
}

String jsonOutput = jsonArray.toJSONString();
} 输出结果为: [ { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 0" }, { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 1" } ]

Json反序列化:JSON字符串->Java对象

1、JSON字符串转换成JSONObject对象

实例: public void testJson2() { ​ JSONObject object = JSONObject.parseObject("{"boolean":true,"string":"string","list":[1,2,3],"int":2}");

//string String s = object.getString("string"); System.out.println(s);

//int int i = object.getIntValue("int"); System.out.println(i);

//boolean boolean b = object.getBooleanValue("boolean"); System.out.println(b);

//list List integers = JSON.parseArray(object.getJSONArray("list").toJSONString(),Integer.class); integers.forEach(System.out::println);

//null System.out.println(object.getString("null")); ​ } 在上例中,首先从 JSON 格式的字符串中构造一个 JSON 对象,之后依次读取字符串、整数、布尔值以及数组,最后分别打印,打印结果如下: string 2 true 1 2 3 null

2、JSON字符串转换成自定义JAVA对象

实例: @Test public void whenJson_thanConvertToObjectCorrect() { Person person = new Person(20, "John", "Doe", new Date()); String jsonObject = JSON.toJSONString(person);

//Json字符串反序列化成Java对象。
Person newPerson = JSON.parseObject(jsonObject, Person.class);

assertEquals(newPerson.getAge(), 0); // 如果我们设置系列化为 false
assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
} 注意反序列化时为对象时,必须要有默认无参的构造函数,否则会报异常:com.alibaba.fastjson.JSONException: default constructor not found.

注意,JSON反序列化时,同样用到Java的@JSONField注解。 @JSONField deserialize 可选项可以指定字段不反序列化。样例: @JSONField(name = "DATE OF BIRTH", deserialize=false) private Date dateOfBirth;

序列化过程中使用过滤器

1、采用ContextValueFilter对value进行过滤 在某些场景下,对Value做过滤,需要获得所属JavaBean的信息,包括类型、字段、方法等。在fastjson-1.2.9中,提供了ContextValueFilter,类似于之前版本提供的ValueFilter,只是多了BeanContext参数可用。 @Test public void givenContextFilter_whenJavaObject_thanJsonCorrect() { ContextValueFilter valueFilter = new ContextValueFilter () { public Object process(BeanContext context, Object object, String name, Object value) { if (name.equals("DATE OF BIRTH")) { return "NOT TO DISCLOSE"; }

    if (value.equals("John")) {
        return ((String) value).toUpperCase();
    } else {
        return null;
    }
}

};

String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);
} 以上实例中我们隐藏了 DATE OF BIRTH 字段,并过滤名字不包含John的字段: [ { "FULL NAME":"JOHN DOE", "DATE OF BIRTH":"NOT TO DISCLOSE" } ]

2、使用 NameFilter 和 SerializeConfig修改key

NameFilter: 序列化时修改 Key。
SerializeConfig:内部是个map容器主要功能是配置并记录每种Java类型对应的序列化类。 @Test public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() { NameFilter formatName = new NameFilter() {

public String process(Object object, String name, Object value) {
return name.toLowerCase().replace(" ", "_");
}
};

SerializeConfig.getGlobalInstance().addFilter(Person.class, formatName);

String jsonOutput = JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd"); } 声明了 formatName过滤器,使用NameFilter匿名类来处理字段名称。 新创建的过滤器与 Person 类相关联,然后添加到全局实例,它是 SerializeConfig 类中的静态属性。

注意我们使用的是 toJSONStringWithDateFormat() 而不是 toJSONString() ,它可以更快速的格式化日期。 输出结果: [
{
"full_name":"John Doe", "date_of_birth":"2016-07-21" }, {
"full_name":"Janette Doe", "date_of_birth":"2016-07-21" } ]

标签:序列化,JAVA,String,....,JSON,Java,JSONField,public
来源: https://www.cnblogs.com/yickel/p/14413282.html