jackson 和flexjson 的性能及比较

对于json对象的序列化和反序列化的性能问题一直是大家关注的焦点和考虑应用哪门技术的出发点。在众的json中 我选择了flexjson 和jackson （jsonlib这个东东就算了吧，跟它谈性能优点离谱）写了个demo做了简单的比较，同时说下自己的应用感受。
1 从API而言flexjson 已经算是很成熟了，jackson却很多方法要自己去搞。当然往往自己去搞的扩展性比较强。（这算是废话，就跟挣钱少的潜力大一样的废话）。
2 从代码的理解、命名和友好性上 flexjson 最起码望文生义，而jackson 就有点不太人性化的类和方法名。
3 从使用广度和深度上，jackson有spring团队的支持和推崇，加之新技术对它的自动封装的支持，使得jackson很快就挤进了json行列，而flexjson则依旧如故的不愠不火，看着官网上的版本最近的都一年前的。。悲剧
4 这里只比较flexjson和jackson 请朋友们不要拿其他json工具包说事。像什么gson、fastjson 等等风起云涌，这里我也表示崇拜下。
5 关键是性能，总体而言 在测试 小数据量时 明显 flexjson 和序列化 比jackson 要强很多，但是反序列化 flexjson 就大不如jackson ，而当内容比较大时 差距就更加明显，当 50--100倍的数据时 flexson 技术增长了10-20倍的开销，而jackson几乎没什么变化，当超过 100倍时 flexjson 直接OOM ，而jackson 依旧稳重性能之增加2倍。
6 所以 使用哪个要看场合，看网络传输、看数据量、看开发成本、看团队、看架构，当然我只是做了个时间的测试，只是从这点来看也不算太全面，但是也是可以反应出一些东西的。个人理解的东西 往往 主管片面，在此我附上代码，愿意测试的朋友可以自己来搞搞，欢迎探讨。

7 测试类 目前四个实体，分别一对多的情况做了三层嵌套，数据量 根据对象的个数自己设置

	public static void main(String[] args) {
		FlexjsonTest test=new  FlexjsonTest();
		int p1=1,p2=1;
		System.out.println("主类 1 个对象，子类分别为 1 、1 、1时 的情况如下");
		test.flexjsonTest(p1, p2);
		test.jacksonTest( p1, p2);

		p1=10;p2=10;
		System.out.println("主类 10 个对象，子类分别为 10 、10、10 时的情况如下");
		test.flexjsonTest(p1, p2);
		test.jacksonTest( p1, p2);

		p1=50;p2=10;
		System.out.println("主类50个对象，子类分别为 10 、10、10 时的情况如下");
		test.flexjsonTest(p1, p2);
		test.jacksonTest( p1, p2);

		p1=100;p2=10;
		System.out.println("主类50个对象，子类分别为 10 、10、10 时的情况如下");
		test.flexjsonTest(p1, p2);
		test.jacksonTest( p1, p2);
	}

public String  flexjsonTest(int p1,int p2){

		List<TestPojo> list=this.getList(p1, p2);

		long start=System.currentTimeMillis();
		JSONSerializer serializer=new JSONSerializer();
		serializer.exclude("*.class");
		String jsonStr=serializer.deepSerialize(list);
		long end=System.currentTimeMillis();
	//	System.out.println("序列化字符串结果:");
	//	System.out.println(jsonStr);
		System.out.println("flexjson序列化消耗时间为："+(end-start)+"ms");
		JSONDeserializer<List<TestPojo>> deserializer=new JSONDeserializer<List<TestPojo>>();
		List<TestPojo> result=deserializer.use(null, TestPojo2.class).deserialize(jsonStr);
		System.out.println("flexjson反序列化的消耗时间为："+(System.currentTimeMillis()-end)+"ms");
	//	System.out.println("flexjson反序列化字符串结果:");
	//	System.out.println(result);
		return jsonStr;
	}

	public void jacksonTest(int p1,int p2){
		List<TestPojo> list=this.getList(p1, p2);
		long start=System.currentTimeMillis();

		ObjectMapper  objectMapper = new ObjectMapper();


		try {
	//		objectMapper.writeValue(System.out, list);
	//		System.out.println("jackson  objectMapper序列化消耗时间为："+(System.currentTimeMillis()-start)+"ms");
			//new File("d:\\json.txt")
			ByteArrayOutputStream stream=new ByteArrayOutputStream();
			JsonGenerator jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(stream, JsonEncoding.UTF8);
			jsonGenerator.writeObject(list); 
		//	System.out.println(stream.toString());
			long end=System.currentTimeMillis();

			System.out.println("jackson  jsonGenerator序列化消耗时间为："+(end-start)+"ms");
			//	System.out.println("jackson序列化字符串结果:");

			List<TestPojo> result=objectMapper.readValue(stream.toString(), ArrayList.class);

			System.out.println("jackson反序列化的消耗时间为："+(System.currentTimeMillis()-end)+"ms");

		} catch (IOException e) {
			e.printStackTrace();
		}

得出结果如下

主类 1 个对象，子类分别为 1 、1 、1时 的情况如下
flexjson序列化消耗时间为：27ms
flexjson反序列化的消耗时间为：22ms
jackson  jsonGenerator序列化消耗时间为：177ms
jackson反序列化的消耗时间为：19ms

主类 10 个对象，子类分别为 10、01 、10时 的情况如下
flexjson序列化消耗时间为：174ms
flexjson反序列化的消耗时间为：113ms
jackson  jsonGenerator序列化消耗时间为：214ms
jackson反序列化的消耗时间为：77ms

主类 50 个对象，子类分别为 10、01 、10时 的情况如下
flexjson序列化消耗时间为：595ms
flexjson反序列化的消耗时间为：447ms
jackson  jsonGenerator序列化消耗时间为：237ms
jackson反序列化的消耗时间为：183ms

Flexjson 100时如下
主类 100 个对象，子类分别为 10、01 、10时 的情况如下
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Jackson 100时
主类 100 个对象，子类分别为 10、01 、10时 的情况如下
jackson  jsonGenerator序列化消耗时间为：381ms
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

总体可见 反序列化确实 比序列化耗费性能 所以 我们在 如参数自己拼对象 比 反序列化对象好多了，可能flex 也是考虑到反序列化用的少，就没在去优化吧。 附件为源码 请参考 直接看 FlexjsonTest 类就可以。