fast-serialization序列化工具

FstSerializer.java

package test;

import org.nustaq.serialization.FSTConfiguration;

/**
 * 序列化工具，线程安全
 * 
 * @author pf-miles
 * @since 2015-7-4
 */
public class FstSerializer {

    private boolean                       multiConf;
    private boolean                       shareReferences;
    private boolean                       fastBinary;

    private ThreadLocal<FSTConfiguration> mc = new ThreadLocal<FSTConfiguration>() {

                                                 @Override
                                                 protected FSTConfiguration initialValue() {
                                                     return createConf(shareReferences, fastBinary);
                                                 }

                                             };

    private FSTConfiguration              c;

    /**
     * @param multiConf 是否要使用threadLocal的conf，这应对高并发场景，否则使用全局唯一的conf
     * @param shareReferences 是否开启环引用检测，关闭时(false)将提升性能，在应对无环的plain message类的对象可关闭
     * @param fastBinary 是否使用unsafe类以提升性能
     */
    public FstSerializer(boolean multiConf, boolean shareReferences, boolean fastBinary){
        this.multiConf = multiConf;
        this.shareReferences = shareReferences;
        this.fastBinary = fastBinary;

        if (!multiConf) {
            c = createConf(shareReferences, fastBinary);
        }
    }

    private static FSTConfiguration createConf(boolean shareReferences, boolean fastBinary) {
        FSTConfiguration ret = null;
        if (fastBinary) {
            ret = FSTConfiguration.createFastBinaryConfiguration();
        } else {
            ret = FSTConfiguration.createDefaultConfiguration();
        }
        ret.setShareReferences(shareReferences);
        return ret;
    }

    private FSTConfiguration resolveConf() {
        FSTConfiguration f = null;
        if (this.multiConf) {
            f = mc.get();
        } else {
            f = c;
        }
        return f;
    }

    public byte[] serialize(Object obj) {
        return resolveConf().asByteArray(obj);
    }

    public <T> T deserialize(byte[] bs) {
        return (T) resolveConf().asObject(bs);
    }
}

FstSerializerTest.java

package test;

import java.io.Serializable;

import junit.framework.TestCase;

/**
 * @author pf-miles
 * @since 2015-7-6
 */
public class FstSerializerTest extends TestCase {

    public void testSer() {
        FstSerializer ser = new FstSerializer(true, false, true);
        TestPojo pojo = new TestPojo("wenyue", 29, new Ball(4.2));
        byte[] bs = ser.serialize(pojo);

        TestPojo p = ser.deserialize(bs);
        assertTrue(p.getName().equals("wenyue"));
        assertTrue(p.getAge() == 29);
        assertTrue(p.getBall().getSize() == 4.2);
    }

    public static final class TestPojo implements Serializable {

        private static final long serialVersionUID = -3244287630711410013L;
        private String            name;
        private int               age;
        private Ball              ball;

        public TestPojo(String name, int age, Ball ball){
            this.name = name;
            this.age = age;
            this.ball = ball;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

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

        public Ball getBall() {
            return ball;
        }

        public void setBall(Ball ball) {
            this.ball = ball;
        }
    }

    public static final class Ball implements Serializable {

        private static final long serialVersionUID = 7362151174904923071L;
        private double            size;

        public Ball(double s){
            this.size = s;
        }

        public double getSize() {
            return size;
        }

        public void setSize(double size) {
            this.size = size;
        }

    }
}