func main() {
   // 对8080端口进行监听
   l, _ := net.Listen("tcp", ":8080")
   // 获取和端口8080完成三次握手的tcp连接
   conn, _ := l.Accept()
   // 此时便能够使用该连接和客户端进行通信
   data := make([]byte, 4096)
   // 可以从conn读取数据缓冲区当中
   conn.Read(data)
   // 将缓冲区的数据打印处理
   print(string(data))
}

type Conn interface {
   // Read reads data from the connection.
   // Read can be made to time out and return an error after a fixed
   // time limit; see SetDeadline and SetReadDeadline.
   Read(b []byte) (n int, err error)
 
   // Write writes data to the connection.
   // Write can be made to time out and return an error after a fixed
   // time limit; see SetDeadline and SetWriteDeadline.
   Write(b []byte) (n int, err error)
 
   // Close closes the connection.
   // Any blocked Read or Write operations will be unblocked and return errors.
   Close() error
}

type Conn struct {
   rwc     net.Conn
   // bufio.Reader 提供了缓存的功能，以及一些函数，方便我们解析HTTP请求体
   br      *bufio.Reader
   bw      *bufio.Writer
   // 是否已经写入响应头
   wroteHaeder bool
 }
 func NewConn(rwc net.Conn) *Conn {
   return &Conn{
      rwc:     rwc,
      br:      bufio.NewReader(rwc),
      bw:      bufio.NewWriter(rwc),
   }
}

type Request struct {
   // 存储请求方法,上面例子便是GET 
   method string
   // 用于存储请求的uri
   uri    string
   // 用于存储http版本
   proto  string
   // http首部字段
   Header map[string]string
}

func (c *Conn) readRequest() (*Request, error) {
   req := NewRequest()
   // 现在只支持Get请求，读取第一行内容
   // GET /ping HTTP1.1
   line, err := c.br.ReadBytes('\n')
   if err != nil {
      return req, err
   }
   var f []string
   // 按空格来进行分割,将请求行分割为三部分
   if f = strings.Split(string(line), " "); len(f) != 3 {
      return req, errors.New("http Header error")
   }
   // 获取到GET, /ping, HTTP/1.1
   req.method, req.url, req.proto = f[0], f[1], f[2]
   // 解析请求体首部字段
   for {   
      line, err = c.br.ReadBytes('\n')
      if err != nil {
         return nil, err
      }
      // 当读取到空行时，说明已经首部字段已经读取完了
      if len(strings.TrimSpace(string(line))) == 0 {
         break
      }
      //举例，读取connection: keep-alive,获取第一个空格的下标
      i := bytes.IndexByte(line, ' ')
      if i == -1 {
         return nil, errors.New("header is error")
      }
      // 此时获取到请求首部key，为connection
      key := string(line[:i-1])
      // 读取到对应的值，这里读取到keep-alive
      value := strings.TrimSpace(string(line[i:]))
      // 简单读取头部字段即可
      req.Header[key] = value
   }
}

func main() {
   // 对8080端口进行监听
   l, _ := net.Listen("tcp", ":8080")
   // 获取和端口8080完成三次握手的tcp连接
   conn, _ := l.Accept()
   // 获取到conn连接
   c := NewConn(conn, handler)
   // 读取到请求体
   req, _ := c.readRequest()
   if request.uri == "/hello" {
     ....
   }else{
     .... 
   }
 }

const (
   StatusOK = 200
)
var statusText = map[int]string{
   StatusOK:                   "OK",
}
 
// 返回响应行
// 构造响应行 HTTP/1.1 200 OK
func (c *Conn) writeHeader(status int) error {
   if c.wroteHeader {
      return errors.New("code has been set")
   }
   c.wroteHeader = true
   var proto string
   //GET /hello HTTP/1.1
   proto = "HTTP/1.1"
   // 获取文本描述,这里为OK
   text, ok := statusText[status]
   if !ok {
      text = "status code " + strconv.Itoa(status)
   }
   // 写入数据 HTTP1.1 200 OK\r\n
   c.bw.WriteString(proto + " " + strconv.Itoa(status) + " " + text + "\r\n")
   // 写入空行
   c.bw.Write("\r\n")
   return nil
}
// 写入响应数据
func (c *Conn) WriteData(data []byte) error {
   // 还没写入请求头 
   if !c.wroteHeader {
       //默认状态码是200 OK
       c.writeHeader(StatusOK)
   }
   c.bw.Write(data)
   return nil
}

func main() {
   // 对8080端口进行监听
   l, _ := net.Listen("tcp", ":8080")
   // 获取和端口8080完成三次握手的tcp连接
   conn, _ := l.Accept()
   // 获取到conn连接
   c := NewConn(conn)
   // 读取到请求体
   req, _ := c.readRequest()
   if request.uri == "hello" {
      c.WriteData("hello")
   }else{
      c.WriteData("hello world")
   }
   // 在最后,需要将缓冲区的数据进行清空
   c.bw.Flush()
   // 因为响应没有设置content-length,所以只有连接断开后，
   // 浏览器才知道数据读取完成了,此处需要断开连接
   c.rwc.Close()
 }