1. 全栈程序员必看首页

Json的FastJson与Jackson

全栈程序员-用户IM • • 未分类

Json的FastJson与JacksonJson的FastJson与Jackson

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

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对象之间的转换

  1. 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);
}
  1. 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);
}
  1. 复杂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之间的转换

  1. 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);
}
  1. 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);
}
  1. 复杂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对象间的之间的转换

  1. 简单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);
}
  1. 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);
}
  1. 复杂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
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

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

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • 解决笔记本外接机械键盘win键失灵的问题

    解决笔记本外接机械键盘win键失灵的问题

    解决笔记本外接机械键盘win键失灵的问题按住Fn+PrtSc就可以解锁

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月30日
  • Java之单例模式

    Java之单例模式

    Java之单例模式

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年7月21日
  • CSS3之border-radius圆角

    CSS3之border-radius圆角

    CSS3之border-radius圆角

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年9月21日
  • Editormd的使用——在线编辑和查看文章

    Editormd的使用——在线编辑和查看文章

    Editormd的使用——在线编辑和查看文章使用Editormd可以方便地在界面上嵌入markdown编辑器，并能够实时预览。先看一下实现效果：编辑文章界面：展示文章界面：用法：首先，到https://pandao.github.io/editor.md/下载Editormd的压缩包，解压到自己的静态资源文件夹下。第二步，引入必要的文件： <linkrel=”stylesheet”href=”/resource/assets/editormd/css/editormd.css”/><linkrel=

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年11月1日
  • pytest指定用例_文件夹排列顺序自定义

    pytest指定用例_文件夹排列顺序自定义

    pytest指定用例_文件夹排列顺序自定义前言测试用例在设计的时候，我们一般要求不要有先后顺序，用例是可以打乱了执行的，这样才能达到测试的效果.有些同学在写用例的时候，用例写了先后顺序，有先后顺序后，后面还会有新的问题（如：上个用例返回

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月30日
  • Socket 编程原理

    Socket 编程原理

    Socket 编程原理目录socket编程基本概念协议TCPUDPDNSICMPHTTPHTTPS编程流程socket函数socket编程基本概念socket编程即计算机网络编程，目的是使两台主机能够进行远程连接，既然要使两者产生联系，那么就要有至少一个信息发送端和一个信息接收端，因此形成了现在绝大多数socket编程都会用到的C/S架构（Client[客户端]/Server[服务端]），最典型的应用就是web服务器/客户端。在Unix/Linux中执行任何形式的I/O操作（比如网络连接）时，都是在读取

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月18日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号