Json的FastJson与Jackson

全栈程序员站长

发布于 2022-08-04 16:18:40

1.6K0

发布于 2022-08-04 16:18:40

文章被收录于专栏：全栈程序员必看

大家好，又见面了，我是你们的朋友全栈君。

FastJson

需要引入 fastjson-1.2.40.jar包

FastJson的介绍

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

FastJson的特点

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

FastJson的简单说明

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

FastJson的用法

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

//json字符串-简单对象型
private static final String  JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";

//json字符串-数组类型
private static final String  JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";

//复杂格式json字符串
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}]}";

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

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

/** * json字符串-简单对象型到JSONObject的转换 */
@Test
public void testJSONStrToJSONObject() { 
   
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
    System.out.println("studentName: " + jsonObject.getString("studentName") + ":" + " studentAge: "
            + jsonObject.getInteger("studentAge"));
}
/** * JSONObject到json字符串-简单对象型的转换 */
@Test
public void testJSONObjectToJSONStr() { 
   

    //已知JSONObject,目标要转换为json字符串
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
    // 第一种方式
    String jsonString = JSONObject.toJSONString(jsonObject);

    // 第二种方式
    //String jsonString = jsonObject.toJSONString();
    System.out.println(jsonString);
}

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

/** * json字符串-数组类型到JSONArray的转换 */
@Test
public void testJSONStrToJSONArray() { 
   

    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

    //遍历方式1
    int size = jsonArray.size();
    for (int i = 0; i < size; i++) { 
   

        JSONObject jsonObject = jsonArray.getJSONObject(i);
        System.out.println("studentName: " + jsonObject.getString("studentName") + ":" + " studentAge: "
                + jsonObject.getInteger("studentAge"));
    }

    //遍历方式2
    for (Object obj : jsonArray) { 
   

        JSONObject jsonObject = (JSONObject) obj;
        System.out.println("studentName: " + jsonObject.getString("studentName") + ":" + " studentAge: "
                + jsonObject.getInteger("studentAge"));
    }
}

/** * JSONArray到json字符串-数组类型的转换 */
@Test
public void testJSONArrayToJSONStr() { 
   

    //已知JSONArray,目标要转换为json字符串
    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);
    //第一种方式
    String jsonString = JSONArray.toJSONString(jsonArray);

    // 第二种方式
    //String jsonString = jsonArray.toJSONString(jsonArray);
    System.out.println(jsonString);
}

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

/** * 复杂json格式字符串到JSONObject的转换 */
@Test
public void testComplexJSONStrToJSONObject() { 
   
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
    String teacherName = jsonObject.getString("teacherName");
    Integer teacherAge = jsonObject.getInteger("teacherAge");
    System.out.println("teacherName: " + teacherName + " teacherAge: " + teacherAge);
    JSONObject jsonObjectcourse = jsonObject.getJSONObject("course");
     //获取JSONObject中的数据
    String courseName = jsonObjectcourse.getString("courseName");
    Integer code = jsonObjectcourse.getInteger("code");
    System.out.println("courseName: " + courseName + " code: " + code);
    JSONArray jsonArraystudents = jsonObject.getJSONArray("students");
    //遍历JSONArray
    for (Object object : jsonArraystudents) { 
   
        JSONObject jsonObjectone = (JSONObject) object;
        String studentName = jsonObjectone.getString("studentName");
        Integer studentAge = jsonObjectone.getInteger("studentAge");
        System.out.println("studentName: " + studentName + " studentAge: " + studentAge);
    }
}
/** * 复杂JSONObject到json格式字符串的转换 */
@Test
public void testJSONObjectToComplexJSONStr() { 
   
   //复杂JSONObject,目标要转换为json字符串
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
    //第一种方式
    //String jsonString = JSONObject.toJSONString(jsonObject);
    //第二种方式
    String jsonString = jsonObject.toJSONString();
    System.out.println(jsonString);
}

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

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

/** * json字符串-简单对象到JavaBean之间的转换 */
@Test
public void testJSONStrToJavaBeanObj() { 
   

    //第一种方式
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);

    String studentName = jsonObject.getString("studentName");
    Integer studentAge = jsonObject.getInteger("studentAge");

    //Student student = new Student(studentName, studentAge);

    //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    //Student student = JSONObject.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});

    //第三种方式,使用Gson的思想
    Student student = JSONObject.parseObject(JSON_OBJ_STR, Student.class);

    System.out.println(student);
}

/** * JavaBean到json字符串-简单对象的转换 */
@Test
public void testJavaBeanObjToJSONStr() { 
   

    Student student = new Student("lily", 12);
    String jsonString = JSONObject.toJSONString(student);
    System.out.println(jsonString);
}

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

/** * json字符串-数组类型到JavaBean_List的转换 */
@Test
public void testJSONStrToJavaBeanList() { 
   
    //第一种方式
    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

    //遍历JSONArray
    List<Student> students = new ArrayList<Student>();
    Student student = null;
    for (Object object : jsonArray) { 
   

        JSONObject jsonObjectone = (JSONObject) object;
        String studentName = jsonObjectone.getString("studentName");
        Integer studentAge = jsonObjectone.getInteger("studentAge");

        student = new Student(studentName,studentAge);
        students.add(student);
    }
    System.out.println("students: " + students);
    //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    List<Student> studentList = JSONArray.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() { 
   });
    System.out.println("studentList: " + studentList);
    //第三种方式,使用Gson的思想
    List<Student> studentList1 = JSONArray.parseArray(JSON_ARRAY_STR, Student.class);
    System.out.println("studentList1: " + studentList1);
}
/** * JavaBean_List到json字符串-数组类型的转换 */
@Test
public void testJavaBeanListToJSONStr() { 
   
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);
    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);
    String jsonString = JSONArray.toJSONString(students);
    System.out.println(jsonString);
}

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

/** * 复杂json格式字符串到JavaBean_obj的转换 */
@Test
public void testComplexJSONStrToJavaBean(){ 
   

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() { 
   });
    System.out.println(teacher);

    //第二种方式,使用Gson思想
    Teacher teacher1 = JSONObject.parseObject(COMPLEX_JSON_STR, Teacher.class);
    System.out.println(teacher1);
}

/** * 复杂JavaBean_obj到json格式字符串的转换 */
@Test
public void testJavaBeanToComplexJSONStr(){ 
   

    //已知复杂JavaBean_obj
    Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() { 
   });
    String jsonString = JSONObject.toJSONString(teacher);
    System.out.println(jsonString);
}

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

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

/** * 简单JavaBean_obj到json对象的转换 */
@Test
public void testJavaBeanToJSONObject(){ 
   

    //已知简单JavaBean_obj
    Student student = new Student("lily", 12);

    //方式一
    String jsonString = JSONObject.toJSONString(student);
    JSONObject jsonObject = JSONObject.parseObject(jsonString);
    System.out.println(jsonObject);

    //方式二
    JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(student);
    System.out.println(jsonObject1);
}

/** * 简单json对象到JavaBean_obj的转换 */
@Test
public void testJSONObjectToJavaBean(){ 
   

    //已知简单json对象
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Student student = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Student>() { 
   });
    System.out.println(student);

    //第二种方式,使用Gson的思想
    Student student1 = JSONObject.parseObject(jsonObject.toJSONString(), Student.class);
    System.out.println(student1);
}

JavaList与JsonArray之间的转换

/** * JavaList到JsonArray的转换 */
@Test
public void testJavaListToJsonArray() { 
   

    //已知JavaList
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);

    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);

    //方式一
    String jsonString = JSONArray.toJSONString(students);
    JSONArray jsonArray = JSONArray.parseArray(jsonString);
    System.out.println(jsonArray);

    //方式二
    JSONArray jsonArray1 = (JSONArray) JSONArray.toJSON(students);
    System.out.println(jsonArray1);
}

/** * JsonArray到JavaList的转换 */
@Test
public void testJsonArrayToJavaList() { 
   

    //已知JsonArray
    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    ArrayList<Student> students = JSONArray.parseObject(jsonArray.toJSONString(),
            new TypeReference<ArrayList<Student>>() { 
   });

    System.out.println(students);
    //第二种方式,使用Gson的思想
    List<Student> students1 = JSONArray.parseArray(jsonArray.toJSONString(), Student.class);
    System.out.println(students1);
}

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

/** * 复杂JavaBean_obj到json对象的转换 */
@Test
public void testComplexJavaBeanToJSONObject() { 
   
    //已知复杂JavaBean_obj
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);

    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);
    Course course = new Course("english", 1270);

    Teacher teacher = new Teacher("crystall", 27, course, students);

    //方式一
    String jsonString = JSONObject.toJSONString(teacher);
    JSONObject jsonObject = JSONObject.parseObject(jsonString);
    System.out.println(jsonObject);

    //方式二
    JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(teacher);
    System.out.println(jsonObject1);
}

/** * 复杂json对象到JavaBean_obj的转换 */
@Test
public void testComplexJSONObjectToJavaBean() { 
   
    //已知复杂json对象
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Teacher teacher = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Teacher>() { 
   });
    System.out.println(teacher);
    //第二种方式,使用Gson的思想
    Teacher teacher1 = JSONObject.parseObject(jsonObject.toJSONString(), Teacher.class);
    System.out.println(teacher1);
}

Jackson

使用jackson需要引入以下第三方jar包:

代码：

package Exercise1_jackson;
 
import java.io.IOException;
import java.util.List;
 
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
 
/** * @author huangxinyi * jackson实现对象和json,集合和json之间的互相转换 * */
public class Test { 
   
	
	private ObjectMapper objectMapper = new ObjectMapper();
	
	@org.junit.Test
	public void test(){ 
   
		String jsonArr = "[{\"brand\":\"联想\",\"type\":\"电脑\",\"color\":\"白色\",\"price\":\"3000\"},"+
                "{\"brand\":\"小米\",\"type\":\"手机\",\"color\":\"黑色\",\"price\":\"2500\"},"+
                "{\"brand\":\"华为\",\"type\":\"手机\",\"color\":\"白色\",\"price\":\"2000\"},"+
                "{\"brand\":\"戴尔\",\"type\":\"电脑\",\"color\":\"蓝色\",\"price\":\"4000\"},"+
                "{\"brand\":\"苹果\",\"type\":\"手机\",\"color\":\"红色\",\"price\":\"5000\"}]";
			
		try { 
   
			//json转集合
			List<Product> plist = objectMapper.readValue(jsonArr, new TypeReference<List<Product>>(){ 
   });
			System.out.println(plist);
			
			//json转对象
			Product p = objectMapper.readValue("{\"brand\":\"小米\",\"type\":\"手机\",\"color\":\"黑色\",\"price\":\"2500\"}", Product.class);
			System.out.println(p);
			
			//对象转json
			String json_p = objectMapper.writeValueAsString(new Product("小米","手机","黑色",2500));
			System.out.println(json_p);
			
			//集合转json
			String json_list = objectMapper.writeValueAsString(plist);
			System.out.println(json_list);
			
		} catch (JsonParseException e) { 
   
			e.printStackTrace();
		} catch (JsonMappingException e) { 
   
			e.printStackTrace();
		} catch (IOException e) { 
   
			e.printStackTrace();
		}
	}
}

JSON技术的简介和优劣

JSON技术的简介

json-lib json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。 json-lib在功能和性能上面都不能满足现在互联网化的需求。
开源的Jackson 相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。 Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式。
阿里巴巴的FastJson Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的jar，能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。 FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。
Google的Gson Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。 Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

综上4种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，如果只是功能要求，没有性能要求，可以使用google的Gson，如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean。

选用的方便性和性能

调用方便性而言： FastJSON提供了大量静态方法，调用简洁方便 Jackson须实例化类，调用相对繁琐，可通过封装成JSON工具类简化调用
性能而言： FastJSON反序列化的性能略差，对于256k的json字符串，平均700ms Jackson 的 data binding反序列化的性能稍好，对于256k的json字符串，平均600ms 两者的序列化性能基本相同，对于256k的json字符串，平均140ms 相对data binding方式（ObjectMapper.writeValueAsString()），Jackson的流输出方式（JsonGenerator.writeObject()）性能稍好，平均130ms

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/106665.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022年4月2，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法