吃透Netty源码系列四十三之HttpRequestDecoder详解一
HttpRequestDecoder
这东西一看就知道是HTTP
请求的解码器,就是用来解析HTTP
协议格式的。我们用一个简单的例子来说,就下面这个,一个请求解码,一个响应编码,最后一个自定义的处理器,我们来分析下,请求解码做了什么。
pipeline.addLast(new HttpRequestDecoder());
pipeline.addLast(new HttpResponseEncoder());
pipeline.addLast("MyTestHttpServerHandler", new MyHttpServerHandler());
类结构
看到他是继承了一个HttpObjectDecoder
,这个应该是一个通用的HTTP
解码器,也是继承以前讲过的ByteToMessageDecoder
,我们先来看下HttpRequestDecoder
这个类,其实没多少东西,主要的在HttpObjectDecoder
都实现了。从下面可以看到其实这个类本身没实现什么解码逻辑,主要的还是在他的父类。
public class HttpRequestDecoder extends HttpObjectDecoder {
//构造函数
public HttpRequestDecoder() {
}
c HttpRequestDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize) {
super(maxInitialLineLength, maxHeaderSize, maxChunkSize, true);
}
public HttpRequestDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize, boolean validateHeaders) {
super(maxInitialLineLength, maxHeaderSize, maxChunkSize, true, validateHeaders);
}
public HttpRequestDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize, boolean validateHeaders,
int initialBufferSize) {
super(maxInitialLineLength, maxHeaderSize, maxChunkSize, true, validateHeaders, initialBufferSize);
}
//根据请求行创建HttpMessage 版本,方法,URI
@Override
protected HttpMessage createMessage(String[] initialLine) throws Exception {
return new DefaultHttpRequest(
HttpVersion.valueOf(initialLine[2]),
HttpMethod.valueOf(initialLine[0]), initialLine[1], validateHeaders);
}
//无效请求
@Override
protected HttpMessage createInvalidMessage() {
return new DefaultFullHttpRequest(HttpVersion.HTTP_1_0, HttpMethod.GET, "/bad-request", validateHeaders);
}
//是否是请求解码
@Override
protected boolean isDecodingRequest() {
return true;
}
}
HttpObjectDecoder
基本属性
我们先了解下一些重要的属性,因为要解析HTTP
协议格式,所以需要有换行符解析器,请求头解析器,还要看是否是用content-length
传输还是用transfer-encoding
块传输。还定义了一些状态,用来执行不同的逻辑。
private static final String EMPTY_VALUE = "";//请求头空值
private final int maxChunkSize;//块的最大长度
private final boolean chunkedSupported;//是否支持分块chunk发送
protected final boolean validateHeaders;//是否验证头名字合法性
private final HeaderParser headerParser;//请求头解析器
private final LineParser lineParser;//换行符解析器
private HttpMessage message;//请求的消息,包括请求行和请求头
private long chunkSize;//保存下一次要读的消息体长度
private long contentLength = Long.MIN_VALUE;//消息体长度
private volatile boolean resetRequested;//重置请求
// These will be updated by splitHeader(...)
private CharSequence name;//头名字
private CharSequence value;//头的值
private LastHttpContent trailer;//请求体结尾
·/** 状态
* The internal state of {@link HttpObjectDecoder}.
* <em>Internal use only</em>.
*/
private enum State {
SKIP_CONTROL_CHARS,//检查控制字符
READ_INITIAL,//开始读取
READ_HEADER,//读取头
READ_VARIABLE_LENGTH_CONTENT,//读取可变长内容,用于chunk传输
READ_FIXED_LENGTH_CONTENT,//读取固定长内容 用于Content-Length
READ_CHUNK_SIZE,//chunk传输的每个chunk尺寸
READ_CHUNKED_CONTENT,//每个chunk内容
READ_CHUNK_DELIMITER,//chunk分割
READ_CHUNK_FOOTER,//最后一个chunk
BAD_MESSAGE,//无效消息
UPGRADED//协议切换
}
//状态
private State currentState = State.SKIP_CONTROL_CHARS;
构造函数
构造函数,参数对应一行最大长度
,请求头的最大长度
,请求体或者某个块的最大长度
,是否支持chunk
块传输。
protected HttpObjectDecoder() {
this(4096, 8192, 8192, true);
}
/**
* Creates a new instance with the specified parameters.
*/
protected HttpObjectDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize, boolean chunkedSupported) {
this(maxInitialLineLength, maxHeaderSize, maxChunkSize, chunkedSupported, true);
}
/**
* Creates a new instance with the specified parameters.
*/
protected HttpObjectDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize,
boolean chunkedSupported, boolean validateHeaders) {
this(maxInitialLineLength, maxHeaderSize, maxChunkSize, chunkedSupported, validateHeaders, 128);
}
protected HttpObjectDecoder(
int maxInitialLineLength, int maxHeaderSize, int maxChunkSize,
boolean chunkedSupported, boolean validateHeaders, int initialBufferSize) {
checkPositive(maxInitialLineLength, "maxInitialLineLength");
checkPositive(maxHeaderSize, "maxHeaderSize");
checkPositive(maxChunkSize, "maxChunkSize");
AppendableCharSequence seq = new AppendableCharSequence(initialBufferSize);
lineParser = new LineParser(seq, maxInitialLineLength);
headerParser = new HeaderParser(seq, maxHeaderSize);
this.maxChunkSize = maxChunkSize;
this.chunkedSupported = chunkedSupported;
this.validateHeaders = validateHeaders;
}
AppendableCharSequence 可添加的字符序列
这个底层是一个字符数组,可以动态添加到最后,具体的源码可以自己看看,因为下面要用,所以我就提一下。
HeaderParser头解析器
其实就是检查字节缓冲区,获取一行头信息,ByteProcessor
这个就是处理是否遇到某个字节,就是process
方法。这边处理的就是如果发现是回车,就不添加任何字符,返回true
,继续解析,遇到换行就返回false
,不解析了,否则将字符添加到字符序列中,返回true
,继续解析。
private static class HeaderParser implements ByteProcessor {
private final AppendableCharSequence seq;//可添加的字符序列
private final int maxLength;//最大长度
private int size;//索引
HeaderParser(AppendableCharSequence seq, int maxLength) {
this.seq = seq;
this.maxLength = maxLength;
}
//解析缓冲区
public AppendableCharSequence parse(ByteBuf buffer) {
final int oldSize = size;
seq.reset();
int i = buffer.forEachByte(this);
if (i == -1) {//没读到换行,或者报异常了
size = oldSize;
return null;
}
buffer.readerIndex(i + 1);
return seq;
}
//读到的字符个数清零
public void reset() {
size = 0;
}
//处理数据,遇到换行了就结束
@Override
public boolean process(byte value) throws Exception {
char nextByte = (char) (value & 0xFF);
if (nextByte == HttpConstants.CR) {//遇到回车符,直接返回true,不添加字符
return true;
}
if (nextByte == HttpConstants.LF) {//遇到换行符,就会结束
return false;
}
if (++ size > maxLength) {//溢出了
throw newException(maxLength);
}
seq.append(nextByte);//添加
return true;
}
//头过大
protected TooLongFrameException newException(int maxLength) {
return new TooLongFrameException("HTTP header is larger than " + maxLength + " bytes.");
}
}
process哪里用到呢
其实是在parse
方法的buffer.forEachByte(this)
里。
forEachByte
这个方法就是传一个字节处理器,然后字节缓冲区挨个处理字节,返回索引。
@Override
public int forEachByte(ByteProcessor processor) {
ensureAccessible();
try {
return forEachByteAsc0(readerIndex, writerIndex, processor);
} catch (Exception e) {
PlatformDependent.throwException(e);
return -1;
}
}
forEachByteAsc0
这个就是具体的方法啦,里面调用了processor
的process
方法,从头到位把每个字节传进去处理,如果有遇到换行符,会返回相应索引,否则就是-1
。
int forEachByteAsc0(int start, int end, ByteProcessor processor) throws Exception {
for (; start < end; ++start) {
if (!processor.process(_getByte(start))) {
return start;
}
}
return -1;//表示没有遇到换行符
}
LineParser行解析器
继承了头解析器,只是解析的时候要reset
一下,就是把读到的个数清0
,因为是一行行读,每次读完一行就得清理个数。虽然字符串序列可以不处理,可以复用。
private static final class LineParser extends HeaderParser {
LineParser(AppendableCharSequence seq, int maxLength) {
super(seq, maxLength);
}
@Override
public AppendableCharSequence parse(ByteBuf buffer) {
reset();//从头开始,要重置索引
return super.parse(buffer);
}
@Override
protected TooLongFrameException newException(int maxLength) {
return new TooLongFrameException("An HTTP line is larger than " + maxLength + " bytes.");
}
}
decode解码
这个是最核心的方法,包括了解析请求行,请求头,请求体,但是会将请求行和请求头整合起来形成一个请求DefaultHttpRequest
传递到后面,把请求体再封装成消息体传递到后面,因为请求体可能很大,所以也可能会有多次封装,那后面处理器就可能收到多次消息体。如果是GET
的话是没有消息体的,首先收到一个DefaultHttpRequest,然后
是一个空
的LastHttpContent
。如果是POST
的话,先收到DefaultHttpRequest
,然后可能多个内容DefaultHttpContent
和一个DefaultLastHttpContent
。下面我们来看源码,这个方法源码很长,所以我打算按照状态来讲。
检查并略过控制字符SKIP_CONTROL_CHARS
首先我们要检查下我们的字节缓冲区里面是不是全是控制字符(类似回车换行,空格这种),如果是的话就不处理,返回了,不是的话就略过控制字符,然后返回。如果不全是控制字符,那就状态切换到READ_INITIAL
开始读取。
case SKIP_CONTROL_CHARS: {
if (!skipControlCharacters(buffer)) {
return;//如果全是控制字符就返回了
}
currentState = State.READ_INITIAL;
}
skipControlCharacters略过控制字符
这个方法就是看没有不是控制字符的,如果全是控制字符,就返回false
,有不是控制字符的就略过控制字符并返回true
。具体方法就是从可读索引开始,直接获取对应的无符号字节,然后判断是不是ISO的控制字符或者空格,如果不是,直接就返回,否则就继续,直到遇到不是的位置,然后要略过控制字符。
private static boolean skipControlCharacters(ByteBuf buffer) {
boolean skiped = false;
final int wIdx = buffer.writerIndex();
int rIdx = buffer.readerIndex();
while (wIdx > rIdx) {
int c = buffer.getUnsignedByte(rIdx++);//获取无符号字节
if (!Character.isISOControl(c) && !Character.isWhitespace(c)) {//不是ISO的控制字符也不是空格
rIdx--;
skiped = true;//有不是控制字符的,直接返回
break;
}
}
buffer.readerIndex(rIdx);//略过控制字符
return skiped;
}
开始读取READ_INITIAL
会开始读取一行,如果没有读到换行符,可能是因为数据还没收全,那就什么都不做,返回。
否则就开始分割,分割出方法,URI,协议
,当然如果请求头无效,就不管了,重新返回到SKIP_CONTROL_CHARS
状态。如果是有效的,就封装成请求消息HttpMessage
包括请求行和请求头信息,讲状态切换到READ_HEADER
读头信息。
case READ_INITIAL: try {//读取请求行
AppendableCharSequence line = lineParser.parse(buffer);//解析一行数据
if (line == null) {//没解析到换行符
return;
}
String[] initialLine = splitInitialLine(line);//行分割后的数组
if (initialLine.length < 3) {//小于3个就说明格式(方法 URI 版本)不对,直接忽略
// Invalid initial line - ignore.
currentState = State.SKIP_CONTROL_CHARS;
return;
}
message = createMessage(initialLine);//创建请求消息
currentState = State.READ_HEADER;
// fall-through
} catch (Exception e) {
out.add(invalidMessage(buffer, e));
return;
}
splitInitialLine分割请求行
可以看到其实执行了3
次检测,刚好把请求行给分割出来,最后用字符串切割出来封装成数组返回。
//按空格进行一行的分割
private static String[] splitInitialLine(AppendableCharSequence sb) {
int aStart;
int aEnd;
int bStart;
int bEnd;
int cStart;
int cEnd;
aStart = findNonWhitespace(sb, 0);//找出不是空格的第一个索引
aEnd = findWhitespace(sb, aStart);//找出空格索引
bStart = findNonWhitespace(sb, aEnd);
bEnd = findWhitespace(sb, bStart);
cStart = findNonWhitespace(sb, bEnd);
cEnd = findEndOfString(sb);
return new String[] {
sb.subStringUnsafe(aStart, aEnd),
sb.subStringUnsafe(bStart, bEnd),
cStart < cEnd? sb.subStringUnsafe(cStart, cEnd) : "" };
}
createMessage创建请求消息
创建一个DefaultHttpRequest
,就是一个HttpRequest
接口的默认实现,封装请求行和请求头信息。
@Override
protected HttpMessage createMessage(String[] initialLine) throws Exception {
return new DefaultHttpRequest(
HttpVersion.valueOf(initialLine[2]),//协议版本
HttpMethod.valueOf(initialLine[0]), initialLine[1], validateHeaders);//方法和URI
}
invalidMessage无效消息
创建一个无效消息,状态直接为BAD_MESSAGE
无效,把缓冲区内的数据直接都略过,如果请求消息没创建好,就创建一个,然后设置失败结果并带上异常信息返回。
private HttpMessage invalidMessage(ByteBuf in, Exception cause) {
currentState = State.BAD_MESSAGE;//设置无效数据,这样后面同一个消息的数据都会被略过
in.skipBytes(in.readableBytes());//直接不可读,略过可读数据
if (message == null) {
message = createInvalidMessage();
}
message.setDecoderResult(DecoderResult.failure(cause));//设置失败
HttpMessage ret = message;
message = null;
return ret;
}
createInvalidMessage创建完整的请求
直接返回完整的请求消息,参数设置成有问题的就可以了。
@Override
protected HttpMessage createInvalidMessage() {
return new DefaultFullHttpRequest(HttpVersion.HTTP_1_0, HttpMethod.GET, "/bad-request", validateHeaders);
}
刚好讲完了解析请求行,好像有点多了,下一篇再讲解析头吧。
好了,今天就到这里了,希望对学习理解有帮助,大神看见勿喷,仅为自己的学习理解,能力有限,请多包涵。