同步操作将从 eric_1989/jfire-codejson 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
标签: 最高性能 Json
[TOC] ##框架优点 性能强劲 codejson是迄今为止最为强大的json框架.性能为fastjson的2.1倍,jackson2的1.8倍,gson的6.7倍。下图为基准测试数据
自由定制输出
codejson具备其他json框架常见的属性和改名功能外,还具备其他框架都不拥有的定制输出能力(截止20151224,还有一款框架btjson也具备定制输出的能力)。可以将同一个对象输出为完全不同的结果。比如在一个场景中将float定制输出为2个小数点,另外地方输出3个小数点;又比如一个地方忽略属性a,另外一个地方输出属性a等等。
极致简单的API
对于序列化来说,只需要使用类似JsonTool.write(entity)
一行静态代码即可得到json字符串。
对于反序列化来说,只需要使用类似JsonTool.read(User.class,str)
一行静态代码即可将json字符串反序列化为pojo对象
##快速入门
假设存在以下几个类
public class Person
{
@JsonIgnore//支持注解忽略属性功能
private String name;
@@JsonRename("a")//支持注解属性改名功能
private int age;
private boolean boy;
}
package link.jfire.test;
public class Home
{
privaet String name;
private Person host;
private float height;
private float weidth;
}
public static void main(String args[])
{
Home home = new Home();
home.setPerson(new Person());
//这样就完成了将home转换为json字符串的动作
String json = JsonTool.write(home);
//这样就完成了将json字符串转换为json对象的动作
JsonObject jsonObject =(JsonObject)jsonTool.fromString(json);
//这样就完成了将json字符串转换为java对象的动作
Home result = JsonTool.read(Home.class,json);
WriteStrategy strategy = new WriteStrategy();
//指定一个输出策略,将name这个属性名在输出的时候替换成hello
strategy.addRenameField("link.jfire.test.Home.name", "hello");
json = strategy.write(home);
strategy = new WriteStrategy();
//指定一个输出策略,将float输出的时候截止到小数点1位
//WriteAdapter是包装器模式,只是简单的覆盖了所有的JsonWriter接口方法。根据策略属性的类型不同,需要选择对应的策略方法进行覆盖改写
strategy.addWriter(float.class,new WriterAdapter(){
@override
public void write(float target,StringCache cache,Object entity){
DecimalFormat format = new DecimalFormat("##.00");
cache.append(format.format(target));
}
});
json = strategy.write(home);
}
##代码说明 代码托管于osc:地址 maven 依赖
<dependency>
<groupId>link.jfire</groupId>
<artifactId>codejson </artifactId>
<version>1.1</version>
</dependency>
##API说明
###常规序列化
对于普通的序列化要求,只需要使用JsonTool.write(entity)
的代码就可以将一个对象序列化为json字符串。
###常规反序列化 对于普通的反序列化要求。
JsonTool.fromString(str)
的代码就可以将json字符串反序列化为json对象可能是jsonObject也可能是jsonArrayJsonTool.read(User.class,str)
的代码就可以将json字符串反序列化为pojo对象。###改名和忽略
对于全局的属性改名和属性忽略需求来说,可以使用注解来完成。改名使用@JsonRename
,忽略使用@JsonIgnore
。如果是在序列化的时候,可以将注解放在get方法上,如果在反序列化的时候,可以将注解放在set方法上。如果放在属性上,则表示序列化和反序列化的时候都会生效。
###策略定制 对于注解来说,改名和忽略都是全局的,也就是说在任何地方的输出都是相同的。但是如果希望不同的场景下忽略不同的字段,则依靠注解是无法完成的。 这种时候就需要依靠codejson自身强大的策略能力来完成了。使用策略的步骤如下
WriteStrategy strategy = new WriteStrategy()
;strategy.addIgnoreField("link.jfire.test.User.age")
.这里的格式是类的全限定名.属性名
strategy.write(entity)
就可以使用策略来来针对这个对象进行输出。在使用过程中策略strategy
相当于一个上下文,包含了所有信息。所以这个对象构建一次就可以到处使用。并且该对象是线程安全的。下面来说下策略的具体添加方式
添加忽略属性策略
使用代码类似strategy.addIgnore("link.jfire.test.User.age")
,参数为类全限定名.属性名
的形式
添加属性改名策略
使用代码类似strategy.addRenameField("link.jfire.test.User.age", "AGE")
,参数1为类全限定名.属性名
的形式用来定位,参数2是改名后的名称。
添加针对类型的策略
比如所有的double都只输出小数点后两位这样的需求。针对类型有特殊需求的。可以使用如下的代码
WriteStrategy strategy = new WriteStrategy();
// 这样对所有的double输出都格式化
//WriteAdapter是适配器模式。包装了9个方法。8个应对基础类型的输出,1个用来应该应对剩余类型。
strategy.addTypeStrategy(double.class, new WriterAdapter() {
//field是要输出的属性,cache是输出中的内容存储,entity是持有这个属性的类对象实例
public void write(double field, StringCache cache,Object entity)
{
DecimalFormat format = new DecimalFormat("##.00");
cache.append(format.format(field));
}
});
//a是float,b是double类型。可以看到double的输出被约束为小数点后2位
String except = "{\"a\":2.2365,\"b\":15.69,\"percent\":\"88.81%\"}";
assertEquals(except, strategy.write(new BaseData()));
添加针对某一个属性的策略
WriteStrategy strategy = new WriteStrategy();
// 第一个参数是属性的位置,格式为类全限定名.属性名
//第二个为一个匿名类,用来表达用户的策略要求
strategy.addFieldStrategy("link.jfire.test.User.address", new WriterAdapter() {
public void write(Object field, StringCache cache,Object entity)
{
User user = (User)field;
//只输出地址的前三个字符
cache.append(user.getAddress().subString(0,3)).append("...");
}
});
//输出为{"name":"test","address":"仓山区..."}。可以看到,特定属性的输出已经被修改
strategy.write(new User());
##性能分析
Jfire-codejson性能如此之强原因在于采用了与众不同的算法。
序列化
传统的序列化框架,或者说相对比较优秀的序列化框架大部分都采用了分析对象内容,而后通过反射调用方法或者反射取出属性值的方式将对象进行序列化。这种思想产生的框架最大的瓶颈在反射导致的性能消耗。Jfire-codejson独特的使用了为序列化对象动态编译一个输出对象,输出对象中全部是调用序列化对象的get方法来得到属性值。并且在拼接json中的key名称时,由于动态编译代码,所以编译代码中是事先知道并且写入的,这样又减少了获取对象属性名称的这一步骤。使得Jfire-codejson的序列化能力逼近理论上限(为每个对象编写代码的这种理论方式)
反序列化
反序列化首先是解析json字符串。在这一步,框架设计了一种无回退的单次字符读取方式。大致原理是依次读取每一个字符,如果遇到一些特殊的表示字符,比如{
,}
,:
,[
,]
等等。在遇到这些字符的时候生成jsonObject或者jsonArray来进行相应的读取处理。使用两个堆栈,一个堆栈存储jsonKey,一个堆栈存储当前待处理的json对象(jsonObject或者jsonArray)。这样子在处理的过程中就可以达到顺序处理的效果。解析的速度非常快,可以达到数倍于fastjson的性能。
将一个json对象反序列化成pojo,原理上和序列化大致相同。通过将对象的所有set方法得到。动态编译一个设置类,该类中对于每一个set方法,都生成类似if(jsonObject.containsKey("name")){entity.setName(jsonObject.getString("name"))}
这样的代码。由于是动态编译,所以事先知道需要进行哪些判断,而且判断完之后是原生代码的set操作,节省了判断时间和调用反射时间,故而反序列化的性能也是非常的优秀。几倍于fastjson。
###序列化 如果要将一个对象序列化,最快的方式无疑是针对这个对象,写出一段特定的代码。代码当中通过调用对象的get方法来得到对象属性值。参考下面的代码
public class User
{
private String name;
private int age;
}
//针对上面的类,最快的序列化json的代码应该是
public static void main(String args[])
{
User user = new User();
StringBuilder str = new StringBuilder();
str.append("{");
str.append("\"name\":");//无需放入变量值,采用固定值节省了变量获取的时间还有利于jvm优化
str.append("\"").append(user.getName()).append("\",");
str.append("\"age\":").append(user.getAge());
str.append("}");
}
在上面的示例代码中,没有反射,没有任何分析。针对对象给出特定的序列化代码。如果说我们的框架也能够模拟这样的方式,就可以达到最大化的序列速度。并且可以逼近理论的上限。为了达到这样的效果,采用了动态代码编译的方式来完成。
builder.append("name").append(":\"").append(entity.getName()).append("\",")
代码。builder.append("anotherObject").append(":");WriteContext.write(entity.getAnotherObject(),builder)
的代码,形成嵌套的分析过程。当嵌套结束时这个对象也就彻底分析完毕.通过上面这样的步骤,框架针对每一个对象,都能生成一个针对该该对象的特定输出类,这个输出类为原生代码编译,获取对象内容以及属性名称都是原生代码调用,性能非常高。
当然,动态代码生成中有很多需要判断的地方。比如如果是对象的情况下,要在字符串中添加{}
。比如字符串需要使用"
包围内容,而数字和布尔值不需要,比如遇到数组需要[]
等等。但是大体的思想就是通过动态代码编译,在运行的时候针对一个特定的对象,生成针对该对象的输出类。并且对这个类进行编译生成Class文件。动态编译这个部分采用Javassist来完成。
生成的代码例子如下
序列化一个如下对象
public class com.jfire.codejson.Home
{
private String name = "home";
private int length = 113;
private int wdith = 89;
//省略get set方法
}
框架针对这个对象生成的动态类的内容是
public class JsonWriter_Home_231313131
{
StringCache cache = (StringCache)$2;
com.jfire.codejson.Home entity =(com.jfire.codejson.Home )$1;
cache.append('{');
cache.append("\"length\":").append(entity.getLength()).append(',');
String name = entity.getName();
if(name!=null)
{
cache.append("\"name\":\"").append(name).append("\",");
}
cache.append("\"wdith\":").append(entity.getWdith()).append(',');
if(cache.isCommaLast())
{
cache.deleteLast();
}
cache.append('}');
}
序列化的算法思路流程如下
###反序列化 ####解析json字符串 因为json是一个kv结构。所以算法设计了两个堆栈结构。堆栈结构,在数据顺序上和算法要求的一遍读取无回溯是相吻合的。
解析json字符串的算法的思路大致可以描述为
{
,}
,:
,[
,]
,,
,'"'等进行特别处理,记录发现位置,根据发现位置决定是否创建新的jsonObject或者jsonArray进行嵌套等。下面是解析过程的详细流程图
####反序列化 将一个json对象反序列化成Pojo,和序列化的流程相似。算法的大致思路如下
EntityClass entity = new EntityClass();
。使用pojo的类创建一个Pojo对象供后面使用if(json.containsKey("name")){entity.setName(json.getString("name"))}
的代码。其中name
就是根据set方法计算出来的属性名。if(json.containsKey("anotherObject")){entity.setAnotherObject(readContext.read(AnotherObject.class,json.getString("name")))}
的代码。其中readContext就是一个保存pojo和转换类映射关系的Map容器。经过以上的四个步骤,就完成了一个输出类的代码生成。使用这个输出类对特定的对象进行反序列化就可以达到非常高的性能。
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。