文章首发于：clawhub.club

JAVA中使用BDB默认是使用JAVA自带的序列化，通过继承Kryo序列化框架，可以提升一些性能。
在创建com.sleepycat.collections.StoredSortedMap对象的时候，要指定键值对的序列化方式，在这个地方，切入Kryo序列化框架：

1
2
3
4
5
6
7
8
public StoredSortedMap(Database database,
                          EntryBinding<K> keyBinding,
                          EntryBinding<V> valueBinding,
                          boolean writeAllowed) {

       super(new DataView(database, keyBinding, valueBinding, null,
                          writeAllowed, null));
   }

具体使用，其中key序列化直接用了默认的LongBinding，值序列化使用自定义的Kryo。

1
2
3
//使用Kryo序列化
       EntryBinding<E> valueBinding = new KryoBinding<>(valueClass);
       queueMap = new StoredSortedMap<>(db, TupleBinding.getPrimitiveBinding(Long.class), valueBinding, true);

KryoBinding源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.je.DatabaseEntry;

/**
 * The type Kryo binding.
 *
 * @param <K> the type parameter
 */
public class KryoBinding<K> implements EntryBinding<K> {
    /**
     * The Base class.
     */
    private Class<K> baseClass;
    /**
     * The Kryo.
     */
    private Kryo kryo;

    /**
     * Instantiates a new Kryo binding.
     * 因为只会初始化一次，所以获取到kryo之后，不释放
     *
     * @param baseClass the base class
     */
    public KryoBinding(Class<K> baseClass) {
        this.baseClass = baseClass;
        //获取kryo
        kryo = KryoPoolFactory.INSTANCE.getPool().borrow();
        //注册结构
        kryo.register(baseClass);
    }

    /**
     * 反序列化
     *
     * @param entry entry
     * @return 对象
     */
    @Override
    public K entryToObject(DatabaseEntry entry) {
        K result;
        try (Input in = new Input(entry.getData())) {
            result = kryo.readObjectOrNull(in, baseClass);
        }
        return result;
    }

    /**
     * 序列化
     *
     * @param object 对象
     * @param entry  entry
     */
    @Override
    public void objectToEntry(K object, DatabaseEntry entry) {
        try (Output out = new Output(4096, 20971520)) {
            kryo.writeClassAndObject(out, object);
            entry.setData(out.getBuffer());
        }
    }

}

因为Kryo有线程安全问题，所以需要用KryoPool实现，KryoPoolFactory源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import com.alibaba.fastjson.JSONObject;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.pool.KryoFactory;
import com.esotericsoftware.kryo.pool.KryoPool;
import org.objenesis.strategy.StdInstantiatorStrategy;

/**
 * The type Kryo pool factory.
 */
public enum KryoPoolFactory {

    /**
     * 初始化字段
     */
    INSTANCE;

    /**
     * The Pool.
     */
    private KryoPool kryoPool;

    /**
     * 类加载时初始化
     */
    KryoPoolFactory() {
        KryoFactory kryoFactory = () -> {
            Kryo kryo = new Kryo();
            //这是对循环引用的支持，可以有效防止栈内存溢出，kryo默认会打开这个属性。
            //确定不会有循环引用发生的时候，可以通过kryo.setReferences(false);关闭循环引用检测，从而提高一些性能
            kryo.setReferences(false);
            //把已知的结构注册到Kryo注册器里面，提高序列化/反序列化效率
            kryo.register(JSONObject.class);
            //显示指定实例化器,首先使用默认无参构造策略DefaultInstantiatorStrategy，若创建对象失败再采用StdInstantiatorStrategy
            kryo.setInstantiatorStrategy(new Kryo.DefaultInstantiatorStrategy(new StdInstantiatorStrategy()));
            return kryo;
        };
        //通过软连接队列维护Kryo,当垃圾回收时，发现系统内存不足，会优先回收
        kryoPool = new KryoPool.Builder(kryoFactory).softReferences().build();
    }


    /**
     * Gets pool.
     *
     * @return the pool
     */
    public KryoPool getPool() {
        return kryoPool;
    }
}

BDB使用了je依赖，具体使用方法可以参考：https://github.com/internetarchive/heritrix3/blob/master/commons/src/main/java/org/archive/bdb/StoredQueue.java

1
2
3
4
5
<dependency>
           <groupId>com.sleepycat</groupId>
           <artifactId>je</artifactId>
           <version>5.0.73</version>
       </dependency>