问题
body, err := ioutil.ReadAll(c.Request().Body)
代码执行完成后，c.Request().Body 内容变成了空，这是为什么？
代码分析
step1 调用内部函数，每次至少读512字节（怎么定的呢？）
可以注意到底层调用了buffer的ReadFrom函数
// readAll reads from r until an error or EOF and returns the data it read
// from the internal buffer allocated with a specified capacity.
func readAll(r io.Reader, capacity int64) (b []byte, err error) {
buf := bytes.NewBuffer(make([]byte, 0, capacity))
// If the buffer overflows, we will get bytes.ErrTooLarge.
// Return that as an error. Any other panic remains.
defer func() {
e := recover()
if e == nil {
return
}
if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
err = panicErr
} else {
panic(e)
}
}()
_, err = buf.ReadFrom(r)
return buf.Bytes(), err
}
// ReadAll reads from r until an error or EOF and returns the data it read.
// A successful call returns err == nil, not err == EOF. Because ReadAll is
// defined to read from src until EOF, it does not treat an EOF from Read
// as an error to be reported.
func ReadAll(r io.Reader) ([]byte, error) {
return readAll(r, bytes.MinRead)
}
step2 buffer readFrom实现分析
Buffer定义，buf：存放的数据，buf中off到len(buf)之间的数据为有效数据，其余数据为0，读的时候从buf[off]开始，写是在buf[len(buf)]。
// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
buf []byte // contents are the bytes buf[off : len(buf)]
off int // read at &buf[off], write at &buf[len(buf)]
bootstrap [64]byte // memory to hold first slice; helps small buffers avoid allocation.
lastRead readOp // last read operation, so that Unread* can work correctly.
}
// ReadFrom reads data from r until EOF and appends it to the buffer, growing
// the buffer as needed. The return value n is the number of bytes read. Any
// error except io.EOF encountered during the read is also returned. If the
// buffer becomes too large, ReadFrom will panic with ErrTooLarge.
func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
b.lastRead = opInvalid
// If buffer is empty, reset to recover space.
if b.off >= len(b.buf) {
b.Truncate(0)
}
for {
//buff 末尾使用的空间不足时，扩容
if free := cap(b.buf) - len(b.buf); free < MinRead {
// not enough space at end，buffer正常情况下是直接尾部写入数据，当发现尾部空间不足时，就需要调整buffer存储形式，将数据区buf[off]到buf[len(buf)]对齐到头部，攒出尾部空间来继续存储。
newBuf := b.buf
if b.off+free < MinRead { //发现可用的空间不够用时，就需要扩容，扩容办法是原buf cap的两倍+最小读取数据大小
// not enough space using beginning of buffer;
// double buffer capacity
newBuf = makeSlice(2*cap(b.buf) + MinRead)
}
copy(newBuf, b.buf[b.off:])//将buf数据区copy到临时buf
b.buf = newBuf[:len(b.buf)-b.off]//再从临时buf把数据copy回去，完成对齐头部
b.off = 0
}
m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])//传入buf 的长度与cap之间的空间给reader
b.buf = b.buf[0 : len(b.buf)+m]//buf取到真实读取的字节位置
n += int64(m)//读取的总字节数增加
if e == io.EOF {//读到eof标记时停止
break
}
if e != nil {
return n, e
}
}
return n, nil // err is EOF, so return nil explicitly
}
step3 io.Reader 的Read实现;以c.Request().Body为例
其中body是这么定义的，是封装了Reader和Closer的interface
Body io.ReadCloser
那么body的reader到底是什么呢？body是在Request结构体中定义的，内容是请求的body体，因此连接建立起来后，body会被赋值，沿着这个思路，找到准备body的reader代码的地方，详细查找路基如下：
【http启动服务】func (srv *Server) Serve(l net.Listener) =>【建立连接】go c.serve(ctx)=>【读取request】c.readRequest(ctx)=>【读取request详细信息】readRequest(b *bufio.Reader, deleteHostHeader bool)=>【解析http协议，读取信息】readTransfer(msg interface{}, r *bufio.Reader)
// Prepare body reader. ContentLength < 0 means chunked encoding
// or close connection when finished, since multipart is not supported yet
switch {
case chunked(t.TransferEncoding):
if noResponseBodyExpected(t.RequestMethod) {
t.Body = NoBody
} else {
t.Body = &body{src: internal.NewChunkedReader(r), hdr: msg, r: r, closing: t.Close}
}
case realLength == 0:
t.Body = NoBody
case realLength > 0:
t.Body = &body{src: io.LimitReader(r, realLength), closing: t.Close}
default:
// realLength < 0, i.e. "Content-Length" not mentioned in header
if t.Close {
// Close semantics (i.e. HTTP/1.0)
t.Body = &body{src: r, closing: t.Close}
} else {
// Persistent connection (i.e. HTTP/1.1)
t.Body = NoBody
}
}
至此，我们发现body是一个bufio.Reader，其定义如下
type Reader struct {
buf []byte //缓冲区
rd io.Reader // reader provided by the client
r, w int // buf read and write positions
err error
lastByte int
lastRuneSize int
}
在server.go中，我们注意到如下初始化，也就是说body是一个带缓冲区的io reader，并且connReader作为数据源的reader
c.r = &connReader{conn: c}
c.bufr = newBufioReader(c.r)
关键！从缓冲区读取数据区，并将buf的读off加n，也就是将buf中已读的数据清空
// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying Reader,
// hence n may be less than len(p).
// At EOF, the count will be zero and err will be io.EOF.
func (b *Reader) Read(p []byte) (n int, err error) {
n = len(p)
if n == 0 {
return 0, b.readErr()
}
if b.r == b.w {
if b.err != nil {
return 0, b.readErr()
}
if len(p) >= len(b.buf) {
// Large read, empty buffer.
// Read directly into p to avoid copy.
n, b.err = b.rd.Read(p)
if n < 0 {
panic(errNegativeRead)
}
if n > 0 {
b.lastByte = int(p[n-1])
b.lastRuneSize = -1
}
return n, b.readErr()
}
// One read.
// Do not use b.fill, which will loop.
b.r = 0
b.w = 0
n, b.err = b.rd.Read(b.buf)////buf为空时，直接从conn的reader中读取，不涉及r、w的变化，buf还是空
if n < 0 {
panic(errNegativeRead)
}
if n == 0 {
return 0, b.readErr()
}
b.w += n
}
// copy as much as we can
n = copy(p, b.buf[b.r:b.w])//从缓冲区读取数据区
b.r += n//将buf的读off加n，也就是将buf中已读的数据清空
b.lastByte = int(b.buf[b.r-1])
b.lastRuneSize = -1
return n, nil
}
结论
ioutil.ReadAll(c.Request().Body) 最终会调用bufio.Reader 的read方法来读取数据，buf被读取后，数据会被清空，所以 ioutil.ReadAll(c.Request().Body) 再次调用时，也读不到数据啦~
