golang 网络编程 - 《Golang学习笔记》

socket编程
- 客户端
- 服务端
HTTP编程
RPC编程
JSON

socket编程

传统的socket编程步骤：
(1) 建立Socket：使用socket()函数。
(2) 绑定Socket：使用bind()函数。
(3) 监听：使用listen()函数。或者连接：使用connect()函数。
(4) 接受连接：使用accept()函数。
(5) 接收：使用recv()函数。或者发送：使用send()函数。
Go语言标准库对此过程进行了抽象和封装。无论我们期望使用什么协议建立什么形式的连接，都只需要调用net.Dial()即可。

客户端

//Dial()函数原型
func Dial(net, addr string) (Conn, error)

其中net参数是网络协议的名字，addr参数是IP地址或域名，而端口号以“:”的形式跟随在地址或域名的后面，端口号可选。如果连接成功，返回连接对象，否则返回error。

//示例：
conn, err := net.Dial("tcp4", "127.0.0.1:16666")
if err != nil {
    fmt.Println("Dial error: ", err)                                     
}

实际上，Dial()函数是对DialTCP()、DialUDP()、DialIP()和DialUnix()的封装。我们也可以直接调用这些函数，它们的功能是一致的。这些函数的原型如下：

func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err error) 
func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err error) 
func DialIP(netProto string, laddr, raddr *IPAddr) (*IPConn, error) 
func DialUnix(net string, laddr, raddr *UnixAddr) (c *UnixConn, err error)

服务端

addr, err := net.ResolveTCPAddr("tcp4", "127.0.0.1:16666")                  
if err != nil {                                                             
    fmt.Println("ResolveTCPAddr err: ", err)                      
}
listen, err := net.ListenTCP("tcp", addr)                                   
if err != nil {                                                             
    fmt.Println("ListenTCP err: ", err)                                                
}
conn, err := listen.AcceptTCP()                                         
if err != nil {                                                         
    fmt.Println("AcceptTCP err: ", err) 
}

HTTP编程

net/http包的Client类型提供了如下几个方法，让我们可以用最简洁的方式实现 HTTP 请求：

func (c *Client) Get(url string) (r *Response, err error) 
func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error) 
func (c *Client) PostForm(url string, data url.Values) (r *Response, err error) 
func (c *Client) Head(url string) (r *Response, err error) 
func (c *Client) Do(req *Request) (resp *Response, err error)

使用 net/http 包提供的 http.ListenAndServe() 方法，可以在指定的地址进行监听，开启一个HTTP，服务端该方法的原型如下：

func ListenAndServe(addr string, handler Handler) error

该方法用于在指定的 TCP 网络地址 addr 进行监听，然后调用服务端处理程序来处理传入的连接请求。该方法有两个参数：第一个参数 addr 即监听地址；第二个参数表示服务端处理程序，通常为空，这意味着服务端调用 http.DefaultServeMux 进行处理，而服务端编写的业务逻辑处理程序 http.Handle() 或 http.HandleFunc() 默认注入 http.DefaultServeMux 中，具体代码如下：

http.Handle("/foo", fooHandler) 
http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { 
    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) 
}) 
log.Fatal(http.ListenAndServe(":8080", nil))
//如果想更多地控制服务端的行为，可以自定义 http.Server，代码如下：
s := &http.Server{ 
    Addr: ":8080", 
    Handler: myHandler, 
    ReadTimeout: 10 * time.Second, 
    WriteTimeout: 10 * time.Second, 
    MaxHeaderBytes: 1 << 20, 
} 
log.Fatal(s.ListenAndServe())
// 这就是用Go实现的一个最简短的hello world服务器.
package main
import "net/http"
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`hello world`))
    })
    http.ListenAndServe(":3000", nil) // <-今天讲的就是这个ListenAndServe是如何工作的
}
//net/http 包还提供 http.ListenAndServeTLS() 方法，用于处理 HTTPS 连接请求：
func ListenAndServeTLS(addr string, certFile string, keyFile string, handler Handler) error

ListenAndServeTLS() 和 ListenAndServe()的行为一致，区别在于只处理HTTPS请求。此外，服务器上必须存在包含证书和与之匹配的私钥的相关文件，如certFile对应SSL证书文件存放路径，keyFile对应证书私钥文件路径。如果证书是由证书颁发机构签署的，certFile参数指定的路径必须是存放在服务器上的经由CA认证过的SSL证书。

//开启 SSL 监听服务也很简单，如下列代码所示：
http.Handle("/foo", fooHandler) 
http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) { 
    fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path)) 
}) 
log.Fatal(http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil)) 
或者是：
ss := &http.Server{ 
    Addr: ":10443", 
    Handler: myHandler, 
    ReadTimeout: 10 * time.Second, 
    WriteTimeout: 10 * time.Second, 
    MaxHeaderBytes: 1 << 20, 
} 
log.Fatal(ss.ListenAndServeTLS("cert.pem", "key.pem"))

RPC编程

RPC（Remote Procedure Call，远程过程调用）是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络细节的应用程序通信协议。RPC协议构建于TCP或UDP，或者是 HTTP 之上，允许开发者直接调用另一台计算机上的程序，而开发者无需额外地为这个调用过程编写网络通信相关代码，使得开发包括网络分布式程序在内的应用程序更加容易。
RPC 采用客户端—服务器（Client/Server）的工作模式。请求程序就是一个客户端（Client），而服务提供程序就是一个服务器（Server）。当执行一个远程过程调用时，客户端程序首先发送一个带有参数的调用信息到服务端，然后等待服务端响应。在服务端，服务进程保持睡眠状态直到客户端的调用信息到达为止。当一个调用信息到达时，服务端获得进程参数，计算出结果，并向客户端发送应答信息，然后等待下一个调用。最后，客户端接收来自服务端的应答信息，获得进程结果，然后调用执行并继续进行。
net/rpc包允许 RPC 客户端程序通过网络或是其他 I/O 连接调用一个远端对象的公开方法（必须是大写字母开头、可外部调用的）。在 RPC 服务端，可将一个对象注册为可访问的服务，之后该对象的公开方法就能够以远程的方式提供访问。一个 RPC 服务端可以注册多个不同类型的对象，但不允许注册同一类型的多个对象。
一个对象中只有满足如下这些条件的方法，才能被 RPC 服务端设置为可供远程访问：

必须是在对象外部可公开调用的方法（首字母大写）；
必须有两个参数，且参数的类型都必须是包外部可以访问的类型或者是Go内建支持的类型；
第二个参数必须是一个指针；
方法必须返回一个error类型的值。

以上4个条件，可以简单地用如下一行代码表示：
func (t T) MethodName(argType T1, replyType T2) error
在上面这行代码中，类型T、T1 和 T2 默认会使用 Go 内置的 encoding/gob 包进行编码解码。该方法的第一个参数表示由 RPC 客户端传入的参数，第二个参数表示要返回给RPC客户端的结果，该方法最后返回一个 error 类型的值。

// 服务器端
package server
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()    //开启服务
    l, e := net.Listen("tcp", ":1234") //端口监听
    if e != nil {
        log.Fatal("listen error:", e)
    }
    go http.Serve(l, nil) //启动HTTP服务
}
// 客户端
package client
func main() {
      client, err := rpc.DialHTTP("tcp", serverAddress + ":1234") //连接服务RPC
      if err != nil {
    log.Fatal("dialing:", err)
}
然后，客户端可以执行远程调用：
// Synchronous call
args := &server.Args{7,8}
var reply int
err = client.Call("Arith.Multiply", args, &reply) //同步调用RPC服务
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d", args.A, args.B, reply)
或：
// Asynchronous call
quotient := new(Quotient)
divCall := client.Go("Arith.Divide", args, quotient, nil) //异步调用RPC服务
replyCall := <-divCall.Done // will be equal to divCall
// check errors, print, etc.

JSON

Go语言内建对JSON的支持。使用Go语言内置的encoding/json 标准库。

//使用json.Marshal()函数可以对一组数据进行JSON格式的编码。json.Marshal()函数的声明如下：
func Marshal(v interface{}) ([]byte, error) 
//假如有如下一个Book类型的结构体：
type Book struct { 
    Title string
    Authors []string
    Publisher string
    IsPublished bool
    Price float 
} 
//并且有如下一个 Book 类型的实例对象：
gobook := Book{ 
    "Go语言编程", 
    ["XuShiwei", "HughLv", "Pandaman", "GuaguaSong", "HanTuo", "BertYuan", 
    "XuDaoli"], 
    "ituring.com.cn", 
    true, 
    9.99 
} 
//然后，我们可以使用 json.Marshal() 函数将gobook实例生成一段JSON格式的文本：
b, err := json.Marshal(gobook) 
//如果编码成功，err 将赋于零值 nil，变量b 将会是一个进行JSON格式化之后的[]byte 类型：
b == []byte(`{ 
    "Title": "Go语言编程", 
    "Authors": ["XuShiwei", "HughLv", "Pandaman", "GuaguaSong", "HanTuo", "BertYuan", 
    "XuDaoli"], 
    "Publisher": "ituring.com.cn", 
    "IsPublished": true, 
    "Price": 9.99 
}`)

当调用json.Marshal(gobook)语句时，会递归遍历gobook对象，如果发现gobook这个数据结构实现了json.Marshaler接口且包含有效的值，Marshal()就会调用其MarshalJSON()方法将该数据结构生成 JSON 格式的文本。
Go语言的大多数数据类型都可以转化为有效的JSON文本，但channel、complex和函数这几种类型除外。
如果转化前的数据结构中出现指针，那么将会转化指针所指向的值，如果指针指向的是零值，那么null将作为转化后的结果输出。
在Go中，JSON转化前后的数据类型映射如下。

布尔值转化为JSON后还是布尔类型。
浮点数和整型会被转化为JSON里边的常规数字。
字符串将以UTF-8编码转化输出为Unicode字符集的字符串，特殊字符比如<将会被转义为\u003c。
数组和切片会转化为JSON里边的数组，但[]byte类型的值将会被转化为 Base64 编码后的字符串，slice类型的零值会被转化为 null。
结构体会转化为JSON对象，并且只有结构体里边以大写字母开头的可被导出的字段才会被转化输出，而这些可导出的字段会作为JSON对象的字符串索引。

转化一个map类型的数据结构时，该数据的类型必须是 map[string]T（T可以是encoding/json 包支持的任意数据类型）。

//可以使用json.Unmarshal()函数将JSON格式的文本解码为Go里边预期的数据结构。json.Unmarshal()函数的原型如下：
func Unmarshal(data []byte, v interface{}) error 
//该函数的第一个参数是输入，即JSON格式的文本（比特序列），第二个参数表示目标输出容器，用于存放解码后的值。要解码一段JSON数据，首先需要在Go中创建一个目标类型的实例对象，用于存放解码后的值：
var book Book 
//然后调用 json.Unmarshal() 函数，将 []byte 类型的JSON数据作为第一个参数传入，将book实例变量的指针作为第二个参数传入：
err := json.Unmarshal(b, &book) 
//如果 b 是一个有效的JSON数据并能和 book 结构对应起来，那么JSON解码后的值将会一一存放到book结构体中。解码成功后的 book 数据如下：
book := Book{ 
  "Go语言编程", 
  ["XuShiwei", "HughLv", "Pandaman", "GuaguaSong", "HanTuo", "BertYuan", 
  "XuDaoli"], 
  "ituring.com.cn", 
  true, 
  9.99 
}