我要评论在编写web项目的场景下：
序列化：服务器端处理完业务逻辑后，需要将数据（如对象）转换为客户端能够理解的格式（通常是json），这个过程就是序列化。序列化后的数据可以通过http响应发送给客户端。
反序列化：客户端接收到服务器的响应后，需要将这些数据（通常是json或xml格式的字符串）转换回客户端程序能够处理的对象，这个过程就是反序列化。
使用案例
所有的序列化和反序列化都是基于objectmapper的，序列化调用writevalue方法（如果是json数据，使用writevalueasstring），反序列化调用readvalue
编写测试类
@springboottest
public class jacksontest {
@test
void jacksontest() {
//定义objectmapper(所有的序列化和反序列化都是基于objectmapper)
objectmapper objectmapper = new objectmapper();
commonresult<string> result = commonresult.error(500, "系统错误");
string str;
//序列化,把对象序列化成string
//其实就是把对象转成json字符串
try {
str = objectmapper.writevalueasstring(result);
system.out.println(str);
} catch (jsonprocessingexception e) {
throw new runtimeexception(e);
}
//反序列化(就是把json字符串转换成对象)
commonresult<string> commonresult = null;//参数2:要转换成的对象
try {
commonresult = objectmapper.readvalue(str,
commonresult.class);
} catch (jsonprocessingexception e) {
throw new runtimeexception(e);
}
system.out.println(commonresult.getcode() + "," + commonresult.getmsg());
//list序列化
//定义list对象
list<commonresult<string>> commonresults = arrays.aslist(commonresult.success("success1"),
commonresult.success("success2"));
try {
str = objectmapper.writevalueasstring(commonresults);
} catch (jsonprocessingexception e) {
throw new runtimeexception(e);
}
//list反序列化
javatype javatype = objectmapper.
gettypefactory().//获取类型工厂
constructparametrictype(list.class, commonresult.class);//构造list的类型,list<commonresult<string>>
try {
commonresults = objectmapper.readvalue(str, javatype);
for (commonresult<string> results : commonresults) {
system.out.println(results.getdata());
}
} catch (jsonprocessingexception e) {
throw new runtimeexception(e);
}
}
}
自定义序列化工具
在使用案例中，我们发现在代码中出现了很多try catch，这样显得代码很不雅观，我们可以借鉴springboot的方法，具体的操作看代码
public class jacksonutil {
private jacksonutil() {
}
//对objectmapper进行单例化操作
private final static objectmapper object_mapper;
static {
//初始化object_mapper
object_mapper = new objectmapper();
}
//get方法
private static objectmapper getobjectmapper() {
return object_mapper;
}
private static <t> t tryparse(callable<t> parser) {
return tryparse(parser, jacksonexception.class);
}
//借鉴springboot统一异常
//callable<t> parser,这个参数,支持我们使用lambda表达式进行处理
private static <t> t tryparse(callable<t> parser, class<? extends exception> check) {
try {
return parser.call();
} catch (exception var4) {
exception ex = var4;
if (check.isassignablefrom(ex.getclass())) {
throw new jsonparseexception(ex);
}
throw new illegalstateexception(ex);
}
}
/**
* 序列化方法
*
* @param o
* @return
*/
public static string writevalueasstring(object o) {
return jacksonutil.tryparse(() -> {
//执行序列化的操作
//如果此处出现异常,直接会在tryparse这里捕获
return jacksonutil.getobjectmapper().writevalueasstring(o);
});
}
/**
* 反序列化object方法
*
* @param content
* @param valuetype
* @param <t>
* @return
*/
public static <t> t readvalue(string content, class<t> valuetype) {
return jacksonutil.tryparse(() -> {
return jacksonutil.getobjectmapper().readvalue(content, valuetype);
});
}
/**
* 反序列化list
*
* @param content
* @param paramclasses
* @param <t>
* @return
*/
public static <t> t readlistvalue(string content, class<?> paramclasses) {
//1.构造javatype
javatype javatype = jacksonutil.getobjectmapper().
gettypefactory().//获取类型工厂
constructparametrictype(list.class, paramclasses);//构造list的类型
//2.反序列化
return jacksonutil.tryparse(() -> {
return jacksonutil.getobjectmapper().readvalue(content, javatype);
});
}
}
到此这篇关于spring项目中如何自定义序列化工具的文章就介绍到这了,更多相关spring自定义序列化内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论