欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java JSON技术框架选型、测试及简单使用

程序员文章站 2022-07-12 23:39:06
...

（转） Java JSON技术框架选型、测试及简单使用

http://bbs.jee-soft.cn:8086/showtopic-155.aspx

一、JSON

        JSON英文全称为JavaScript Object Natation，采用key:value键值对的方式存贮数据，与xml格式相比，JSON是一种轻量级的数据交换格式；不要被Javascript这个单词迷惑，实际上JSON只是一种数据格式，与具体语言并无关系。JSON已被广泛应用于业界，比如目前NoSQL数据库存贮大都采用key:value存贮结构，以Mongo为例，其脚本语法甚至直接使用Javascript；在数据传输时，采用JSON格式也被广泛应用，大部分开放API都开放JSON模式的数据输出；在ajax请求数据时，json格式也被广泛推荐。json更多信息的可以查看json官方网站http://json.org。

二、Java transient关键字 
         JAVA规范原文The transient marker is not fully specified by the Java Language Specification but is used in object serialization to mark member variables that should not be serialized.为了方便存贮和网络传输，java有系列化对象机制，transient可用来指定当前不想被系列化的成员对象。举个例子说明transient的应用，在Mongo+Morphia开源项目下，如果对Java PO的成员指定transient，那么该成员数据将不会被存入Mongo数据库。另外一种应用场景就是这里要讲到的JSON，如果JAVA PO使用了Refrence(Mongo的Refrence)或者LazyLoading(可以理解成Hibernate LazyLoading概念)，那么大部分的开源JAVA JSON相关项目，会自动加载这些Refrence、LazyLoading对象，如果PO形成相互引用，那就会形成死循环，即使没有形成死循环，大量不必要的数据被输出到客户端对资源的浪费也不容小觑。加上transient是一种解决办法。
三、基于JAVA的JSON主要开源项目及其对比 

        Json开源项目非常多，如org.json、 JSON-Lib、jsontool、Jackson、Gson、SimpleJSON等等，后来专门查看了几种json开源测试数据对比后，决定采用Jackson。展示两组测试数据。首先来看大侠wangym(原博客http://wangym.iteye.com/blog/738933)对Jackson、JSON-Lib、Gson的测试结果

JSON转Bean，5个线程并发，约200字节对象，1千万次转换：

 

  Jackson JSON-lib Gson
吞吐量 64113.7 8067.4 13952.8
总耗时(秒) 155 1238 700

 


Bean转JSON，5个线程并发，约200字节对象，1千万次转换：

 

  Jackson JSON-lib Gson
吞吐量 54802 15093.2 17308.2
总耗时(秒) 181 661 560

 

下面是参考Fastjson 的测试数据（http://www.iteye.com/topic/1113183）

性能对比

 

测试案例 JSON-Lib Simple-JSON Fastjson Jackson
IntArray1000Decode 3,626 1,431 563 596
StringArray1000Decode 2,698 2,283 677 774
Map100StringDecode 515 597 208 230

 

功能对比

 

特性 JSON-Lib Simple-JSON Fastjson Jackson
序列化支持数组 不支持 不支持 支持 支持
序列化支持Enum 不支持 不支持 支持 支持
支持JavaBean 不直接支持 不直接支持 支持 支持
支持hibernate laze 不直接支持 不直接支持 支持 支持
循环引用 支持 支持 支持 支持

 

测试总结：
1、显而易见，无论是哪种形式的转换，Jackson > Gson > Json-lib。
     Jackson的处理能力甚至高出Json-lib有10倍左右
2、JSON-lib似乎已经停止更新，最新的版本也是基于JDK15，而Jackson的社区则较为活跃；
3、在测试性能的同时，又以人肉方式对这三个类库转换的正确性进行了检查，三者均达100%正确；
4、JSON-lib在转换诸如Date类型时较为累赘，如以下是两者的转换结果：
JSON-lib：
{"brithday":{"date":17,"day":2,"hours":9,"minutes":24,"month":7,"seconds":26,"time":1282008266398,"timezoneOffset":-480,"year":110}}
Jackson：
{"brithday":1282008123101}
5、JSON-lib依赖commons系列的包及ezmorph包共5个，而Jackson除自身的以外只依赖于commons-logging
6、Jackson提供完整基于节点的Tree Model，以及完整的OJM数据绑定功能。
四、为什么选择Jackson？
参考博文（http://blog.****.net/chaijunkun/article/details/7208828）

      最近在研究JSON，Java中有很多处理JSON的类库，lib-json、sf-json、fastjson还有Jackson Json。第一个就不说了，性能和功能都没有什么亮点。

sf-json最大的优点就是随机读取方便。代码很简单：

JSONObject json= JSONObject.fromObject(str);

然后读取字段内容:

json.getString或者getInt之类的。但是工作效率有待商榷，而且容易出错。

另外sf-json还有个优点就是自动使用unicode编码，当内容中出现中文或者符号的时候会自动将其转换为\uFFFF这样的unicode编码。这样即便是在web服务器端的response中没有设置编码，直接推送json也不会出现乱码问题。

    fastjson，顾名思义就是快。网上已经有很多性能对比的数据了，我就不多说其性能了。

      这里要说的就是它的功能性问题。可能是定位不一样，最初fastjson就是要快，因此在对象的序列化与反序列化上下了很大功夫。但是在功能上有所缺乏。

不知在哪个版本开始加上了key按字典排序的功能。但是貌似这个功能没有办法关闭。有些时候我是不希望字段顺序被打乱的，这个问题就无法解决。

我使用的fastjson版本为1.1.14。另外fastjson还有一些bug没有解决，而且是比较明显的bug。例如在@JsonField注解中format参数，这个是用来指定Date类型数据如何序列化的。如果你使用英文或符号，OK，没有问题（例如yyyy-MM-dd），但是格式中一旦出现中文就会出错（例如yyyy年MM月dd日）。而且经过实验，所有的注解都要放在属性的Getter（就是getXXX()方法）上，直接放在属性上是无法工作的。在eclipse中，一般我们都是直接写属性，属性写完后用自动生成的方式生成Getter和Setter方法。如果今后该类的属性发生变化了，个人更倾向于直接删除所有Getter和Setter，然后重新生成。那么假如把注解全放到Getter上面，我删的时候就要非常小心。

再有一个比较致命的就是文档。几乎找不到全面的文档来介绍或支持fastjson。整个项目都由一个名为“温少”的人来负责，存在很多不确定的因素。

 

经过个人的评估，我更倾向于使用Jackson Json。首先说文档，Jackson Json官方网站上对每一个版本都有详尽的文档（http://jackson.codehaus.org/）。另外Jackson Json的序列化与反序列化速度也并不见得有多慢。更重要的是它的注解支持要好于fastjson。就拿刚才说到的key按字典排序的功能吧，可以在实体类上直接加上@JsonPropertyOrder(alphabetic=false)注解就可以关闭排序功能。而对于其他功能的注解支持也很好。

例如Date的序列与反序列化注解支持

@JsonSerialize(using=DateSerializer.class)
@JsonDeserialize(using=DateDeserializer.class)
private Date birthday;

这样就能指定对birthday字段的序列化与反序列化方法。另外，这两个注解都直接放在了属性上，没有放在Getter上。

针对上面的两个注解，我的序列化器是这样写的

public class DateSerializer extends JsonSerializer<Date>

继承了JsonSerializer，泛型中指定了序列化类型为Date，然后重写如下方法

@Override
public void serialize(Date date, JsonGenerator gen, SerializerProvider provider) throws IOException, JsonProcessingException

方法中传进来的date就是将要被序列化的数据，接下来你可以任意展示该数据，在退出该方法之前使用gen.writeString(formattedDate);来完成序列化就可以了。

类似地，我的反序列化器是这样写的：

public class DateDeserializer extends JsonDeserializer<Date>

继承了JsonDeserializer，泛型中指定了反序列化类型为Date，然后重写如下方法

@Override
public Date deserialize(JsonParser parser, DeserializationContext context)throws IOException, JsonProcessingException {

这里面方法的返回值就是反序列化后的最终内容。方法内部你可以使用parser.getText()来获取到当前要处理的内容。你可以随便折腾里面的数据，只需要最后返回你想要的Date就可以了。

另外在制作基于Jackson Json的Service时想使用泛型的思想来写一个接口，最终目的就是希望方法能随着参数类型不同，返回值的类型也随之不同。以前很少写泛型的方法，这个问题虽然基础，但是难住了我，经过查看Jackson Json的源代码，我得到了启示，像下面这样写就OK了：

public <T> T strToObj(String jsonStr, Class<T> clazz)

这样写就可以了。假设我有一个Result类型的对象需要反序列化，当前已经有了一个json字符串jsonStr，那么我只需要指定第二个参数clazz就可以直接得到Result类型的对象了：

  1. Result newResult= jsonProcessService.strToObj(jsonStr, Result.class);
复制代码

这样就不用在方法前加入(Result)类型强制转换了。

五、Jackson区别于竞争对手的7个杀手锏
参考博文（http://hi.baidu.com/suofang/blog/item/60e7316d9a1e99db4216946b.html）
Jackson JSON 处理器 为一行之有效的Java JSON处理器，诸如它具有如下特点： 



  • 简但且方便的JSON解析，以及与Java对象的相互转换。 
  • 通过注释（annotations）和配置（settings）可扩展的配置性。 
  • 超快的基于流的解析性能，以及完整的数据绑定。

但许多其他Java的JSON库仅考虑方便性和配置性，性能反倒不是面向用户的最重要层面。
那么，为何Java开发人员不选择Jackson而放弃其竞争产品呢？
以上功能的简短列表其实不过是Jackson功能的冰山一角。 的确，这三个常见功能是重要的，但某种程度上也仅是最基本的东西，起码，JSON处理器应被作为值得考虑的工具使用。除此之外，还有很多很多功能应该提供，而这也正是Jackson具备的能力。
因此，让我们来看看7个样例 -- 吉祥的数字 -- "杀手锏" --Jackson近年来领先竞争对手的几点，依据先后顺序介绍（始于1.0版，最新的一个特性是1.6版加入的）。
1.多处理模式，且可很好协作
从基本开始，有多种方法来使用和生产JSON数据，尽管多数JSON包仅提供单一的处理方式，但却有三种互补的JSON处理方式（详细解释见：There are Tree ways...）：



  • 增量解析及生成（流模式）。高性能，低开销的顺序访问。这是最低级的处理方法，相当于用于处理XML的SAX和StAX API。所有包装内部必须有这样的分析器，但并非所有都公开。 
  • 基于树的数据模式（JSON DOM）。 树是一种描述JSON内容的自然的概念模型，因此许多软件包提供将JSON作为逻辑树处理的功能。这是一个灵活的模式，可很好适用某类任务，原型处理或即席访问也相当杰出。 
  • 数据绑定(JSON 与POJO相互转换。极为方便，通常较树状模式更高的存取效率，也是适于Java开发人员通用的自然的数据绑定方式。常用于大多数Java REST框架，诸如JAX-RS。

尽管多角度的好处显而易见，且各自提供最佳的用例，很少有（如果有的话？）其他的Java JSON包提供这些规范的处理模式。
大多数只提供一个模式（org.json以树组织数据； Gson实现了数据绑定）。 Jackson提供所有模式，所有模式完全支持，且最棒的是，它很容易在两种模式之间转换，混合和适配。 例如，处理非常大的JSON流时，通常始于流解析，而使用数据绑定器将子数据段绑定到Java对象：这允许处理巨大的文件而没有过多的内存占用，但却提供完整便利的数据绑定能力。
2. 可使用任何构造及工厂方法（不只是默的零参方法）
大多数数据（对JSON和XML）绑定工具需要一个定义和无参数的构造函数，实例化Java对象，并通过setter设置属性或直接访问字段。 不幸的是它使人们难以利用用“不可变对象”模式，也不同于正常代码中的访问模式。
Jackson thinks that developers deserve ability to specify whatever constructor or factory methods they want for instantiation; just annotate thing you want like so:Jacson认为，开发者应该能够指定他们想为实例化的任何工厂或构造方法，只要你喜欢，注释即可：

  1. public class MyBean {
  2.   private final int value;
  3.   @JsonCreator
  4.   public MyBean(@JsonProperty("value") int v) {
  5.     this.value = v;
  6.   }
  7.   public int getValue() { return value; }
  8. }
复制代码


而你可以这样定义POJO，JSON处理的情况下也无妨。（Jackson处理不可变对象的信息，可见： 博客条目 ）
3. 不仅是注解，可以混合式注解！
虽然有很多好处，利用Java注解定义元数据(如类型安全、编译时检查，消除单独的XML配置，DTY原则等），但也有缺点：如明显的是，添加注解须能修改类。 而你通常不能（也不应该）修改第三方库的代码，至少不只是JSON序列化配置方面。
但是，如果你只可以松散动态关联注释，而不是嵌入在代码中？我认为这是个了不起的想法，不管你对Jackson的混合式注解了解多少：您可以将注释与目标类关联（声明为代理接口或类的一部分）目标类的处理方式如同目标类本身声明的注解一样。
要了解更多信息，请阅读“使用混合式注解实现重用、解耦 ”。
4. 完全支持泛型类型
现在，泛型是Java开发的完整组成部分，然而，并非所有的JSON库支持泛型，甚至在处理非常复杂的数据类型时会出错。
以下列泛型为例：

  1. public class Wrapper&lt;T&gt; {
  2. public T value;
  3. }
  4. public class ListWrapper&lt;E&gt; extends Wrapper&lt;List&lt;E&gt;&gt; { }
复制代码


若需反序列化这些类型的数据，代码如下：

  1. ListWrapper&lt;Integer&gt; w = objectMapper.readValue("[{\"value\":13},{\"value\":7}]",
  2. new TypeReference&lt;ListWrapper&lt;Integer&gt;&gt;() { } );
复制代码


Jackson在弄清必要的东西及生成期望的值方面有点小麻烦，但却是支持泛型（或更多）的仅有的Java包。
5. 多态类型
下面是另一个factoid：继承和多态类型可用于面向对象开发的很好方法，但也是任意实现数据绑定功能的系统的PITA。
ORM（如Hibernate）大部分的复杂性是由于沿继承层次结构扁平化和非扁平化数据功能的需要，同样适用于像JAXB的数据序列化包。这也就难怪，当时，只有极少数的Java包支持多态类型的JSON反序列化，大多数需要用户建立应用代码显式进行类型解析。
  Jackson怎么样？ Jackson 不仅支持自动序列化和反序列化动态和多态类型，它试图尽力把它做好。具体来说，没有必要公开Java类名（这是其它JSON包支持多态的唯一机制）作为类型信息 - 尽管，人们可以，它是可配置 - 但可以使用逻辑类型名称（通过注解，或注册实现配置）。不管采用什么类型的标识符，包含的方法也可以配置（这很好，因为极大地简化了JSON格式）。所有这一切都与合理的缺省功能，具有上下文适用性（这意味着你也可以定义不同类型的设置！）。
关于Jackson如何处理多态，详见： "Jackson 1.5: 多态类型处理"。
6. 物化接口 (even less monkey code to write!)
尽管支持多态类型是强大的功能 -- 但却存在固有的充足的复杂性 -- 这里是简化事情的方式：物化接口（或抽象类）。.
给定接口如下：

  1. public interface Bean {
  2.   public int getX(); 
  3.   public void setX(int value);
  4. }
复制代码


你可能想跳过这一步“Bean接口实现，包含两倍代码的类”，而直接处理：
Bean bean = objectMapper.readValue(json, Bean.class);
（不收你200元...呃，书写10行代码的猴子 - 注意，那就是，我们可以省略接口中的'setX（）;Bean先生很聪明，知道一些方法需要注入值）。
只有一行配置，便可实现这神奇的功能（又称“Bean先生”）。更多关于物化接口的信息参见“ 物化接口信息“。
.我还没有找到一个愿写这些接口实现的编码人员，因此，如果寻找Jackson的单一功能亮点，那就是它了。
7. 支持父/子引用（一对多，ORM）
   经过前面的通用功能集，我们总结的东西更为具体：能够干净地处理循环类型的某些子集，成为父/子链接。 这些都是互相紧密耦合的引用，其中两个对象以层次结构的方式交叉引用，如父/子树节点的关联， 或更常见的，ORM采用的表间连接（join）的描述。
对引用问题（或更普遍的，循环引用），JSON没有处理它们的自然方法。，不像Java对象，没有标识信息可用。
常用的解决方法是只标记一个被忽略的引用（Jackson可通过使用@ JsonIgnore注解实现），但其缺点是反序列化时会丢失实际的耦合目标。
Jackson 有简单的基于注解的解决该问题的方案：两个引用需要一个注解（对“子”连接作@JsonManagedReference注解，对“父”或“返回”连接作@JsonBackReference注解），并在此基础，Jackson知道要省略反向引用的序列化，但反序列化对象时要恢复它。此方式适用于典型的ORM用例。
8. 这是全部吗，有何异议？
  实际上，Jackson的一些特性并未包含在本文中，若如此，请指正！
原文链接：http://www.cowtowncoder.com/blog/archives/2010/11/entry_434.html
六、常用功能介绍 

关于对象转json和json就不在这解介绍了，一下主要介绍常用的特殊功能，（具体你可以看一下封装的jacksons的类的方法 在下面打包）

1.使用Jackson时转换JSON时，日期格式设置：

使用Jackson转化JSON对象的时候出现： 显示的时候，日期始终显示不正确，输出的日期是一串数字代表的时间戳，不符合要求，所以想到Jackson应当有方法设置输出的日期格式。后来一查果然有两种方式来实现

①普通的方式：

默认是转成timestamps形式的，通过下面方式可以取消timestamps。
objectMapper.configure(Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT,false);
这样将使时间生成使用所谓的使用 [ISO-8601 ]-compliant notation, 输出类似如下格式的时间: "1970-01-01T00:00:00.000+0000".

当然也可以自定义输出格式：

  1. /** 格式化时间的string */
  2. private static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  3. mapper.setDateFormat(new SimpleDateFormat(DATE_TIME_FORMAT));
复制代码


② annotaion的注释方式：

可以支持序列号（@JsonSerialize(using=CustomDateSerializer.class)）

和反序列化（@JsonDeserialize(using=CustomDateDeserializer.class)）
先定义自己需要的格式，例如：

 

  1. /**
  2. * java日期对象经过Jackson库转换成JSON日期格式化自定义类
  3. * &lt;pre&gt;
  4. * @JsonSerialize(using = CustomDateSerializer.class)
  5. * public Date getTime() {
  6. *   this.time = time;
  7. * }
  8. * &lt;/pre&gt;
  9. * 
  10. * @author zxh
  11. * @date 2012-7-25 下午11:36:33
  12. */
  13. public class CustomDateSerializer extends JsonSerializer&lt;Date&gt; {
  14. @Override
  15. public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)
  16.      throws  IOException,JsonProcessingException {
  17.    jgen.writeString(DateFormatUtils.format(value, "yyyy-MM-dd"));
  18.   }
  19. }
复制代码

 

然后在你的POJO上找到日期的属性上加上：

 

  1. @JsonSerialize(using=CustomDateSerializer.class)
  2. protected java.util.Date updatetime;
复制代码

 

2.annotation(注解)、属性的过滤

① @JsonAutoDetect (class)这是作用于类的annotation，主要用于指明该类使用annotation，并且可以自动侦测getter，setter，构造方法，以便生成json对象

② @JsonIgnore (method/field):作用于方法或字段，用来表明，当生成json的时候忽略有该annotation的方法或字段

③ @JsonIgnoreProperties (value = { "hibernateLazyInitializer" ,  "password" }) ，主要用于过滤掉一些不需要的属性

参考（http://hi.baidu.com/suofang/blog/item/c4f3a351d83a9faf8d543069.html）

3.设置循环策略 ：解决json最头疼的问题死循环    

能够干净地处理循环类型的某些子集，成为父/子链接。 这些都是互相紧密耦合的引用，其中两个对象以层次结构的方式交叉引用，如父/子树节点的关联，或更常见的，ORM采用的表间连接（join）的描述。

对引用问题（或更普遍的，循环引用），JSON没有处理它们的自然方法。，不像Java对象，没有标识信息可用。
  常用的解决方法是只标记一个被忽略的引用（Jackson可通过使用@ JsonIgnore注解实现），但其缺点是反序列化时会丢失实际的耦合目标。

Jackson 有简单的基于注解的解决该问题的方案：两个引用需要一个注解（对“子”连接作@JsonManagedReference 注解，对“父”或“返回”连接作@JsonBackReference注解），并在此基础，Jackson知道要省略反向引用的序列化，但反序列化对象时要恢复它。此方式适用于典型的ORM用例。

1.父子关系引用

直接输出肯定是报循环错误，Jackson 提供了两个注解

  1. @JsonManagedReference
  2. public Set&lt;Article&gt; getArticles() {
  3.   return articles;
  4. }
复制代码

 

  1. @JsonIgnore
  2. public Set&lt;Article&gt; getArticles() {
  3.   return articles;
  4. }
复制代码

 

打印结果为:

 

{"name":"chris","createDate":"2012-04-18"}

 

{"title":"title","user":{"name":"chris","createDate":"2012-04-18"}}

 

单向Article 加该注解

 

    1. @JsonIgnore
  • public User getUser() {
  •   return user;
  • }
复制代码

 

打印结果:

 

{"name":"chris","createDate":"2012-04-18","articles":[{"title":"title"}]}

 

{"title":"title"}


4.解决:hibernate延时加载设置

因为jsonplugin用的是java的内审机制.hibernate会给被管理的pojo加入一个 hibernateLazyInitializer属性,jsonplugin会把hibernateLazyInitializer也拿出来操作,并读取里面一个不能被反射操作的属性就产生了这个异常.   

不过我用的是jackson来转json，所以想到了用annotation来排除hibernateLazyInitializer 这个属性
在你的pojo类声明加上：

 

    1. @JsonIgnoreProperties (value = { "hibernateLazyInitializer"})
  • public
  • class Department extends BaseModel {}
复制代码

 

5.设置字段的过滤

 

参考（http://www.iteye.com/topic/1122855）

 

①@JsonIgnoreProperties

 

这个加在类级别上, 用法很简单@JsonIgnoreProperties({"property1", "property2"})

 

动态过滤属性，这个比较麻烦。

 

有两种方法。

 

1.使用@JsonFilter注解

 

   使用方法为先给ObjectMapper添加一个filter，然后还要在需要过滤的类上加@JsonFilter("filterName")
注解。

 

  比如说要过滤User 上的name属性，先

 

Jacksons.json().filter("myFilter", "name").readAsString(user)，具体看Jacksons代码。并在User类上加@JsonFilter("myFilter")。

 

有点不爽的是如果用另外一个没有添加该filter的ObjectMapper解析的话会报错。

 

  如果这个User类已经添加了@JsonFilter("myFilter")注解，但在另外一个地方又要解析它并不想过滤name 属性，那只能是

 

Jacksons.me().filter("myFilter", "")，然后在读出来。

 

2.添加混入注解(暂时这么翻译)

 

  定义一个接口或类先, 在该类上添加@JsonIgnoreProperties("name"), 然后在ObjectMapper的配置项上添加混入注解

 

输出为:

 

  1. String mixInUser = Jacksons.json().addMixInAnnotations(User.class, MixInUser.class).readAsString(user);
  2. System.out.println(mixInUser);
复制代码

 

 

 

七、附录
1.性能测试
使用

json-test.rar

测试的结果： 

 

 

2012-7-26 11:55:18 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[jackson（重用ObjectMapper）]
avg: 6.31 ms
total: 631.43 ms
tps: 158.37
running: 100 times
in 10 Threads

 

2012-7-26 11:55:18 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [jackson（重用ObjectMapper）]
3,133.712 Kb

 

2012-7-26 11:55:19 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[fastJson]
avg: 4.68 ms
total: 467.97 ms
tps: 213.69
running: 100 times
in 10 Threads

 

2012-7-26 11:55:19 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [fastJson]
1,195.920 Kb

 

2012-7-26 11:55:21 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[Gson]
avg: 13.47 ms
total: 1,347.07 ms
tps: 74.24
running: 100 times
in 10 Threads

 

2012-7-26 11:55:21 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [Gson]
2,077.808 Kb

 

2012-7-26 11:55:24 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[FlexJson]
avg: 17.67 ms
total: 1,766.68 ms
tps: 56.60
running: 100 times
in 10 Threads

 

2012-7-26 11:55:24 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [FlexJson]
1,529.720 Kb

 

2012-7-26 11:55:31 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[json-lib]
avg: 43.12 ms
total: 4,311.97 ms
tps: 23.19
running: 100 times
in 10 Threads

 

2012-7-26 11:55:31 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [json-lib]
3,098.696 Kb

 

2012-7-26 11:55:31 com.alisoft.nano.bench.listener.SimpleMeasure outputMeasureInfo

 

信息:

 

[StringBuffer]
avg: 4.21 ms
total: 420.93 ms
tps: 237.57
running: 100 times
in 10 Threads

 

2012-7-26 11:55:31 com.alisoft.nano.bench.listener.MemoryUsage outputMeasureInfo

 

信息:

 

memory-usage: [StringBuffer]
1,337.712 Kb

 

 

网上测试：http://www.iteye.com/topic/561368
2.测试用例
对jackson的相关测试 

  1. @Test
  2. public void testJackson()
  3. {
  4. List&lt;Department&gt; departmentList = departmentDao.getAll(); 
  5.    String json = Jacksons.json().setDateFormate()
  6.            //.filter("myfilter", new String []{"demension" })
  7.           .fromObjectToJson(departmentList);
  8.       System.out.println(json);
  9.      List&lt;Department&gt; list = Jacksons.json().fromJsonToObject(json, List.class);
  10.     System.out.println(list);
  11. }
复制代码

 

测试结果:
[{"version":null,"orgId":null,"orgPath":null,"depId":10000,"depName":"技术部","depDesc":null,"depLevel":2,"parentId":1,"path":"0.1.10000.","orgType":1,"creatorId":1,"createtime":"2012-07-18 10:37:56","updateId":1,"updatetime":"2012-07-18","sn":null,"chargeIds":"10020","chargeNames":"超级管理员","demension":{"version":null,"orgId":null,"orgPath":null,"demId":1,"demName":"行政维度","demDesc":"行政维度","demType":1,"organizations":[]}},{"version":null,"orgId":null,"orgPath":null,"depId":10002,"depName":"技术2部","depDesc":"技术2部","depLevel":3,"parentId":10000,"path":"0.1.10000.10002.","orgType":2,"creatorId":1,"createtime":"2012-07-18 10:38:47","updateId":1,"updatetime":"2012-07-18","sn":null,"chargeIds":"","chargeNames":"","demension":{"version":null,"orgId":null,"orgPath":null,"demId":1,"demName":"行政维度","demDesc":"行政维度","demType":1,"organizations":[]}},{"version":null,"orgId":null,"orgPath":null,"depId":1,"depName":"宏天软件","depDesc":"宏天软件","depLevel":1,"parentId":0,"path":"0.1.","orgType":1,"creatorId":1,"createtime":"2011-08-29 00:00:00","updateId":1,"updatetime":"2011-08-29","sn":null,"chargeIds":"","chargeNames":"","demension":{"version":null,"orgId":null,"orgPath":null,"demId":1,"demName":"行政维度","demDesc":"行政维度","demType":1,"organizations":[]}},{"version":null,"orgId":null,"orgPath":null,"depId":10001,"depName":"技术1部","depDesc":"技术1部","depLevel":3,"parentId":10000,"path":"0.1.10000.10001.","orgType":2,"creatorId":1,"createtime":"2012-07-18 10:38:15","updateId":1,"updatetime":"2012-07-18","sn":null,"chargeIds":"","chargeNames":"","demension":{"version":null,"orgId":null,"orgPath":null,"demId":1,"demName":"行政维度","demDesc":"行政维度","demType":1,"organizations":[]}}]

 

     [{version=null, orgId=null, orgPath=null, depId=10000, depName=技术部, depDesc=null, depLevel=2, parentId=1, path=0.1.10000., orgType=1, creatorId=1, createtime=2012-07-18 10:37:56, updateId=1, updatetime=2012-07-18, sn=null, chargeIds=10020, chargeNames=超级管理员, demension={version=null, orgId=null, orgPath=null, demId=1, demName=行政维度, demDesc=行政维度, demType=1, organizations=[]}}, {version=null, orgId=null, orgPath=null, depId=10002, depName=技术2部, depDesc=技术2部, depLevel=3, parentId=10000, path=0.1.10000.10002., orgType=2, creatorId=1, createtime=2012-07-18 10:38:47, updateId=1, updatetime=2012-07-18, sn=null, chargeIds=, chargeNames=, demension={version=null, orgId=null, orgPath=null, demId=1, demName=行政维度, demDesc=行政维度, demType=1, organizations=[]}}, {version=null, orgId=null, orgPath=null, depId=1, depName=宏天软件, depDesc=宏天软件, depLevel=1, parentId=0, path=0.1., orgType=1, creatorId=1, createtime=2011-08-29 00:00:00, updateId=1, updatetime=2011-08-29, sn=null, chargeIds=, chargeNames=, demension={version=null, orgId=null, orgPath=null, demId=1, demName=行政维度, demDesc=行政维度, demType=1, organizations=[]}}, {version=null, orgId=null, orgPath=null, depId=10001, depName=技术1部, depDesc=技术1部, depLevel=3, parentId=10000, path=0.1.10000.10001., orgType=2, creatorId=1, createtime=2012-07-18 10:38:15, updateId=1, updatetime=2012-07-18, sn=null, chargeIds=, chargeNames=, demension={version=null, orgId=null, orgPath=null, demId=1, demName=行政维度, demDesc=行政维度, demType=1, organizations=[]}}]

 

相关标签： json jackson 死循环

上一篇： SpringCloud模拟微服务3-高可用Eureka

下一篇： (转)关于在中显示文本的自动截断

推荐阅读