8.1 Socket编程

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) (int, error) func (c *TCPConn) Read(b []byte) (int, error)

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

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

type TCPAddr struct { IP IP Port int Zone string // IPv6 scoped addressing zone }

在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(network string, laddr, raddr *TCPAddr) (*TCPConn, 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(network string, laddr *TCPAddr) (*TCPListener, error) func (l *TCPListener) Accept() (Conn, 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

设置keepAlive属性，是操做系统层在tcp上没有数据和ACK的时候，会间隔性的发送keepalive包，操做系统能够经过该包来判断一个tcp链接是否已经断开，在windows上默认2个小时没有收到数据和keepalive包的时候人为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应用。