Java MessageToByteEncoder类代码示例

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
protected AbstractNetTcp(DataManager data, MessageReceivedListener listener, String netName){
	super(data, netName);
	initializer = new ChannelInitializer<SocketChannel>() {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			ch.pipeline().addLast("encoder", new MessageToByteEncoder<byte[]>() {
				@Override
				protected void encode(ChannelHandlerContext ctx, byte[] msg, ByteBuf out) throws Exception {
					out.writeBytes(msg);
				}
			});
			ch.pipeline().addLast("handler", new TCPHandler(data, listener));
		}
	};
	this.data = data;
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
    UserConnection info = new UserConnection(socketChannel);
    // init protocol
    new ProtocolPipeline(info);
    // Add originals
    this.method.invoke(this.original, socketChannel);

    HandlerConstructor constructor = ClassGenerator.getConstructor();
    // Add our transformers
    MessageToByteEncoder encoder = constructor.newEncodeHandler(info, (MessageToByteEncoder) socketChannel.pipeline().get("encoder"));
    ByteToMessageDecoder decoder = constructor.newDecodeHandler(info, (ByteToMessageDecoder) socketChannel.pipeline().get("decoder"));
    BukkitPacketHandler chunkHandler = new BukkitPacketHandler(info);

    socketChannel.pipeline().replace("encoder", "encoder", encoder);
    socketChannel.pipeline().replace("decoder", "decoder", decoder);
    socketChannel.pipeline().addAfter("packet_handler", "viaversion_packet_handler", chunkHandler);
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
    // Ensure ViaVersion is loaded
    if (ProtocolRegistry.SERVER_PROTOCOL != -1) {
        UserConnection info = new UserConnection(socketChannel);
        // init protocol
        new ProtocolPipeline(info);
        // Add originals
        this.method.invoke(this.original, socketChannel);
        // Add our transformers
        MessageToByteEncoder encoder = new SpongeEncodeHandler(info, (MessageToByteEncoder) socketChannel.pipeline().get("encoder"));
        ByteToMessageDecoder decoder = new SpongeDecodeHandler(info, (ByteToMessageDecoder) socketChannel.pipeline().get("decoder"));
        SpongePacketHandler chunkHandler = new SpongePacketHandler(info);

        socketChannel.pipeline().replace("encoder", "encoder", encoder);
        socketChannel.pipeline().replace("decoder", "decoder", decoder);
        socketChannel.pipeline().addAfter("packet_handler", "viaversion_packet_handler", chunkHandler);
    } else {
        this.method.invoke(this.original, socketChannel);
    }
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
public static ByteBuf callEncode(MessageToByteEncoder encoder, ChannelHandlerContext ctx, ByteBuf input) throws InvocationTargetException {
    ByteBuf output = ctx.alloc().buffer();
    try {
        BungeePipelineUtil.ENCODE_METHOD.invoke(encoder, ctx, input, output);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return output;
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
public static ByteBuf compress(ChannelHandlerContext ctx, ByteBuf bytebuf) {
    try {
        return callEncode((MessageToByteEncoder) ctx.pipeline().get("compress"), ctx.pipeline().context("compress"), bytebuf);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
        return ctx.alloc().buffer();
    }
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
public MessageToByteEncoder<Object> getEncoder() {
    ByteEncoder encoder = new ByteEncoder();
    encoder.setMessageCodec(msgCodec);
    encoder.setHeadCodec(headCodec);
    return encoder;
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
protected Result beginEncode(HttpResponse headers, String acceptEncoding) {
    return new Result("test", new EmbeddedChannel(new MessageToByteEncoder<ByteBuf>() {
        @Override
        protected void encode(ChannelHandlerContext ctx, ByteBuf in, ByteBuf out) throws Exception {
            out.writeBytes(String.valueOf(in.readableBytes()).getBytes(CharsetUtil.US_ASCII));
            in.skipBytes(in.readableBytes());
        }
    }));
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
public ChannelOutboundHandler newEncoder() {
	return new MessageToByteEncoder<byte[]>() {

		@Override
		protected void encode(ChannelHandlerContext ctx, byte[] msg,
				ByteBuf out) throws Exception {
			out.writeBytes(msg);
		}
		
	};
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
public ChannelOutboundHandler newEncoder() {
	return new MessageToByteEncoder<ByteBean>() {

		@Override
		protected void encode(ChannelHandlerContext ctx, ByteBean msg,
				ByteBuf out) throws Exception {
			out.writeBytes(msg.getContent(), msg.getPosition(), msg.getLength());
		}
		
	};
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
protected Result beginEncode(HttpResponse headers, CharSequence acceptEncoding) {
    return new Result("test", new EmbeddedChannel(new MessageToByteEncoder<ByteBuf>() {
        @Override
        protected void encode(ChannelHandlerContext ctx, ByteBuf in, ByteBuf out) throws Exception {
            out.writeBytes(String.valueOf(in.readableBytes()).getBytes(CharsetUtil.US_ASCII));
            in.skipBytes(in.readableBytes());
        }
    }));
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
@Override
public BukkitEncodeHandler newEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    return new BukkitEncodeHandler(info, minecraftEncoder);
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
public BukkitEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    this.info = info;
    this.minecraftEncoder = minecraftEncoder;
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
public SpongeEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    this.info = info;
    this.minecraftEncoder = minecraftEncoder;
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
/**
 * Call the encode method on a netty MessageToByteEncoder
 *
 * @param encoder The encoder
 * @param ctx     The current context
 * @param msg     The packet to encode
 * @param output  The bytebuf to write the output to
 * @throws InvocationTargetException If an exception happens while executing
 */
public static void callEncode(MessageToByteEncoder encoder, ChannelHandlerContext ctx, Object msg, ByteBuf output) throws InvocationTargetException {
    try {
        PipelineUtil.ENCODE_METHOD.invoke(encoder, ctx, msg, output);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}
 

import io.netty.handler.codec.MessageToByteEncoder; //导入依赖的package包/类
/**
 * 获取编码器 @see MessageToByteEncoder
 * 
 * @return 编码器
 */
MessageToByteEncoder<Object> getEncoder();