golang的socket编程

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

type IP []byte

输入的IP地址需要解析，以免输入的是错误格式的IP地址：

func ParseIP(s string) IP

参数s可以是字符串类型的ipv4或ipv6地址，如果解析错误会返回nil。

在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可以用在客户端和服务器端来读写数据。而TCP的地址信息用TCPAddr来表示：

type TCPAddr struct {
    IP IP
    Port int
}

通过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".

通过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表示远程的服务地址

客户端代码如下所示：

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

在服务器端我们需要绑定服务到指定的非激活端口，并监听此端口，当有客户端请求到达的时候可以接收到来自客户端连接的请求。net包中有相应功能的函数，函数定义如下：

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

服务器端代码如下：

package main

import (
    "fmt"
    "net"
    "os"
    "time"
    "strconv"
)

func main() {
    service := ":1200"
    tcpAddr,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 128KB 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 string(request) == "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,err.Error())
        os.Exit(1)
    }
}

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连接时的握手开销，对于一些需要频繁交换数据的应用场景比较适用。

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

func ResolveUDPAddr(net,addr string) (*UDPAddr,os.Error)
func DialUDP(net string,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的客户端代码如下：

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",err := net.DialUDP("udp",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)
    }
}

服务器端的代码如下：

package main

import (
    "fmt"
    "net"
    "os"
    "time"
)

func main() {
    service := ":1200"
    udpAddr,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,err.Error())
        os.Exit(1)
    }
}

可见TCP与UDP的conn对象是不同的，前者是net.Conn，后者是net.UDPConn。另外UDP的服务器端的读写是要带着地址的，这个地址是客户端的地址。原文链接：https://www.f2er.com/go/191232.html

猜你在找的Go相关文章