Skip to content

S
serialize-compare

thrunder liu / serialize-compare

通知 1
Star 0
Fork 0
S
serialize-compare

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 ffde5e8a 编写于 作者: L liu_lei
浏览文件
操作

提交测试成功工程

上级
隐藏空白更改
内联 并排
Showing with 739 addition and 0 deletion
pom.xml 0 → 100644
浏览文件 @ ffde5e8a
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.liulei.fly</groupId>
<artifactId>serializeCompare</artifactId>
<version>1.0-SNAPSHOT</version>
<name>serializeCompare</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.baidu/jprotobuf -->
<dependency>
<groupId>com.baidu</groupId>
<artifactId>jprotobuf</artifactId>
<version>2.2.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.esotericsoftware/kryo -->
<dependency>
<groupId>com.esotericsoftware</groupId>
<artifactId>kryo</artifactId>
<version>4.0.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.11</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.6.0</version>
</dependency>
</dependencies>
<build>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
<!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>3.7.1</version>
</plugin>
<plugin>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>3.0.0</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
src/instruction/result 0 → 100644
浏览文件 @ ffde5e8a
D:\java\jdk1.8\bin\java.exe "-javaagent:D:\InstallWorkTools\IntelliJ IDEA 2018.1.4\lib\idea_rt.jar=59748:D:\InstallWorkTools\IntelliJ IDEA 2018.1.4\bin" -Dfile.encoding=UTF-8 -classpath D:\java\jdk1.8\jre\lib\charsets.jar;D:\java\jdk1.8\jre\lib\deploy.jar;D:\java\jdk1.8\jre\lib\ext\access-bridge-64.jar;D:\java\jdk1.8\jre\lib\ext\cldrdata.jar;D:\java\jdk1.8\jre\lib\ext\dnsns.jar;D:\java\jdk1.8\jre\lib\ext\jaccess.jar;D:\java\jdk1.8\jre\lib\ext\jfxrt.jar;D:\java\jdk1.8\jre\lib\ext\localedata.jar;D:\java\jdk1.8\jre\lib\ext\nashorn.jar;D:\java\jdk1.8\jre\lib\ext\sunec.jar;D:\java\jdk1.8\jre\lib\ext\sunjce_provider.jar;D:\java\jdk1.8\jre\lib\ext\sunmscapi.jar;D:\java\jdk1.8\jre\lib\ext\sunpkcs11.jar;D:\java\jdk1.8\jre\lib\ext\zipfs.jar;D:\java\jdk1.8\jre\lib\javaws.jar;D:\java\jdk1.8\jre\lib\jce.jar;D:\java\jdk1.8\jre\lib\jfr.jar;D:\java\jdk1.8\jre\lib\jfxswt.jar;D:\java\jdk1.8\jre\lib\jsse.jar;D:\java\jdk1.8\jre\lib\management-agent.jar;D:\java\jdk1.8\jre\lib\plugin.jar;D:\java\jdk1.8\jre\lib\resources.jar;D:\java\jdk1.8\jre\lib\rt.jar;D:\workspace_git\serializeCompare\target\classes;D:\Develop\Work\mavenrepo\com\baidu\jprotobuf\2.2.7\jprotobuf-2.2.7.jar;D:\Develop\Work\mavenrepo\com\google\protobuf\protobuf-java\3.0.2\protobuf-java-3.0.2.jar;D:\Develop\Work\mavenrepo\javassist\javassist\3.12.1.GA\javassist-3.12.1.GA.jar;D:\Develop\Work\mavenrepo\com\google\auto\value\auto-value\1.0-rc2\auto-value-1.0-rc2.jar;D:\Develop\Work\mavenrepo\com\google\auto\auto-common\0.3\auto-common-0.3.jar;D:\Develop\Work\mavenrepo\com\google\auto\service\auto-service\1.0-rc2\auto-service-1.0-rc2.jar;D:\Develop\Work\mavenrepo\com\google\guava\guava\17.0\guava-17.0.jar;D:\Develop\Work\mavenrepo\org\ow2\asm\asm\4.1\asm-4.1.jar;D:\Develop\Work\mavenrepo\org\apache\velocity\velocity\1.7\velocity-1.7.jar;D:\Develop\Work\mavenrepo\commons-collections\commons-collections\3.2.1\commons-collections-3.2.1.jar;D:\Develop\Work\mavenrepo\commons-lang\commons-lang\2.4\commons-lang-2.4.jar;D:\Develop\Work\mavenrepo\com\baidu\jprotobuf-protoparser\1.0.1\jprotobuf-protoparser-1.0.1.jar;D:\Develop\Work\mavenrepo\com\esotericsoftware\kryo\4.0.0\kryo-4.0.0.jar;D:\Develop\Work\mavenrepo\com\esotericsoftware\reflectasm\1.11.3\reflectasm-1.11.3.jar;D:\Develop\Work\mavenrepo\com\esotericsoftware\minlog\1.3.0\minlog-1.3.0.jar;D:\Develop\Work\mavenrepo\org\objenesis\objenesis\2.2\objenesis-2.2.jar;D:\Develop\Work\mavenrepo\commons-codec\commons-codec\1.11\commons-codec-1.11.jar;D:\Develop\Work\mavenrepo\io\protostuff\protostuff-core\1.6.0\protostuff-core-1.6.0.jar;D:\Develop\Work\mavenrepo\io\protostuff\protostuff-api\1.6.0\protostuff-api-1.6.0.jar;D:\Develop\Work\mavenrepo\io\protostuff\protostuff-runtime\1.6.0\protostuff-runtime-1.6.0.jar;D:\Develop\Work\mavenrepo\io\protostuff\protostuff-collectionschema\1.6.0\protostuff-collectionschema-1.6.0.jar com.liulei.fly.TestSerialize
kryo序列化10000个对象耗时：44ms;大小为:842
kryo序列化10000个对象耗时：39ms;大小为:842
kryo序列化10000个对象耗时：54ms;大小为:842
kryo序列化10000个对象耗时：26ms;大小为:842
kryo反序列化10000个对象耗时：36ms;
kryo反序列化10000个对象耗时：31ms;
kryo反序列化10000个对象耗时：31ms;
kryo反序列化10000个对象耗时：47ms;
jprotobuf序列化10000个对象耗时：27ms;大小为:809
jprotobuf序列化10000个对象耗时：36ms;大小为:809
jprotobuf序列化10000个对象耗时：25ms;大小为:809
jprotobuf序列化10000个对象耗时：24ms;大小为:809
jprotobuf序列化10000个对象耗时：16ms;
jprotobuf序列化10000个对象耗时：21ms;
jprotobuf序列化10000个对象耗时：28ms;
jprotobuf序列化10000个对象耗时：28ms;
protoStuff序列化10000个对象耗时：24ms;大小为:809
protoStuff序列化10000个对象耗时：24ms;大小为:809
protoStuff序列化10000个对象耗时：24ms;大小为:809
protoStuff序列化10000个对象耗时：24ms;大小为:809
protoStuff反序列10000个对象化耗时：19ms;
protoStuff反序列10000个对象化耗时：19ms;
protoStuff反序列10000个对象化耗时：19ms;
protoStuff反序列10000个对象化耗时：18ms;
Process finished with exit code 0
kryo序列化10000个对象耗时：44ms;大小为:920
kryo序列化10000个对象耗时：37ms;大小为:920
kryo序列化10000个对象耗时：48ms;大小为:920
kryo序列化10000个对象耗时：30ms;大小为:920
kryo反序列化10000个对象耗时：53ms;
kryo反序列化10000个对象耗时：64ms;
kryo反序列化10000个对象耗时：79ms;
kryo反序列化10000个对象耗时：91ms;
protoStuff序列化10000个对象耗时：44ms;大小为:771
protoStuff序列化10000个对象耗时：16ms;大小为:771
protoStuff序列化10000个对象耗时：21ms;大小为:771
protoStuff序列化10000个对象耗时：16ms;大小为:771
protoStuff反序列10000个对象化耗时：32ms;
protoStuff反序列10000个对象化耗时：21ms;
protoStuff反序列10000个对象化耗时：20ms;
protoStuff反序列10000个对象化耗时：27ms;
\ No newline at end of file
src/instruction/technology 0 → 100644
浏览文件 @ ffde5e8a
1、jprotobuf
1.1、介绍
为百度封装谷歌的protobuf，使用方便切效率高于谷歌原生类库3倍左右
1.2、使用方法：
使用注释标注实体类
使用protobufProxy代理生成编解码器codec：
如：Codec<PojoPersion> codec = ProtobufProxy.create(PojoPersion.class, false);
使用编解码器api序列化与反序列化对象：
codec.encode();codedecode()
2、kryo序列化参考kryoUtil类中注释（此kryo工具类是从Github中摘取的）。
\ No newline at end of file
src/main/java/com/liulei/fly/TestSerialize.java 0 → 100644
浏览文件 @ ffde5e8a
package com.liulei.fly;
import com.baidu.bjf.remoting.protobuf.Codec;
import com.baidu.bjf.remoting.protobuf.ProtobufProxy;
import com.liulei.fly.kryo.KryoUtil;
import com.liulei.fly.model.PojoPersion;
import com.liulei.fly.protostuff.ProtoBufUtil;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Auther: fly
* @Date: 2019/1/5
* @Description:序列化测试类
*/
public class TestSerialize {
private static final int pojoNum = 1 * 10000;
public static void main(String[] args) {
List<PojoPersion> datas = getPojoPersionList();
List<byte[]> bytesOfDatas = null;
for(int i = 0; i < 2; i++)
bytesOfDatas = serializeWithKryo(datas);
for(int i = 0; i < 2; i++)
deSerializeWithKryo(bytesOfDatas);
//for(int i = 0; i < 5; i++)
// bytesOfDatas = serializeWithProtobuf(datas);
//for(int i = 0; i < 5; i++)
// deSerializeWithProtobuf(bytesOfDatas);
for(int i = 0; i < 2; i++)
bytesOfDatas = serializeWithProtoStuff(datas);
for(int i = 0; i < 2; i++)
deSerializeWithProtoStuff(bytesOfDatas);
}
public static void deSerializeWithProtoStuff(List<byte[]> bytesOfDatas){
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
PojoPersion deserializer = ProtoBufUtil.deserializer(bytesOfDatas.get(i), PojoPersion.class);
//System.out.println(deserializer.toString());
}
System.out.println("protoStuff反序列" + pojoNum + "个对象化耗时：" + (System.currentTimeMillis() - s0) + "ms;");
}
public static List<byte[]> serializeWithProtoStuff(List<PojoPersion> datas){
List<byte[]> bytesOfData = new ArrayList<>(datas.size());
byte[] bytes = null;
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
bytes = ProtoBufUtil.serializer(datas.get(i));
bytesOfData.add(bytes);
}
System.out.println("protoStuff序列化" + pojoNum + "个对象耗时：" + (System.currentTimeMillis() - s0) + "ms;大小为:" + bytes.length);
return bytesOfData;
}
public static void deSerializeWithProtobuf(List<byte[]> bytesOfDatas){
Codec<PojoPersion> codec = ProtobufProxy.create(PojoPersion.class, false);
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
try {
codec.decode(bytesOfDatas.get(i));
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("protobuf反序列" + pojoNum + "个对象化耗时：" + (System.currentTimeMillis() - s0) + "ms;");
}
public static List<byte[]> serializeWithProtobuf(List<PojoPersion> datas){
List<byte[]> bytesOfData = new ArrayList<>(datas.size());
byte[] bytes = null;
Codec<PojoPersion> codec = ProtobufProxy.create(PojoPersion.class, false);
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
try {
bytes = codec.encode(datas.get(i));
bytesOfData.add(bytes);
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("protobuf序列化" + pojoNum + "个对象耗时：" + (System.currentTimeMillis() - s0) + "ms;大小为:" + bytes.length);
return bytesOfData;
}
public static void deSerializeWithKryo(List<byte[]> bytesOfData){
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
PojoPersion po = KryoUtil.readFromByteArray(bytesOfData.get(i));
//System.out.println(po.toString());
}
System.out.println("kryo反序列化" + pojoNum + "个对象耗时：" + (System.currentTimeMillis() - s0) + "ms;");
}
public static List<byte[]> serializeWithKryo(List<PojoPersion> datas){
List<byte[]> bytesOfData = new ArrayList<>(datas.size());
byte[] bytes = null;
long s0 = System.currentTimeMillis();
for(int i = 0; i < pojoNum; i++){
bytes = KryoUtil.writeToByteArray(datas.get(i));
bytesOfData.add(bytes);
}
System.out.println("kryo序列化" + pojoNum + "个对象耗时：" + (System.currentTimeMillis() - s0) + "ms;大小为:" + bytes.length);
return bytesOfData;
}
public static List<PojoPersion> getPojoPersionList(){
List<PojoPersion> pojoList = new ArrayList<>();
for (int i = 0; i < pojoNum; i ++){
PojoPersion pojoPersion = new PojoPersion();
pojoPersion.setName("我的名字叫**" + i);
pojoPersion.setHeight(i);
pojoPersion.setWeight(i);
pojoPersion.setSchool("我的学校是***，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript1("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript2("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript3("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript4("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript5("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript6("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript7("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript8("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript9("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript10("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.setDescript11("测试，我要多一点字符串，以便对象大一些" + i);
pojoPersion.getMap().put("test","测试引用");
pojoPersion.getList().add("测试list");
pojoList.add(pojoPersion);
}
return pojoList;
}
}
src/main/java/com/liulei/fly/kryo/KryoUtil.java 0 → 100644
浏览文件 @ ffde5e8a
package com.liulei.fly.kryo;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import org.apache.commons.codec.binary.Base64;
import org.objenesis.strategy.StdInstantiatorStrategy;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
/**
* @Auther: liulei
* @Date: 2019/1/5 $time
* @Description:
*/
public class KryoUtil {
private static final String DEFAULT_ENCODING = "UTF-8";
//每个线程的 Kryo 实例
private static final ThreadLocal<Kryo> kryoLocal = new ThreadLocal<Kryo>() {
@Override
protected Kryo initialValue() {
Kryo kryo = new Kryo();
/**
* 不要轻易改变这里的配置！更改之后，序列化的格式就会发生变化，
* 上线的同时就必须清除 Redis 里的所有缓存，
* 否则那些缓存再回来反序列化的时候，就会报错
*/
//支持对象循环引用（否则会栈溢出）
kryo.setReferences(true); //默认值就是 true，添加此行的目的是为了提醒维护者，不要改变这个配置
//不强制要求注册类（注册行为无法保证多个 JVM 内同一个类的注册编号相同；而且业务系统中大量的 Class 也难以一一注册）
kryo.setRegistrationRequired(false); //默认值就是 false，添加此行的目的是为了提醒维护者，不要改变这个配置
//Fix the NPE bug when deserializing Collections.
((Kryo.DefaultInstantiatorStrategy) kryo.getInstantiatorStrategy())
.setFallbackInstantiatorStrategy(new StdInstantiatorStrategy());
return kryo;
}
};
/**
* 获得当前线程的 Kryo 实例
*
* @return 当前线程的 Kryo 实例
*/
public static Kryo getInstance() {
return kryoLocal.get();
}
//-----------------------------------------------
// 序列化/反序列化对象，及类型信息
// 序列化的结果里，包含类型的信息
// 反序列化时不再需要提供类型
//-----------------------------------------------
/**
* 将对象【及类型】序列化为字节数组
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字节数组
*/
public static <T> byte[] writeToByteArray(T obj) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Output output = new Output(byteArrayOutputStream);
Kryo kryo = getInstance();
kryo.writeClassAndObject(output, obj);
output.flush();
return byteArrayOutputStream.toByteArray();
}
/**
* 将对象【及类型】序列化为 String
* 利用了 Base64 编码
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字符串
*/
public static <T> String writeToString(T obj) {
try {
return new String(Base64.encodeBase64(writeToByteArray(obj)), DEFAULT_ENCODING);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
/**
* 将字节数组反序列化为原对象
*
* @param byteArray writeToByteArray 方法序列化后的字节数组
* @param <T> 原对象的类型
* @return 原对象
*/
@SuppressWarnings("unchecked")
public static <T> T readFromByteArray(byte[] byteArray) {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
Input input = new Input(byteArrayInputStream);
Kryo kryo = getInstance();
return (T) kryo.readClassAndObject(input);
}
/**
* 将 String 反序列化为原对象
* 利用了 Base64 编码
*
* @param str writeToString 方法序列化后的字符串
* @param <T> 原对象的类型
* @return 原对象
*/
public static <T> T readFromString(String str) {
try {
return readFromByteArray(Base64.decodeBase64(str.getBytes(DEFAULT_ENCODING)));
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
//-----------------------------------------------
// 只序列化/反序列化对象
// 序列化的结果里，不包含类型的信息
//-----------------------------------------------
/**
* 将对象序列化为字节数组
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字节数组
*/
public static <T> byte[] writeObjectToByteArray(T obj) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Output output = new Output(byteArrayOutputStream);
Kryo kryo = getInstance();
kryo.writeObject(output, obj);
output.flush();
return byteArrayOutputStream.toByteArray();
}
/**
* 将对象序列化为 String
* 利用了 Base64 编码
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字符串
*/
public static <T> String writeObjectToString(T obj) {
try {
return new String(Base64.encodeBase64(writeObjectToByteArray(obj)), DEFAULT_ENCODING);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
/**
* 将字节数组反序列化为原对象
*
* @param byteArray writeToByteArray 方法序列化后的字节数组
* @param clazz 原对象的 Class
* @param <T> 原对象的类型
* @return 原对象
*/
@SuppressWarnings("unchecked")
public static <T> T readObjectFromByteArray(byte[] byteArray, Class<T> clazz) {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
Input input = new Input(byteArrayInputStream);
Kryo kryo = getInstance();
return kryo.readObject(input, clazz);
}
/**
* 将 String 反序列化为原对象
* 利用了 Base64 编码
*
* @param str writeToString 方法序列化后的字符串
* @param clazz 原对象的 Class
* @param <T> 原对象的类型
* @return 原对象
*/
public static <T> T readObjectFromString(String str, Class<T> clazz) {
try {
return readObjectFromByteArray(Base64.decodeBase64(str.getBytes(DEFAULT_ENCODING)), clazz);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
}
src/main/java/com/liulei/fly/model/PojoPersion.java 0 → 100644
浏览文件 @ ffde5e8a
package com.liulei.fly.model;
import com.baidu.bjf.remoting.protobuf.annotation.ProtobufClass;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
import io.protostuff.Exclude;
import io.protostuff.Tag;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Auther: liulei
* @Date: 2019/1/5 $time
* @Description: 序列化对象
*/
@ProtobufClass
public class PojoPersion {
//@FieldSerializer.Optional("")
//@Exclude
private Map<String, String> map = new HashMap<>();
private List<String> list = new ArrayList<>();
//@FieldSerializer.Optional("")
@Exclude
private String school;
private String name;
private double height;
private double weight;
private String descript1;
private String descript2;
private String descript3;
private String descript4;
private String descript5;
private String descript6;
private String descript7;
private String descript8;
private String descript9;
private String descript10;
private String descript11;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public String getDescript1() {
return descript1;
}
public void setDescript1(String descript1) {
this.descript1 = descript1;
}
public String getDescript2() {
return descript2;
}
public void setDescript2(String descript2) {
this.descript2 = descript2;
}
public String getDescript3() {
return descript3;
}
public void setDescript3(String descript3) {
this.descript3 = descript3;
}
public String getDescript4() {
return descript4;
}
public void setDescript4(String descript4) {
this.descript4 = descript4;
}
public String getDescript5() {
return descript5;
}
public void setDescript5(String descript5) {
this.descript5 = descript5;
}
public String getDescript6() {
return descript6;
}
public void setDescript6(String descript6) {
this.descript6 = descript6;
}
public String getDescript7() {
return descript7;
}
public void setDescript7(String descript7) {
this.descript7 = descript7;
}
public String getDescript8() {
return descript8;
}
public void setDescript8(String descript8) {
this.descript8 = descript8;
}
public String getDescript9() {
return descript9;
}
public void setDescript9(String descript9) {
this.descript9 = descript9;
}
public String getDescript10() {
return descript10;
}
public void setDescript10(String descript10) {
this.descript10 = descript10;
}
public String getDescript11() {
return descript11;
}
public void setDescript11(String descript11) {
this.descript11 = descript11;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
@Override
public String toString() {
return "PojoPersion{" +
"map=" + map +
", list=" + list +
", school='" + school + '\'' +
", name='" + name + '\'' +
", height=" + height +
", weight=" + weight +
", descript1='" + descript1 + '\'' +
", descript2='" + descript2 + '\'' +
", descript3='" + descript3 + '\'' +
", descript4='" + descript4 + '\'' +
", descript5='" + descript5 + '\'' +
", descript6='" + descript6 + '\'' +
", descript7='" + descript7 + '\'' +
", descript8='" + descript8 + '\'' +
", descript9='" + descript9 + '\'' +
", descript10='" + descript10 + '\'' +
", descript11='" + descript11 + '\'' +
'}';
}
}
src/main/java/com/liulei/fly/protostuff/ProtoBufUtil.java 0 → 100644
浏览文件 @ ffde5e8a
package com.liulei.fly.protostuff;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtobufIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
/**
* @author liu_l
* @email: liu_lei_programmer@163.com
* @time 2019/1/15 10:16
* @Description: 描述:
*/
public class ProtoBufUtil {
public static <T> byte[] serializer(T o) {
Schema schema = RuntimeSchema.getSchema(o.getClass());
return ProtobufIOUtil.toByteArray(o, schema, LinkedBuffer.allocate(256));
}
public static <T> T deserializer(byte[] bytes, Class<T> clazz) {
T obj = null;
try {
obj = clazz.newInstance();
Schema schema = RuntimeSchema.getSchema(obj.getClass());
ProtobufIOUtil.mergeFrom(bytes, obj, schema);
//ProtostuffIOUtil.mergeFrom(bytes, obj, schema);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或