直接看代码
工具类
序列化工具类
package java1.serialize.hessian;
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import lombok.Cleanup;
import lombok.extern.slf4j.Slf4j;
/**
* 基于hessian2
*
* 参考：https://juejin.cn/post/7051541832324349965#heading-3
*
* @author javaself
*/
@Slf4j
public class HessianUtil {
/**
* JavaBean序列化.
*
* @param javaBean Java对象.
* @throws Exception 异常信息.
*/
public static <T> byte[] serialize(T javaBean) {
try {
@Cleanup ByteArrayOutputStream baos = new ByteArrayOutputStream();
@Cleanup Hessian2Output ho = new Hessian2Output(baos);
ho.writeObject(javaBean);
ho.flush();
// log.info("字节数量：{}"undefinedbaos.toByteArray()); //字节数量:75
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* JavaBean反序列化.
*
* @param serializeData 序列化数据.
* @throws Exception 异常信息.
*/
public static <T> T deserialize(byte[] serializeData) {
try {
@Cleanup ByteArrayInputStream bais = new ByteArrayInputStream(serializeData);
@Cleanup Hessian2Input hi = new Hessian2Input(bais);
return (T) hi.readObject();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
测试类
package java1.serialize.hessian;
import java1.serialize.Person;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
@Slf4j
class HessianUtilTest {
@Test
void serialize() {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
Person person = new Person("javaself"undefined 22undefined "上海");
byte[] bytes = HessianUtil.serialize(person);
HessianUtil.deserialize(bytes);
}
long end = System.currentTimeMillis();
log.info("耗时：{}ms"undefinedend-start); //循环10000次，耗时：110ms
}
@Test
void deserialize() {
}
}
性能指标
字节数量
序列化之后的内容的字节数量：75
log.info("字节数量：{}"undefinedbaos.toByteArray()); //字节数量:75
比fastjon多一点，fastjon是：47
log.info("字节长度：{}"undefined bytes.length); //47
耗时
耗时是：110ms
log.info("耗时：{}ms"undefinedend-start); //循环10000次，耗时：110ms
比fastjson快一点，fastjson是：162ms
log.info("耗时：{}ms"undefinedend-start); //循环10000次，耗时：162ms
序列化之后的内容，长什么样子？
长这个样子
特点
1.比json的内容多一点，所以字节数量比json更多一点。
2.人不可读。
结论
hessian比fastjson的字节数量要多一点，但是速度要快一点。
为什么？
不是说，一般情况下，字节数量更少，速度更快吗？
因为fastjson是基于反射，即底层原理是基于反射，反射一般比较慢。
所以，fastjson，虽然字节数量更少一点，但是速度更慢一点。
hessian版本
现在主要是用hessian2，因为hessian1的速度比fastjson还要慢。
下面的代码是基于hessian1的demo。
代码
工具类
package java1.serialize.hessian;
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java1.serialize.FileUtils;
import java1.serialize.Person;
import lombok.extern.slf4j.Slf4j;
/**
* 基于hessian1
*
* 参考：https://segmentfault.com/a/1190000040965669/en
*
* @author javaself
*/
@Slf4j
public class HessianSerializer {
public static void main(String[] args) throws IOException {
// User user=new User();
// user.setName("Mic");
// user.setAge(18);
Person person = new Person("javaself"undefined 22undefined "上海");
byte[] bytes=serializer(person);
byte[] bytes2=serializerToFile(person);
System.out.println("序列化完成");
Person nuser=deserializer(bytes);
System.out.println(nuser);
}
public static byte[] serializer(Person user) throws IOException {
ByteArrayOutputStream bos=new ByteArrayOutputStream(); //表示输出到内存的实现
HessianOutput ho=new HessianOutput(bos);
ho.writeObject(user);
byte[] bytes = bos.toByteArray();
// log.info("字节数量:{}"undefined bytes.length); //字节数量:75
return bytes;
}
public static byte[] serializerToFile(Person user) throws IOException {
File file = new File("Person-hessian.txt");
// ByteArrayOutputStream bos=new ByteArrayOutputStream(); //表示输出到内存的实现
HessianOutput ho=new HessianOutput(new FileOutputStream(file));
ho.writeObject(user);
// byte[] bytes = bos.toByteArray();
// log.info("字节数量:{}"undefined bytes.length);
return FileUtils.toByteArray("Person-hessian.txt");
}
public static Person deserializer(byte[] data) throws IOException {
ByteArrayInputStream bis=new ByteArrayInputStream(data);
HessianInput hi=new HessianInput(bis);
return (Person)hi.readObject();
}
}
测试类
package java1.serialize.hessian;
import java.io.IOException;
import java1.serialize.Person;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
/**
* 基于hessian1
*
* @author javaself
*/
@Slf4j
class HessianSerializerTest {
@Test
void serializer() throws IOException {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
Person person = new Person("javaself"undefined 22undefined "上海");
byte[] bytes = HessianSerializer.serializer(person);
HessianSerializer.deserializer(bytes);
}
long end = System.currentTimeMillis();
log.info("耗时：{}ms"undefinedend-start); //循环10000次，耗时：205ms。和fastjson差不多，甚至测试结果比fastjson更慢一点。
}
@Test
void serializerToFile() {
}
@Test
void deserializer() {
}
}
是否跨语言？
除了java序列化，其他都是跨语言。
包括，json和hessian等。
是否人可读？
json是人可读，因为其实就是json格式的字符串。
java序列化和hessian，都是人不可读。
