java fastjson string转不了map的报错处理 fastjson string转json

文章目录

• Fastjson学习笔记

• Fastjson 简介
• Fastjson 特性
• 将 Java 对象转换为 JSON 格式（Java对象的序列化）
• JSONField 配置方式
• 使用format配置日期格式化
• 使用 serialize/deserialize 指定字段不序列化
• 使用 ordinal 指定字段的顺序
• 创建 JSON 对象
• JSON 字符串转换为 Java 对象（反序列化）
• 使用 NameFilter 和 SerializeConfig（看名字知道意思吼！）

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方法即可将Java对象转换成 JSON 字符串，parseObject 方法则反过来将 JSON 字符串转换成Java对象。
• 允许转换预先存在的无法修改的对象（只有class、无源代码）。
• Java泛型的广泛支持。
• 允许对象的自定义表示、允许自定义序列化类。
• 支持任意复杂对象（具有深厚的继承层次和广泛使用的泛型类型）。

下载和使用

可以在 maven 中央仓库中直接下载（链接已废）。

或者配置 maven 依赖:

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

x.x.x 是版本号，根据需要使用特定版本。

将 Java 对象转换为 JSON 格式（Java对象的序列化）

定义以下Person JavaBean:

public class Person {//构造Java类

  @JSONField(name = "AGE")//定义json字段名接收json格式数据
  private int age;//字段定义和Java中一致

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

  @JSONField(name = "DATE OF BIRTH")
  private Date dateOfBirth;//Java中的Date对象

  public Person(int age, String fullName, Date dateOfBirth) {//构造Java对象
    super();//调用父类的方法
    this.age = age;//编写读写规则
    this.fullName= fullName;
    this.dateOfBirth = dateOfBirth;
  }

  // 标准 getters & setters，JavaBean
}

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

private List<Person> listOfPersons = new ArrayList<Person>();//Java泛型List集合定义

@Before
public void setUp() {//编写setUp方法添加Java对象
  listOfPersons.add(new Person(15, "John Doe", new Date()));//向list集合中添加Java对象
  listOfPersons.add(new Person(20, "Janette Doe", new Date()));//向list集合中添加Java对象
}

@Test
public void whenJavaList_thanConvertToJsonCorrect() {
  String jsonOutput= JSON.toJSONString(listOfPersons);
}//把Java对象转换为json对象输出

输出结果为（类似JavaScript的写法）【这里注意和JavaScript不同的是，除字符类型的其他数据无需加引号】：

[  
    {  
        "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 属性*。
• 默认情况下， FastJson 库可以序列化 Java bean 实体， 也可以使用 serialize* 指定字段不序列化*。
• 使用 *ordinal* 参数指定字段的顺序

输出结果（json格式）为：

[
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Jhon",
        "DATE OF BIRTH":"19/07/2016"
    },
    {
        "FIRST NAME":"Doe",
        "LAST NAME":"Janette",
        "DATE OF BIRTH":"19/07/2016"
    }
]

@JSONField

作用对象:

1. Field（字段）
2. Setter 和 Getter 方法（JavaBean）

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

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

span style="color: #000000; font-weight: bold;">package com.alibaba.fastjson.annotation;

public @interface JSONField {//json字段注解@JSONField的变化使用，json在解析过程中会判断有无使用该注解进行解析重命名，需要在字段上加上@JSONField注解，避免部分未赋值的现象
  // 配置序列化和反序列化的顺序，1.1.42版本之后才支持*
  int ordinal() default 0;//注意到都要加上default默认

   *// 指定字段的名称*
  String name() default "";//字符串类型数据默认为空的字符串""

  *// 指定字段的格式，对日期格式有用*
  String format() default "";//默认为空的格式

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

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

JSONField 配置方式

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

配置在 getter/setter 上

public class A {
   private int id;
 
   @JSONField(name="ID")
   public int getId() {return id;}//写法依旧同Java
   @JSONField(name="ID")
   public void setId(int value) {this.id = id;}
}

配置在 field 上

public class A {    
	@JSONField(name="ID")    
	private int id;  //定义字段    
	public int getId() {return id;} //定义方法
	public void setId(int value) {this.id = id;}  
	}

使用format配置日期格式化

span style="color: #000000; font-weight: bold;"
public class A {
   // 配置date序列化和反序列使用yyyyMMdd日期格式
   @JSONField(format="yyyyMMdd")
   public Date date;
 }

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

span style="color: #000000; font-weight: bold;"
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 以上版本。

span style="color: #000000; font-weight: bold;"
public static class VO {//定义静态类
  @JSONField(ordinal = 3)
  private int f0;

  @JSONField(ordinal = 2)
  private int f1;

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

FastJson 还支持 BeanToArray 序列化功能：（字面意思是把Java对象转换为数组了）

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);//并且输出咯！

输出结果为（下面介个是两个小数组，一个大的数组？小数组里面包含一个对象）：

[
    [
        15,
        1469003271063,
        "John Doe"
    ],
    [
        20,
        1469003271063,
        "Janette Doe"
    ]
]

创建 JSON 对象

创建 JSON 对象使用 JSONObject（fastJson提供的json对象） 和 JSONArray（fastJson提供json数组对象） 对象即可。

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

源码：

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

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

@Test
public void whenGenerateJson_thanGenerationCorrect() throws ParseException {//转换异常
  JSONArray jsonArray = new JSONArray();//实例化json数组对象
  for (int i = 0; i < 2; i++) {//遍历json数组对象插入json数据
    JSONObject jsonObject = new JSONObject();//实例化json对象
    jsonObject.put("AGE", 10);//put接收数据
    jsonObject.put("FULL NAME", "Doe " + i);
    jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
    jsonArray.add(jsonObject);//把json对象添加到json数组对象中
  }
  String jsonOutput = jsonArray.toJSONString();//把json数组对象转换为json格式输出输出
}

输出结果为：

[
   {
      "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 字符串转换为 Java 对象（反序列化）

解析 JSON：

@Test
public void whenJson_thanConvertToObjectCorrect() {
  Person person = new Person(20, "John", "Doe", new Date());//实例化Java对象并传入数据
  String jsonObject = JSON.toJSONString(person);//将Java对象转换为json格式，再创建json对象
  Person newPerson = JSON.parseObject(jsonObject, Person.class);//将json对象转换为Java对象类传给创建的新的Java对象
   //如果设置序列化为 true
  assertEquals(newPerson.getAge(), 0); //这个应该一定是异常的吧？
  *// 如果设置序列化为 false*
  assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}

junit.framework包下的Assert提供了多个断言方法. 主用于比较测试传递进去的两个参数.

Assert.assertEquals();及其重载方法: 1. 如果两者一致, 程序继续往下运行. 2. 如果两者不一致, 中断测试方法, 抛出异常信息 AssertionFailedError .
查看源码, 以Assert.assertEquals(int expected, int actual)为例:

/** *Asserts that two ints are equal. 断言两个int是相等的 */ static public void assertEquals(int expected, int actual) {预期值和真实值！ assertEquals(null, expected, actual); }

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

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

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

简单的实例测试：

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

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

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

输出结果为（这就是一个Java对象了吧，和Java的表示是不一样滴~）【注意日期数据是null，因为它没有反序列化，还是一个可爱的json字符串！】：

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

使用 ContextValueFilter 配置 JSON 转换（过滤器要的应该是滤渣，被操作掉了；滤液应该是留下来的东西）

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

@Test
public void givenContextFilter_whenJavaObject_thanJsonCorrect() {
  ContextValueFilter valueFilter = new ContextValueFilter () {//构造一个过滤器配置json转换
    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();//这个过滤原理是什么？变成JOHN了！
      } else {
        return null;//空指针大概就是不过滤的意思吧？
      }
    }
  };
  String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);//过滤得到的东西，就是滤渣，转换为json格式并输出
}

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

[
    {
        "FULL NAME":"JOHN DOE",
        "DATE OF BIRTH":"NOT TO DISCLOSE"
    }
]

使用 NameFilter 和 SerializeConfig（看名字知道意思吼！）

NameFilter: 序列化时修改 Key。

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

@Test
public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
  NameFilter formatName = new NameFilter() {//构造key名称过滤器，叫做格式化名称？
    public String process(Object object, String name, Object value) {
      return name.toLowerCase().replace(" ", "_");//用下划线把空格替换掉，并且都变成大写的名称！起到修改的作用
    }
  };
   
SerializeConfig.getGlobalInstance().addFilter(Person.class,  formatName);//在这个配置的实例中添加过滤器，传参被过滤的Java类+过滤器名称
String jsonOutput =
   JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");//把过滤到的被修改后的Java对象用特定的日期格式"参数二"来转换为json格式输出
}

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

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

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

输出结果：

[  
    {  
        "full_name":"John Doe",
        "date_of_birth":"2016-07-21"
    },
    {  
        "full_name":"Janette Doe",
        "date_of_birth":"2016-07-21"
    }
]

---