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