Java 类io.netty.handler.codec.MessageToByteEncoder 实例源码

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

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

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

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

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

@Override
public MessageToByteEncoder<Object> getEncoder() {
    ByteEncoder encoder = new ByteEncoder();
    encoder.setMessageCodec(msgCodec);
    encoder.setHeadCodec(headCodec);
    return encoder;
}

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

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

@Override
public ChannelOutboundHandler newEncoder() {
    return new MessageToByteEncoder<byte[]>() {

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

    };
}

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

    };
}

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

@Override
public BukkitEncodeHandler newEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    return new BukkitEncodeHandler(info, minecraftEncoder);
}

public BukkitEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    this.info = info;
    this.minecraftEncoder = minecraftEncoder;
}

public SpongeEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder) {
    this.info = info;
    this.minecraftEncoder = minecraftEncoder;
}

/**
 * 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();
    }
}

/**
 * 获取编码器 @see MessageToByteEncoder
 * 
 * @return 编码器
 */
MessageToByteEncoder<Object> getEncoder();

public MessageToByteEncoder newEncodeHandler(UserConnection info, MessageToByteEncoder minecraftEncoder);