Go 网络服务器端程序与客户端程序

1.服务器程序

package main

import (
    "bytes"
    "fmt"
    "io"
    "net"
    "time"
)

const (
    SERVER_NETWORK = "tcp4"
    SERVER_ADDRESS = ":8082"
    DELIMITER      = '\t'
)

var logSn int32 = 0

func printLog(format string, a ...interface{}) {
    fmt.Printf("%d:%s", logSn, fmt.Sprintf(format, a...))
    logSn++
}

func handleConn(conn net.Conn) {
    defer conn.Close()
    printLog("RemoteAddr:%s\n", conn.RemoteAddr().String())

    for {
        conn.SetReadDeadline(time.Now().Add(10 * time.Second))
        strReq, err := read(conn)
        if err != nil {
            if err == io.EOF {
                printLog("The connection is closed by another side.(server)\n")
            } else {
                printLog("Read Error: %s(server)\n", err)
            }

            break
        }

        printLog("Received request:%s(server)\n", strReq)

        write(conn, "hello world")
    }
}

func write(conn net.Conn, content string) (n int, err error) {
    var buffer bytes.Buffer
    buffer.WriteString(content)
    buffer.WriteByte(DELIMITER)
    return conn.Write(buffer.Bytes())
}

func read(conn net.Conn) (string, error) {
    readBytes := make([]byte, 1)
    var buffer bytes.Buffer

    for {
        _, err := conn.Read(readBytes)
        if err != nil {
            return "", err
        }

        readByte := readBytes[0]
        if readByte == DELIMITER {
            break
        }

        buffer.WriteByte(readByte)
    }

    return buffer.String(), nil
}

func serverGo() {
    listenerFD, err := net.Listen(SERVER_NETWORK, SERVER_ADDRESS)
    if err != nil {
        printLog("Listen Error: %s\n", err)
        return
    }

    defer listenerFD.Close()
    printLog("Got listener for the server.(local address: %s)\n", listenerFD.Addr().String())

    for {
        clientFD, err := listenerFD.Accept()
        if err != nil {
            fmt.Printf("接受客户端连接失败：%s\n", err.Error())
            continue
        }

        go handleConn(clientFD)
    }
}

func main() {
    serverGo()
}

2.客户端程序

// client
package main

import (
    "bytes"
    "fmt"
    "net"
    "sync"
    "time"
)

const (
    SERVER_NETWORK = "tcp"
    SERVER_ADDRESS = "127.0.0.1:8082"
    DELIMITER      = '\t'
)

var logSn int32 = 1

func printLog(format string, a ...interface{}) {
    fmt.Printf("%d:%s", logSn, fmt.Sprintf(format, a...))
    logSn++
}

func clientGo(id int) {
    defer wp.Done()
    conn, err := net.DialTimeout(SERVER_NETWORK, SERVER_ADDRESS, 40*time.Second)
    if err != nil {
        printLog("Dial Error: %s (client[%d])\n", err, id)
        return
    }

    defer conn.Close()

    printLog("Connected to server (remote address:%s,local address:%s)(client[%d])\n", conn.RemoteAddr().String(), conn.LocalAddr().String(), id)

    for {
        _, err := write(conn, "hello server")
        if err != nil {
            printLog("Write data error: %s\n", err.Error())
            break
        }

        rep, err := read(conn)
        if err != nil {
            printLog("Read data error: %s\n", err.Error())
            break
        }

        printLog("server:%s\n", rep)

        time.Sleep(time.Millisecond)
    }
}

func read(conn net.Conn) (string, error) {
    readBytes := make([]byte, 1)
    var buffer bytes.Buffer

    for {
        _, err := conn.Read(readBytes)
        if err != nil {
            return "", err
        }

        readByte := readBytes[0]
        if readByte == DELIMITER {
            break
        }

        buffer.WriteByte(readByte)
    }

    return buffer.String(), nil
}

func write(conn net.Conn, content string) (n int, err error) {
    var buffer bytes.Buffer
    buffer.WriteString(content)
    buffer.WriteByte(DELIMITER)
    return conn.Write(buffer.Bytes())
}

var wp sync.WaitGroup

func main() {
    wp.Add(4000)

    for i := 0; i < 4000; i++ {
        go clientGo(i)
    }

    wp.Wait()
}

“`

共启动了4千个连接，每个连接每毫秒发送一个“Hello Server”字符串，服务器端回复一个”hello world字符串