json工具性能比较：json-lib和jackson进行Java对象到json字符串序列化

，的确是有这个问题。。。之前确实没有注意到，更正确的做法是要在不同线程中公用，这样测出的性能应该更高。
另外这个ObjectMapper在官方文档上有说明，这个是线程安全的。

非常不错的文章，目前也关注jackson

希望楼主  [color=red]再详细测试一下反序列化的性能 [/color]

我一个java类，就只有
public String id = "ABCD";
    public int age = 20;
    public Integer age1 = 2000; 属性
//get/set.....

 

下面测试代码 

JsonUtils里的工具方法
public static String getJson(Object obj) throws Exception{
        StringWriter writer = new StringWriter();
        try{
            ObjectMapper mapper = new ObjectMapper();
            mapper.writeValue(writer, obj);
            writer.close();
            return writer.toString();
        }catch (Exception ex){
            throw ex;
        }finally {
            writer.close();
        }

    }

public static String getJsonList(Object obj){
        
        StringBuffer data = new StringBuffer();
        if(obj != null){
            if(obj instanceof Collection){
                if(CollectionUtils.isEmpty((Collection)obj)){
                    data.append(nullJsons);
                }else{
                    data.append(JSONSerializer.toJSON(obj).toString());
                }
            }else if(obj instanceof Map){
                if(MapUtils.isNotEmpty((Map)obj)){
                    data.append(LEFTJSONS)
                            .append(JSONSerializer.toJSON(obj).toString())
                            .append(RIGHTJSONS);
                }else{
                    data.append(nullJsons);
                }
            }else{
                data.append(LEFTJSONS)
                        .append(JSONSerializer.toJSON(obj).toString())
                        .append(RIGHTJSONS);
            }
        }else{
            data.append(nullJsons);
        }

        return data.toString();
    }

 

TestJsonObjectJack testJsonObjectJack2 = new TestJsonObjectJack();
            Long l = 0L;
            for(int i = 0 ; i < 20000; i++){
                StopWatch stopWatch2 = new StopWatch();
                stopWatch2.start();
                JsonUtil.getJson(testJsonObjectJack2);
                stopWatch2.stop();
                l += stopWatch2.getTime();
            }

            System.out.println("l = " + l +" 毫秒");

 

看到的 毫秒数 l = 2203 毫秒

 

而是用 json-lib如下

TestJsonObjectJack testJsonObjectJack2 = new TestJsonObjectJack();
            Long l = 0L;
            for(int i = 0 ; i < 20000; i++){
                StopWatch stopWatch2 = new StopWatch();
                stopWatch2.start();
                JsonUtil.getJsonList(testJsonObjectJack2);
                stopWatch2.stop();
                l += stopWatch2.getTime();
            }

            System.out.println("l = " + l +" 毫秒");

 

看到的 毫秒数 l = 1079 毫秒

 

有些东西还是实际做做才知道真假

我没有做过详细的测试，但做过粗略的测试，两者相差的性能更大

你得出的结论是：
jackson/json-lib : 2203 毫秒/ 1079毫秒
有些东西还是实际做做才知道真假

不知道ls有没有注意到我的测试里面对jackson其实有两种测试：jackson with cache和jackson without cache，前者才是正确的做法，因为ObjectMapper是线程安全的，后者是为了说明有的情况下，也会出现这样的对jackson错误的实践，而ls上面的使用方法刚好用了后者。
另外不知道为何ls测出的数据会这么大，我同样用了与ls一样的Object，属性也一样，循环次数也一样，结果测出来的时间jackson/json-lib: 64 毫秒/ 250毫秒

另外，这个东西我们公司里用的时候也是因为一次用了json-lib出了问题，然后换成jackson的，所以也是“实际做做才知道的”。另外，ls也应该可以看到上面的json-lib的序列化也太麻烦了。我比较不喜欢它的一个原因是因为它都引入了自己的类型，比如null并不是真正的null，而一个json-lib自己的一个表达Null的对象

你这个测试工具非常不错啊，冲这点投你一票。
我用你这个工具测试了一下JSEL。还揪出JSEL JSON工具一个多线程的bug ，非常感谢，呵呵。


jackson 的性能确实非常不错。我折腾了一个下午，硬是没能超越，吧JSEL的测试结果补上。

[JSEL]	avg: 21.12 ms	total: 2,112.45 ms	tps: 47.34	running: 100 times	in 10 Threads
2010-8-15 22:30:23 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo
信息: 
memory-usage: [JSEL]	1,319.808 Kb

2010-8-15 22:30:24 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo
信息: 
[JSEL(Without Check)]	avg: 11.00 ms	total: 1,099.92 ms	tps: 90.92	running: 100 times	in 10 Threads
2010-8-15 22:30:24 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo
信息: 
memory-usage: [JSEL(Without Check)]	420.296 Kb

2010-8-15 22:30:26 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo
信息: 
[jackson（重用ObjectMapper）]	avg: 8.35 ms	total: 835.41 ms	tps: 119.70	running: 100 times	in 10 Threads
2010-8-15 22:30:26 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo
信息: 
memory-usage: [jackson（重用ObjectMapper）]	1,197.456 Kb

2010-8-15 22:30:33 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo
信息: 
[jackson（不重用ObjectMapper）]	avg: 56.11 ms	total: 5,611.23 ms	tps: 17.82	running: 100 times	in 10 Threads
2010-8-15 22:30:33 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo
信息: 
memory-usage: [jackson（不重用ObjectMapper）]	4,956.536 Kb

请问楼主

        class User{
		
	public Integer id;
	public String name;
		
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
		
	public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {
			
		ObjectMapper mapp = new ObjectMapper();
		
		User u = new User();
		u.setId(1);
		u.setName("\"zhangsan");
		
		StringWriter writer1 = new StringWriter();
		mapp.writeValue(writer1,"\"zhangsan");
		System.out.println(writer1.toString());
		
		StringWriter writer2 = new StringWriter();
		mapp.writeValue(writer2,u.getName());
		System.out.println(writer2.toString());
		
		StringWriter writer3 = new StringWriter();
		mapp.writeValue(writer3,u);
		System.out.println(writer3.toString());
	}
}

输出结果：

"\"zhangsan"    //为什么不是""zhangsan"
"\"zhangsan"
{"name":"\"zhangsan","id":1}

基于field的侵入性更小，有些东西并全是pojo，比如pojo有一些方法getXXX()，返回的却是属性的计算结果，jackson就很麻烦了。

gson慢有慢的道理，毕竟是基于field的，要重复反射，不像基于method的可以缓存Method。

另外有多少应用在意这快的0.xxx毫秒哪？！对现有系统影响小，api简单才是关键。

一次调用0.xxx毫秒确实不会在意，但是如果你的是接口服务，并且并发量很大的话，就会出现性能瓶颈。
很多接口服务是以json形式暴露，有些接口服务对性能要求还是比较高的。我在公司做过一个项目就是先后用了这两种工具，这个项目并发量很大。用jackson是一方面是因为性能问题，另一方面是因为json-lib的api太不好友好了，并且因为用了一些json-lib自己的对象，程序出现过一些莫名奇妙的错误，而jackson的要易用多了，api也简单。