RESTful 架构 && RESTful API All In One

REpresentational State Transfer (REST) 具象状态传输
https://en.wikipedia.org/wiki/Representational_state_transfer

SOAP (Simple Object Access Protocol) 简单对象访问协议

https://en.wikipedia.org/wiki/SOAP

XML-RPC is a Remote Procedure Call (RPC) protocol which uses XML to encode its calls and HTTP as a transport mechanism.

XML-RPC是一个远程过程调用（远端程序呼叫）（remote procedure call，RPC)的分布式计算协议，通过XML将调用函数封装，并使用HTTP协议作为传送机制.

https://en.wikipedia.org/wiki/XML-RPC

8.3 REST

RESTful，是目前最为流行的一种互联网软件架构。因为它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。本小节我们将来学习它到底是一种什么样的架构？以及在Go里面如何来实现它。

什么是REST

REST(REpresentational State Transfer)这个概念，首次出现是在 2000年Roy Thomas Fielding（他是HTTP规范的主要编写者之一）的博士论文中，它指的是一组架构约束条件和原则。满足这些约束条件和原则的应用程序或设计就是RESTful的。

要理解什么是REST，我们需要理解下面几个概念:

资源（Resources） REST是"表现层状态转化"，其实它省略了主语。"表现层"其实指的是"资源"的"表现层"。

那么什么是资源呢？就是我们平常上网访问的一张图片、一个文档、一个视频等。这些资源我们通过URI来定位，也就是一个URI表示一个资源。
表现层（Representation）

资源是做一个具体的实体信息，他可以有多种的展现方式。而把实体展现出来就是表现层，例如一个txt文本信息，他可以输出成html、json、xml等格式，一个图片他可以jpg、png等方式展现，这个就是表现层的意思。

URI确定一个资源，但是如何确定它的具体表现形式呢？应该在HTTP请求的头信息中用Accept和Content-Type字段指定，这两个字段才是对"表现层"的描述。
状态转化（State Transfer）

访问一个网站，就代表了客户端和服务器的一个互动过程。在这个过程中，肯定涉及到数据和状态的变化。而HTTP协议是无状态的，那么这些状态肯定保存在服务器端，所以如果客户端想要通知服务器端改变数据和状态的变化，肯定要通过某种方式来通知它。

客户端能通知服务器端的手段，只能是HTTP协议。具体来说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源。

综合上面的解释，我们总结一下什么是RESTful架构：

（1）每一个URI代表一种资源；
（2）客户端和服务器之间，传递这种资源的某种表现层；
（3）客户端通过四个HTTP动词，对服务器端资源进行操作，实现"表现层状态转化"。

Web应用要满足REST最重要的原则是:客户端和服务器之间的交互在请求之间是无状态的,即从客户端到服务器的每个请求都必须包含理解请求所必需的信息。如果服务器在请求之间的任何时间点重启，客户端不会得到通知。此外此请求可以由任何可用服务器回答，这十分适合云计算之类的环境。因为是无状态的，所以客户端可以缓存数据以改进性能。

另一个重要的REST原则是系统分层，这表示组件无法了解除了与它直接交互的层次以外的组件。通过将系统知识限制在单个层，可以限制整个系统的复杂性，从而促进了底层的独立性。

下图即是REST的架构图：

图8.5 REST架构图

当REST架构的约束条件作为一个整体应用时，将生成一个可以扩展到大量客户端的应用程序。它还降低了客户端和服务器之间的交互延迟。统一界面简化了整个系统架构，改进了子系统之间交互的可见性。REST简化了客户端和服务器的实现，而且对于使用REST开发的应用程序更加容易扩展。

下图展示了REST的扩展性：

图8.6 REST的扩展性

RESTful的实现

Go没有为REST提供直接支持，但是因为RESTful是基于HTTP协议实现的，所以我们可以利用net/http包来自己实现，当然需要针对REST做一些改造，REST是根据不同的method来处理相应的资源，目前已经存在的很多自称是REST的应用，其实并没有真正的实现REST，我暂且把这些应用根据实现的method分成几个级别，请看下图：

图8.7 REST的level分级

上图展示了我们目前实现REST的三个level，我们在应用开发的时候也不一定全部按照RESTful的规则全部实现他的方式，因为有些时候完全按照RESTful的方式未必是可行的，RESTful服务充分利用每一个HTTP方法，包括DELETE和PUT。可有时，HTTP客户端只能发出GET和POST请求：

HTML标准只能通过链接和表单支持GET和POST。在没有Ajax支持的网页浏览器中不能发出PUT或DELETE命令
有些防火墙会挡住HTTP PUT和DELETE请求要绕过这个限制，客户端需要把实际的PUT和DELETE请求通过 POST 请求穿透过来。RESTful 服务则要负责在收到的 POST 请求中找到原始的 HTTP 方法并还原。

我们现在可以通过POST里面增加隐藏字段_method这种方式可以来模拟PUT、DELETE等方式，但是服务器端需要做转换。我现在的项目里面就按照这种方式来做的REST接口。当然Go语言里面完全按照RESTful来实现是很容易的，我们通过下面的例子来说明如何实现RESTful的应用设计。

package main
import (

"fmt"

"github.com/drone/routes"

"net/http"

)
func getuser(w http.ResponseWriter, r *http.Request) {

params := r.URL.Query()

uid := params.Get(":uid")

fmt.Fprintf(w, "you are get user %s", uid)

}
func modifyuser(w http.ResponseWriter, r *http.Request) {

params := r.URL.Query()

uid := params.Get(":uid")

fmt.Fprintf(w, "you are modify user %s", uid)

}
func deleteuser(w http.ResponseWriter, r *http.Request) {

params := r.URL.Query()

uid := params.Get(":uid")

fmt.Fprintf(w, "you are delete user %s", uid)

}
func adduser(w http.ResponseWriter, r *http.Request) {

uid := r.FormValue("uid")

fmt.Fprint(w, "you are add user %s", uid)

}
func main() {

mux := routes.New()

mux.Get("/user/:uid", getuser)

mux.Post("/user/", adduser)

mux.Del("/user/:uid", deleteuser)

mux.Put("/user/:uid", modifyuser)

http.Handle("/", mux)

http.ListenAndServe(":8088", nil)

}

上面的代码演示了如何编写一个REST的应用，我们访问的资源是用户，我们通过不同的method来访问不同的函数，这里使用了第三方库github.com/drone/routes，在前面章节我们介绍过如何实现自定义的路由器，这个库实现了自定义路由和方便的路由规则映射，通过它，我们可以很方便的实现REST的架构。通过上面的代码可知，REST就是根据不同的method访问同一个资源的时候实现不同的逻辑处理。

总结

REST是一种架构风格，汲取了WWW的成功经验：无状态，以资源为中心，充分利用HTTP协议和URI协议，提供统一的接口定义，使得它作为一种设计Web服务的方法而变得流行。在某种意义上，通过强调URI和HTTP等早期Internet标准，REST是对大型应用程序服务器时代之前的Web方式的回归。目前Go对于REST的支持还是很简单的，通过实现自定义的路由规则，我们就可以为不同的method实现不同的handle，这样就实现了REST的架构。

8.2 WebSocket

WebSocket是HTML5的重要特性，它实现了基于浏览器的远程socket，它使浏览器和服务器可以进行全双工通信，许多浏览器（Firefox、Google Chrome和Safari）都已对此做了支持。

在WebSocket出现之前，为了实现即时通信，采用的技术都是“轮询”，即在特定的时间间隔内，由浏览器对服务器发出HTTP Request，服务器在收到请求后，返回最新的数据给浏览器刷新，“轮询”使得浏览器需要对服务器不断发出请求，这样会占用大量带宽。

WebSocket采用了一些特殊的报头，使得浏览器和服务器只需要做一个握手的动作，就可以在浏览器和服务器之间建立一条连接通道。且此连接会保持在活动状态，你可以使用JavaScript来向连接写入或从中接收数据，就像在使用一个常规的TCP Socket一样。它解决了Web实时化的问题，相比传统HTTP有如下好处：

一个Web客户端只建立一个TCP连接
Websocket服务端可以推送(push)数据到web客户端.
有更加轻量级的头，减少数据传送量

WebSocket URL的起始输入是ws://或是wss://（在SSL上）。下图展示了WebSocket的通信过程，一个带有特定报头的HTTP握手被发送到了服务器端，接着在服务器端或是客户端就可以通过JavaScript来使用某种套接口（socket），这一套接口可被用来通过事件句柄异步地接收数据。

图8.2 WebSocket原理图

WebSocket原理

WebSocket的协议颇为简单，在第一次handshake通过以后，连接便建立成功，其后的通讯数据都是以”\x00″开头，以”\xFF”结尾。在客户端，这个是透明的，WebSocket组件会自动将原始数据“掐头去尾”。

浏览器发出WebSocket连接请求，然后服务器发出回应，然后连接建立成功，这个过程通常称为“握手” (handshaking)。请看下面的请求和反馈信息：

图8.3 WebSocket的request和response信息

在请求中的"Sec-WebSocket-Key"是随机的，对于整天跟编码打交到的程序员，一眼就可以看出来：这个是一个经过base64编码后的数据。服务器端接收到这个请求之后需要把这个字符串连接上一个固定的字符串：

258EAFA5-E914-47DA-95CA-C5AB0DC85B11

即：f7cb4ezEAl6C3wRaU6JORA==连接上那一串固定字符串，生成一个这样的字符串：

f7cb4ezEAl6C3wRaU6JORA==258EAFA5-E914-47DA-95CA-C5AB0DC85B11

对该字符串先用 sha1安全散列算法计算出二进制的值，然后用base64对其进行编码，即可以得到握手后的字符串：

rE91AJhfC+6JdVcVXOGJEADEJdQ=

将之作为响应头Sec-WebSocket-Accept的值反馈给客户端。

Go实现WebSocket

Go语言标准包里面没有提供对WebSocket的支持，但是在由官方维护的go.net子包中有对这个的支持，你可以通过如下的命令获取该包：

go get code.google.com/p/go.net/websocket

WebSocket分为客户端和服务端，接下来我们将实现一个简单的例子:用户输入信息，客户端通过WebSocket将信息发送给服务器端，服务器端收到信息之后主动Push信息到客户端，然后客户端将输出其收到的信息，客户端的代码如下：

<html>
<head></head>
<body>
    <script type="text/javascript">
        var sock = null;
        var wsuri = "ws://127.0.0.1:1234";
    window.onload = function() {

        console.log("onload");

        sock = new WebSocket(wsuri);

        sock.onopen = function() {
            console.log("connected to " + wsuri);
        }

        sock.onclose = function(e) {
            console.log("connection closed (" + e.code + ")");
        }

        sock.onmessage = function(e) {
            console.log("message received: " + e.data);
        }
    };

    function send() {
        var msg = document.getElementById('message').value;
        sock.send(msg);
    };
&lt;/script&gt;
&lt;h1&gt;WebSocket Echo Test&lt;/h1&gt;
&lt;form&gt;
    &lt;p&gt;
        Message: &lt;input id="message" type="text" value="Hello, world!"&gt;
    &lt;/p&gt;
&lt;/form&gt;
&lt;button onclick="send();"&gt;Send Message&lt;/button&gt;

</body>

</html>

可以看到客户端JS，很容易的就通过WebSocket函数建立了一个与服务器的连接sock，当握手成功后，会触发WebScoket对象的onopen事件，告诉客户端连接已经成功建立。客户端一共绑定了四个事件。

1）onopen 建立连接后触发
2）onmessage 收到消息后触发
3）onerror 发生错误时触发
4）onclose 关闭连接时触发

我们服务器端的实现如下：

package main
import (

"golang.org/x/net/websocket"

"fmt"

"log"

"net/http"

)
func Echo(ws *websocket.Conn) {

var err error
for {
    var reply string

    if err = websocket.Message.Receive(ws, &amp;reply); err != nil {
        fmt.Println("Can't receive")
        break
    }

    fmt.Println("Received back from client: " + reply)

    msg := "Received:  " + reply
    fmt.Println("Sending to client: " + msg)

    if err = websocket.Message.Send(ws, msg); err != nil {
        fmt.Println("Can't send")
        break
    }
}

}
func main() {

http.Handle("/", websocket.Handler(Echo))
if err := http.ListenAndServe(":1234", nil); err != nil {
    log.Fatal("ListenAndServe:", err)
}

}

当客户端将用户输入的信息Send之后，服务器端通过Receive接收到了相应信息，然后通过Send发送了应答信息。

图8.4 WebSocket服务器端接收到的信息

通过上面的例子我们看到客户端和服务器端实现WebSocket非常的方便，Go的源码net分支中已经实现了这个的协议，我们可以直接拿来用，目前随着HTML5的发展，我想未来WebSocket会是Web开发的一个重点，我们需要储备这方面的知识。

8.4 RPC

前面几个小节我们介绍了如何基于Socket和HTTP来编写网络应用，通过学习我们了解了Socket和HTTP采用的是类似"信息交换"模式，即客户端发送一条信息到服务端，然后(一般来说)服务器端都会返回一定的信息以表示响应。客户端和服务端之间约定了交互信息的格式，以便双方都能够解析交互所产生的信息。但是很多独立的应用并没有采用这种模式，而是采用类似常规的函数调用的方式来完成想要的功能。

RPC就是想实现函数调用模式的网络化。客户端就像调用本地函数一样，然后客户端把这些参数打包之后通过网络传递到服务端，服务端解包到处理过程中执行，然后执行的结果反馈给客户端。

RPC（Remote Procedure Call Protocol）——远程过程调用协议，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。它假定某些传输协议的存在，如TCP或UDP，以便为通信程序之间携带信息数据。通过它可以使函数调用模式网络化。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

RPC工作原理

图8.8 RPC工作流程图

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

1.调用客户端句柄；执行传送参数
2.调用本地系统内核发送网络消息
3.消息传送到远程主机
4.服务器句柄得到消息并取得参数
5.执行远程过程
6.执行的过程将结果返回服务器句柄
7.服务器句柄返回结果，调用远程系统内核
8.消息传回本地主机
9.客户句柄由内核接收消息
10.客户接收句柄返回的数据

Go RPC

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

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

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

举个例子，正确的RPC函数格式如下：

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

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

任何的RPC都需要通过网络来传递数据，Go RPC可以利用HTTP和TCP来传递数据，利用HTTP的好处是可以直接复用net/http里面的一些函数。详细的例子请看下面的实现

HTTP RPC

http的服务端代码实现如下：

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(":1234", nil)
if err != nil {
    fmt.Println(err.Error())
}

}

通过上面的例子可以看到，我们注册了一个Arith的RPC服务，然后通过rpc.HandleHTTP函数把该服务注册到了HTTP协议上，然后我们就可以利用http的方式来传递数据了。

请看下面的客户端代码：

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+":1234")
if err != nil {
    log.Fatal("dialing:", err)
}
// Synchronous call
args := Args{17, 8}
var reply int
err = client.Call("Arith.Multiply", args, &amp;reply)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, reply)

var quot Quotient
err = client.Call("Arith.Divide", args, &amp;quot)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d/%d=%d remainder %d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, quot.Quo, quot.Rem)

}

我们把上面的服务端和客户端的代码分别编译，然后先把服务端开启，然后开启客户端，输入代码，就会输出如下信息：

$ ./http_c 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

上面我们实现了基于HTTP协议的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", ":1234")
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)

}

}

上面这个代码和http的服务器相比，不同在于:在此处我们采用了TCP协议，然后需要自己控制连接，当有客户端连接上来后，我们需要把这个连接交给rpc来处理。

如果你留心了，你会发现这它是一个阻塞型的单用户的程序，如果想要实现多并发，那么可以使用goroutine来实现，我们前面在socket小节的时候已经介绍过如何处理goroutine。下面展现了TCP实现的RPC客户端：

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)
}
// Synchronous call
args := Args{17, 8}
var reply int
err = client.Call("Arith.Multiply", args, &amp;reply)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, reply)

var quot Quotient
err = client.Call("Arith.Divide", args, &amp;quot)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d/%d=%d remainder %d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, quot.Quo, quot.Rem)

}

这个客户端代码和http的客户端代码对比，唯一的区别一个是DialHTTP，一个是Dial(tcp)，其他处理一模一样。

JSON RPC

JSON RPC是数据编码采用了JSON，而不是gob编码，其他和上面介绍的RPC概念一模一样，下面我们来演示一下，如何使用Go提供的json-rpc标准包，请看服务端代码的实现：

package main
import (

"errors"

"fmt"

"net"

"net/rpc"

"net/rpc/jsonrpc"

"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", ":1234")
checkError(err)

listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)

for {
    conn, err := listener.Accept()
    if err != nil {
        continue
    }
    jsonrpc.ServeConn(conn)
}

}
func checkError(err error) {

if err != nil {

fmt.Println("Fatal error ", err.Error())

os.Exit(1)

}

}

通过示例我们可以看出 json-rpc是基于TCP协议实现的，目前它还不支持HTTP方式。

请看客户端的实现代码：

package main
import (

"fmt"

"log"

"net/rpc/jsonrpc"

"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")

log.Fatal(1)

}

service := os.Args[1]
client, err := jsonrpc.Dial("tcp", service)
if err != nil {
    log.Fatal("dialing:", err)
}
// Synchronous call
args := Args{17, 8}
var reply int
err = client.Call("Arith.Multiply", args, &amp;reply)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d*%d=%d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, reply)

var quot Quotient
err = client.Call("Arith.Divide", args, &amp;quot)
if err != nil {
    log.Fatal("arith error:", err)
}
fmt.Printf("Arith: %d/%d=%d remainder %d<span class="pl-cce"><span class="pl-en">\n<span class="pl-v">", args.A, args.B, quot.Quo, quot.Rem)

}

总结

Go已经提供了对RPC的良好支持，通过上面HTTP、TCP、JSON RPC的实现,我们就可以很方便的开发很多分布式的Web应用，我想作为读者的你已经领会到这一点。但遗憾的是目前Go尚未提供对SOAP RPC的支持，欣慰的是现在已经有第三方的开源实现了。

8.1 Socket编程

在很多底层网络应用开发者的眼里一切编程都是Socket，话虽然有点夸张，但却也几乎如此了，现在的网络编程几乎都是用Socket来编程。你想过这些情景么？我们每天打开浏览器浏览网页时，浏览器进程怎么和Web服务器进行通信的呢？当你用QQ聊天时，QQ进程怎么和服务器或者是你的好友所在的QQ进程进行通信的呢？当你打开PPstream观看视频时，PPstream进程如何与视频服务器进行通信的呢？如此种种，都是靠Socket来进行通信的，以一斑窥全豹，可见Socket编程在现代编程中占据了多么重要的地位，这一节我们将介绍Go语言中如何进行Socket编程。

什么是Socket？

Socket起源于Unix，而Unix基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现，网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用：Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

Socket如何通信

网络中的进程之间如何通过Socket通信呢？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中需要互相通信的进程，就可以利用这个标志在他们之间进行交互。请看下面这个TCP/IP协议结构图

图8.1 七层网络协议图

使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是为什么说“一切皆Socket”。

Socket基础知识

通过上面的介绍我们知道Socket有两种：TCP Socket和UDP Socket，TCP和UDP是协议，而要确定一个进程的需要三元组，需要IP地址和端口。

IPv4地址

目前的全球因特网所采用的协议族是TCP/IP协议。IP是TCP/IP协议中网络层的协议，是TCP/IP协议族的核心协议。目前主要采用的IP协议的版本号是4(简称为IPv4)，发展至今已经使用了30多年。

IPv4的地址位数为32位，也就是最多有2的32次方的网络设备可以联到Internet上。近十年来由于互联网的蓬勃发展，IP位址的需求量愈来愈大，使得IP位址的发放愈趋紧张，前一段时间，据报道IPV4的地址已经发放完毕，我们公司目前很多服务器的IP都是一个宝贵的资源。

地址格式类似这样：127.0.0.1 172.122.121.111

IPv6地址

IPv6是下一版本的互联网协议，也可以说是下一代互联网的协议，它是为了解决IPv4在实施过程中遇到的各种问题而被提出的，IPv6采用128位地址长度，几乎可以不受限制地提供地址。按保守方法估算IPv6实际可分配的地址，整个地球的每平方米面积上仍可分配1000多个地址。在IPv6的设计过程中除了一劳永逸地解决了地址短缺问题以外，还考虑了在IPv4中解决不好的其它问题，主要有端到端IP连接、服务质量（QoS）、安全性、多播、移动性、即插即用等。

地址格式类似这样：2002:c0e8:82e7:0:0:0:c0e8:82e7

Go支持的IP类型

在Go的net包中定义了很多类型、函数和方法用来网络编程，其中IP的定义如下：

type IP []byte

在net包中有很多函数来操作IP，但是其中比较有用的也就几个，其中ParseIP(s string) IP函数会把一个IPv4或者IPv6的地址转化成IP类型，请看下面的例子:

package main
import (
    "net"
    "os"
    "fmt"
)
func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0])
        os.Exit(1)
    }
    name := os.Args[1]
    addr := net.ParseIP(name)
    if addr == nil {
        fmt.Println("Invalid address")
    } else {
        fmt.Println("The address is ", addr.String())
    }
    os.Exit(0)
}

执行之后你就会发现只要你输入一个IP地址就会给出相应的IP格式

TCP Socket

当我们知道如何通过网络端口访问一个服务时，那么我们能够做什么呢？作为客户端来说，我们可以通过向远端某台机器的的某个网络端口发送一个请求，然后得到在机器的此端口上监听的服务反馈的信息。作为服务端，我们需要把服务绑定到某个指定端口，并且在此端口上监听，当有客户端来访问时能够读取信息并且写入反馈信息。

在Go语言的net包中有一个类型TCPConn，这个类型可以用来作为客户端和服务器端交互的通道，他有两个主要的函数：

func (c *TCPConn) Write(b []byte) (n int, err os.Error)
func (c *TCPConn) Read(b []byte) (n int, err os.Error)

TCPConn可以用在客户端和服务器端来读写数据。

还有我们需要知道一个TCPAddr类型，他表示一个TCP的地址信息，他的定义如下：

type TCPAddr struct {
    IP IP
    Port int
}

在Go语言中通过ResolveTCPAddr获取一个TCPAddr

func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)

net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only),TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个).
addr表示域名或者IP地址，例如"www.google.com:80" 或者"127.0.0.1:22".

TCP client

Go语言中通过net包中的DialTCP函数来建立一个TCP连接，并返回一个TCPConn类型的对象，当连接建立时服务器端也创建一个同类型的对象，此时客户端和服务器段通过各自拥有的TCPConn对象来进行数据交换。一般而言，客户端通过TCPConn对象将请求信息发送到服务器端，读取服务器端响应的信息。服务器端读取并解析来自客户端的请求，并返回应答信息，这个连接只有当任一端关闭了连接之后才失效，不然这连接可以一直在使用。建立连接的函数定义如下：

func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error)

net参数是"tcp4"、"tcp6"、"tcp"中的任意一个，分别表示TCP(IPv4-only)、TCP(IPv6-only)或者TCP(IPv4,IPv6的任意一个)
laddr表示本机地址，一般设置为nil
raddr表示远程的服务地址

接下来我们写一个简单的例子，模拟一个基于HTTP协议的客户端请求去连接一个Web服务端。我们要写一个简单的http请求头，格式类似如下：

"HEAD / HTTP/1.0\r\n\r\n"

从服务端接收到的响应信息格式可能如下：

HTTP/1.0 200 OK
ETag: "-9985996"
Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT
Content-Length: 18074
Connection: close
Date: Sat, 28 Aug 2010 00:43:48 GMT
Server: lighttpd/1.4.23

我们的客户端代码如下所示：

package main
import (

"fmt"

"io/ioutil"

"net"

"os"

)
func main() {

if len(os.Args) != 2 {

fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0])

os.Exit(1)

}

service := os.Args[1]

tcpAddr, err := net.ResolveTCPAddr("tcp4", service)

checkError(err)

conn, err := net.DialTCP("tcp", nil, tcpAddr)

checkError(err)

_, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))

checkError(err)

result, err := ioutil.ReadAll(conn)

checkError(err)

fmt.Println(string(result))

os.Exit(0)

}

func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)

}

}

通过上面的代码我们可以看出：首先程序将用户的输入作为参数service传入net.ResolveTCPAddr获取一个tcpAddr,然后把tcpAddr传入DialTCP后创建了一个TCP连接conn，通过conn来发送请求信息，最后通过ioutil.ReadAll从conn中读取全部的文本，也就是服务端响应反馈的信息。

TCP server

上面我们编写了一个TCP的客户端程序，也可以通过net包来创建一个服务器端程序，在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下：

func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error)
func (l *TCPListener) Accept() (c Conn, err os.Error)

参数说明同DialTCP的参数一样。下面我们实现一个简单的时间同步服务，监听7777端口

package main
import (

"fmt"

"net"

"os"

"time"

)
func main() {

service := ":7777"

tcpAddr, err := net.ResolveTCPAddr("tcp4", service)

checkError(err)

listener, err := net.ListenTCP("tcp", tcpAddr)

checkError(err)

for {

conn, err := listener.Accept()

if err != nil {

continue

}

daytime := time.Now().String()

conn.Write([]byte(daytime)) // don't care about return value

conn.Close()                // we're finished with this client

}

}

func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)

}

}

上面的服务跑起来之后，它将会一直在那里等待，直到有新的客户端请求到达。当有新的客户端请求到达并同意接受Accept该请求的时候他会反馈当前的时间信息。值得注意的是，在代码中for循环里，当有错误发生时，直接continue而不是退出，是因为在服务器端跑代码的时候，当有错误发生的情况下最好是由服务端记录错误，然后当前连接的客户端直接报错而退出，从而不会影响到当前服务端运行的整个服务。

上面的代码有个缺点，执行的时候是单任务的，不能同时接收多个请求，那么该如何改造以使它支持多并发呢？Go里面有一个goroutine机制，请看下面改造后的代码

package main
import (

"fmt"

"net"

"os"

"time"

)
func main() {

service := ":1200"

tcpAddr, err := net.ResolveTCPAddr("tcp4", service)

checkError(err)

listener, err := net.ListenTCP("tcp", tcpAddr)

checkError(err)

for {

conn, err := listener.Accept()

if err != nil {

continue

}

go handleClient(conn)

}

}
func handleClient(conn net.Conn) {

defer conn.Close()

daytime := time.Now().String()

conn.Write([]byte(daytime)) // don't care about return value

// we're finished with this client

}

func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)

}

}

通过把业务处理分离到函数handleClient，我们就可以进一步地实现多并发执行了。看上去是不是很帅，增加go关键词就实现了服务端的多并发，从这个小例子也可以看出goroutine的强大之处。

有的朋友可能要问：这个服务端没有处理客户端实际请求的内容。如果我们需要通过从客户端发送不同的请求来获取不同的时间格式，而且需要一个长连接，该怎么做呢？请看：

package main
import (

"fmt"

"net"

"os"

"time"

"strconv"

"strings"

)
func main() {

service := ":1200"

tcpAddr, err := net.ResolveTCPAddr("tcp4", service)

checkError(err)

listener, err := net.ListenTCP("tcp", tcpAddr)

checkError(err)

for {

conn, err := listener.Accept()

if err != nil {

continue

}

go handleClient(conn)

}

}
func handleClient(conn net.Conn) {

conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout

request := make([]byte, 128) // set maxium request length to 128B to prevent flood attack

defer conn.Close()  // close connection before exit

for {

read_len, err := conn.Read(request)
    if err != nil {
        fmt.Println(err)
        break
    }

    if read_len == 0 {
        break // connection already closed by client
    } else if strings.TrimSpace(string(request[:read_len])) == "timestamp" {
        daytime := strconv.FormatInt(time.Now().Unix(), 10)
        conn.Write([]byte(daytime))
    } else {
        daytime := time.Now().String()
        conn.Write([]byte(daytime))
    }

    request = make([]byte, 128) // clear last read content
}

}
func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())

os.Exit(1)

}

}

在上面这个例子中，我们使用conn.Read()不断读取客户端发来的请求。由于我们需要保持与客户端的长连接，所以不能在读取完一次请求后就关闭连接。由于conn.SetReadDeadline()设置了超时，当一定时间内客户端无请求发送，conn便会自动关闭，下面的for循环即会因为连接已关闭而跳出。需要注意的是，request在创建时需要指定一个最大长度以防止flood attack；每次读取到请求处理完毕后，需要清理request，因为conn.Read()会将新读取到的内容append到原内容之后。

控制TCP连接

TCP有很多连接控制函数，我们平常用到比较多的有如下几个函数：

func DialTimeout(net, addr string, timeout time.Duration) (Conn, error)

设置建立连接的超时时间，客户端和服务器端都适用，当超过设置时间时，连接自动关闭。

func (c *TCPConn) SetReadDeadline(t time.Time) error
func (c *TCPConn) SetWriteDeadline(t time.Time) error

用来设置写入/读取一个连接的超时时间。当超过设置时间时，连接自动关闭。

func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error

设置客户端是否和服务器端保持长连接，可以降低建立TCP连接时的握手开销，对于一些需要频繁交换数据的应用场景比较适用。

更多的内容请查看net包的文档。

UDP Socket

Go语言包中处理UDP Socket和TCP Socket不同的地方就是在服务器端处理多个客户端请求数据包的方式不同,UDP缺少了对客户端连接请求的Accept函数。其他基本几乎一模一样，只有TCP换成了UDP而已。UDP的几个主要函数如下所示：

func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error)
func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error)
func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error)
func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error)
func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error)

一个UDP的客户端代码如下所示,我们可以看到不同的就是TCP换成了UDP而已：

package main
import (

"fmt"

"net"

"os"

)
func main() {

if len(os.Args) != 2 {

fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])

os.Exit(1)

}

service := os.Args[1]

udpAddr, err := net.ResolveUDPAddr("udp4", service)

checkError(err)

conn, err := net.DialUDP("udp", nil, udpAddr)

checkError(err)

_, err = conn.Write([]byte("anything"))

checkError(err)

var buf [512]byte

n, err := conn.Read(buf[0:])

checkError(err)

fmt.Println(string(buf[0:n]))

os.Exit(0)

}

func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())

os.Exit(1)

}

}

我们来看一下UDP服务器端如何来处理：

package main
import (

"fmt"

"net"

"os"

"time"

)
func main() {

service := ":1200"

udpAddr, err := net.ResolveUDPAddr("udp4", service)

checkError(err)

conn, err := net.ListenUDP("udp", udpAddr)

checkError(err)

for {

handleClient(conn)

}

}

func handleClient(conn *net.UDPConn) {

var buf [512]byte

_, addr, err := conn.ReadFromUDP(buf[0:])

if err != nil {

return

}

daytime := time.Now().String()

conn.WriteToUDP([]byte(daytime), addr)

}

func checkError(err error) {

if err != nil {

fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())

os.Exit(1)

}

}

总结

通过对TCP和UDP Socket编程的描述和实现，可见Go已经完备地支持了Socket编程，而且使用起来相当的方便，Go提供了很多函数，通过这些函数可以很容易就编写出高性能的Socket应用。

demos

(🐞 反爬虫测试！打击盗版⚠️）如果你看到这个信息, 说明这是一篇剽窃的文章，请访问 https://www.cnblogs.com/xgqfrms/ 查看原创文章！

refs

©xgqfrms 2012-2021
www.cnblogs.com/xgqfrms 发布文章使用：只允许注册用户才可以访问！

原创文章，版权所有©️xgqfrms, 禁止转载 🈲️，侵权必究⚠️！

posted @ 2016-09-01 10:53 xgqfrms 阅读(194) 评论(6) 编辑收藏举报

刷新页面返回顶部

xgqfrms

welcome to xgqfrms's official blogs of cnblogs!

RESTful 架构 && RESTful API All In One

RESTful 架构 && RESTful API All In One

8.3 REST

什么是REST

RESTful的实现

总结

8.2 WebSocket

WebSocket原理

Go实现WebSocket

8.4 RPC

RPC工作原理

Go RPC

HTTP RPC

TCP RPC

JSON RPC

总结

8.1 Socket编程

什么是Socket？

Socket如何通信

Socket基础知识

IPv4地址

IPv6地址

Go支持的IP类型

TCP Socket

TCP client

TCP server

控制TCP连接

UDP Socket

总结

demos

(🐞 反爬虫测试！打击盗版⚠️）如果你看到这个信息, 说明这是一篇剽窃的文章，请访问 https://www.cnblogs.com/xgqfrms/ 查看原创文章！

refs

©xgqfrms 2012-2021
www.cnblogs.com/xgqfrms 发布文章使用：只允许注册用户才可以访问！

原创文章，版权所有©️xgqfrms, 禁止转载 🈲️，侵权必究⚠️！

公告

xgqfrms

welcome to xgqfrms's official blogs of cnblogs!

RESTful 架构 && RESTful API All In One

RESTful 架构 && RESTful API All In One

8.3 REST

什么是REST

RESTful的实现

总结

8.2 WebSocket

WebSocket原理

Go实现WebSocket

8.4 RPC

RPC工作原理

Go RPC

HTTP RPC

TCP RPC

JSON RPC

总结

8.1 Socket编程

什么是Socket？

Socket如何通信

Socket基础知识

IPv4地址

IPv6地址

Go支持的IP类型

TCP Socket

TCP client

TCP server

控制TCP连接

UDP Socket

总结

demos

(🐞 反爬虫测试！打击盗版⚠️）如果你看到这个信息, 说明这是一篇剽窃的文章，请访问 https://www.cnblogs.com/xgqfrms/ 查看原创文章！

refs

©xgqfrms 2012-2021 www.cnblogs.com/xgqfrms 发布文章使用：只允许注册用户才可以访问！ 原创文章，版权所有©️xgqfrms, 禁止转载 🈲️，侵权必究⚠️！

公告

©xgqfrms 2012-2021
www.cnblogs.com/xgqfrms 发布文章使用：只允许注册用户才可以访问！

原创文章，版权所有©️xgqfrms, 禁止转载 🈲️，侵权必究⚠️！