本篇文章主要介绍了java如何利用fastjson、gson、jackson三种json格式工具自定义时间序列化，具有一定的参考价值，有兴趣的可以了解一下
java处理json数据有三个比较流行的类库fastjson、gson和jackson。
jackson
jackson是由其社区进行维护，简单易用并且性能也相对高些。但是对于复杂的bean转换json，转换的格式鄙视标准的json格式。ps:jackson为spring mvc内置json解析工具
gson
gson是由谷歌公司研发的产品，目前是最全的json解析工具。完全可以将复杂的类型的json解析成bean或者bean到json的转换
fastjson
fastjson是一个java语言编写的高性能的json处理器,由阿里巴巴公司开发。fastjson采用独创的算法，将parse的速度提升到极致，超过所有json库。但是在对一些复杂类型的bean转换json上会出现一些问题，需要特殊处理。
1.遇到的问题
在java平台通过接口调用.net提供的服务的时候，在json序列化的时候，经常遇到时间格式的转换的不对的问题。
.net平台内置的json序列化使用的是system.runtime.serialization，序列化出来的时间是下面的这种格式
\/date(1296576000000+0800)\/
2.思路
为了能够调用.net平台提供的服务，那么在时间格式（date）序列化的时候，能够序列化成上面的格式。那么就拼时间字符串。
date now = new date();
string nowstr = string.format("\\/date(%s+0800)\\/", now.gettime());
3.代码
依赖jar包
compile group: 'com.google.code.gson', name: 'gson', version: '2.8.1'
compile group: 'com.alibaba', name: 'fastjson', version: '1.2.36'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.0'
自定义时间转化字符串代码
public class stringsmallutils {
/**
* 时间类型格式转换为指定的string类型
*
* @param date
* @return
*/
protected static string datetospecialstring(date date) {
if (date == null)
return null;
return string.format("\\/date(%s+0800)\\/", date.gettime());
}
/**
* 指定的string类型转换为时间类型格式
*
* @param str
* @return
*/
protected static date specialstringtodate(string str) {
if (isempty(str))
return null;
if (!contains(str,"date"))
return null;
str = str.replace("\\/date(", "").replace("+0800)\\/", "").trim();
return new date(long.parselong(str));
}
/**
* 判断字符串是否包含输入的字符串
*
* @param str
* @param searchstr
* @return
*/
public static boolean contains(string str, string searchstr) {
if (str == null || searchstr == null) {
return false;
}
return str.contains(searchstr);
}
/**
* 判断字符串是否为空
*
* @param str
* @return
*/
public static boolean isempty(string str) {
return ((str == null) || (str.trim().isempty()));
}
}
3.1 gson自定义实现date json字符串序列化
gson自定义json序列类只需要实现jsonserializer<t>接口，以及反序列化接口jsondeserializer<t>
public class gsoncustomerdatejsonserializer implements jsonserializer<date>, jsondeserializer<date> {
@override
public jsonelement serialize(date src, type typeofsrc, jsonserializationcontext context) {
return new jsonprimitive(stringsmallutils.datetospecialstring(src));
}
@override
public date deserialize(jsonelement json, type typeoft, jsondeserializationcontext context) throws jsonparseexception {
return stringsmallutils.specialstringtodate(json.getasstring());
}
}
测试
gson的自定义的序列化类是通过适配器模式进行注册到gson上的。
public class program {
public static void main(string[] args) throws jsonprocessingexception {
date start = new date();
gson gson = new gsonbuilder().registertypeadapter(date.class, new gsoncustomerdatejsonserializer()).create();
string gsonstr = gson.tojson(createuser());
date end = new date();
long interval = (end.gettime() - start.gettime());
system.out.println(string.format("gson序列化之后的字符串:%s，花费时间%d毫秒", gsonstr, interval));
}
private static user createuser() {
user user = new user();
user.setname("张三");
user.setage(21);
user.setlastlogintime(new date());
return user;
}
}
3.2 fasjson自定义实现date json字符串序列化
fastjson自定义序列化只需要实现objectserializer接口，以及反序列化接口objectdeserializer
public class fastjsoncustomerdatejsonserializer implements objectserializer, objectdeserializer {
@override
public void write(jsonserializer serializer, object object, object fieldname, type fieldtype, int features) throws ioexception {
serializewriter out = serializer.getwriter();
out.write(stringsmallutils.datetospecialstring((date) object));
}
@override
public <t> t deserialze(defaultjsonparser parser, type type, object fieldname) {
return (t) stringsmallutils.specialstringtodate(parser.getinput());
}
@override
public int getfastmatchtoken() {
return 0;
}
}
测试
fastjson自定义的序列化类是通过serializeconfig内部维护的serializersmap对象
public class program {
public static void main(string[] args) throws jsonprocessingexception {
date start1 = new date();
serializeconfig mapping = new serializeconfig();
mapping.put(date.class, new fastjsoncustomerdatejsonserializer());
string fastjsonstr = json.tojsonstring(createuser(), mapping);
date end1 = new date();
long interval1 = (end1.gettime() - start1.gettime());
system.out.println(string.format("fastjson序列化之后的字符串:%s，花费时间%d毫秒", fastjsonstr, interval1));
}
private static user createuser() {
user user = new user();
user.setname("张三");
user.setage(21);
user.setlastlogintime(new date());
return user;
}
}
3.3 jackson自定义实现date json字符串序列化
jackson自定义的序列化的类需要继承jsondeserializer<t>。由于java只能单向继承，所以jackson的自定义反序列化的类就需要再新建一个反序列化的类继承jsondeserializer<t>类
public class jacksoncustomerdatejsonserializer extends jsonserializer<date> {
@override
public void serialize(date value, jsongenerator gen, serializerprovider serializers) throws ioexception {
gen.writestring(stringsmallutils.datetospecialstring(value));
}
}
public class jacksoncustomerdatejsondeserializer extends jsondeserializer<date> {
@override
public date deserialize(jsonparser p, deserializationcontext ctxt) throws ioexception, jsonprocessingexception {
return stringsmallutils.specialstringtodate(p.gettext());
}
}
测试
jackson自定义的序列化类需要通过registermodule。也就是需要将新建的序列化类注册到simplemodule
public class program {
public static void main(string[] args) throws jsonprocessingexception {
date start2 = new date();
objectmapper mapper = new objectmapper();
simplemodule module = new simplemodule();
module.addserializer(date.class, new jacksoncustomerdatejsonserializer());
module.adddeserializer(date.class, new jacksoncustomerdatejsondeserializer());
mapper.registermodule(module);
string jacksonstr = mapper.writevalueasstring(createuser());
date end2 = new date();
long interval2 = (end2.gettime() - start2.gettime());
system.out.println(string.format("jackson序列化之后的字符串:%s，花费时间%d毫秒", jacksonstr, interval2));
}
private static user createuser() {
user user = new user();
user.setname("张三");
user.setage(21);
user.setlastlogintime(new date());
return user;
}
}
4.总结
上面三种最终运行的时间及结果如下：
gson序列化之后的字符串:{name:张三,age:21,lastlogintime:\\/date(1502366214027+0800)\\/}，花费时间77毫秒
fastjson序列化之后的字符串:{age:21,lastlogintime:\/date(1502366214100+0800)\/,name:张三}，花费时间99毫秒
jackson序列化之后的字符串:{name:张三,age:21,lastlogintime:\\/date(1502366214307+0800)\\/}，花费时间200毫秒
1.就代码实现方式上，gson与fastjson的实现方式优于jackson。面向接口编程。
2.就注册方式上，gson优于fastjson与jackson。使用了适配器模型
3.就运行效率上，gson与fastjson的效率优于jackson。gson相当于jackson的三倍，fastjson是jackson的二倍。
在实际项目，优先考虑使用gson与fastjson
以上就是java使用json格式工具（fastjson、gson、jackson三种）实现自定义时间序列化的实例的详细内容。