网络、模板和网页应用

tcp服务器

这部分将使用TCP协议和协程范式编写一个简单的客户端-服务端应用，一个(web)服务器应用需要响应众多客户端的并发请求：Go会为每一个客户端产生一个协程用来处理请求。需要使用net包中网络通信的功能。它包含了处理TCP/IP以及UDP协议、域名解析等方法。

server.go:

package main
import (
    "fmt"
    "net"
)
func doServerStuff(conn net.Conn) {
    for {
        buf := make([]byte, 512)
        len, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Error reading", err.Error())
            return
        }
        fmt.Printf("Received data: %v", string(buf[:len]))
    }
}
func main() {
    fmt.Println("Starting the server ...")
    listener, err := net.Listen("tcp", "localhost:50000")
    if err != nil {
        fmt.Println("Error listening", err.Error())
        return // 终止程序
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting", err.Error())
            return // 终止程序
        }
        go doServerStuff(conn)
    }
}

在 main() 中创建了一个 net.Listener 类型的变量 listener，他实现了服务器的基本功能：用来监听和接收来自客户端的请求（在 localhost 即 IP 地址为 127.0.0.1 端口为 50000 基于 TCP 协议）。Listen() 函数可以返回一个 error 类型的错误变量。用一个无限 for 循环的 listener.Accept() 来等待客户端的请求。客户端的请求将产生一个 net.Conn 类型的连接变量。然后一个独立的协程使用这个连接执行 doServerStuff()，开始使用一个 512 字节的缓冲 data 来读取客户端发送来的数据，并且把它们打印到服务器的终端，len 获取客户端发送的数据字节数；当客户端发送的所有数据都被读取完成时，协程就结束了。这段程序会为每一个客户端连接创建一个独立的协程。必须先运行服务器代码，再运行客户端代码。

client.go:

package main
import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)
func main() {
    conn, err := net.Dial("tcp", "localhost:50000")
    if err != nil {
        fmt.Println("Error dialing", err.Error())
        return
    }
    inputReader := bufio.NewReader(os.Stdin)
    fmt.Println("First, what is your name?")
    clientName, _ := inputReader.ReadString('\n')
    trimmedClient := strings.Trim(clientName, "\n")
    // 给服务器发送信息直到程序退出
    for {
        fmt.Println("What to send to the server? Type Q to quit")
        input, _ := inputReader.ReadString('\n')
        trimmedInput := strings.Trim(input, "\n")
        if trimmedInput == "Q" {
            return
        }
        _, err = conn.Write([]byte(trimmedClient + "says: " + trimmedInput))
    }
}

客户端通过 net.Dial 创建了一个和服务器之间的连接。它通过无限循环从 os.Stdin 接收来自键盘的输入，直到输入了“Q”。注意裁剪 \r 和 \n 字符（仅 Windows 平台需要）。裁剪后的输入被 connection 的 Write 方法发送到服务器。当然，服务器必须先启动好，如果服务器并未开始监听，客户端是无法成功连接的。

在网络编程中 net.Dial 函数是非常重要的，一旦你连接到远程系统，函数就会返回一个 Conn 类型的接口，我们可以用它发送和接收数据。Dial 函数简洁地抽象了网络层和传输层。所以不管是 IPv4 还是 IPv6，TCP 或者 UDP 都可以使用这个公用接口。

以下示例先使用 TCP 协议连接远程 80 端口，然后使用 UDP 协议连接，最后使用 TCP 协议连接 IPv6 地址：

// make a connection with www.example.org:
package main
import (
    "fmt"
    "net"
    "os"
)
func main() {
    conn, err := net.Dial("tcp", "192.0.32.10:80") // tcp ipv4
    checkConnection(conn, err)
    conn, err = net.Dial("udp", "192.0.32.10:80") // udp
    checkConnection(conn, err)
    conn, err = net.Dial("tcp", "[2620:0:2d0:200::10]:80") // tcp ipv6
    checkConnection(conn, err)
}
func checkConnection(conn net.Conn, err error) {
    if err != nil {
        fmt.Printf("error %v connecting!", err)
        os.Exit(1)
    }
    fmt.Printf("Connection is made with %v\n", conn)
}

下班是一个使用net包从socket中打开，写入、读取数据的例子：

package main
import (
    "fmt"
    "io"
    "net"
)
func main() {
    var (
        host          = "www.apache.org"
        port          = "80"
        remote        = host + ":" + port
        msg    string = "GET / \n"
        data          = make([]uint8, 4096)
        read          = true
        count         = 0
    )
    // 创建一个socket
    con, err := net.Dial("tcp", remote)
    // 发送消息，一个http Get请求
    io.WriteString(con, msg)
    // 读取服务器的响应
    for read {
        count, err = con.Read(data)
        read = (err == nil)
        fmt.Printf(string(data[0:count]))
    }
    con.Close()
}

下边这个版本的 simple_tcp_server.go 从很多方面优化了第一个 tcp 服务器的示例 server.go 并且拥有更好的结构，它只用了 80 行代码！

simple_tcp_server.go：

package main
import (
    "flag"
    "fmt"
    "net"
    "syscall"
)
const maxRead = 25
func initServer(hostAndPort string) net.Listener {
    serverAddr, err := net.ResolveTCPAddr("tcp", hostAndPort)
    checkError(err, "Resolving address:port failed: '"+hostAndPort+"'")
    listener, err := net.ListenTCP("tcp", serverAddr)
    checkError(err, "ListenTCP: ")
    println("Listening to: ", listener.Addr().String())
    return listener
}
func connectionHandler(conn net.Conn) {
    connFrom := conn.RemoteAddr().String()
    println("Connection from: ", connFrom)
    sayHello(conn)
    for {
        var ibuf []byte = make([]byte, maxRead+1)
        length, err := conn.Read(ibuf[0:maxRead])
        ibuf[maxRead] = 0
        switch err {
        case nil:
            handleMsg(length, err, ibuf)
        case syscall.EAGAIN: // try again
            continue
        default:
            goto DISCONNECT
        }
    }
DISCONNECT:
    err := conn.Close()
    println("Closed connection: ", connFrom)
    checkError(err, "Close: ")
}
func sayHello(to net.Conn) {
    obuf := []byte{'L', 'e', 't', '\'', 's', ' ', 'G', 'O', '!', '\n'}
    wrote, err := to.Write(obuf)
    checkError(err, "Write: write "+string(wrote)+" bytes.")
}
func handleMsg(length int, err error, msg []byte) {
    if length > 0 {
        print("<", length, ":")
        for i := 0; ; i++ {
            if msg[i] == 0 {
                break
            }
            fmt.Printf("%c", msg[i])
        }
        print(">")
    }
}
func checkError(error error, info string) {
    if error != nil {
        panic("ERROR: " + info + " " + error.Error()) // terminate program
    }
}
func main() {
    flag.Parse()
    if flag.NArg() != 2 {
        panic("usage: host port")
    }
    hostAndPort := fmt.Sprintf("%s:%s", flag.Arg(0), flag.Arg(1))
    listener := initServer(hostAndPort)
    for {
        conn, err := listener.Accept()
        checkError(err, "Accept: ")
        go connectionHandler(conn)
    }
}

• 在 initServer 函数中通过 net.ResolveTCPAddr 得到了服务器地址和端口，这个函数最终返回了一个 *net.TCPListener
• 每一个连接都会以协程的方式运行 connectionHandler 函数。函数首先通过 conn.RemoteAddr() 获取到客户端的地址并显示出来
• 它使用 conn.Write 发送 Go 推广消息给客户端
• 它使用一个 25 字节的缓冲读取客户端发送的数据并一一打印出来。如果读取的过程中出现错误，代码会进入 switch 语句 default 分支，退出无限循环并关闭连接。如果是操作系统的 EAGAIN 错误，它会重试。
• 所有的错误检查都被重构在独立的函数 checkError 中，当错误产生时，利用错误上下文来触发 panic。

一个简单的web服务器

Go提供了net/http包，下边示例是是一个简单的网页服务器，它引入http包并启动了网页服务器，使用http.ListenAndServe("localhost:8080", nil)函数，如果成功则返回空，否则会返回一个错误(地址localhost部分可以省略，8080是指定的端口号)。

http.URL用于表示网页地址，其中字符串属性Path用于保存url的路径；http.Request描述了客户端请求，内含一个URL字段。

如果req是来自html表单的POST类型请求，”var1”是该表单中一个输入域的名称，那么用户输入的值就可以通过Go代码req.FormValue("var1")获取到。还有一种方法是先执行request.ParseForm()，然后再获取request.Form["var1"]的第一个返回参数：

var1, found := request.Form["var1"]

第二个参数found为true。如果var1并未出现在表单中，found就是false。

表单属性实际上是map[string][]string类型。网页服务器发送一个http.Response响应，它是通过http.ResponseWriter对象输出的，后者组装了HTTP服务器响应，通过对其写入内容，将数据发送给了HTTP客户端。

现在仍然要编写程序，以实现服务器必须做的事，即如何处理请求。这是通过http.HandleFunc函数完成的。在这个例子中，当根路径”/“被请求的时候，HelloServer函数被执行了。这个函数是http.HandleFunc类型的，通常被命名为Prefhandler，和某个路径前缀Pref匹配。

http.HandleFunc注册了一个处理函数(这里是HelloServer)来处理对应/的请求。

/可以被替换为其他更特定的url，比如/create,/edit等；可以为每一个特定的url定义个单独的处理函数。这个函数需要两个参数：第一个是ReponseWriter类型的w；第二个是请求req。程序向w写入了Hello和r.URL.Path[1:]组成的字符串：末尾的[]表示”创建一个从索引为1的字符到结尾的子切片“，用来丢弃路径开头的”/“，fmt.Fprint()函数完成了本次写入；另一种可行的写法是io.WriteString(w, "hello\n")。

总结：第一个参数是请求的路径，第二个参数是当路径被请求时，需要调用的处理函数的引用。

webserver.go:

package main
import (
    "fmt"
    "log"
    "net/http"
)
func HelloServer(w http.ResponseWriter, req *http.Request) {
    fmt.Println("Inside helloserver handler")
    fmt.Fprintf(w, "hello,"+req.URL.Path[1:])
}
func main() {
    http.HandleFunc("/", HelloServer)
    err := http.ListenAndServe("localhost:8080", nil)
    if err != nil {
        log.Fatal("ListenAndServer", err.Error())
    }
}

1. 前两行(没有错误处理代码)可以替换成以下写法：

http.ListenAndServe(":8080", http.HandleFunc(HelloServer))

1. fmt.Fprint和fmt.Fprintf都是可以用来写入http.ResponseWriter的函数（他们实现了io.Writer）

fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", title, body)

1. 如果你需要使用安全的https连接，使用http.ListenAndServeTLS()代替http.ListenAndServe()
2. 除了http.HandleFunc("/", Hfunc)，其中的Hfunc是一个处理函数，签名为：

func Hfunc(w http.ResponseWriter, req *http.Request) {
    ...
}

也可以使用这种方式：http.Handle("/",http.HandlerFunc(Hfunc))

HandlerFunc只是定义了上述HFunc签名的别名：

type HandlerFunc func(ResponseWriter, *Request)

它是一个可以把普通的函数当做HTTP处理器(Handler)的适配器。如果函数f声明的合适，HandlerFunc(f)就是一个执行f函数的Handler对象。

http.Handle的第二个参数也可以是T类型的对象obj：http.Handle("/", obj)，如果T有ServeHTTP方法，那就实现了http的Handler接口：

func (obj *Typ) ServeHTTP( w http.ResponseWriter, req *http.Request ) {
    ...
}

访问并读取页面数据

在下边这个程序中，数组中的url都将被访问：会发送一个简单的http.Head()请求查看返回值；它的声明如下：func Head(url string) (r *Response, err error)，返回的响应Response其状态码会被打印出来

package main
import (
    "fmt"
    "net/http"
)
var urls = []string{
    "https://www.baidu.com",
    "https://golang.org",
    "https://www.google.com",
}
func main() {
    for _, url := range urls {
        reps, err := http.Head(url)
        if err != nil {
            fmt.Println("Error", url, err)
        }
        fmt.Println(url, ": ", reps.Status)
    }
}

http包中其他重要的函数：

• http.Redirect(w ResponseWriter, r *Request, url string, code int)：这个函数会让浏览器重定向到url(可以是基于请求url的相对路径)，同时指定状态码；
• http.NotFound(w ResponseWriter, r *Request): 这个函数将返回网页没有找到，HTTP404错误；
• http.Error(w ResponseWriter, error string, code int): 这个函数返回特定的错误信息和HTTP代码；
• 另一个http.Request对象req的重要属性：req.Method，用来描述网页是以何种方式被请求的；
• 可以使用w.header().Set("Content-Type", "../..")设置头信息

一个简单的网页应用

下边的程序在端口 8088 上启动了一个网页服务器；SimpleServer 会处理 url /test1 使它在浏览器输出 hello world。FormServer 会处理 url /test2：如果 url 最初由浏览器请求，那么它是一个 GET 请求，返回一个 form 常量，包含了简单的 input 表单，这个表单里有一个文本框和一个提交按钮。当在文本框输入一些东西并点击提交按钮的时候，会发起一个 POST 请求。FormServer 中的代码用到了 switch 来区分两种情况。请求为 POST 类型时，name 属性 为 inp 的文本框的内容可以这样获取：request.FormValue(“inp”)。然后将其写回浏览器页面中。在控制台启动程序，然后到浏览器中打开 url http://localhost:8088/test2 来测试这个程序：

package main
import (
    "io"
    "net/http"
)
const form = `
    <html> <body>
        <form action="#" method="post" name="bar">
            <input type="text" name="in" />
            <input type="submit" value="submit" />
        </form>
    </body></html>
`
/* handle a simple get request */
func SimpleServer(w http.ResponseWriter, req *http.Request) {
    io.WriteString(w, "<h1> hello, world </h1>")
}
func FormServer(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Context-Type", "text/html")
    switch req.Method {
    case "GET":
        io.WriteString(w, form)
    case "POST":
        io.WriteString(w, req.FormValue("in"))
    }
}
func main() {
    http.HandleFunc("/test1", SimpleServer)
    http.HandleFunc("/test2", FormServer)
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

练习：编写一个网页程序，可以让用户输入一连串的数字，然后将它们打印出来，计算出这些数字的均值和中值

// statistics.go
package main
import (
    "fmt"
    "log"
    "net/http"
    "sort"
    "strconv"
    "strings"
)
type statistics struct {
    numbers []float64
    mean    float64
    median  float64
}
const form = `<html><body><form action="/" method="POST">
<label for="numbers">Numbers (comma or space-separated):</label><br>
<input type="text" name="numbers" size="30"><br />
<input type="submit" value="Calculate">
</form></html></body>`
const error = `<p class="error">%s</p>`
var pageTop = ""
var pageBottom = ""
func main() {
    http.HandleFunc("/", homePage)
    if err := http.ListenAndServe(":9001", nil); err != nil {
        log.Fatal("failed to start server", err)
    }
}
func homePage(writer http.ResponseWriter, request *http.Request) {
    writer.Header().Set("Content-Type", "text/html")
    err := request.ParseForm() // Must be called before writing response
    fmt.Fprint(writer, pageTop, form)
    if err != nil {
        fmt.Fprintf(writer, error, err)
    } else {
        if numbers, message, ok := processRequest(request); ok {
            stats := getStats(numbers)
            fmt.Fprint(writer, formatStats(stats))
        } else if message != "" {
            fmt.Fprintf(writer, error, message)
        }
    }
    fmt.Fprint(writer, pageBottom)
}
func processRequest(request *http.Request) ([]float64, string, bool) {
    var numbers []float64
    var text string
    if slice, found := request.Form["numbers"]; found && len(slice) > 0 {
        //处理如果网页中输入的是中文逗号
        if strings.Contains(slice[0], "&#65292") {
            text = strings.Replace(slice[0], "&#65292;", " ", -1)
        } else {
            text = strings.Replace(slice[0], ",", " ", -1)
        }
        for _, field := range strings.Fields(text) {
            if x, err := strconv.ParseFloat(field, 64); err != nil {
                return numbers, "'" + field + "' is invalid", false
            } else {
                numbers = append(numbers, x)
            }
        }
    }
    if len(numbers) == 0 {
        return numbers, "", false // no data first time form is shown
    }
    return numbers, "", true
}
func getStats(numbers []float64) (stats statistics) {
    stats.numbers = numbers
    sort.Float64s(stats.numbers)
    stats.mean = sum(numbers) / float64(len(numbers))
    stats.median = median(numbers)
    return
}
func sum(numbers []float64) (total float64) {
    for _, x := range numbers {
        total += x
    }
    return
}
func median(numbers []float64) float64 {
    middle := len(numbers) / 2
    result := numbers[middle]
    if len(numbers)%2 == 0 {
        result = (result + numbers[middle-1]) / 2
    }
    return result
}
func formatStats(stats statistics) string {
    return fmt.Sprintf(`<table border="1">
<tr><th colspan="2">Results</th></tr>
<tr><td>Numbers</td><td>%v</td></tr>
<tr><td>Count</td><td>%d</td></tr>
<tr><td>Mean</td><td>%f</td></tr>
<tr><td>Median</td><td>%f</td></tr>
</table>`, stats.numbers, len(stats.numbers), stats.mean, stats.median)
}

确保网页应用健壮

当网页应用的处理函数发生panic，服务器会简单地终止运行。网页服务器必须是足够健壮的程序，能够承受任何可能的突发问题。

首先想到的是在每个处理函数中使用defer/recover，但会产生太多的重复代码。使用闭包的错误处理模式是更优雅的方案，它可以被简单应用到任何网页服务器程序中。

为增强代码可读性，为网页处理函数创建一个类型：

type HandleFnc func(http.ResponseWriter, *http.Request)

错误处理函数logPanics:

func logPaincs(function HandleFnc) HandleFnc {
    return func(writer http.ResponseWriter, request *http.Request) {
        defer func() {
            if x:=recover();x != nil {
                log.Printf("[%v] caught panic: %v", request.RemoteAdder, x)
            }
        }()
        function(writer, request)
    }
}

然后用logPanics来包装对处理函数的调用：

http.HandleFunc("/test1", logPanics(SimpleServer))
http.HandleFunc("/test2", logPanics(FormServer))

rebust_webserver.go:

package main
import (
    "io"
    "log"
    "net/http"
)
const form = `
    <html> <body>
        <form action="#" method="post" name="bar">
            <input type="text" name="in" />
            <input type="submit" value="submit" />
        </form>
    </body></html>
`
/* handle a simple get request */
func SimpleServer(w http.ResponseWriter, req *http.Request) {
    io.WriteString(w, "<h1> hello, world </h1>")
}
type HandleFnc func(http.ResponseWriter, *http.Request)
func FormServer(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Context-Type", "text/html")
    switch req.Method {
    case "GET":
        io.WriteString(w, form)
    case "POST":
        io.WriteString(w, req.FormValue("in"))
    }
}
func main() {
    http.HandleFunc("/test1", logPanics(SimpleServer))
    http.HandleFunc("/test2", logPanics(FormServer))
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}
func logPanics(function HandleFnc) HandleFnc {
    return func(writer http.ResponseWriter, req *http.Request) {
        defer func() {
            if x := recover(); x != nil {
                log.Printf("[%v] caught panic: %v", req.RemoteAddr, x)
            }
        }()
        function(writer, req)
    }
}

用模板编写网页应用

以下程序是用 100 行以内代码实现可行的 wiki 网页应用，它由一组页面组成，用于阅读、编辑和保存。它是来自 Go 网站 codelab 的 wiki 制作教程，我所知的最好的 Go 教程之一，非常值得进行完整的实验，以见证并理解程序是如何被构建起来的https://golang.org/doc/articles/wiki/。这里，我们将以自顶向下的视角，从整体上给出程序的补充说明。程序是网页服务器，它必须从命令行启动，监听某个端口，例如 8080。浏览器可以通过请求 URL 阅读 wiki 页面的内容，例如：http://localhost:8080/view/page1。

接着，页面的文本内容从一个文件中读取，并显示在网页中。它包含一个超链接，指向编辑页面http://localhost:8080/edit/page1。编辑页面将内容显示在一个文本域中，用户可以更改文本，点击“保存”按钮保存到对应的文件中。然后回到阅读页面显示更改后的内容。如果某个被请求阅读的页面不存在，例如：http://localhost:8080/edit/page999，程序可以作出识别，立即重定向到编辑页面，如此新的 wiki 页面就可以被创建并保存。

wiki页面需要一个标题和文本内容，它在程序中被建模为如下结构体，Body字段存放内容，由字节切片组成：

type Page struct {
    Title string
    Body []byte
}

示例：wiki.go:

package main
import (
    "html/template"
    "io/ioutil"
    "log"
    "net/http"
    "regexp"
    "text/template"
)
const lenPath = len("/view")
var titleValidator = regexp.MustCompile("^[a-zA-Z0-9]+$")
var templates = make(map[string]*template.Template)
var err error
type Page struct {
    Title string
    Body  []byte
}
func init() {
    for _, tmpl := range []string{"edit", "view"} {
        templates[tmpl] = template.Must(template.ParseFiles(tmpl + ".html"))
    }
}
func main() {
    http.HandleFunc("/view/", makeHandler(viewHandler))
    http.HandleFunc("/edit/", makeHandler(editHandler))
    http.HandleFunc("/save/", makeHandler(saveHandler))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServer: ", err.Error())
    }
}
func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        title := r.URL.Path[lenPath:]
        if !titleValidator.MatchString(title) {
            http.NotFound(w, r)
            return
        }
        fn(w, r, title)
    }
}
func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
    p, err := load(title)
    if err != nil { //page not found
        http.Redirect(w, r, "/edit/"+title, http.StatusFound)
        return
    }
    renderTemplate(w, "view", p)
}
func editHandler(w http.ResponseWriter, r *http.Request, title string) {
    p, err := load(title)
    if err != nil {
        p = &Page{Title: tile}
    }
    renderTemplate(w, "edit", p)
}
func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
    body := r.FormValue("body")
    p := &Page{Title: title, Body: []byte(body)}
    err := p.save()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    http.Redirect(w, r, "/view/"+title, http.StatusNotFound)
}
func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
    err := templates[tmpl].Execute(w, p)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}
func (p *Page) save() error {
    filename := p.Title + ".txt"
    return ioutil.WriteFile(filename, p.Body, 0600)
}
func load(title string) (*Page, error) {
    filename := title + ".txt"
    body, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, err
    }
    return &Page{Title: title, Body: body}, nil
}

• io/ioutil方便地读写文件，regexp用于验证输入标题，template来动态创建html文档；
• 为避免黑客构造特殊输入攻击服务器，用如下正则表达式检查用户在浏览器输入的URL：

var titleValidator = regexp.MustCompile("^[a-zA-Z0-9]+$")

makeHandler会用它对请求管控。

• 必须有一种机制把Page结构体数据插入到网页的标题和内容中，可以利用template包通过如下步骤完成：

  • 现在文本编辑器中创建html模板文件，例如view.html:

    <h1> {{.Title |html}}</h1>
    <p>[<a href="/edit/{{.Title |html}}">edit</a>]</p>
    <div>{{printf "%s" .Body |html}}</div>

    {{.Title |html}}``{{printf "%s" .Body |html}}

  • template.Must(template.ParseFiles(tmpl + ".html"))把模板文件转换为*template.Template类型的对象，为了高效，在程序运行时仅做一次解析，在init()函数中处理可以方便地达到目的。所有模板对象都被保持在内存中，存放在以html文件名作为索引的map中：

    templates = make(map[string] *template.Template)

  • 为了真正从模板和结构体构建出页面，必须使用：

    templates[tmpl].Exectu(w, p)

    renderTemplate

• 在 main() 中网页服务器用 ListenAndServe 启动并监听 8080 端口。需要先为紧接在 URL localhost:8080/ 之后， 以view, edit 或 save 开头的 url 路径定义一些处理函数。

在此定义了 3 个处理函数，由于包含重复的启动代码，我们将其提取到单独的 makeHandler 函数中。这是一个值得研究的特殊高阶函数：其参数是一个函数，返回一个新的闭包函数：

func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        title := r.URL.Path[lenPath:]
        if !titleValidator.MatchString(title) {
            http.NotFound(w, r)
            return
        }
        fn(w, r, title)
    }
}

• 闭包封闭了函数变量fn来构造其返回值。但在此之前，先用titleValidator.MatchString(title)验证输入标题title的有效性。如果标题包含了字母和数字以外的字符，就触发NotFound错误(例如：localhost:8080/view/page++)。viewHandler,editHandler和saveHandler都是传入main()中makrHandler的参数，类型必须都与fn相同。
• viewHander尝试按标题读取文本文件，这是通过调用load()函数完成的，它会构建文件名并用ioutil.ReadFile读取内容。如果文件存在，其内容会存入字符串中。一个指向Page结构体的指针按字面量被创建：&Page{Title: title, Body: body}

另外，该值和表示没有error的nil值一起返回给调用者。然后再renderTemplate中将该结构体与模板对象整合。

万一发生错误，wiki页面在磁盘上不存在，错误会被返回给viewHandler，此时会自动重定向，跳转请求对应标题的编辑页面。

• 当在编辑页面点击“保存”按钮时，触发保存页面内容的动作。按钮须放在html表单中，它开头是这样的：

<form action="/save/{{.Title |html}}" method="POST">

这意味着，当提交表单到类似http://localhost/save/{Title}这样的 URL 格式时，一个 POST 请求被发往网页服务器。针对这样的URL我们已经定义好了处理函数：saveHandler()。在 request 对象上调用FormValue()方法，可以提取名称为body的文本域内容，用这些信息构造一个 Page 对象，然后尝试通过调用save()方法保存其内容。万一运行失败，执行http.Error以将错误显示到浏览器。如果保存成功，重定向浏览器到该页的阅读页面。save()函数非常简单，利用ioutil.WriteFile()，写入Page结构体的Body字段到文件filename中，之后会被用于模板替换占位符 {{printf “%s” .Body |html}}。

template包

template对象把数据结构整合到HTML模板中，模板是一项更为通用的技术方案：数据驱动的模板被创建出来，以生成文本输出。

模板通过与数据结构的整合来生成，通常为结构体或其切片。当数据传递给tmpl.Execute()，它用其中的元素进行替换，动态地重写某一小段文本。只有被导出的数据项才可以被整合进模板中。可以在{{ }}中加入数据求值或控制结构。数据项可以是值或者指针，接口隐藏了它们的差异。

字段替换：{{.FieldName}}

要在模板中包含某个字段的内容，使用双花括号括起以点（.）开头的字段名。例如，假设 Name 是某个结构体的字段，其值要在被模板整合时替换，则在模板中使用文本 {{.Name}}。当 Name 是 map 的键时这么做也是可行的。要创建一个新的 Template 对象，调用 template.New，其字符串参数可以指定模板的名称。正如上边示例出现过的，Parse 方法通过解析模板定义字符串，生成模板的内部表示。当使用包含模板定义字符串的文件时，将文件路径传递给 ParseFiles 来解析。解析过程如产生错误，这两个函数第二个返回值 error != nil。最后通过 Execute 方法，数据结构中的内容与模板整合，并将结果写入方法的第一个参数中，其类型为 io.Writer。再一次地，可能会有 error 返回。以下程序演示了这些步骤，输出通过 os.Stdout 被写到控制台。

template_field.go:

package main
import (
    "fmt"
    "os"
    "text/template"
)
type Person struct {
    Name               string
    nonExporteAgeField string
}
func main() {
    t := template.New("hello")
    t, _ = t.Parse("hello {{.Name}}")
    // t, _ = t.Parse("your age is {{.nonExporteAgeField}}")
    // t, _ = t.Parse("hello {{.}}")
    p := Person{Name: "test", nonExporteAgeField: "30"}
    if err := t.Execute(os.Stdout, p); err != nil {
        fmt.Println("There was an error:", err.Error())
    }
}

数据结构中包含一个未导出的字段，当尝试把它整合到类似这样的定义字符串：

t, _ = t.Parse("your age is {{.nonExporteAgeField}}")

会产生错误：nonExporteAgeField is an unexported field of struct type main.Person

如果只是想简单地把Execute()方法的第二个参数用于替换，使用{{.}}

当在浏览器环境中进行这些步骤，应首先使用html过滤器来过滤内容，例如{{html .}}，或者对FieldName过滤：{{.FieldName |html}}。|html这部分代码，是请求模板引擎在输出FieldName的结果前把值传递给html格式化器，它会执行HTML字符转义。这可以避免用户输入数据破坏HTML文档结构。

验证模板格式

为了确保模板定义语法是正确的，使用Must函数处理Parse的返回结果。在下面的例子中tOK是正确的模板，tErr验证时发生错误，会导致运行panic。

template_validation.go:

package main
import (
    "fmt"
    "html/template"
)
func main() {
    tOk := template.New("ok")
    template.Must(tOk.Parse("/* and a comment */ some static text: {{.Name}}"))
    fmt.Println("The first one parsed OK.")
    fmt.Println("The next one ought to fail.")
    tErr := template.New("error_template")
    template.Must(tErr.Parse("some static text {{.Name}}"))
}

if-else

运行Execute产生的结果来自模板的输出，它包含静态文本，以及被{{}}包裹的称之为管道的文本。

可以对管道数据的输出结果用if-else-end设置条件约束：如果管道是空的，类似于：

{{if ``}} Will not print. {{end}}

或者

{{if `anything`}} Print IF part. {{else}} Print ELSE part.{{end}}

template_ifelse.go:

package main
import (
    "os"
    "html/template"
)
func main() {
    tEmpty := template.New("template test")
    tEmpty = template.Must(tEmpty.Parse("Empty pipeline if demo: {{if ``}} Will not print. {{end}}\n")) //empty pipeline following if
    tEmpty.Execute(os.Stdout, nil)
    tWithValue := template.New("template test")
    tWithValue = template.Must(tWithValue.Parse("Non empty pipeline if demo: {{if `anything`}} Will print. {{end}}\n")) //non empty pipeline following if condition
    tWithValue.Execute(os.Stdout, nil)
    tIfElse := template.New("template test")
    tIfElse = template.Must(tIfElse.Parse("if-else demo: {{if `anything`}} Print IF part. {{else}} Print ELSE part.{{end}}\n")) //non empty pipeline following if condition
    tIfElse.Execute(os.Stdout, nil)
}

点号和with-end

with语句将点号设为管道的值。如果管道是空的，那么不管with-end块之间有什么，都会被忽略。在被嵌套时，点号根据最近的作用域取得值。以下程序演示了这点：

package main
import (
    "os"
    "html/template"
)
func main() {
    t := template.New("test")
    t, _ = t.Parse("{{with `hello`}}{{.}}{{end}}!\n")
    t.Execute(os.Stdout, nil)
    t, _ = t.Parse("{{with `hello`}}{{.}} {{with `Mary`}}{{.}}{{end}}{{end}}!\n")
    t.Execute(os.Stdout, nil)
}

模板变量$

可以在模板内为管道设置本地变量，变量名以$符号作为前缀。变量名只能包含字母、数字和下划线。以下示例使用了多种形式的有效变量名。

package main
import (
    "os"
    "html/template"
)
func main() {
    t := template.New("test")
    t = template.Must(t.Parse("{{with $3 := `hello`}}{{$3}}{{end}}!\n"))
    t.Execute(os.Stdout, nil)
    t = template.Must(t.Parse("{{with $x3 := `hola`}}{{$x3}}{{end}}!\n"))
    t.Execute(os.Stdout, nil)
    t = template.Must(t.Parse("{{with $x_1 := `hey`}}{{$x_1}} {{.}} {{$x_1}}{{end}}!\n"))
    t.Execute(os.Stdout, nil)
}

range-end

range-end 结构格式为：{{range pipeline}} T1 {{else}} T0 {{end}}。

range被用于在集合上迭代：管道的值必须是数组、切片或map。如果管道的值长度为零，点号的值不受影响，且执行T0；否则，点号被设置为数组、切片或map内元素的值，并执行T1。

{{range .}}
{{.}}
{{end}}
s := []int{1,2,3,4}
t.Execute(os.Stdout, s)

模板预定义函数

也有一些可以在模板代码中使用的预定义函数，例如printf函数工作方式类似于fmt.Sprintf：

package main
import (
    "os"
    "html/template"
)
func main() {
    t := template.New("test")
    t = template.Must(t.Parse("{{with $x := `hello`}}{{printf `%s %s` $x `Mary`}}{{end}}!\n"))
    t.Execute(os.Stdout, nil)
}

网页服务器功能

package main
import (
    "bytes"
    "expvar"
    "flag"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strconv"
)
var helloRequests = expvar.NewInt("hello-requests")
var webroot = flag.String("root", "/home/user", "web root directory")
var booleanflag = flag.Bool("boolean", true, "another flag for testing")
type Counter struct {
    n int
}
type Chan chan int
func main() {
    flag.Parse()
    http.Handle("/", http.HandlerFunc(Logger))
    http.Handle("/go/hello", http.HandlerFunc(HelloServer))
    ctr := new(Counter)
    expvar.Publish("counter", ctr)
    http.Handle("/counter", ctr)
    http.Handle("/go/", http.StripPrefix("/go/", http.FileServer(http.Dir(*webroot))))
    http.Handle("/flags", http.HandlerFunc(FlagServer))
    http.Handle("/args", http.HandlerFunc(ArgServer))
    http.Handle("/chan", ChanCreate())
    http.Handle("/date", http.HandlerFunc(DateServer))
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        log.Panicln("ListenAndServe:", err)
    }
}
func Logger(w http.ResponseWriter, req *http.Request) {
    log.Print(req.URL.String())
    w.WriteHeader(404)
    w.Write([]byte("oops"))
}
func HelloServer(w http.ResponseWriter, req *http.Request) {
    helloRequests.Add(1)
    io.WriteString(w, "hello world!\n")
}
func (ctr *Counter) String() string { return fmt.Sprintf("%d", ctr.n) }
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    switch req.Method {
    case "GET":
        ctr.n++
    case "POST":
        buf := new(bytes.Buffer)
        io.Copy(buf, req.Body)
        body := buf.String()
        if n, err := strconv.Atoi(body); err != nil {
            fmt.Fprintf(w, "bad POST: %v\nbody: [%v]\n", err, body)
        } else {
            ctr.n = n
            fmt.Fprint(w, "counter reset\n")
        }
    }
    fmt.Fprintf(w, "counter = %d\n", ctr.n)
}
func FlagServer(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprint(w, "Flags:\n")
    flag.VisitAll(func(f *flag.Flag) {
        if f.Value.String() != f.DefValue {
            fmt.Fprintf(w, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue)
        } else {
            fmt.Fprintf(w, "%s = %s\n", f.Name, f.Value.String())
        }
    })
}
func ArgServer(w http.ResponseWriter, req *http.Request) {
    for _, s := range os.Args {
        fmt.Fprint(w, s, " ")
    }
}
func ChanCreate() Chan {
    c := make(Chan)
    go func(c Chan) {
        for x := 0; ; x++ {
            c <- x
        }
    }(c)
    return c
}
func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    io.WriteString(w, fmt.Sprintf("channel send #%d\n", <-ch))
}
func DateServer(rw http.ResponseWriter, req *http.Request) {
    rw.Header().Set("Content-Type", "text/plain; charset=utf-8")
    r, w, err := os.Pipe()
    if err != nil {
        fmt.Fprintf(rw, "pipe: %s\n", err)
        return
    }
    p, err := os.StartProcess("/bin/date", []string{"date"}, &os.ProcAttr{Files: []*os.File{nil, w, w}})
    defer r.Close()
    w.Close()
    if err != nil {
        fmt.Fprintf(rw, "fork/exec: %s\n", err)
        return
    }
    defer p.Release()
    io.Copy(rw, r)
    wait, err := p.Wait()
    if err != nil {
        fmt.Fprintf(rw, "wait: %s\n", err)
        return
    }
    if !wait.Exited() {
        fmt.Fprintf(rw, "date: %v\n", wait)
        return
    }
}

用rpc实现远程过程调用

RPC(Remote Procedure Call Protocol)，远程过程调用协议，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。它假定某些传输协议的存在，如TCP或UDP，以便为通信程序之间携带信息数据。通过它可以使函数调用模式网络化。客户端就像调用本地函数一样，然后客户端把这些参数打包之后通过网络传递到服务端，服务端解包到处理过程中执行，然后执行的结果反馈给客户端。

运行时，一次客户机对服务器的RPC调用，其内部操作大致有如下十步：

• 调用客户端句柄；执行传送参数
• 调用本地系统内核发送网络消息
• 消息传送到远程主机
• 服务器句柄得到消息并取得参数
• 执行远程过程
• 执行的过程将结果返回服务器句柄
• 服务器句柄返回结果，调用远程系统内核
• 消息传回本地主机
• 客户句柄由内核接收消息
• 客户接收句柄返回的结果

Go标准包中提供了对RPC的支持，支持三个级别的RPC：TCP、HTTP、JSONRPC。但Go的RPC包是独一无二的RPC，它和传统的RPC系统不同，它只支持Go开发的服务器与客户端之间的交互，因为在内部，它们采用了Gob来编码。

Go RPC的函数只有符合下面的条件才能被远程访问，不然会被忽略，详细的要求如下：

• 函数必须是导出的(首字母大写)
• 必须有两个导出类型的参数
• 第一个参数是接收的参数，第二个参数是返回给客户端的参数，第二个参数必须是指针类型的
• 函数还要有一个返回值error

func (t *T) MethodName(argType T1, replyType *T2) error

T、T1和T2类型必须能被encoding/god包编解码。

HTTP RPC

服务端示例：

package main
import (
    "errors"
    "fmt"
    "net/http"
    "net/rpc"
)
type Args struct {
    A, B int
}
type Quotient struct {
    Quo, Rem int
}
type Arith int
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}
func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}
func main() {
    arith := new(Arith)
    rpc.Register(arith)
    rpc.HandleHTTP()
    err := http.ListenAndServe(":8081", nil)
    if err != nil {
        fmt.Println(err.Error())
    }
}

客户端示例：

package main
import (
    "fmt"
    "log"
    "net/rpc"
    "os"
)
type Args struct {
    A, B int
}
type Quotient struct {
    Quo, Rem int
}
func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ", os.Args[0], "server")
        os.Exit(1)
    }
    serverAddress := os.Args[1]
    client, err := rpc.DialHTTP("tcp", serverAddress+":8081")
    if err != nil {
        log.Fatal("dialing:", err)
    }
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)
    var quot Quotient
    err = client.Call("Arith.Divide", args, &quot)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)
}

执行go run http_rpc_client.go localhost:

Arith: 17*8=136
Arith: 17/8=2 remainder 1

通过上面的调用可以看到参数和返回值是我们定义的struct类型，在服务端我们把它们当做调用函数的参数的类型，在客户端作为client.Call的第2，3两个参数的类型。客户端最重要的就是这个Call函数，它有3个参数，第1个要调用的函数的名字，第2个是要传递的参数，第3个要返回的参数(主要是指针类型)，通过上面的代码例子我们可以发现，使用Go的RPC实现相当的简单，方便。

TCP RPC

服务端代码：

package main
import (
    "errors"
    "fmt"
    "net"
    "net/rpc"
    "os"
)
type Args struct {
    A, B int
}
type Quotient struct {
    Quo, Rem int
}
type Arith int
func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}
func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}
func main() {
    arith := new(Arith)
    rpc.Register(arith)
    tcpAddr, err := net.ResolveTCPAddr("tcp", ":8082")
    checkError(err)
    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)
    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        rpc.ServeConn(conn)
    }
}
func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error", err.Error())
        os.Exit(1)
    }
}

客户端代码：

package main
import (
    "fmt"
    "log"
    "net/rpc"
    "os"
)
type Args struct {
    A, B int
}
type Quotient struct {
    Quo, Rem int
}
func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ", os.Args[0], "server:port")
        os.Exit(1)
    }
    service := os.Args[1]
    client, err := rpc.Dial("tcp", service)
    if err != nil {
        log.Fatal("dialing:", err)
    }
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)
    var quot Quotient
    err = client.Call("Arith.Divide", args, &quot)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)
}