您现在的位置： 365建站网 > 365文章 > JSON框架之FastJson的用法和实例

JSON框架之FastJson的用法和实例

文章来源：365jz.com     点击数：562    更新时间：2018-06-09 09:15   参与评论

1.1.FastJson的介绍:

JSON协议使用方便，越来越流行,JSON的处理器有很多,这里我介绍一下FastJson,FastJson是阿里的开源框架,被不少企业使用,是一个极其优秀的Json框架,Github地址: FastJson

1.2.FastJson的特点:

1.FastJson数度快,无论序列化和反序列化,都是当之无愧的fast 
2.功能强大(支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum) 
3.零依赖(没有依赖其它任何类库)

1.3.FastJson的简单说明:

FastJson对于json格式字符串的解析主要用到了下面三个类： 
1.JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换 
2.JSONObject：fastJson提供的json对象 
3.JSONArray：fastJson提供json数组对象

还在迷茫和彷徨吗,快上车,老司机带你飞!

2.FastJson的用法

首先定义三个json格式的字符串

</>code
  1. //json字符串-简单对象型
  2. private static final String  JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";
  3. //json字符串-数组类型
  4. private static final String  JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
  5. //复杂格式json字符串
  6. private static final String  COMPLEX_JSON_STR = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";

fastJson对于json格式字符串的解析主要用到了一下三个类：

JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换。

JSONObject：fastJson提供的json对象。

JSONArray：fastJson提供json数组对象。

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

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

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

2.1.JSON格式字符串与JSON对象之间的转换

2.1.1.json字符串-简单对象型与JSONObject之间的转换

</>code
  1. /**
  2.  * json字符串-简单对象型到JSONObject的转换
  3.  */@Testpublic void testJSONStrToJSONObject() {
  4.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
  5.     System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  6.             + jsonObject.getInteger("studentAge"));
  7. }/**
  8.  * JSONObject到json字符串-简单对象型的转换
  9.  */@Testpublic void testJSONObjectToJSONStr() {    //已知JSONObject,目标要转换为json字符串
  10.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);    // 第一种方式
  11.     String jsonString = JSONObject.toJSONString(jsonObject);    // 第二种方式
  12.     //String jsonString = jsonObject.toJSONString();
  13.     System.out.println(jsonString);
  14. }

2.1.2.json字符串(数组类型)与JSONArray之间的转换

</>code
  1. /**
  2.  * json字符串-数组类型到JSONArray的转换
  3.  */@Testpublic void testJSONStrToJSONArray() {
  4.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);    //遍历方式1
  5.     int size = jsonArray.size();    for (int i = 0; i < size; i++) {
  6.         JSONObject jsonObject = jsonArray.getJSONObject(i);
  7.         System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  8.                 + jsonObject.getInteger("studentAge"));
  9.     }    //遍历方式2
  10.     for (Object obj : jsonArray) {
  11.         JSONObject jsonObject = (JSONObject) obj;
  12.         System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  13.                 + jsonObject.getInteger("studentAge"));
  14.     }
  15. }/**
  16.  * JSONArray到json字符串-数组类型的转换
  17.  */@Testpublic void testJSONArrayToJSONStr() {    //已知JSONArray,目标要转换为json字符串
  18.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);    //第一种方式
  19.     String jsonString = JSONArray.toJSONString(jsonArray);    // 第二种方式
  20.     //String jsonString = jsonArray.toJSONString(jsonArray);
  21.     System.out.println(jsonString);
  22. }

2.1.3.复杂json格式字符串与JSONObject之间的转换

</>code
  1. /**
  2.  * 复杂json格式字符串到JSONObject的转换
  3.  */@Testpublic void testComplexJSONStrToJSONObject() {
  4.     JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
  5.     String teacherName = jsonObject.getString("teacherName");
  6.     Integer teacherAge = jsonObject.getInteger("teacherAge");
  7.     System.out.println("teacherName:  " + teacherName + "   teacherAge:  " + teacherAge);
  8.     JSONObject jsonObjectcourse = jsonObject.getJSONObject("course");     //获取JSONObject中的数据
  9.     String courseName = jsonObjectcourse.getString("courseName");
  10.     Integer code = jsonObjectcourse.getInteger("code");
  11.     System.out.println("courseName:  " + courseName + "   code:  " + code);
  12.     JSONArray jsonArraystudents = jsonObject.getJSONArray("students");    //遍历JSONArray
  13.     for (Object object : jsonArraystudents) {
  14.         JSONObject jsonObjectone = (JSONObject) object;
  15.         String studentName = jsonObjectone.getString("studentName");
  16.         Integer studentAge = jsonObjectone.getInteger("studentAge");
  17.         System.out.println("studentName:  " + studentName + "   studentAge:  " + studentAge);
  18.     }
  19. }/**
  20.  * 复杂JSONObject到json格式字符串的转换
  21.  */@Testpublic void testJSONObjectToComplexJSONStr() {   //复杂JSONObject,目标要转换为json字符串
  22.     JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);    //第一种方式
  23.     //String jsonString = JSONObject.toJSONString(jsonObject);
  24.     //第二种方式
  25.     String jsonString = jsonObject.toJSONString();
  26.     System.out.println(jsonString);
  27. }

2.2.JSON格式字符串与javaBean之间的转换

2.2.1.json字符串-简单对象型与javaBean之间的转换

</>code
  1. /**
  2.  * json字符串-简单对象到JavaBean之间的转换
  3.  */@Testpublic void testJSONStrToJavaBeanObj() {    //第一种方式
  4.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
  5.     String studentName = jsonObject.getString("studentName");
  6.     Integer studentAge = jsonObject.getInteger("studentAge");    //Student student = new Student(studentName, studentAge);
  7.     //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  8.     //Student student = JSONObject.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});
  9.     //第三种方式,使用Gson的思想
  10.     Student student = JSONObject.parseObject(JSON_OBJ_STR, Student.class);
  11.     System.out.println(student);
  12. }/**
  13.  * JavaBean到json字符串-简单对象的转换
  14.  */@Testpublic void testJavaBeanObjToJSONStr() {
  15.     Student student = new Student("lily", 12);
  16.     String jsonString = JSONObject.toJSONString(student);
  17.     System.out.println(jsonString);
  18. }

2.2.2.json字符串-数组类型与javaBean之间的转换

</>code
  1. /**
  2.  * json字符串-数组类型到JavaBean_List的转换
  3.  */@Testpublic void testJSONStrToJavaBeanList() {    //第一种方式
  4.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);    //遍历JSONArray
  5.     List<Student> students = new ArrayList<Student>();
  6.     Student student = null;    for (Object object : jsonArray) {
  7.         JSONObject jsonObjectone = (JSONObject) object;
  8.         String studentName = jsonObjectone.getString("studentName");
  9.         Integer studentAge = jsonObjectone.getInteger("studentAge");
  10.         student = new Student(studentName,studentAge);
  11.         students.add(student);
  12.     }
  13.     System.out.println("students:  " + students);    //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  14.     List<Student> studentList = JSONArray.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});
  15.     System.out.println("studentList:  " + studentList);    //第三种方式,使用Gson的思想
  16.     List<Student> studentList1 = JSONArray.parseArray(JSON_ARRAY_STR, Student.class);
  17.     System.out.println("studentList1:  " + studentList1);
  18. }/**
  19.  * JavaBean_List到json字符串-数组类型的转换
  20.  */@Testpublic void testJavaBeanListToJSONStr() {
  21.     Student student = new Student("lily", 12);
  22.     Student studenttwo = new Student("lucy", 15);
  23.     List<Student> students = new ArrayList<Student>();
  24.     students.add(student);
  25.     students.add(studenttwo);
  26.     String jsonString = JSONArray.toJSONString(students);
  27.     System.out.println(jsonString);
  28. }

2.2.3.复杂json格式字符串与与javaBean之间的转换

</>code
  1. /**
  2.  * 复杂json格式字符串到JavaBean_obj的转换
  3.  */@Testpublic void testComplexJSONStrToJavaBean(){    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  4.     Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
  5.     System.out.println(teacher);    //第二种方式,使用Gson思想
  6.     Teacher teacher1 = JSONObject.parseObject(COMPLEX_JSON_STR, Teacher.class);
  7.     System.out.println(teacher1);
  8. }/**
  9.  * 复杂JavaBean_obj到json格式字符串的转换
  10.  */@Testpublic void testJavaBeanToComplexJSONStr(){    //已知复杂JavaBean_obj
  11.     Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
  12.     String jsonString = JSONObject.toJSONString(teacher);
  13.     System.out.println(jsonString);
  14. }

2.3.javaBean与json对象间的之间的转换

2.3.1.简单javaBean与json对象之间的转换

</>code
  1. /**
  2.  * 简单JavaBean_obj到json对象的转换
  3.  */@Testpublic void testJavaBeanToJSONObject(){    //已知简单JavaBean_obj
  4.     Student student = new Student("lily", 12);    //方式一
  5.     String jsonString = JSONObject.toJSONString(student);
  6.     JSONObject jsonObject = JSONObject.parseObject(jsonString);
  7.     System.out.println(jsonObject);    //方式二
  8.     JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(student);
  9.     System.out.println(jsonObject1);
  10. }/**
  11.  * 简单json对象到JavaBean_obj的转换
  12.  */@Testpublic void testJSONObjectToJavaBean(){    //已知简单json对象
  13.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  14.     Student student = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Student>() {});
  15.     System.out.println(student);    //第二种方式,使用Gson的思想
  16.     Student student1 = JSONObject.parseObject(jsonObject.toJSONString(), Student.class);
  17.     System.out.println(student1);
  18. }

2.3.2.JavaList与JsonArray之间的转换

</>code
  1. /**
  2.  * JavaList到JsonArray的转换
  3.  */@Testpublic void testJavaListToJsonArray() {    //已知JavaList
  4.     Student student = new Student("lily", 12);
  5.     Student studenttwo = new Student("lucy", 15);
  6.     List<Student> students = new ArrayList<Student>();
  7.     students.add(student);
  8.     students.add(studenttwo);    //方式一
  9.     String jsonString = JSONArray.toJSONString(students);
  10.     JSONArray jsonArray = JSONArray.parseArray(jsonString);
  11.     System.out.println(jsonArray);    //方式二
  12.     JSONArray jsonArray1 = (JSONArray) JSONArray.toJSON(students);
  13.     System.out.println(jsonArray1);
  14. }/**
  15.  * JsonArray到JavaList的转换
  16.  */@Testpublic void testJsonArrayToJavaList() {    //已知JsonArray
  17.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  18.     ArrayList<Student> students = JSONArray.parseObject(jsonArray.toJSONString(),            new TypeReference<ArrayList<Student>>() {});
  19.     System.out.println(students);    //第二种方式,使用Gson的思想
  20.     List<Student> students1 = JSONArray.parseArray(jsonArray.toJSONString(), Student.class);
  21.     System.out.println(students1);
  22. }

2.3.3.复杂JavaBean_obj与json对象之间的转换

</>code
  1. /**
  2.  * 复杂JavaBean_obj到json对象的转换
  3.  */@Testpublic void testComplexJavaBeanToJSONObject() {    //已知复杂JavaBean_obj
  4.     Student student = new Student("lily", 12);
  5.     Student studenttwo = new Student("lucy", 15);
  6.     List<Student> students = new ArrayList<Student>();
  7.     students.add(student);
  8.     students.add(studenttwo);
  9.     Course course = new Course("english", 1270);
  10.     Teacher teacher = new Teacher("crystall", 27, course, students);    //方式一
  11.     String jsonString = JSONObject.toJSONString(teacher);
  12.     JSONObject jsonObject = JSONObject.parseObject(jsonString);
  13.     System.out.println(jsonObject);    //方式二
  14.     JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(teacher);
  15.     System.out.println(jsonObject1);
  16. }/**
  17.  * 复杂json对象到JavaBean_obj的转换
  18.  */@Testpublic void testComplexJSONObjectToJavaBean() {    //已知复杂json对象
  19.     JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
  20.     Teacher teacher = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Teacher>() {});
  21.     System.out.println(teacher);    //第二种方式,使用Gson的思想
  22.     Teacher teacher1 = JSONObject.parseObject(jsonObject.toJSONString(), Teacher.class);
  23.     System.out.println(teacher1);
  24. }

此外的：

1，对于JSON对象与JSON格式字符串的转换可以直接用 toJSONString()这个方法。

2，javaBean与JSON格式字符串之间的转换要用到：JSON.toJSONString(obj);

3，javaBean与json对象间的转换使用：JSON.toJSON(obj)，然后使用强制类型转换，JSONObject或者JSONArray。

另一实例：

</>code
  1. package junit.test;
  2. import java.util.ArrayList;
  3. import java.util.HashMap;
  4. import java.util.List;
  5. import java.util.Map;
  6. import com.alibaba.fastjson.JSON;
  7. import com.alibaba.fastjson.TypeReference;
  8. /*
  9.  * 这里将json的转化和解析都放在一起了，大家可以根据实际需要来转化json字符串和解析json字符串
  10.  */
  11. public class TestFastJson {
  12. static class Person{
  13. private String id ;
  14. private String name;
  15. private int age ;
  16. public Person(){
  17. }
  18. public Person(String id,String name,int age){
  19. this.id=id;
  20. this.name=name;
  21. this.age=age;
  22. }
  23. public String getId() {
  24. return id;
  25. }
  26. public void setId(String id) {
  27. this.id = id;
  28. }
  29. public String getName() {
  30. return name;
  31. }
  32. public void setName(String name) {
  33. this.name = name;
  34. }
  35. public int getAge() {
  36. return age;
  37. }
  38. public void setAge(int age) {
  39. this.age = age;
  40. }
  41. @Override
  42. public String toString() {
  43. return "Person [age=" + age + ", id=" + id + ", name=" + name + "]";
  44. }
  45. }
  46. public static void main(String[] args) {
  47. method1();
  48. method2();
  49. method3();
  50. method4();
  51. }
  52. static void method1(){
  53. System.out.println("javabean转化示例开始----------");
  54. Person person = new Person("1","fastjson",1);
  55. //这里将javabean转化成json字符串
  56. String jsonString = JSON.toJSONString(person);
  57. System.out.println(jsonString);
  58. //这里将json字符串转化成javabean对象,
  59. person =JSON.parseObject(jsonString,Person.class);
  60. System.out.println(person.toString());
  61. System.out.println("javabean转化示例结束----------");
  62. }
  63. static void method2(){
  64. System.out.println("List<javabean>转化示例开始----------");
  65. Person person1 = new Person("1","fastjson1",1);
  66. Person person2 = new Person("2","fastjson2",2);
  67. List<Person> persons = new ArrayList<Person>();
  68. persons.add(person1);
  69. persons.add(person2);
  70. String jsonString = JSON.toJSONString(persons);
  71. System.out.println("json字符串:"+jsonString);
  72. //解析json字符串
  73. List<Person> persons2 = JSON.parseArray(jsonString,Person.class);
  74. //输出解析后的person对象，也可以通过调试模式查看persons2的结构
  75. System.out.println("person1对象："+persons2.get(0).toString());
  76. System.out.println("person2对象："+persons2.get(1).toString());
  77. System.out.println("List<javabean>转化示例结束----------");
  78. }
  79. static void method3(){
  80. System.out.println("List<String>转化示例开始----------");
  81. List<String> list = new ArrayList<String>();
  82. list.add("fastjson1");
  83. list.add("fastjson2");
  84. list.add("fastjson3");
  85. String jsonString = JSON.toJSONString(list);
  86. System.out.println("json字符串:"+jsonString);
  87. //解析json字符串
  88. List<String> list2 = JSON.parseObject(jsonString,new TypeReference<List<String>>(){}); 
  89. System.out.println(list2.get(0)+"::"+list2.get(1)+"::"+list2.get(2));
  90. System.out.println("List<String>转化示例结束----------");
  91. }
  92. static void method4(){
  93. System.out.println(" List<Map<String,Object>>转化示例开始 ----------");
  94. Map<String,Object> map = new HashMap<String,Object>();
  95. map.put("key1", "value1");
  96. map.put("key2", "value2");
  97. Map<String,Object> map2 = new HashMap<String,Object>();
  98. map2.put("key1", 1);
  99. map2.put("key2", 2);
  100. List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
  101. list.add(map);
  102. list.add(map2);
  103. String jsonString = JSON.toJSONString(list);
  104. System.out.println("json字符串:"+jsonString);
  105. //解析json字符串
  106. List<Map<String,Object>> list2 = JSON.parseObject(jsonString,new TypeReference<List<Map<String,Object>>>(){});
  107. System.out.println("map的key1值"+list2.get(0).get("key1"));
  108. System.out.println("map的key2值"+list2.get(0).get("key2"));
  109. System.out.println("ma2p的key1值"+list2.get(1).get("key1"));
  110. System.out.println("map2的key2值"+list2.get(1).get("key2"));
  111. }
  112. }


如对本文有疑问，请提交到交流论坛，广大热心网友会为你解答！！ 点击进入论坛

您可能感兴趣的文章:

发表评论 (562人查看，0条评论)
请自觉遵守互联网相关的政策法规，严禁发布色情、暴力、反动的言论。
昵称：
最新评论
------分隔线----------------------------
大家感兴趣的内容
最近更新的内容

公司信息

· 网站介绍
· 联系我们
· 加入我们
· 服务条款

快速入口

· 365软件
· 杰创官网
· 建站工具
· 网站大全

其它栏目

· 建站教程
· 365学习

业务咨询

· 技术支持
· 服务时间：9:00-18:00
365建站网二维码

Powered by 365建站网 RSS地图 HTML地图

copyright © 2013-2024 版权所有 鄂ICP备17013400号