org.msgpack.MessagePack Java Examples

public static <T> Writer<T> getMsgpackInstance(final OutputStream out, Map<Class, WriteHandler<?,?>> customHandlers, WriteHandler<?, ?> defaultWriteHandler, Function<Object,Object> transform) throws IOException {

        Packer packer = new MessagePack().createPacker(out);

        final MsgpackEmitter emitter = new MsgpackEmitter(packer, handlerMap(customHandlers), defaultWriteHandler, transform);

        final WriteCache writeCache = new WriteCache(true);

        return new Writer<T>() {
            @Override
            public void write(T o) {
                try {
                    emitter.emit(o, false, writeCache.init());
                    out.flush();
                } catch (Throwable e) {
                    throw new RuntimeException(e);
                }
            }
        };
    }
 

public static int serializeClusteringInfo(Path path, String urlList,
		Integer port, Configuration conf) throws IOException {
	FileSystem fs = path.getFileSystem(conf);
	if (fs.exists(path)) {
		return 0;
	}
	
	MsgpackClient client = new MsgpackClient(urlList, port, conf.get("com.b5m.msgpack.collection"));
	client.setTimeout(1000);
	Value res = client.read(new Object[0], "getClusteringInfos");
	AdClusteringsInfo response = new org.msgpack.unpacker.Converter(
			new MessagePack(), res).read(AdClusteringsInfo.class);

	DataOutputStream out = fs.create(path);
	response.write(out);
	out.close();
	return 0;
}
 

private Unpacker read_parameters_MessagePack_Init(String name) {
    MessagePack msgpack = new MessagePack();
    File f = new File(name);
    byte[] nbytes = null;

    try {
        FileInputStream fin = new FileInputStream(f);
        nbytes = new byte[(int)f.length()];
        fin.read(nbytes);
        fin.close();

    } catch (Exception e) {
        Log.d("MessagePack_Init:", e.getMessage());
        return null;
    }

    ByteArrayInputStream in = new ByteArrayInputStream(nbytes);
    org.msgpack.unpacker.Unpacker unpack = msgpack.createUnpacker(in);
    return unpack;
}
 

public Value unpack(byte[] obj) {
    try {
        return MessagePack.unpack(obj);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}
 

public EventLoop(ExecutorService workerExecutor, ExecutorService ioExecutor,
        ScheduledExecutorService scheduledExecutor, MessagePack messagePack) {
    this.workerExecutor = workerExecutor;
    this.scheduledExecutor = scheduledExecutor;
    this.ioExecutor = ioExecutor;
    this.messagePack = messagePack;
}
 

/**
 * Create a client builder for MessagePack values.
 * @return The builder
 */
public static <T> MemcachedClientBuilder<T> newMessagePackClient(final MessagePack messagePack, final Class<T> valueType) {
  if (!ClassUtils.isPrimitiveOrWrapper(valueType)) {
    messagePack.register(valueType);
  }
  return newClient(new MessagePackTranscoder<>(messagePack, valueType));
}
 

public Reader readerOf(Object... things) throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    MessagePack msgpack = new MessagePack();
    Packer packer = msgpack.createPacker(out);

    for (Object o : things) {
        packer.write(o);
    }

    InputStream in = new ByteArrayInputStream(out.toByteArray());
    return TransitFactory.reader(TransitFactory.Format.MSGPACK, in);

}
 

@org.junit.Test
    public void test() throws IOException {

        // Create serialize objects.
        List<String> src = new ArrayList<String>();
        src.add("msgpack");
        src.add("kumofs");
        src.add("viver");

        MessagePack msgpack = new MessagePack();
// Serialize
        byte[] raw = msgpack.write(src);

// Deserialize directly using a template
        List<String> dst1 = msgpack.read(raw, Templates.tList(Templates.TString));
        System.out.println(dst1.get(0));
        System.out.println(dst1.get(1));
        System.out.println(dst1.get(2));

// Or, Deserialze to Value then convert type.
        Value dynamic = msgpack.read(raw);
        List<String> dst2 = new Converter(dynamic)
                .read(Templates.tList(Templates.TString));
        System.out.println(dst2.get(0));
        System.out.println(dst2.get(1));
        System.out.println(dst2.get(2));
    }
 

public NettyEventLoop(ExecutorService workerExecutor,
        ExecutorService ioExecutor,
        ScheduledExecutorService scheduledExecutor, MessagePack messagePack) {
    super(workerExecutor, ioExecutor, scheduledExecutor, messagePack);
}
 

public static void main(String[] args) throws IOException {

        TestUser user = new TestUser();
        MessagePack messagePack = new MessagePack();

        //序列化
        byte[] bs = messagePack.write(user);

        //反序列化
        user = messagePack.read(bs, TestUser.class);
    }
 

public void sendMessage(Message message) {
    Packet packet = new Packet(message.getCmd(), ClientInfo.getSessionId());
    try {
        packet.setBody(new MessagePack().write(message));
        channel.writeAndFlush(packet);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

public T decode(Packet packet) {
    try {
        return new MessagePack().read(packet.getBody(), getType());
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}
 

public byte[] pack(Object obj) {
    try {
        return MessagePack.pack( obj );
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
    final int length = msg.readableBytes();
    final byte[] array = new byte[length];
    msg.getBytes(msg.readerIndex(), array, 0, length);
    out.add(new MessagePack().read(array, Packet.class));
}
 

static public EventLoop start(ExecutorService workerExecutor, ExecutorService ioExecutor) {
    return start(workerExecutor, ioExecutor,
            Executors.newScheduledThreadPool(2), new MessagePack());
}
 

public Dispatcher build(Object handler, MessagePack messagePack) {
    return new MethodDispatcher(
            new Reflect(messagePack), handler);
}
 

static public EventLoop start(
        ExecutorService workerExecutor, ExecutorService ioExecutor,
        ScheduledExecutorService scheduledExecutor, MessagePack messagePack) {
    return getFactory().make(workerExecutor, ioExecutor, scheduledExecutor, messagePack);
}
 

public MessagePack getMessagePack() {
    return messagePack;
}
 

public void setMessagePack(MessagePack messagePack) {
    this.messagePack = messagePack;
}
 

static public EventLoop start(MessagePack messagePack) {
    return start(Executors.newCachedThreadPool(),
            Executors.newCachedThreadPool(),
            Executors.newScheduledThreadPool(2), messagePack);
}
 

public EventLoop make(ExecutorService workerExecutor, ExecutorService ioExecutor,
ScheduledExecutorService scheduledExecutor, MessagePack messagePack);
 

Future(MessagePack messagePack, FutureImpl impl) {
    this(messagePack, impl, null);
}
 

Future(MessagePack messagePack, FutureImpl impl, Template resultTemplate) {
    this.impl = impl;
    this.resultTemplate = resultTemplate;
    this.messagePack = messagePack;
}
 

public Future(MessagePack messagePack, Future<Value> future, Class<V> resultClass) {
    this(messagePack, future.impl, null);
    if (resultClass != void.class) {
        this.resultTemplate = messagePack.lookup(resultClass);
    }
}
 

public Future(MessagePack messagePack, Future<Value> future, Template resultTemplate) {
    this(messagePack, future.impl, resultTemplate);
}
 

public Reflect(MessagePack messagePack) {
    invokerBuilder = new ReflectionInvokerBuilder(messagePack);
    proxyBuilder = new ReflectionProxyBuilder(messagePack);
}
 

public JavassistInvokerBuilder(MessagePack messagePack) {
    pool = ClassPool.getDefault();
    this.messagePack = messagePack;
}
 

public Dispatcher build(Object handler, MessagePack messagePack) {
    return decorate(baseBuilder.build(handler,messagePack));
}
 

public MessagePackEncoder(int estimatedLength, MessagePack messagePack) {
    this.estimatedLength = estimatedLength;
    this.messagePack = messagePack;
}
 

public MessagePackEncoder(MessagePack messagePack) {
    this(1024, messagePack);
}