import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> T run(KryoCallback<T> callback) {
    Kryo kryo = this.borrowOne();

    T t;
    try {
        t = callback.execute(kryo);
    } finally {
        this.returnOne(kryo);
    }
    return t;
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> T run(KryoCallback<T> callback) {
    Kryo kryo = null;
    try {
        kryo = kryoPool.borrowObject();
        return callback.execute(kryo);
    } catch (Exception e) {
        fkcExceptionHandler.dealException(e);
        return null;
    } finally {
        if (kryo != null) {
            kryoPool.returnObject(kryo);
        }
    }
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> byte[] serialize(T obj) {
  return getPool().run(new KryoCallback<byte[]>() {
    @Override
    public byte[] execute(Kryo kryo) {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      Output output = new Output(baos);
      kryo.writeClassAndObject(output, obj);
      output.close();
      return baos.toByteArray();
    }
  });
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> T deserialize(byte[] serObj, Class<T> clazz) {
  return getPool().run(new KryoCallback<T>() {
    @Override
    public T execute(Kryo kryo) {
      ByteArrayInputStream bais = new ByteArrayInputStream(serObj);
      Input input = new Input(bais);
      return clazz.cast(kryo.readClassAndObject(input));
    }
  });
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
/**
 * Serialize an object to byte array, with a custom class loader.
 * 
 * <p>
 * This method uses Kryo lib.
 * </p>
 * 
 * @param obj
 * @param classLoader
 * @return
 */
public static byte[] toByteArrayKryo(final Object obj, final ClassLoader classLoader) {
    if (obj == null) {
        return null;
    }
    return kryoPool.run(new KryoCallback<byte[]>() {
        @Override
        public byte[] execute(Kryo kryo) {
            ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
            if (classLoader != null) {
                Thread.currentThread().setContextClassLoader(classLoader);
            }
            try {
                try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
                    try (Output output = new Output(baos)) {
                        kryo.setClassLoader(classLoader != null ? classLoader : oldClassLoader);
                        // kryo.writeObject(output, obj);
                        kryo.writeClassAndObject(output, obj);
                        output.flush();
                        return baos.toByteArray();
                    }
                } catch (Exception e) {
                    throw e instanceof SerializationException ? (SerializationException) e
                            : new SerializationException(e);
                }
            } finally {
                Thread.currentThread().setContextClassLoader(oldClassLoader);
            }
        }
    });
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
/**
 * Deserialize a byte array back to an object, with custom class loader.
 * 
 * <p>
 * This method uses Kryo lib.
 * </p>
 * 
 * @param data
 * @param clazz
 * @param classLoader
 * @return
 */
public static <T> T fromByteArrayKryo(byte[] data, final Class<T> clazz,
        final ClassLoader classLoader) {
    if (data == null) {
        return null;
    }
    return kryoPool.run(new KryoCallback<T>() {
        @SuppressWarnings("unchecked")
        @Override
        public T execute(Kryo kryo) {
            ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
            if (classLoader != null) {
                Thread.currentThread().setContextClassLoader(classLoader);
            }
            try {
                try (Input input = new Input(new ByteArrayInputStream(data))) {
                    kryo.setClassLoader(classLoader != null ? classLoader : oldClassLoader);
                    // return kryo.readObject(input, clazz);
                    Object result = kryo.readClassAndObject(input);
                    if (result != null && clazz.isAssignableFrom(result.getClass())) {
                        return (T) result;
                    } else {
                        return null;
                    }
                } catch (Exception e) {
                    throw e instanceof DeserializationException ? (DeserializationException) e
                            : new DeserializationException(e);
                }
            } finally {
                Thread.currentThread().setContextClassLoader(oldClassLoader);
            }
        }
    });
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> T run(KryoCallback<T> callback) {
    return pool.run(callback);
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
@Override
public <T> T run(KryoCallback<T> callback) {
  return pool.run(callback);
}
 

import com.esotericsoftware.kryo.pool.KryoCallback; //导入依赖的package包/类
/**
 * 从pool中获取一个kryo后马上执行callback
 *
 * @param callback callback
 * @param <T>
 * @return 返回值
 */
<T> T run(KryoCallback<T> callback);