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 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;
}
 

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 byte[] pack(Object obj) {
    try {
        return MessagePack.pack( obj );
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}
 

public Value unpack(byte[] obj) {
    try {
        return MessagePack.unpack(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));
}
 

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

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 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);
    }
 

@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 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);

}
 

/**
 * 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 NettyEventLoop(ExecutorService workerExecutor,
        ExecutorService ioExecutor,
        ScheduledExecutorService scheduledExecutor, MessagePack messagePack) {
    super(workerExecutor, ioExecutor, scheduledExecutor, messagePack);
}
 

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

@Override
protected void encode(ChannelHandlerContext ctx, Packet packet, ByteBuf out) throws Exception {
    out.writeBytes(new MessagePack().write(packet));
}
 

@Bean
public MessagePack messagePack() {
    return new MessagePack();
}
 

public MessagePackHolder(MessagePack messagePack) {
    this.messagePack = messagePack;
}
 

@Override
protected AbstractParser createParser() {
    MessagePack mp = new MessagePack();
    return new MsgpackParser(mp.createUnpacker(in), handlers, defaultHandler,
            mapBuilder, listBuilder);
}
 

public MessagePackTranscoder(final MessagePack messagePack, final Type valueType) {
  this.messagePack = Objects.requireNonNull(messagePack, "messagePack must not be null");
  this.valueType = Objects.requireNonNull(valueType, "valueType must not be null");
}
 

public MessagePackRequestMarshaller() {
  msgPack = new MessagePack();
  msgPackMarshallingStrategy = new MessagePackMarshallingStrategy(msgPack);
}
 

public EventLoop make(ExecutorService workerExecutor,
        ExecutorService ioExecutor,
        ScheduledExecutorService scheduledExecutor, MessagePack messagePack) {
    return new NettyEventLoop(workerExecutor, ioExecutor,
            scheduledExecutor, messagePack);
}
 

public MessagePackStreamDecoder(MessagePack msgpack) {
    super();
    this.msgpack = msgpack;
}
 

StreamPipelineFactory(MessagePack messagePack, RpcMessageHandler handler) {
    this.handler = handler;
    this.messagePack = messagePack;
}
 

public MessagePackDecoder(MessagePack messagePack) {
    super();
    this.messagePack = messagePack;
}
 

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

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

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

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

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

public MessagePack getMessagePack() {
    return messagePack;
}