FastJSON 原理剖析 以及 和 Jackson的对比 who is the most fast!

FastJSON定义： FastJSON是一个阿里巴巴内部人员开发的，用于JSON对象和普通类对象互相转换的库。号称性能超越Jackson，今天我们就来看看，阿里巴巴大牛 vs Tatu Saloranta，到底 who is the most awesome!

FastJSON原理： 

-对象 to JSON ：利用反射找到对象类的所有Get方法，然后把"get"去掉，小写化，作为JSON的每个key值，如 getA  对应的key值为 a，而与真实的类成员名无关。

-JSON to  pojo ：先同样通过反射找到对象类所有的Set方法，然后使用无参数构造函数（所以一定要有无参数的构造函数）新建一个类对象，从JSON字符串中取出一个key 如 a，先大写化为A，那么从所有Set方法中找到 SetA()，然后进行赋值。 如果找不到 setA （seta也不行），那么该值被忽略，也不报错。

Jackson 的原理和FastJson一致，但是在 JSON to Java pojo的步骤中，做了更加科学的check，因而能识别seta这样的小写。但是如果getA 和geta都找不到，则会抛出异常（除非把a设置为忽略）。

其他的步骤原理和FastJSON类似。

测试验证代码：

package jar;

import com.alibaba.fastjson.JSON;

public class Test{

	private int aaa=0;
	private String bbb = "000";

	public Test() {
		// TODO Auto-generated constructor stub
		aaa = 1;
		bbb = "111";
		System.out.println(" default construct function is called!!!");
	}

	public Test(int a ,String b) {
		// TODO Auto-generated constructor stub
		aaa = a;
		bbb = b;
		System.out.println("construct 2 function is called!!!");
	}

	public int getA() {
		return aaa;
	}

	public void seta(int a)
	{
		this.aaa =a;
	}

	public String getB() {
		return bbb;
	}

	 //test
	 public static void main(String[] args) throws Exception
	 {     	 

		   Test test =new Test(2,"222");
		   String code =  JSON.toJSONString(test);
		   System.out.println(code);
		   Test reverse = JSON.parseObject(code,Test.class);

		   System.out.println(reverse.getA());
		   System.out.println(reverse.getB());
	 }

}

下面是对 FastJson 和 Jackson  （pojo to json-编码） 以及 （json to pojo-解码）以及综合（编码+解码） 在不同成员数量 下 ，不同循环次数的耗时（ns纳秒）对比。

//         code + decode -----------------------------------------------------
//         10000  - 23 members
//		   Jackson :235750737 ns
//		   FastJSON:347795550 ns
//         10000  - 2 members
//		   Jackson :164173126 ns
//		   FastJSON:159078284 ns

//	       100000 - 23 members
//		   Jackson :1004902734 ns
//		   FastJSON:1689072614 ns
//	       100000 - 2 members
//		   Jackson :392344461 ns
//		   FastJSON:299521240 ns

// 	       1000000 - 23 members
//		   Jackson :8547741285 ns
//		   FastJSON:15377369425 ns
// 	       1000000 - 2 members
//		   Jackson :2581267623 ns
//		   FastJSON:1591827729 ns

//         code only -------------------------------------------------------
//         10000  - 23 members
//		   Jackson :115036100 ns
//		   FastJSON:158681243 ns
//         10000  - 2 members
//		   Jackson :87886170 ns
//		   FastJSON:103086025 ns

//	       100000 - 23 members
//		   Jackson :417539325 ns
//		   FastJSON:349358062 ns
//	       100000 - 2 members
//		   Jackson :185865488 ns
//		   FastJSON:144893485 ns

// 	       1000000 - 23 members
//		   Jackson :3384171740 ns
//		   FastJSON:2200190119 ns
// 	       1000000 - 2 members
//		   Jackson :1193815955 ns
//		   FastJSON:568776506 ns

//         decode only -------------------------------------------------------
//         10000  - 23 members
//		   Jackson :122597862 ns
//		   FastJSON:183567261 ns
//         10000  - 2 members
//		   Jackson :75418145 ns
//		   FastJSON:47832689 ns

//	       100000 - 23 members
//		   Jackson :497670344 ns
//		   FastJSON:1254994458 ns
//	       100000 - 2 members
//		   Jackson :165368101 ns
//		   FastJSON:117555618 ns

// 	       1000000 - 23 members
//		   Jackson :4189147981 ns
//		   FastJSON:12004873228 ns
// 	       1000000 - 2 members
//		   Jackson :999578584 ns
//		   FastJSON:863444723 ns

结论：

编码(pojo to json):  当循环数量较小时，FastJSON的性能 低于 JackSON；

当循环数量越大时，FastJSON的性能开始超过Jackson；

解码( json to pojo):当成员数量越大时，FastJSON的相对性能越差，JackSON的相对性能则越好；

当成员数量越小时，FastJSON的性能越好。

综合(编码+解码): 当成员变量数量越大时，Jackson 获胜。无关于循环数量。

当成员变量数量越小时，FastJSON获胜。

一般情况下，系统中的循环数量一般不会大的惊人，应该是偏小的。而成员变量变多，是一个企业级系统常见的情况。

SO， who is the most fast or best? 我就不点出了。

。。。

Whatever， 两个JSON框架都是很棒的。而且本人很喜欢FastJSON的易用性，干净。

有时间，有兴趣的可以继续研究研究FastJSON在多成员变量解码时的劣势是什么原因导致的。

付上测试代码：

package jar;

import java.io.StringWriter;

import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.map.ObjectMapper;

import com.alibaba.fastjson.JSON;

public class Test{

	private int aaa=0;
	private String bbb = "000";

	private String c1 = "000";
	private String c2 = "000";
	private String c3 = "000";
	private String c4 = "000";
	private String c5 = "000";
	private String c6 = "000";
	private String c7 = "000";
	private String c8 = "000";
	private String c9 = "000";
	private String c10 = "000";
	private String c11 = "000";
	private String c12 = "000";
	private String c13 = "000";
	private String c14 = "000";
	private String c15 = "000";
	private String c16 = "000";
	private String c17 = "000";
	private String c18 = "000";
	private String c19 = "000";
	private String c20 = "000";
	private String c21 = "000";

	public Test()
	{

	}

	public Test(int a ,String b) {
		// TODO Auto-generated constructor stub
		aaa = a;
		bbb = b;
		//System.out.println("construct 2 function is called!!!");
	}

	public int getA() {
		return aaa;
	}

	public void setA(int a)
	{
		this.aaa = a;
	}

	public String getB() {
		return bbb;
	}

	public void setB(String b) {
		this.bbb = b;
	}

	public String getC1() {
		return c1;
	}

	public void setC1(String c1) {
		this.c1 = c1;
	}

	public String getC2() {
		return c2;
	}

	public void setC2(String c2) {
		this.c2 = c2;
	}

	public String getC3() {
		return c3;
	}

	public void setC3(String c3) {
		this.c3 = c3;
	}

	public String getC4() {
		return c4;
	}

	public void setC4(String c4) {
		this.c4 = c4;
	}

	public String getC5() {
		return c5;
	}

	public void setC5(String c5) {
		this.c5 = c5;
	}

	public String getC6() {
		return c6;
	}

	public void setC6(String c6) {
		this.c6 = c6;
	}

	public String getC7() {
		return c7;
	}

	public void setC7(String c7) {
		this.c7 = c7;
	}

	public String getC8() {
		return c8;
	}

	public void setC8(String c8) {
		this.c8 = c8;
	}

	public String getC9() {
		return c9;
	}

	public void setC9(String c9) {
		this.c9 = c9;
	}

	public String getC10() {
		return c10;
	}

	public void setC10(String c10) {
		this.c10 = c10;
	}

	public String getC11() {
		return c11;
	}

	public void setC11(String c11) {
		this.c11 = c11;
	}

	public String getC12() {
		return c12;
	}

	public void setC12(String c12) {
		this.c12 = c12;
	}

	public String getC13() {
		return c13;
	}

	public void setC13(String c13) {
		this.c13 = c13;
	}

	public String getC14() {
		return c14;
	}

	public void setC14(String c14) {
		this.c14 = c14;
	}

	public String getC15() {
		return c15;
	}

	public void setC15(String c15) {
		this.c15 = c15;
	}

	public String getC16() {
		return c16;
	}

	public void setC16(String c16) {
		this.c16 = c16;
	}

	public String getC17() {
		return c17;
	}

	public void setC17(String c17) {
		this.c17 = c17;
	}

	public String getC18() {
		return c18;
	}

	public void setC18(String c18) {
		this.c18 = c18;
	}

	public String getC19() {
		return c19;
	}

	public void setC19(String c19) {
		this.c19 = c19;
	}

	public String getC20() {
		return c20;
	}

	public void setC20(String c20) {
		this.c20 = c20;
	}

	public String getC21() {
		return c21;
	}

	public void setC21(String c21) {
		this.c21 = c21;
	}

	//test
	 /**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception
	 {     	 

		   Test test =new Test(2,"222");

		   //JackJSON 初始化
		   ObjectMapper objectMapper = new ObjectMapper();  

		   long startTime=0;   //获取开始时间
		   long endTime=0; //获取结束时间

		   int  loopCount  =100000;

//         code + decode -----------------------------------------------------
//         10000  - 23 members
//		   Jackson :235750737 ns
//		   FastJSON:347795550 ns
//         10000  - 2 members
//		   Jackson :164173126 ns
//		   FastJSON:159078284 ns

//	       100000 - 23 members
//		   Jackson :1004902734 ns
//		   FastJSON:1689072614 ns
//	       100000 - 2 members
//		   Jackson :392344461 ns
//		   FastJSON:299521240 ns

// 	       1000000 - 23 members
//		   Jackson :8547741285 ns
//		   FastJSON:15377369425 ns
// 	       1000000 - 2 members
//		   Jackson :2581267623 ns
//		   FastJSON:1591827729 ns

//         code only -------------------------------------------------------
//         10000  - 23 members
//		   Jackson :115036100 ns
//		   FastJSON:158681243 ns
//         10000  - 2 members
//		   Jackson :87886170 ns
//		   FastJSON:103086025 ns

//	       100000 - 23 members
//		   Jackson :417539325 ns
//		   FastJSON:349358062 ns
//	       100000 - 2 members
//		   Jackson :185865488 ns
//		   FastJSON:144893485 ns

// 	       1000000 - 23 members
//		   Jackson :3384171740 ns
//		   FastJSON:2200190119 ns
// 	       1000000 - 2 members
//		   Jackson :1193815955 ns
//		   FastJSON:568776506 ns

//         decode only -------------------------------------------------------
//         10000  - 23 members
//		   Jackson :122597862 ns
//		   FastJSON:183567261 ns
//         10000  - 2 members
//		   Jackson :75418145 ns
//		   FastJSON:47832689 ns

//	       100000 - 23 members
//		   Jackson :497670344 ns
//		   FastJSON:1254994458 ns
//	       100000 - 2 members
//		   Jackson :165368101 ns
//		   FastJSON:117555618 ns

// 	       1000000 - 23 members
//		   Jackson :4189147981 ns
//		   FastJSON:12004873228 ns
// 	       1000000 - 2 members
//		   Jackson :999578584 ns
//		   FastJSON:863444723 ns

		   //Jackson

		   startTime =  System.nanoTime();

		   for(int i=0;i<loopCount;i++)
		   {
			   StringWriter sw = new StringWriter();
			   JsonGenerator jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(sw);
			   jsonGenerator.writeObject(test);
			   String result = sw.toString();
			  // Test acc = objectMapper.readValue(result, Test.class);
		   }
		   endTime =  System.nanoTime();
		   System.out.println("Jackson :"+(endTime-startTime)+" ns");

		   startTime =  System.nanoTime();
		   //FastJSON
		   for(int i=0;i<loopCount;i++)
		   {
			   String code =  JSON.toJSONString(test);
			 // Test reverse = JSON.parseObject(code,Test.class);
		   }
		   endTime =  System.nanoTime();

		   System.out.println("FastJSON:"+(endTime-startTime)+" ns");

	 }

}

还有一篇TS回复挑战者的基准测试结果的文章，虽然和本文没有直接关系，但是反映了一些东西。可以了解了解。

http://www.infoq.com/cn/news/2014/05/jackson-founder-responds

时间： 2024-10-11 17:20:09

FastJSON 原理剖析 以及 和 Jackson的对比 who is the most fast!的相关文章

【Xamain 跨平台机制原理剖析】

原文:[Xamain 跨平台机制原理剖析] [看了请推荐,推荐满100后,将发补丁地址] Xamarin项目从喊口号到现在,好几个年头了,在内地没有火起来,原因无非有三,1.授权费贵 2.贵 3.原生态Java开发Android的越来越多,人工费用成本降低. 上面说的3条,都跟钱相关,不占技术边,看起来跟本文的标题严重不符.但是,细细看来,如果这个产品的圈子打不开,再牛的技术,也是枉然.因为技术是在不断推进的, 性能问题,技术问题,实现问题,等等都可以随着时间的推动去解决,但是,Xamarin公

HTTPS 原理剖析与项目场景

最近手头有两个项目,XX导航和XX产业平台,都需要使用HTTPS协议,因此,这次对HTTPS协议做一次整理与分享. 为什么使用HTTPS HTTP 协议,本身是明文传输的,没有经过任何安全处理.那么这个时候就很容易在传输过程中被中间者窃听.篡改.冒充等风险.这里提到的中间者主要指一些网络节点,是用户数据在浏览器和服务器中间传输必须要经过的节点,比如 WIFI 热点,路由器,防火墙,反向代理,缓存服务器等. HTTP 协议,中间者可以窃听隐私,使用户的敏感数据暴露无遗:篡改网页,例如往页面插的广告

MapReduce/Hbase进阶提升(原理剖析、实战演练)

什么是MapReduce? MapReduce是一种编程模型,用于大规模数据集(大于1TB)的并行运算.概念"Map(映射)"和"Reduce(归约)",和他们的主要思想,都是从函数式编程语言里借来的,还有从矢量编程语言里借来的特性.他极大地方便了编程人员在不会分布式并行编程的情况下,将自己的程序运行在分布式系统上. 当前的软件实现是指定一个Map(映射)函数,用来把一组键值对映射成一组新的键值对,指定并发的Reduce(归约)函数,用来保证所有映射的键值对中的每一

EventBus的使用和原理剖析

尊重原创:http://blog.csdn.net/yuanzeyao/article/details/38174537 代码下载:http://download.csdn.net/detail/yuanzeyao2008/7684041 在编程过程中,当我们想通知其他组件某些事情发生时,我们通常使用观察者模式,正式因为观察者模式非常常见,所以在jdk1.5中已经帮助我们实现了观察者模式,我们只需要简单的继承一些类就可以快速使用观察者模式,在Android中也有一个类似功能的开源库EventBu

清除浮动的原理剖析

常用的清除浮动的几种方法总结下: 1,手动设置一个标签(在浮动元素下方),然后对其设置clear属性 2,给浮动元素设置 :after伪类,创建块元素,设置clear属性 3,给父元素设置浮动 4,给父元素设置overflow设置非visible值(auto,hidden) 5,给父元素的display设置为table-cell 7,在ie6,7中,设置zoom或者width,height来触发haslayout,使父元素包含浮动元素 原理剖析: 1,2方法之所以可以成功,是因为了clear属性

Koa框架实践与中间件原理剖析

Koa框架实践与中间件原理剖析 最近尝试用了一下Koa,并在此记录一下使用心得. 注意:本文是以读者已经了解Generator和Promise为前提在写的,因为单单Generator和Promise都能够写一篇博文来讲解介绍了,所以就不在这里赘述.网上资料很多,可以自行查阅. Koa是Express原班人马打造的一个更小,基于nodejs平台的下一代web开发框架.Koa的精妙之处就在于其使用generator和promise,实现了一种更为有趣的中间件系统,Koa的中间件是一系列generat

图像处理之基础---二维卷积运算原理剖析

卷积运算(Convolution)是通过两个函数f 和g 生成第三个函数的一种数学算子,表示函数f 与经过翻转和平移与g 的重叠部分的累积.如果将参加卷积的一个函数看作区间的指示函数,卷积还可以被看作是“滑动平均”的推广.假设: f(x),g(x)是R1上的两个可积函数,并且积分是存在的.这样,随着 x 的不同取值,这个积分就定义了一个新函数h(x),称为函数f 与g 的卷积,记为h(x)＝(f*g)(x). 两个向量卷积,说白了就是多项式乘法.下面用个矩阵例子说明其工作原理: a和d的卷积就是

ASP.NET Core 运行原理剖析2:Startup 和 Middleware(中间件)

小分享:我有几张阿里云优惠券,用券购买或者升级阿里云相应产品最多可以优惠五折!领券地址:https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=ohmepe03 ASP.NET Core 运行原理剖析2:Startup 和 Middleware(中间件) Startup Class 1.Startup Constructor(构造函数) 2.ConfigureServices 3.Configure方法

简单代码生成器原理剖析（二）

上篇<简单代码生成器原理剖析(一)>分 析了代码生成器的原理,查询数据库系统视 图:INFORMATION_SCHEMA.TABLES. INFORMATION_SCHEMA.COLUMNS  可以获得数据库中表.列的相关信息,再运用StringBuilder类的其AppendLine方法追加字符串,最后早运用 File.WriteAllText方法将字符串写入文件. 第二版代码生成器在第一版的基础上扩展了以下功能: 使用了部分类(partial):当使用大项目或自动生成的代码(如由 Wind