Netty 4.x怎么处理多个protobuf协议？

参考官方的例子：PortUnificationServerHandler

简单的说就是在每个包的第一个字符写一个特殊的char,通过这个字符来动态加载不同的handler，这样就可以在一个端口实现多个协议的解析。不过本人不建议这么做。

public class PortUnificationServerHandler extends ByteToMessageDecoder {



    private final SslContext sslCtx; 
    private final boolean detectSsl; 
    private final boolean detectGzip; 


    public PortUnificationServerHandler(SslContext sslCtx) { 
        this(sslCtx, true, true); 
    } 


    private PortUnificationServerHandler(SslContext sslCtx, boolean detectSsl, boolean detectGzip) { 
        this.sslCtx = sslCtx; 
        this.detectSsl = detectSsl; 
        this.detectGzip = detectGzip; 
    } 


    @Override 
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception { 
        // Will use the first five bytes to detect a protocol. 
        if (in.readableBytes() < 5) { 
            return; 
        } 


        if (isSsl(in)) { 
            enableSsl(ctx); 
        } else { 
            final int magic1 = in.getUnsignedByte(in.readerIndex()); 
            final int magic2 = in.getUnsignedByte(in.readerIndex() + 1); 
            if (isGzip(magic1, magic2)) { 
                enableGzip(ctx); 
            } else if (isHttp(magic1, magic2)) { 
                switchToHttp(ctx); 
            } else if (isFactorial(magic1)) { 
                switchToFactorial(ctx); 
            } else { 
                // Unknown protocol; discard everything and close the connection. 
                in.clear(); 
                ctx.close(); 
            } 
        } 
    } 


    private boolean isSsl(ByteBuf buf) { 
        if (detectSsl) { 
            return SslHandler.isEncrypted(buf); 
        } 
        return false; 
    } 


    private boolean isGzip(int magic1, int magic2) { 
        if (detectGzip) { 
            return magic1 == 31 && magic2 == 139; 
        } 
        return false; 
    } 


    private static boolean isHttp(int magic1, int magic2) { 
        return 
            magic1 == 'G' && magic2 == 'E' || // GET 
            magic1 == 'P' && magic2 == 'O' || // POST 
            magic1 == 'P' && magic2 == 'U' || // PUT 
            magic1 == 'H' && magic2 == 'E' || // HEAD 
            magic1 == 'O' && magic2 == 'P' || // OPTIONS 
            magic1 == 'P' && magic2 == 'A' || // PATCH 
            magic1 == 'D' && magic2 == 'E' || // DELETE 
            magic1 == 'T' && magic2 == 'R' || // TRACE 
            magic1 == 'C' && magic2 == 'O';   // CONNECT 
    } 


    private static boolean isFactorial(int magic1) { 
        return magic1 == 'F'; 
    } 


    private void enableSsl(ChannelHandlerContext ctx) { 
        ChannelPipeline p = ctx.pipeline(); 
        p.addLast("ssl", sslCtx.newHandler(ctx.alloc())); 
        p.addLast("unificationA", new PortUnificationServerHandler(sslCtx, false, detectGzip)); 
        p.remove(this); 
    } 


    private void enableGzip(ChannelHandlerContext ctx) { 
        ChannelPipeline p = ctx.pipeline(); 
        p.addLast("gzipdeflater", ZlibCodecFactory.newZlibEncoder(ZlibWrapper.GZIP)); 
        p.addLast("gzipinflater", ZlibCodecFactory.newZlibDecoder(ZlibWrapper.GZIP)); 
        p.addLast("unificationB", new PortUnificationServerHandler(sslCtx, detectSsl, false)); 
        p.remove(this); 
    } 


    private void switchToHttp(ChannelHandlerContext ctx) { 
        ChannelPipeline p = ctx.pipeline(); 
        p.addLast("decoder", new HttpRequestDecoder()); 
        p.addLast("encoder", new HttpResponseEncoder()); 
        p.addLast("deflater", new HttpContentCompressor()); 
        p.addLast("handler", new HttpSnoopServerHandler()); 
        p.remove(this); 
    } 


    private void switchToFactorial(ChannelHandlerContext ctx) { 
        ChannelPipeline p = ctx.pipeline(); 
        p.addLast("decoder", new BigIntegerDecoder()); 
        p.addLast("encoder", new NumberEncoder()); 
        p.addLast("handler", new FactorialServerHandler()); 
        p.remove(this); 
    } 
}