该文章主要介绍com.alibaba.fastjson的使用。
首先创建maven工程，导入fastjson.挑个热度高的版本就好了。
首先考虑下，我们通常什么时候会使用序列化和反序列化：
1.将java对象序列化为一个JSON字符串
// 将javaBean转换成json字符串，有一个Student对象stu1
//Student对象直接输出为Student [id=20180306, name=Claire, age=18, gender=girl]
String stuToJsonStr1 = JSON.toJSONString(stu1);
System.out.println("Student的一个对象通过 JSON.toJSONString转换成字符串格式"+stuToJsonStr1);
String stuToJsonStr2 = JSONObject.toJSONString(stu1);
System.out.println("Student的一个对象通过JSONObject.toJSONString转换成字符串格式"+stuToJsonStr2);
String stuToJsonStr3 = JSONArray.toJSONString(stu1);
System.out.println("Student的一个对象通过JSONArray.toJSONString转换成字符串格式"+stuToJsonStr3);
2.将java对象序列化为一个Json对象
// 将javaBean转换成Json对象,生成的对象，其中字段顺序并不与Javabean字段相同
//有一个Student对象stu1
//Student对象直接输出为Student [id=20180306, name=Claire, age=18, gender=girl]
Object obj1 = JSONObject.toJSON(stu1);
if (obj1 instanceof JSON) {
System.out.println("student对象（id,name,age,gender）通过JSONObject.toJSON转换成json对象，是无序的"+obj1);
}
Object obj2 = JSON.toJSON(stu1);
if (obj1 instanceof JSON) {
System.out.println("student对象（id,name,age,gender）通过JSON.toJSON转换成json对象，是无序的"+obj2);
}
Object obj3 = JSONArray.toJSON(stu1);
if (obj1 instanceof JSON) {
System.out.println("student对象（id,name,age,gender）通过JSONArray.toJSON转换成json对象，是无序的"+obj3);
}
3.将Json对象写到某文件中
// 把序列化之后的json对象写到指定文件中
//文件显示为{"gender":"girl","name":"Claire","id":20180306,"age":18}
JSON.writeJSONString(new FileWriter("C:\\your\\file\\path\\fileName.txt"), obj3);
4.将JSON字符串转换成JSON对象
// 把json字符串转换成json对象
String jsonString = "{\"age\":18,\"gender\":\"girl\",\"id\":20180306,\"name\":\"Claire\"}";
Object obj4 = JSONArray.parse(jsonString);
System.out.println("用JSONArray.parse将json字符串转化为json对象" + obj4);
//System.out.println(JSONArray.parseArray(jsonString));这里会报错的，因为这个方法只能转换带【】的
System.out.println(JSONObject.parseObject(jsonString));
5.将JSON对象转换成Java对象、JSON字符串转换成java对象
// json对象转换成javaBean
//下面是将JSON对象转换成student对象，如果将前面的json对象换成JSON字符串，就是将json字符串转换成student对象了
Student stu2 = JSON.toJavaObject((JSON) obj4, Student.class);
System.out.println("用JSON.toJavaObject将Jason对象转换成java对象" + stu2);
System.out.println(
"用JSONArray.toJavaObject将Jason对象转换成java对象" + JSONArray.toJavaObject((JSON) obj4, Student.class));
System.out.println(
"用JSONObject.toJavaObject将Jason对象转换成java对象" + JSONObject.toJavaObject((JSON) obj4, Student.class));
6.对象数组转换成json对象
// 对象数组转换成json对象
Student stuobj1 = new Student(10001, "leafly", 19, "xinjiboy");
Student stuobj2 = new Student(10002, "Claire", 19, "beauifyGirl");
Student[] stuArry = { stuobj1, stuobj2 };
String jsonObjStr = JSONObject.toJSONString(stuArry);
System.out.println("对象数组转换成json字符串" + jsonObjStr);// [{"age":19,"gender":"xinjiboy","id":10001,"name":"leafly"},{"age":19,"gender":"beauifyGirl","id":10002,"name":"Claire"}]
String jString = JSON.toJSONString(stu1);
System.out.println("单个对象转换成json字符串" + jString);//单个对象转换成json字符串{"age":18,"gender":"girl","id":20180306,"name":"Claire"}
介绍下JSONObject：
其底层是Map<String, Object>。所以，可以通过下面方式来遍历我们JSONObject中的所有元素
// jsonObject的结构解析,底层是map
Object jsonObject2 = JSON.toJSON(stu1);
JSONObject jsonobj = (JSONObject) jsonObject2;
Map<String, Object> map = jsonobj.getInnerMap();
Set<String> mapKeys = map.keySet();
for (String mapKey : mapKeys) {
System.out.println("getInnerMap的方法来遍历" + mapKey + "---" + map.get(mapKey));
}
// 第二种遍历方法，entrySet是保存了map（即：jsonObject）的set集合
// public Set<Map.Entry<String, Object>> entrySet() {}
Iterator<Entry<String, Object>> it = jsonobj.entrySet().iterator();
while (it.hasNext()) {
Entry<String, Object> entry = it.next();
System.out.println("entrySet的方法2来遍历" + entry.getKey() + "----" + entry.getValue());
}
介绍下JSONArray：
其底层是个list，可以通过下面方式来遍历元素
// jsonArray的结构解析,底层是ArrayList
// JSONArray jsonArray =(JSONArray)JSONArray.toJSON(stu1);
String jsonObjectStr1 = "[{'aa':'claire'},{'bb':'leaf'},{'cc':'黎明'},{'dd':'郭富城'}]";
//JSONArray.ParseArray只能解析[]这种类型的（[{'aa':'claire'},{'bb':'leaf'},{'cc':'黎明'},{'dd':'郭富城'}]）
JSONArray jsonArray = JSONArray.parseArray(jsonObjectStr1);
Iterator<Object> it2 = jsonArray.iterator();
for (Object object : jsonArray) {
System.out.println("遍历jsonArray" + object);
}
除了上述基本语法之外，我们还经常会遇到一个问题：对象A中的某个字段aa，并不想序列化它。此时，有5种解决方式。大家可以了解下：
package com.claire.jing;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.annotation.JSONField;
import com.alibaba.fastjson.serializer.PropertyFilter;
import com.alibaba.fastjson.serializer.SerializeFilter;
import com.alibaba.fastjson.serializer.SimplePropertyPreFilter;
public class TestPropertyFilter {
//第三种设置个别字段不参数化的方式：创建一个fastJson的拦截器
public static void main(String[] args) {
PropertyFilter filter = new PropertyFilter() {
public boolean apply(Object object, String name, Object value) {
//拦截掉gender 字段
if (name.equals("gender")) {
return false;
}else {
return true;
}
}
};
//创建pet对象
Pet pet =new Pet(10001, "cat-mimi", "boy");
//将pet对象转换成JSON字符串,输出结果为{"id":10001,"name":"cat-mimi"}
String jsonString = JSON.toJSONString(pet,filter);
// System.out.println(jsonString);
//第四种设置个别字段不参数化的方式（想要哪些字段参数化，将其列出来）
SimplePropertyPreFilter simpleFilter =new SimplePropertyPreFilter(Pet.class, "id","gender");
//将pet对象转换成JSON字符串,输出结果为：{"gender":"boy","id":10001}
//System.out.println(JSONArray.toJSONString(pet, simpleFilter));
//第五种设置个别字段不参数化的方式，深层次过滤
//当一个类A中含有其他类B的引用时，如果要参数化过滤某字段时，就需要深层次过滤（其实就是过滤A又过滤B）
//先创建2个Pet
Pet cat = new Pet(100001, "cat-mimi2", "boy");
Pet dog = new Pet(100002, "dog-wangwang", "girl");
List<Pet> petList = new ArrayList<Pet>();
petList.add(cat);
petList.add(dog);
//创建一个PetOwner
PetOwner owner = new PetOwner(20001, petList);
String petOwnerJsonStr1 = JSON.toJSONString(owner);
System.out.println(petOwnerJsonStr1);
SimplePropertyPreFilter simpleFilter1 = new SimplePropertyPreFilter(PetOwner.class,"id","ownPets");
SimplePropertyPreFilter simpleFilter2 = new SimplePropertyPreFilter(Pet.class,"name","gender");
//创建一个SerializeFilter的数组，因为后面转换的时候，想要传入多个SimplePropertyPreFilter必须将其组织成数组
SerializeFilter[] filters = {simpleFilter1,simpleFilter2};
//将PetOwner对象转换成Json字符串
String petOwnerJsonStr = JSON.toJSONString(owner, filters);
System.out.println(petOwnerJsonStr);
}
}
class PetOwner{
int id;
List<Pet> ownPets;
//
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<Pet> getOwnPets() {
return ownPets;
}
public void setOwnPets(List<Pet> ownPets) {
this.ownPets = ownPets;
}
//
@Override
public String toString() {
StringBuffer buffer = new StringBuffer();
for (Pet pet : ownPets) {
buffer.append("PetOwner [id=" + id + ", pet=" + pet + "]") ;
}
return buffer.toString();
}
//
public PetOwner(int id, List<Pet> ownPets) {
super();
this.id = id;
this.ownPets = ownPets;
}
public PetOwner() {
}
}
class Pet{
private int id;
private String name;
private String gender;
//第一种防止字段序列化的方法：加上transient字段
private transient String kind;
//第二种防止字段序列化的方法：注解
@JSONField(serialize=false)
private String length;
//getter setter
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
//
public Pet(int id, String name, String gender) {
super();
this.id = id;
this.name = name;
this.gender = gender;
}
public Pet() {
}
//
@Override
public String toString() {
return "Pet [id=" + id + ", name=" + name + ", gender=" + gender + "]";
}
}
有时需要将我们的配置文件读成JSON对象，下面是实现方法：
package com.claire.jing;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import javax.sound.midi.Soundbank;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
public class ReadJsonProToJsonObj {
public static void main(String[] args) throws IOException, InterruptedException {
//创建流怼到配置文件上
BufferedReader reader = new BufferedReader(new FileReader("C:\\your\\file\\path\\fileName.txt"));
//一行一行读取配置文件，
StringBuffer buffer = new StringBuffer(1024*10);
String temp =null;
while ((temp = reader.readLine()) != null ) {
buffer.append(temp);
}
String proStr = buffer.toString();
reader.close();
String[] jsonStrs = proStr.split(";");
for (String jsonStr : jsonStrs) {
jsonStr.trim();
if (jsonStr.startsWith("[")&&jsonStr.endsWith("]")) {
JSONArray array = JSONArray.parseArray(jsonStr);
System.out.println(array);
//转换成JSON对象的时候,是需要时间的，如果这个还没转化完就去转换别的了，就会报错。这里给他10S钟去转换，时间足够了。
Thread.sleep(10000);
}
else if (jsonStr.startsWith("{") && jsonStr.endsWith("}")) {
Object obj2 = JSON.parse(jsonStr);
System.out.println(obj2);
Thread.sleep(10000);
}
}
}
}
特别注意：需要序列化类A的对象，那么类A中必须要Getter setter方法，必须有无参构造函数。不然就序列化不出来啦！！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
