1.7. Web服务

Go语言的内置库使得写一个类似fetch的web服务器变得异常地简单。在本节中，我们会展示一个微型服务器，这个服务器的功能是返回当前用户正在访问的URL。比如用户访问的是 http://localhost:8000/hello ，那么响应是URL.Path = “hello”。

gopl.io/ch1/server1

  1. // Server1 is a minimal "echo" server.
  2. package main
  4. import (
  5.     "fmt"
  6.     "log"
  7.     "net/http"
  8. )
  10. func main() {
  11.     http.HandleFunc("/", handler) // each request calls handler
  12.     log.Fatal(http.ListenAndServe("localhost:8000", nil))
  13. }
  15. // handler echoes the Path component of the request URL r.
  16. func handler(w http.ResponseWriter, r *http.Request) {
  17.     fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
  18. }

我们只用了八九行代码就实现了一个Web服务程序，这都是多亏了标准库里的方法已经帮我们完成了大量工作。main函数将所有发送到/路径下的请求和handler函数关联起来，/开头的请求其实就是所有发送到当前站点上的请求，服务监听8000端口。发送到这个服务的“请求”是一个http.Request类型的对象，这个对象中包含了请求中的一系列相关字段，其中就包括我们需要的URL。当请求到达服务器时，这个请求会被传给handler函数来处理，这个函数会将/hello这个路径从请求的URL中解析出来，然后把其发送到响应中，这里我们用的是标准输出流的fmt.Fprintf。Web服务会在第7.7节中做更详细的阐述。

让我们在后台运行这个服务程序。如果你的操作系统是Mac OS X或者Linux，那么在运行命令的末尾加上一个&符号，即可让程序简单地跑在后台，windows下可以在另外一个命令行窗口去运行这个程序。

  1. $ go run src/gopl.io/ch1/server1/main.go &

现在可以通过命令行来发送客户端请求了：

  1. $ go build gopl.io/ch1/fetch
  2. $ ./fetch http://localhost:8000
  3. URL.Path = "/"
  4. $ ./fetch http://localhost:8000/help
  5. URL.Path = "/help"

还可以直接在浏览器里访问这个URL，然后得到返回结果，如图1.2：

1.7. Web服务 - 图1

在这个服务的基础上叠加特性是很容易的。一种比较实用的修改是为访问的url添加某种状态。比如，下面这个版本输出了同样的内容，但是会对请求的次数进行计算；对URL的请求结果会包含各种URL被访问的总次数，直接对/count这个URL的访问要除外。

gopl.io/ch1/server2

  1. // Server2 is a minimal "echo" and counter server.
  2. package main
  4. import (
  5.     "fmt"
  6.     "log"
  7.     "net/http"
  8.     "sync"
  9. )
  11. var mu sync.Mutex
  12. var count int
  14. func main() {
  15.     http.HandleFunc("/", handler)
  16.     http.HandleFunc("/count", counter)
  17.     log.Fatal(http.ListenAndServe("localhost:8000", nil))
  18. }
  20. // handler echoes the Path component of the requested URL.
  21. func handler(w http.ResponseWriter, r *http.Request) {
  22.     mu.Lock()
  23.     count++
  24.     mu.Unlock()
  25.     fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
  26. }
  28. // counter echoes the number of calls so far.
  29. func counter(w http.ResponseWriter, r *http.Request) {
  30.     mu.Lock()
  31.     fmt.Fprintf(w, "Count %d\n", count)
  32.     mu.Unlock()
  33. }

这个服务器有两个请求处理函数，根据请求的url不同会调用不同的函数：对/count这个url的请求会调用到counter这个函数，其它的url都会调用默认的处理函数。如果你的请求pattern是以/结尾，那么所有以该url为前缀的url都会被这条规则匹配。在这些代码的背后，服务器每一次接收请求处理时都会另起一个goroutine，这样服务器就可以同一时间处理多个请求。然而在并发情况下，假如真的有两个请求同一时刻去更新count，那么这个值可能并不会被正确地增加；这个程序可能会引发一个严重的bug：竞态条件（参见9.1）。为了避免这个问题，我们必须保证每次修改变量的最多只能有一个goroutine，这也就是代码里的mu.Lock()和mu.Unlock()调用将修改count的所有行为包在中间的目的。第九章中我们会进一步讲解共享变量。

下面是一个更为丰富的例子，handler函数会把请求的http头和请求的form数据都打印出来，这样可以使检查和调试这个服务更为方便：

gopl.io/ch1/server3

  1. // handler echoes the HTTP request.
  2. func handler(w http.ResponseWriter, r *http.Request) {
  3.     fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
  4.     for k, v := range r.Header {
  5.         fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
  6.     }
  7.     fmt.Fprintf(w, "Host = %q\n", r.Host)
  8.     fmt.Fprintf(w, "RemoteAddr = %q\n", r.RemoteAddr)
  9.     if err := r.ParseForm(); err != nil {
  10.         log.Print(err)
  11.     }
  12.     for k, v := range r.Form {
  13.         fmt.Fprintf(w, "Form[%q] = %q\n", k, v)
  14.     }
  15. }

我们用http.Request这个struct里的字段来输出下面这样的内容：

  1. GET /?q=query HTTP/1.1
  2. Header["Accept-Encoding"] = ["gzip, deflate, sdch"]
  3. Header["Accept-Language"] = ["en-US,en;q=0.8"]
  4. Header["Connection"] = ["keep-alive"]
  5. Header["Accept"] = ["text/html,application/xhtml+xml,application/xml;..."]
  6. Header["User-Agent"] = ["Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5)..."]
  7. Host = "localhost:8000"
  8. RemoteAddr = "127.0.0.1:59911"
  9. Form["q"] = ["query"]

可以看到这里的ParseForm被嵌套在了if语句中。Go语言允许这样的一个简单的语句结果作为局部的变量声明出现在if语句的最前面，这一点对错误处理很有用处。我们还可以像下面这样写（当然看起来就长了一些）：

  1. err := r.ParseForm()
  2. if err != nil {
  3.     log.Print(err)
  4. }

用if和ParseForm结合可以让代码更加简单，并且可以限制err这个变量的作用域，这么做是很不错的。我们会在2.7节中讲解作用域。

在这些程序中，我们看到了很多不同的类型被输出到标准输出流中。比如前面的fetch程序，把HTTP的响应数据拷贝到了os.Stdout，lissajous程序里我们输出的是一个文件。fetchall程序则完全忽略到了HTTP的响应Body，只是计算了一下响应Body的大小，这个程序中把响应Body拷贝到了ioutil.Discard。在本节的web服务器程序中则是用fmt.Fprintf直接写到了http.ResponseWriter中。

尽管三种具体的实现流程并不太一样，他们都实现一个共同的接口，即当它们被调用需要一个标准流输出时都可以满足。这个接口叫作io.Writer，在7.1节中会详细讨论。

Go语言的接口机制会在第7章中讲解，为了在这里简单说明接口能做什么，让我们简单地将这里的web服务器和之前写的lissajous函数结合起来，这样GIF动画可以被写到HTTP的客户端，而不是之前的标准输出流。只要在web服务器的代码里加入下面这几行。

  1. handler := func(w http.ResponseWriter, r *http.Request) {
  2.     lissajous(w)
  3. }
  4. http.HandleFunc("/", handler)

或者另一种等价形式：

  1. http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  2.     lissajous(w)
  3. })

HandleFunc函数的第二个参数是一个函数的字面值，也就是一个在使用时定义的匿名函数。这些内容我们会在5.6节中讲解。

做完这些修改之后，在浏览器里访问 http://localhost:8000 。每次你载入这个页面都可以看到一个像图1.3那样的动画。

1.7. Web服务 - 图2

练习 1.12： 修改Lissajour服务，从URL读取变量，比如你可以访问 http://localhost:8000/?cycles=20 这个URL，这样访问可以将程序里的cycles默认的5修改为20。字符串转换为数字可以调用strconv.Atoi函数。你可以在godoc里查看strconv.Atoi的详细说明。