Golang实现的聊天程序服务端和客户端代码分享

实现逻辑

1、golang 版本  1.3

2、实现原理：

　　1、主进程建立tcp监听服务，并且初始化一个变量 talkchan := make(map[int]chan string)

　　2、当主进程accept连接请求后，利用go 启动一个协程a去维持和客户端的连接，把taokchan带入到协程里

　　3、和客户端建立连接的协程a，发送消息给客户端，使其发送自己的用户信息。

　　4、协程a在收到客户端发送的用户信息后，建立一个此用户对应的管道 talkchan[uid] = make(chan string)

　　5、协程a再启动一个协程a1去专门用来读取客户端发送的消息，并且用来判断是发送给谁的消息，然后把消息放到对应的chan里。

　　6、协程a再启动一个协程a2用来读取此用户对应的管道，如果里面有信息，则取出来发送到客户端。

实现代码

服务端测试代码：server.go

package main

import (
    "fmt"
    "log"
    "net"
    "strconv"
)

func handleconnection(conn net.conn, talkchan map[int]chan string) {
    //fmt.printf("%p\n", talkchan)  //用以检查是否是传过来的指针

    /*
        定义当前用户的uid
    */
    var curuid int

    var err error

    /*
        定义关闭通道
    */
    var closed = make(chan bool)

    defer func() {
        fmt.println("defer do : conn closed")
        conn.close()
        fmt.printf("delete userid [%v] from talkchan", curuid)
        delete(talkchan, curuid)
    }()

    /**
     * 提示用户设置自己的uid， 如果没设置，则不朝下执行
     */
    for {
        //提示客户端设置用户id
        _, err = conn.write([]byte("请设置用户uid"))
        if err != nil {
            return
        }
        data := make([]byte, 1024)
        c, err := conn.read(data)
        if err != nil {
            //closed <- true  //这样会阻塞 | 后面取closed的for循环，没有执行到。
            return
        }
        suid := string(data[0:c])

        //转成int类型
        uid, _ := strconv.atoi(suid)
        if uid < 1 {
            continue
        }
        curuid = uid
        talkchan[uid] = make(chan string)
        //fmt.println(conn, "have set uid ", uid, "can talk")

        _, err = conn.write([]byte("have set uid "+suid+" can talk"))
        if err != nil {
            return
        }
        break
    }

    fmt.println("err 3")

    //当前所有的连接
    fmt.println(talkchan)

    //读取客户端传过来的数据
    go func() {
        for {
            //不停的读客户端传过来的数据
            data := make([]byte, 1024)
            c, err := conn.read(data)
            if err != nil {
                fmt.println("have no client write", err)
                closed <- true //这里可以使用 | 因为是用用的go 新开的线程去处理的。 |  即便chan阻塞，后面的也会执行去读 closed 这个chan
            }

            clientstring := string(data[0:c])

            //将客户端过来的数据，写到相应的chan里
            if curuid == 3 {
                talkchan[4] <- clientstring
            } else {
                talkchan[3] <- clientstring
            }

        }
    }()

    /*
        从chan 里读出给这个客户端的数据 然后写到该客户端里
    */
    go func() {
        for {
            talkstring := <-talkchan[curuid]
            _, err = conn.write([]byte(talkstring))
            if err != nil {
                closed <- true
            }
        }
    }()

    /*
       检查是否已经关闭连接 如果关闭则推出该线程  去执行defer语句
    */
    for {
        if <-closed {
            return
        }
    }
}

func main() {

    /**
    建立监听链接
    */
    ln, err := net.listen("tcp", "127.0.0.1:6010")
    if err != nil {
        panic(err)
    }

    //创建一个管道

    //talkchan := map[f]
    talkchan := make(map[int]chan string)

    fmt.printf("%p\n", talkchan)

    /*
       监听是否有客户端过来的连接请求
    */
    for {
        fmt.println("wait connect...")
        conn, err := ln.accept()
        if err != nil {
            log.fatal("get client connection error: ", err)
        }

        go handleconnection(conn, talkchan)
    }
}

客户端测试代码：client.go

package main

import (
    "fmt"
    "math/rand"
    "net"
)

func main() {
    conn, err := net.dial("tcp", "127.0.0.1:6010")
    if err != nil {
        panic(err)
    }

    fmt.fprintf(conn, "hello server\n")

    defer conn.close()
    go writefromserver(conn)

    for {
        var talkcontent string
        fmt.scanln(&talkcontent)

        if len(talkcontent) > 0 {
            _, err = conn.write([]byte(talkcontent))
            if err != nil {
                fmt.println("write to server error")
                return
            }
        }
    }
}

func connect() {
    conn, err := net.dial("tcp", "127.0.0.1:6010")
    if err != nil {
        panic(err)
    }

    fmt.fprintf(conn, "hello server\n")

    defer conn.close()
    go writefromserver(conn)

    for {
        var talkcontent string
        fmt.scanln(&talkcontent)

        if len(talkcontent) > 0 {
            _, err = conn.write([]byte(talkcontent))
            if err != nil {
                fmt.println("write to server error")
                return
            }
        }
    }
}

func writefromserver(conn net.conn) {
    defer conn.close()
    for {
        data := make([]byte, 1024)
        c, err := conn.read(data)
        if err != nil {
            fmt.println("rand", rand.intn(10), "have no server write", err)
            return
        }
        fmt.println(string(data[0:c]) + "\n ")
    }
}