1
type Request struct

1
// 利用指定的method, url以及可选的body返回一个新的请求.如果body参数实现了
2
// io.Closer接口，Request返回值的Body 字段会被设置为body，并会被Client
3
// 类型的Do、Post和PostForm方法以及Transport.RoundTrip方法关闭。
4
func NewRequest(method, urlStr string, body io.Reader) (*Request, error)
5

6
// 从b中读取和解析一个请求.
7
func ReadRequest(b *bufio.Reader) (req *Request, err error)
8

9
// 给request添加cookie, AddCookie向请求中添加一个cookie.按照RFC 6265
10
// section 5.4的规则, AddCookie不会添加超过一个Cookie头字段.
11
// 这表示所有的cookie都写在同一行, 用分号分隔（cookie内部用逗号分隔属性）
12
func (r *Request) AddCookie(c *Cookie)
13

14
// 返回request中指定名name的cookie，如果没有发现，返回ErrNoCookie
15
func (r *Request) Cookie(name string) (*Cookie, error)
16

17
// 返回该请求的所有cookies
18
func (r *Request) Cookies() []*Cookie
19

20
// 利用提供的用户名和密码给http基本权限提供具有一定权限的header。
21
// 当使用http基本授权时，用户名和密码是不加密的
22
func (r *Request) SetBasicAuth(username, password string)
23

24
// 如果在request中发送，该函数返回客户端的user-Agent
25
func (r *Request) UserAgent() string
26

27
// 对于指定格式的key，FormFile返回符合条件的第一个文件，如果有必要的话，
28
// 该函数会调用ParseMultipartForm和ParseForm。
29
func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)
30

31
// 返回key获取的队列中第一个值。在查询过程中post和put中的主题参数优先级
32
// 高于url中的value。为了访问相同key的多个值，调用ParseForm然后直接
33
// 检查RequestForm。
34
func (r *Request) FormValue(key string) string
35

36
// 如果这是一个有多部分组成的post请求，该函数将会返回一个MIME 多部分reader，
37
// 否则的话将会返回一个nil和error。使用本函数代替ParseMultipartForm
38
// 可以将请求body当做流stream来处理。
39
func (r *Request) MultipartReader() (*multipart.Reader, error)
40

41
// 解析URL中的查询字符串，并将解析结果更新到r.Form字段。对于POST或PUT
42
// 请求，ParseForm还会将body当作表单解析，并将结果既更新到r.PostForm也
43
// 更新到r.Form。解析结果中，POST或PUT请求主体要优先于URL查询字符串
44
// （同名变量，主体的值在查询字符串的值前面）。如果请求的主体的大小没有被
45
// MaxBytesReader函数设定限制，其大小默认限制为开头10MB。
46
// ParseMultipartForm会自动调用ParseForm。重复调用本方法是无意义的。
47
func (r *Request) ParseForm() error
48

49
// ParseMultipartForm将请求的主体作为multipart/form-data解析。
50
// 请求的整个主体都会被解析，得到的文件记录最多 maxMemery字节保存在内存，
51
// 其余部分保存在硬盘的temp文件里。如果必要，ParseMultipartForm会
52
// 自行调用 ParseForm。重复调用本方法是无意义的。
53
func (r *Request) ParseMultipartForm(maxMemory int64) error
54

55
// 返回post或者put请求body指定元素的第一个值，其中url中的参数被忽略。
56
func (r *Request) PostFormValue(key string) string
57

58
// 检测在request中使用的http协议是否至少是major.minor
59
func (r *Request) ProtoAtLeast(major，minor int) bool
60

61
// 如果request中有refer，那么refer返回相应的url。Referer在request
62
// 中是拼错的，这个错误从http初期就已经存在了。该值也可以从Headermap中
63
// 利用Header["Referer"]获取；在使用过程中利用Referer这个方法而
64
// 不是map的形式的好处是在编译过程中可以检查方法的错误，而无法检查map中
65
// key的错误。
66
func (r *Request) Referer() string
67

68
// Write方法以有线格式将HTTP/1.1请求写入w（用于将请求写入下层TCPConn等）
69
// 。本方法会考虑请求的如下字段：Host URL Method (defaults to "GET")
70
//  Header ContentLength TransferEncoding Body如果存在Body，
71
// ContentLength字段<= 0且TransferEncoding字段未显式设置为
72
// ["identity"]，Write方法会显式添加”Transfer-Encoding: chunked”
73
// 到请求的头域。Body字段会在发送完请求后关闭。
74
func (r *Request) Write(w io.Writer) error
75

76
// 该函数与Write方法类似，但是该方法写的request是按照http代理的格式去写。
77
// 尤其是，按照RFC 2616 Section 5.1.2，WriteProxy会使用绝对URI
78
// （包括协议和主机名）来初始化请求的第1行（Request-URI行）。无论何种情况，
79
// WriteProxy都会使用r.Host或r.URL.Host设置Host头。
80
func (r *Request) WriteProxy(w io.Writer) error

1
// 注意是在response.go中定义的，而在server.go有一个
2
// type response struct  ，注意大小写。这个结构是体现在server端的功能。
3
type Response struct
4

5
// ReadResponse从r读取并返回一个HTTP 回复。req参数是可选的，指定该回复
6
// 对应的请求（即是对该请求的回复）。如果是nil，将假设请 求是GET请求。
7
// 客户端必须在结束resp.Body的读取后关闭它。读取完毕并关闭后，客户端可以
8
// 检查resp.Trailer字段获取回复的 trailer的键值对。
9
func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)
10

11
// 解析cookie并返回在header中利用set-Cookie设定的cookie值。
12
func (r *Response) Cookies() []*Cookie
13

14
// 返回response中Location的header值的url。如果该值存在的话，则对于
15
// 请求问题可以解决相对重定向的问题，如果该值为nil，则返回ErrNOLocation。
16
func (r *Response) Location() (*url.URL，error)
17

18
// 判定在response中使用的http协议是否至少是major.minor的形式。
19
func (r *Response) ProtoAtLeast(major, minor int) bool
20

21
// 将response中信息按照线性格式写入w中。
22
func (r *Response) Write(w io.Writer) error

1
// Client具有Do，Get，Head，Post以及PostForm等方法。 其中Do方法可以对
2
// Request进行一系列的设定，而其他的对request设定较少。如果Client使用默认的
3
// Client，则其中的Get，Head，Post以及PostForm方法相当于默认的http.Get,
4
// http.Post, http.Head以及http.PostForm函数。
5
type Client struct
6

7
// 利用GET方法对一个指定的URL进行请求，如果response是如下重定向中的一个
8
// 代码，则Get之后将会调用重定向内容，最多10次重定向。
9
// 301 (永久重定向，告诉客户端以后应该从新地址访问)
10
// 302 (暂时性重定向，作为HTTP1.0的标准，PHP的默认Location重定向用到
11
// 也是302)，注：303和307其实是对302的细化。
12
// 303 (对于Post请求，它表示请求已经被处理，客户端可以接着使用GET方法去
13
// 请求Location里的URl)
14
// 307 (临时重定向，对于Post请求，表示请求还没有被处理，客户端应该向
15
// Location里的URL重新发起Post请求)
16
func Get(url string) (resp *Response, err error)
17

18
// 该函数功能见net中Head方法功能。该方法与默认的defaultClient中
19
// Head方法一致。
20
func Head(url string) (resp *Response, err error)
21

22
// 该方法与默认的defaultClient中Post方法一致。
23
func Post(url string, bodyType string, body io.Reader) (resp *Response, err error)
24

25
// 该方法与默认的defaultClient中PostForm方法一致。
26
func PostForm(url string, data url.Values) (resp *Response, err error)
27

28
// Do发送http请求并且返回一个http响应, 遵守client的策略, 如重定向,
29
// cookies以及auth等.错误经常是由于策略引起的, 当err是nil时, resp
30
// 总会包含一个非nil的resp.body.当调用者读完resp.body之后应该关闭它,
31
// 如果resp.body没有关闭, 则Client底层RoundTripper将无法重用存在的
32
// TCP连接去服务接下来的请求, 如果resp.body非nil, 则必须对其进行关闭.
33
// 通常来说, 经常使用Get, Post, 或者PostForm来替代Do.
34
func (c *Client) Do(req *Request) (resp *Response, err error)
35

36
// 利用get方法请求指定的url.Get请求指定的页面信息，并返回实体主体。
37
func (c *Client) Get(url string) (resp *Response, err error)
38

39
// 利用head方法请求指定的url，Head只返回页面的首部。
40
func (c *Client) Head(url string) (resp *Response, err error)
41

42
// post方法请求指定的URl, 如果body也是一个io.Closer, 则在请求之后关闭它
43
func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *Response, err error)
44

45
// 利用post方法请求指定的url, 利用data的key和value作为请求体.
46
func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error)

1
package main
2

3
import (
4
  "compress/gzip"
5
  "fmt"
6
  "io/ioutil"
7
  "net/http"
8
  "strconv"
9
)
10

11
func main() {
12
  // 简式声明一个http.Client空结构体指针对象
13
  client := &http.Client{}
14

15
  // 使用http.NewRequest构建http Request请求
16
  request, err := http.NewRequest("GET", "http://www.baidu.com", nil)
17
  if err != nil {
18
    fmt.Println(err)
19
  }
20

21
  // 使用http.Cookie结构体初始化一个cookie键值对
22
  cookie := &http.Cookie{Name: "userId", Value: strconv.Itoa(12345)}
23

24
  // 使用前面构建的request方法AddCookie往请求中添加cookie
25
  request.AddCookie(cookie)
26

27
  // 设置request的Header，具体可参考http协议
28
  request.Header.Set("Accept", "text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8")
29
  request.Header.Set("Accept-Charset", "GBK, utf-8;q=0.7, *;q=0.3")
30
  request.Header.Set("Accept-Encoding", "gzip, deflate, sdch")
31
  request.Header.Set("Accept-Language", "zh-CN, zh;q=0.8")
32
  request.Header.Set("Cache-Control", "max-age=0")
33
  request.Header.Set("Connection", "keep-alive")
34

35
  // 使用http.Client 来发送request，这里使用了Do方法。
36
  response, err := client.Do(request)
37
  if err != nil {
38
    fmt.Println(err)
39
    return
40
  }
41

42
  // 程序结束时关闭response.Body响应流
43
  defer response.Body.Close()
44

45
  // 接收到的http Response 状态值
46
  fmt.Println(response.StatusCode)
47
  if response.StatusCode == 200 { // 200意味成功得到http Server返回的http Response信息
48

49
    // gzip.NewReader对压缩的返回信息解压（考虑网络传输量，http Server
50
  // 一般都会对响应压缩后再返回）
51
    body, err := gzip.NewReader(response.Body)
52
    if err != nil {
53
      fmt.Println(err)
54
    }
55

56
    defer body.Close()
57

58
    r, err := ioutil.ReadAll(body)
59
    if err != nil {
60
      fmt.Println(err)
61
    }
62
    // 打印出http Server返回的http Response信息
63
    fmt.Println(string(r))
64
  }
65
}

1
package main
2

3
import (
4
  "fmt"
5
  "io/ioutil"
6
  "net/http"
7
)
8

9
func main() {
10
  // var DefaultClient = &Client{}
11
  // func Get(url string) (resp *Response, err error) {
12
  // return DefaultClient.Get(url)
13
  // }
14
  /*
15
    func (c *Client) Get(url string) (resp *Response, err error) {
16
      req, err := NewRequest("GET", url, nil)
17
      if err != nil {
18
        return nil, err
19
      }
20
      return c.Do(req)
21
    }
22
  */
23

24
  // http.Get实际上是DefaultClient.Get(url)，Get函数是高度封装的，只有一个参数url。
25
  // 对于一般的http Request是可以使用，但是不能定制Request
26
  response, err := http.Get("http://www.baidu.com")
27
  if err != nil {
28
    fmt.Println(err)
29
  }
30

31
  //程序在使用完回复后必须关闭回复的主体。
32
  defer response.Body.Close()
33

34
  body, _ := ioutil.ReadAll(response.Body)
35
  fmt.Println(string(body))
36
}

1
package main
2

3
import (
4
  "fmt"
5
  "io/ioutil"
6
  "net/http"
7
  "strings"
8
)
9

10
func main() {
11
  // application/x-www-form-urlencoded：为POST的contentType
12
  // strings.NewReader("mobile=xxxxxxxxxx&isRemberPwd=1") 理解为传递的参数
13
  resp, err := http.Post("http://localhost:8080/login.do",
14
    "application/x-www-form-urlencoded", strings.NewReader("mobile=xxxxxxxxxx&isRemberPwd=1"))
15
  if err != nil {
16
    fmt.Println(err)
17
    return
18
  }
19
  defer resp.Body.Close()
20
  body, err := ioutil.ReadAll(resp.Body)
21
  if err != nil {
22
    fmt.Println(err)
23
    return
24
  }
25
  fmt.Println(string(body))
26
}

1
package main
2

3
import (
4
  "fmt"
5
  "io/ioutil"
6
  "net/http"
7
  "net/url"
8
)
9

10
func main() {
11
  postParam := url.Values{
12
    "mobile":      {"xxxxxx"},
13
    "isRemberPwd": {"1"},
14
  }
15
  // 数据的键值会经过URL编码后作为请求的body传递
16
  resp, err := http.PostForm("http://localhost：8080/login.do", postParam)
17
  if err != nil {
18
    fmt.Println(err)
19
    return
20
  }
21
  defer resp.Body.Close()
22
  body, err := ioutil.ReadAll(resp.Body)
23
  if err != nil {
24
    fmt.Println(err)
25
    return
26
  }
27
  fmt.Println(string(body))
28
}

1
func NewRequest(method, url string, body io.Reader) (*Request, error)
2

3
func (c *Client) Get(url string) (resp *Response, err error) {
4
  req, err := NewRequest("GET", url, nil)
5
......
6

7
func (c *Client) Post(url string, contentType string, body io.Reader) (resp *Response, err error) {
8
  req, err := NewRequest("POST", url, body)
9
......

1
type Handler interface {
2
  ServeHTTP(ResponseWriter, *Request)
3
}
4

5
type Server struct
6

7
// 监听TCP网络地址srv.Addr然后调用Serve来处理接下来连接的请求。
8
// 如果srv.Addr是空的话，则使用“:http”。
9
func (srv *Server) ListenAndServe() error
10

11
// ListenAndServeTLS监听srv.Addr确定的TCP地址，并且会调用Serve
12
// 方法处理接收到的连接。必须提供证书文件和对应的私钥文 件。如果证书是由
13
// 权威机构签发的，certFile参数必须是顺序串联的服务端证书和CA证书。
14
// 如果srv.Addr为空字符串，会使 用”:https”。
15
func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error
16

17
// 接受Listener l的连接，创建一个新的服务协程。该服务协程读取请求然后调用
18
// srv.Handler来应答。实际上就是实现了对某个端口进行监听，然后创建相应的连接。
19
func (srv *Server) Serve(l net.Listener) error
20

21
// 该函数控制是否http的keep-alives能够使用，默认情况下，keep-alives总是可用的。
22
// 只有资源非常紧张的环境或者服务端在关闭进程中时，才应该关闭该功能。
23
func (s *Server) SetKeepAlivesEnabled(v bool)
24

25
// 是一个http请求多路复用器，它将每一个请求的URL和
26
// 一个注册模式的列表进行匹配，然后调用和URL最匹配的模式的处理器进行后续操作。
27
type ServeMux
28

29
// 初始化一个新的ServeMux
30
func NewServeMux() *ServeMux
31

32
// 将handler注册为指定的模式，如果该模式已经有了handler，则会出错panic。
33
func (mux *ServeMux) Handle(pattern string, handler Handler)
34

35
// 将handler注册为指定的模式
36
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))
37

38
// 根据指定的r.Method, r.Host以及r.RUL.Path返回一个用来处理给定请求的handler。
39
// 该函数总是返回一个非nil的 handler，如果path不是一个规范格式，则handler会
40
// 重定向到其规范path。Handler总是返回匹配该请求的的已注册模式；在内建重定向
41
// 处理器的情况下，pattern会在重定向后进行匹配。如果没有已注册模式可以应用于该请求，
42
// 本方法将返回一个内建的”404 page not found”处理器和一个空字符串模式。
43
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)
44

45
// 该函数用于将最接近请求url模式的handler分配给指定的请求。
46
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

1
func main() {
2
  http.HandleFunc("/", myfunc)
3
  http.ListenAndServe(":8080", nil)
4
}

1
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
2
    DefaultServeMux.HandleFunc(pattern, handler)
3
}

1
var DefaultServeMux = &defaultServeMux
2
var defaultServeMux ServeMux
3

4
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
5
  mux.Handle(pattern, HandlerFunc(handler))
6
}

1
func myfunc(w http.ResponseWriter, r *http.Request) {
2
  fmt.Fprintf(w, "hi")
3
}

1
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
2
  f(w, r) // 这相当于自身的调用
3
}

1
func ListenAndServe(addr string, handler Handler) error {
2
    server := &Server{Addr: addr, Handler: handler}
3
    return server.ListenAndServe()
4
}

1
http.ListenAndServe(":8080", nil)

1
for {
2
    rw, e := l.Accept()
3
    ...
4
    c := srv.newConn(rw)
5
c.setState(c.rwc, StateNew)
6
go c.serve(ctx)
7
}

1
type serverHandler struct {
2
srv *Server
3
}
4

5
func (sh serverHandler) ServeHTTP(rw ResponseWriter, req Request) {
6
handler := sh.srv.Handler
7
if handler == nil {
8
handler = DefaultServeMux
9
}
10
if req.RequestURI == "" && req.Method == "OPTIONS" {
11
handler = globalOptionsHandler{}
12
}
13
handler.ServeHTTP(rw, req)
14
}

1
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
2
  if r.RequestURI == "*" {
3
    if r.ProtoAtLeast(1, 1) {
4
      w.Header().Set("Connection", "close")
5
    }
6
    w.WriteHeader(StatusBadRequest)
7
    return
8
  }
9
  h, _ := mux.Handler(r)
10
  h.ServeHTTP(w, r)
11
}

1
Request -> ServeMux(Multiplexer) -> handler-> Response

1
http.ListenAndServe(":8080", nil)
2
func ListenAndServe(addr string, handler Handler) error {
3
    server := &Server{Addr: addr, Handler: handler}
4
    return server.ListenAndServe()
5
}

1
package main
2

3
import (
4
  "fmt"
5
  "net/http"
6
)
7

8
func myfunc(w http.ResponseWriter, r *http.Request) {
9
  fmt.Fprintf(w, "hi")
10
}
11

12
func main() {
13
  // 更多http.Server的字段可以根据情况初始化
14
  server := http.Server{
15
    Addr:         ":8080",
16
    ReadTimeout:  0,
17
    WriteTimeout: 0,
18
  }
19
  http.HandleFunc("/", myfunc)
20
  server.ListenAndServe()
21
}
22

23
这样服务也能跑起来，而且我们完全可以根据情况来自定义我们的Server！
24

25
还可以指定Servemux的用法:
26

27
GOPATH\src\go42\chapter-15\15.3\7\main.go
28

29
package main
30

31
import (
32
  "fmt"
33
  "net/http"
34
)
35

36
func myfunc(w http.ResponseWriter, r *http.Request) {
37
  fmt.Fprintf(w, "hi")
38
}
39

40
func main() {
41
  mux := http.NewServeMux()
42

43
  mux.HandleFunc("/", myfunc)
44
  http.ListenAndServe(":8080", mux)
45
}

1
package main
2

3
import (
4
  "fmt"
5
  "net/http"
6
)
7

8
func myfunc(w http.ResponseWriter, r *http.Request) {
9
  fmt.Fprintf(w, "hi")
10
}
11

12
func main() {
13
  server := http.Server{
14
    Addr:         ":8080",
15
    ReadTimeout:  0,
16
    WriteTimeout: 0,
17
  }
18
  mux := http.NewServeMux()
19
  server.Handler = mux
20

21
  mux.HandleFunc("/", myfunc)
22
  server.ListenAndServe()
23
}

1
func init() {
2
  http.HandleFunc("/debug/pprof/", Index)
3
  http.HandleFunc("/debug/pprof/cmdline", Cmdline)
4
  http.HandleFunc("/debug/pprof/profile", Profile)
5
  http.HandleFunc("/debug/pprof/symbol", Symbol)
6
  http.HandleFunc("/debug/pprof/trace", Trace)
7
}

1
package main
2

3
import (
4
  "log"
5
  "net/http"
6
  "time"
7
)
8

9
type timeHandler struct {
10
  format string
11
}
12

13
func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
14
  tm := time.Now().Format(th.format)
15
  w.Write([]byte("The time is: " + tm))
16
}
17

18
func main() {
19
  mux := http.NewServeMux()
20

21
  th := &timeHandler{format: time.RFC1123}
22
  mux.Handle("/time", th)
23

24
  log.Println("Listening...")
25
  http.ListenAndServe(":3000", mux)
26
}

1
package main
2

3
import (
4
  "log"
5
  "net/http"
6
  "time"
7
)
8

9
func timeHandler(w http.ResponseWriter, r *http.Request) {
10
  tm := time.Now().Format(time.RFC1123)
11
  w.Write([]byte("The time is: " + tm))
12
}
13

14
func main() {
15
  mux := http.NewServeMux()
16

17
  // Convert the timeHandler function to a HandlerFunc type
18
  th := http.HandlerFunc(timeHandler)
19
  // And add it to the ServeMux
20
  mux.Handle("/time", th)
21

22
  log.Println("Listening...")
23
  http.ListenAndServe(":3000", mux)
24
}

1
func index(w http.ResponseWriter, r *http.Request) {
2
    w.Header().Set("Content-Type", "text/html")
3

4
    html := `<doctype html>
5
        <html>
6
        <head>
7
          <title>Hello World</title>
8
        </head>
9
        <body>
10
        <p>
11
          Welcome
12
        </p>
13
        </body>
14
</html>`
15
    fmt.Fprintln(w, html)
16
}
17

18
func main(){
19
    http.HandleFunc("/", index)
20

21
    server := &http.Server{
22
        Addr: ":8000",
23
        ReadTimeout: 60 * time.Second,
24
        WriteTimeout: 60 * time.Second,
25
    }
26
    server.ListenAndServe()
27
}

1
func index(w http.ResponseWriter, r *http.Request) {
2
    w.Header().Set("Content-Type", "text/html")
3

4
    html := `<doctype html>
5
        <html>
6
        <head>
7
          <title>Hello World</title>
8
        </head>
9
        <body>
10
        <p>
11
          Welcome
12
        </p>
13
        </body>
14
</html>`
15
    fmt.Fprintln(w, html)
16
}
17

18
func middlewareHandler(next http.Handler) http.Handler{
19
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request){
20
        // 执行handler之前的逻辑
21
        next.ServeHTTP(w, r)
22
        // 执行完毕handler后的逻辑
23
    })
24
}
25

26
func loggingHandler(next http.Handler) http.Handler {
27
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
28
        start := time.Now()
29
        log.Printf("Started %s %s", r.Method, r.URL.Path)
30
        next.ServeHTTP(w, r)
31
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
32
    })
33
}
34

35
func main() {
36
    http.Handle("/", loggingHandler(http.HandlerFunc(index)))
37

38
    http.ListenAndServe(":8000", nil)
39
}

1
package main
2

3
import (
4
  "net/http"
5
)
6

7
func main() {
8
  http.Handle("/", http.FileServer(http.Dir("D:/html/static/")))
9
  http.ListenAndServe(":8080", nil)
10
}