腳本之家服務(wù)器常用軟件

快捷導航

Golang實現(xiàn)的聊天程序服務(wù)端和客戶端代碼分享

更新時間：2014年10月29日 13:25:32 投稿：junjie

這篇文章主要介紹了Golang實現(xiàn)的聊天程序服務(wù)端和客戶端代碼分享,本文先是講解了實現(xiàn)邏輯,然后給出了實現(xiàn)代碼,需要的朋友可以參考下

實現(xiàn)邏輯

1、Golang 版本 1.3

2、實現(xiàn)原理：

　　1、主進程建立TCP監(jiān)聽服務(wù)，并且初始化一個變量 talkChan := make(map[int]chan string)

　　2、當主進程ACCEPT連接請求后，利用go 啟動一個協(xié)程A去維持和客戶端的連接，把taokChan帶入到協(xié)程里

　　3、和客戶端建立連接的協(xié)程A，發(fā)送消息給客戶端，使其發(fā)送自己的用戶信息。

　　4、協(xié)程A在收到客戶端發(fā)送的用戶信息后，建立一個此用戶對應的管道 talkChan[uid] = make(chan string)

　　5、協(xié)程A再啟動一個協(xié)程A1去專門用來讀取客戶端發(fā)送的消息，并且用來判斷是發(fā)送給誰的消息，然后把消息放到對應的chan里。

　　6、協(xié)程A再啟動一個協(xié)程A2用來讀取此用戶對應的管道，如果里面有信息，則取出來發(fā)送到客戶端。

實現(xiàn)代碼

服務(wù)端測試代碼：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

    /*
        定義關(guān)閉通道
    */
    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)
    }()

    /**
     * 提示用戶設(shè)置自己的uid，如果沒設(shè)置，則不朝下執(zhí)行
     */
    for {
        //提示客戶端設(shè)置用戶id
        _, err = conn.Write([]byte("請設(shè)置用戶uid"))
        if err != nil {
            return
        }
        data := make([]byte, 1024)
        c, err := conn.Read(data)
        if err != nil {
            //closed <- true //這樣會阻塞 | 后面取closed的for循環(huán)，沒有執(zhí)行到。
            return
        }
        sUid := string(data[0:c])

        //轉(zhuǎn)成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)

    //讀取客戶端傳過來的數(shù)據(jù)
    go func() {
        for {
            //不停的讀客戶端傳過來的數(shù)據(jù)
            data := make([]byte, 1024)
            c, err := conn.Read(data)
            if err != nil {
                fmt.Println("have no client write", err)
                closed <- true //這里可以使用 | 因為是用用的go 新開的線程去處理的。 | 即便chan阻塞，后面的也會執(zhí)行去讀 closed 這個chan
            }

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

            //將客戶端過來的數(shù)據(jù)，寫到相應的chan里
            if curUid == 3 {
                talkChan[4] <- clientString
            } else {
                talkChan[3] <- clientString
            }

}
}()

    /*
        從chan 里讀出給這個客戶端的數(shù)據(jù) 然后寫到該客戶端里
    */
    go func() {
        for {
            talkString := <-talkChan[curUid]
            _, err = conn.Write([]byte(talkString))
            if err != nil {
                closed <- true
            }
        }
    }()

    /*
       檢查是否已經(jīng)關(guān)閉連接如果關(guān)閉則推出該線程去執(zhí)行defer語句
    */
    for {
        if <-closed {
            return
        }
    }
}

func main() {

    /**
    建立監(jiān)聽鏈接
    */
    ln, err := net.Listen("tcp", "127.0.0.1:6010")
    if err != nil {
        panic(err)
    }

//創(chuàng)建一個管道

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

fmt.Printf("%p\n", talkChan)

    /*
       監(jiān)聽是否有客戶端過來的連接請求
    */
    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 ")
    }
}

您可能感興趣的文章: