解决Netty解码http请求获取URL乱码问题

目录

• Netty解码http请求获取URL乱码
• 解决方案
• 原因
• Netty---编解码(原理) 
• 1.ByteToMessageDecoder
• 2.FixedLengthFrameDecoder
• 3.MessageToByteEncoder

Netty解码http请求获取URL乱码

解决方案

获取URI时，使用URLDecoder进行解码

    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
        FullHttpRequest fhr = (FullHttpRequest) msg;
        String uri = URLDecoder.decode(fhr.uri().trim().replace("/", "")
                .replace("\\", ""), "UTF-8");
    }

原因

1、URLEncoder.encode和URLDecoder.decode

URL只能使用英文字母、阿拉伯数字和某些标点符号，不能使用其他文字和符号，即

只有字母和数字[0-9a-zA-Z]、一些特殊符号$-_.+!*'()[不包括双引号]、以及某些保留字（空格转换为+），才可以不经过编码直接用于URL，如果URL中有汉字，就必须编码后使用。

• URLDecoder类包含一个decode(String s,String enc)静态方法，它可以将application/x-www-form-urlencoded MIME字符串转成编码前的字符串；
• URLEncoder类包含一个encode(String s,String enc)静态方法，它可以将中文字符及特殊字符用转换成application/x-www-form-urlencoded MIME字符串。

2、使用URLEncoder.encode编码

public static String urlEncode(String urlToken) {
    String encoded = null;
    try {
        //用URLEncoder.encode方法会把空格变成加号（+）,encode之后在替换一下
        encoded = URLEncoder.encode(urlToken, "UTF-8").replace("+", "%20");
    } catch (UnsupportedEncodingException e) {
        logger.error("URLEncode error {}", e);
    }
    return encoded;
}

3、使用URLEncoder.encode解码

public static String urlEncode(String urlToken) {
    String decoded = null;
    try {
        decoded =URLDecoder.decode(urlToken, "UTF-8"); 
    } catch (UnsupportedEncodingException e) {
        logger.error("URLEncode error {}", e);
    }
    return decoded;
}

Netty---编解码(原理) 

1.ByteToMessageDecoder

用于将ByteBuf解码成为POJO对象

重要字段：

ByteBuf cumulation;     //缓存
private Cumulator cumulator = MERGE_CUMULATOR; //累计器
private boolean singleDecode;  
private boolean first; //是否第一次解码
private boolean firedChannelRead;
//状态码
private byte decodeState = STATE_INIT;
private int discardAfterReads = 16; //解码次数阈值，用来删除已读数据
private int numReads; //解码次数

介绍一下累计器：Cumulator类是干什么的

它的本类中的内部类，而且还是一个接口，只提供了方法。它的实现，只有匿名类，所以就是开头的静态两个字段了。

public interface Cumulator {
    ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in);
}

也就是我们默认使用的cumulator->MEGRE_CUMULATOR，我们看看它是如何实现的cumulator接口

public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
    //参数：ByteBuf的分配器，本类中的ByteBuf，传递过来的ByteBuf
    @Override
    public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
        if (!cumulation.isReadable() && in.isContiguous()) {
            累加的不可读（比如空缓存），且新的是连续的
            cumulation.release(); //释放
            return in;
        }
        try {
            final int required = in.readableBytes(); //返回可读区域
            //可读区域，大于累加器中的可写区域， 或者累加器只能读
            if (required > cumulation.maxWritableBytes() ||
                    (required > cumulation.maxFastWritableBytes() && cumulation.refCnt() > 1) ||
                    cumulation.isReadOnly()) {
                return expandCumulation(alloc, cumulation, in); //扩充累计器
            }
            //写入到累计器中
            cumulation.writeBytes(in, in.readerIndex(), required);
            in.readerIndex(in.writerIndex()); //调整in的读指针到写的位置，那么可读区域为0
            return cumulation;
        } finally {
            in.release();  //释放ByteBuf
        }
    }
};

这个类的实现方法，很重要，因为下面的ChannelRead()方法的核心就是调用上面的方法，

重要方法：channelRead()

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    if (msg instanceof ByteBuf) { //判断传入的 是否是ByteBuf对象
        CodecOutputList out = CodecOutputList.newInstance();
        try {
            first = cumulation == null;  //如果为null，说明是第一次
            cumulation = cumulator.cumulate(ctx.alloc(),
                    first ? Unpooled.EMPTY_BUFFER : cumulation, (ByteBuf) msg); //判断解码器是否缓存了没有解码完成的半包信息
            callDecode(ctx, cumulation, out);                               //如果为空，说明第一次解析，或者上一次的已经解析完成。
        }...
        } finally {
            try {
                if (cumulation != null && !cumulation.isReadable()) { //不为空，不可读，要释放
                    numReads = 0;
                    cumulation.release();
                    cumulation = null;
                } else if (++numReads >= discardAfterReads) {//读取数据的次数大于阈值，则尝试丢弃已读数据
                    numReads = 0;
                    discardSomeReadBytes();
                }
                int size = out.size();
                firedChannelRead |= out.insertSinceRecycled(); //有被添加或者设置，表示已经读过了
                fireChannelRead(ctx, out, size);   //尝试传递数据
            } finally {
                out.recycle();
            }
        }
    } else {
        ctx.fireChannelRead(msg);  //其他类型进行传递
    }
}

先看ctx.alloc()方法就得到的什么，它对应上面cumulator()的第一个参数，返回的自然是Bytebuf的分配器

public ByteBufAllocator alloc() {
    return channel().config().getAllocator(); //返回ByteBufAllocator，要嘛是池化的，要嘛是非池化
}

如何对msg中的信息，进行转移到本地的cumulator中，

之后调用callDecode进行解码

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List