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

[JAVA]-Java中使用JSON（整理）

2021-02-18 20:03:42 作者：互联网

参考：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 特性

提供服务器端、安卓客户端两种解析工具，性能表现较好。
提供了 toJSONString() 和 parseObject() 方法来将 Java 对象与 JSON 相互转换。调用toJSONString()方法即可将对象转换成 JSON 字符串，parseObject() 方法则反过来将 JSON 字符串转换成对象。
允许转换预先存在的无法修改的对象（只有class、无源代码）。
Java泛型的广泛支持。
允许对象的自定义表示、允许自定义序列化类。
支持任意复杂对象（具有深厚的继承层次和广泛使用的泛型类型）。

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