@Override public byte[] serialize(final T object) { return pool.run(new KryoCallback<byte[]>() { public byte[] execute(Kryo kryo) { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); Output output = new Output(byteArrayOutputStream); kryo.writeClassAndObject(output, object); output.flush(); return byteArrayOutputStream.toByteArray(); } }); }
@Override public T clone(final T object) { return pool.run(new KryoCallback<T>() { public T execute(Kryo kryo) { return kryo.copy(object); } }); } }
@Override public T deserialize(final byte[] bytes) { return pool.run(new KryoCallback<T>() { public T execute(Kryo kryo) { ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes); Input input = new Input(byteArrayInputStream); return (T) kryo.readClassAndObject(input); } }); }
@Override public <T> T run(KryoCallback<T> callback) { return kryoPool.run(callback); }
@Override public Object readFrom(final Class<Object> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException, WebApplicationException { final Input input = new Input(entityStream); return kryoPool.run(new KryoCallback() { public Object execute(Kryo kryo) { return kryo.readObject(input, type); } }); }
@Override public <T> T clone(final T object) { if (object != null) { return kryoPool.run(kryo -> kryo.copy(object)); } return null; } }
@Override public void writeTo(final Object object, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream) throws IOException, WebApplicationException { final Output output = new Output(entityStream); kryoPool.run(new KryoCallback() { public Object execute(Kryo kryo) { kryo.writeObject(output, object); return null; } }); output.flush(); }
/** * Deserializes given byte array to Object using Kryo instance in pool. * * @param bytes serialized bytes * @param <T> deserialized Object type * @return deserialized Object */ public <T> T deserialize(final byte[] bytes) { return kryoInputPool.run(input -> { input.setInputStream(new ByteArrayInputStream(bytes)); return kryoPool.run(kryo -> { @SuppressWarnings("unchecked") T obj = (T) kryo.readClassAndObject(input); return obj; }); }, DEFAULT_BUFFER_SIZE); }
/** * Serializes given object to byte array using Kryo instance in pool. * * @param obj Object to serialize * @param bufferSize maximum size of serialized bytes * @return serialized bytes */ public byte[] serialize(final Object obj, final int bufferSize) { return kryoOutputPool.run(output -> { return kryoPool.run(kryo -> { kryo.writeClassAndObject(output, obj); output.flush(); return output.getByteArrayOutputStream().toByteArray(); }); }, bufferSize); }
@Override public Message deserializeMessage(BasicRuntime basicRuntime, final byte[] payload) throws Exception { return inputPool.run(in -> { in.setInputStream(new ByteArrayInputStream(payload)); return kryoPool.run(kryo -> { final Message message = new Message(); message.setMessageType(in.readByte()); message.setMessageId(in.readInt()); message.setReferenceAddress(readNodeAddress(in)); message.setInterfaceId(in.readInt()); message.setMethodId(in.readInt()); message.setObjectId(readObjectId(kryo, in)); message.setHeaders(readHeaders(kryo, in)); message.setFromNode(readNodeAddress(in)); message.setPayload(readPayload(kryo, in)); return message; }); }, DEFAULT_BUFFER_SIZE); }
@Override public void encode(final Object object, OutputStream outputStream) throws IOException { Assert.notNull(object, "cannot encode a null object"); Assert.notNull(outputStream, "'outputSteam' cannot be null"); final Output output = (outputStream instanceof Output ? (Output) outputStream : new Output(outputStream)); this.pool.run(kryo -> { doEncode(kryo, object, output); return Void.class; }); output.close(); }
@Override public <T> T decode(InputStream inputStream, final Class<T> type) throws IOException { Assert.notNull(inputStream, "'inputStream' cannot be null"); Assert.notNull(type, "'type' cannot be null"); final Input input = (inputStream instanceof Input ? (Input) inputStream : new Input(inputStream)); T result = null; try { result = this.pool.run(kryo -> doDecode(kryo, input, type)); } finally { input.close(); } return result; }
@Override public byte[] serializeMessage(BasicRuntime basicRuntime, Message message) throws Exception { return outputPool.run(out -> { return kryoPool.run(kryo -> { out.writeByte(message.getMessageType()); out.writeInt(message.getMessageId()); writeNodeAddress(out, message.getReferenceAddress()); out.writeInt(message.getInterfaceId()); out.writeInt(message.getMethodId()); writeObjectId(kryo, out, message); writeHeaders(kryo, out, message.getHeaders()); writeNodeAddress(out, message.getFromNode()); writePayload(kryo, out, message); out.flush(); return out.getByteArrayOutputStream().toByteArray(); }); }, DEFAULT_BUFFER_SIZE); }
public static byte[] serialize(final Object obj) { return pool.run(new KryoCallback<byte[]>() { @Override public byte[] execute(Kryo kryo) { ByteArrayOutputStream stream = new ByteArrayOutputStream(); Output output = new Output(stream); kryo.writeClassAndObject(output, obj); output.close(); return stream.toByteArray(); } }); }
@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)); } }); }
public static Serializable kryoDeserialize(byte[] byteArray) throws IOException { final Input input = new Input(new ByteArrayInputStream(byteArray)); try { return kryoPool.run(new KryoCallback<Serializable>() { public Serializable execute(Kryo kryo) { return (Serializable) kryo.readClassAndObject(input); } }); } finally { CommonUtils.closeQuietly(input); } }
@SuppressWarnings("unchecked") public static <V> V deserialize(final byte[] objectData) { return pool.run(kryo -> { Input input = new Input(objectData); return (V) kryo.readClassAndObject(input); }); }
protected byte[] serialize(Object payload) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); final Output output = new Output(baos); this.pool.run(kryo -> { kryo.writeObject(output,payload); return Void.TYPE; }); output.close(); return baos.toByteArray(); }
@Override public void encode(final Object object, OutputStream outputStream) throws IOException { Assert.notNull(object, "cannot encode a null object"); Assert.notNull(outputStream, "'outputSteam' cannot be null"); final Output output = (outputStream instanceof Output ? (Output) outputStream : new Output(outputStream)); this.pool.run(kryo -> { doEncode(kryo, object, output); return Void.class; }); output.close(); }
public static byte[] serialize(final Object obj) { return pool.run(kryo -> { ByteArrayOutputStream stream = new ByteArrayOutputStream(); Output output = new Output(stream); kryo.writeClassAndObject(output, obj); output.close(); return stream.toByteArray(); }); }