高性能序列化框架FST

fst是完全兼容JDK序列化协议的系列化框架，序列化速度大概是JDK的4-10倍，大小是JDK大小的1/3左右。

首先引入pom

<dependency>
  <groupId>de.ruedigermoeller</groupId>
  <artifactId>fst</artifactId>
  <version>2.04</version>
</dependency>

 测试代码：

package zookeeper.seria;

import java.io.Serializable;

public class FSTSeriazle {

	public static void main(String[] args) {
		User bean = new User();
		bean.setUsername("xxxxx");
		bean.setPassword("123456");
		bean.setAge(1000000);
		System.out.println("序列化 ， 反序列化 对比测试：");
		long size = 0;
		long time1 = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			byte[] jdkserialize = JRedisSerializationUtils.jdkserialize(bean);
			size += jdkserialize.length;
			JRedisSerializationUtils.jdkdeserialize(jdkserialize);
		}
		System.out.println("原生序列化方案[序列化10000次]耗时："
				+ (System.currentTimeMillis() - time1) + "ms size:=" + size);

		size = 0;
		long time2 = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			byte[] serialize = JRedisSerializationUtils.serialize(bean);
			size += serialize.length;
			User u = (User) JRedisSerializationUtils.unserialize(serialize);
		}
		System.out.println("fst序列化方案[序列化10000次]耗时："
				+ (System.currentTimeMillis() - time2) + "ms size:=" + size);
		size = 0;
		long time3 = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) {
			byte[] serialize = JRedisSerializationUtils.kryoSerizlize(bean);
			size += serialize.length;
			User u = (User) JRedisSerializationUtils.kryoUnSerizlize(serialize);
		}
		System.out.println("kryo序列化方案[序列化10000次]耗时："
				+ (System.currentTimeMillis() - time3) + "ms size:=" + size);

	}

}

class User implements Serializable{

	private String username;
	private int age;
	private String password;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

}

 结果：

　　序列化 ， 反序列化 对比测试：
　　原生序列化方案[序列化10000次]耗时：458ms size:=1160000
　　fst序列化方案[序列化10000次]耗时：184ms size:=550000
　　kryo序列化方案[序列化10000次]耗时：462ms size:=390000

 
工具类：

1. package zookeeper.seria;
2.   
3.  import java.io.ByteArrayInputStream;
4.  import java.io.ByteArrayOutputStream;
5.  import java.io.IOException;
6.  import java.io.ObjectInputStream;
7.  import java.io.ObjectOutputStream;
8.   
9.  import org.nustaq.serialization.FSTConfiguration;
10.   
11.  import com.esotericsoftware.kryo.Kryo;
12.  import com.esotericsoftware.kryo.io.Input;
13.  import com.esotericsoftware.kryo.io.Output;
14.   
15.  public class JRedisSerializationUtils {
16.   
17.  public JRedisSerializationUtils() {
18.  }
19.   
20.  static FSTConfiguration configuration = FSTConfiguration
21. 　　 // .createDefaultConfiguration();
22. 　　 .createStructConfiguration();
23.  
24.  // fst序列换方案
25.  public static byte[] serialize(Object obj) {
26.  　　return configuration.asByteArray(obj);
27.  }
28.   
29.  public static Object unserialize(byte[] sec) {
30. 　　 return configuration.asObject(sec);
31.  }
32.   
33.  // kryo序列换方案
34.  public static byte[] kryoSerizlize(Object obj) {
35.         Kryo kryo = new Kryo();
36.         byte[] buffer = new byte[2048];
37.         try(
38.                Output output = new Output(buffer);
39.         ) {
40.   
41.                kryo.writeClassAndObject(output, obj);
42.                return output.toBytes();
43.         } catch (Exception e) {
44.         }
45.         return buffer;
46.  }
47.   
48.  static Kryo kryo = new Kryo();
50.  public static Object kryoUnSerizlize(byte[] src) {
51.        try(
52.                Input input = new Input(src);
53.        ){
54.                return kryo.readClassAndObject(input);
55.         }catch (Exception e) {
56.         }
57.         return kryo;
58.  }
59.   
60.  // jdk原生序列换方案
61.  public static byte[] jdkserialize(Object obj) {
62.           try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
63.           ObjectOutputStream oos = new ObjectOutputStream(baos);) {
64.                    oos.writeObject(obj);
65.                    return baos.toByteArray();
66.           } catch (IOException e) {
67.                    throw new RuntimeException(e);
68.           }
69.  }
70.   
71.  public static Object jdkdeserialize(byte[] bits) {
72.           try (ByteArrayInputStream bais = new ByteArrayInputStream(bits);
73.                    ObjectInputStream ois = new ObjectInputStream(bais);
74.   
75.           ) {
76.                    return ois.readObject();
77.           } catch (Exception e) {
78.                    throw new RuntimeException(e);
79.          }
80.  }
81.  }

转载于:https://www.cnblogs.com/guankai/p/10025276.html