GO语言练习：channel 工程实例

1、工程代码

2、编译及运行

---

1、工程目录结构

$ tree cgss
cgss
├── cgss.go
└── src
    ├── cg
    │   ├── centerclient.go
    │   ├── center.go
    │   └── player.go
    └── ipc
        ├── client.go
        ├── ipc_test.go
        └── server.go

　　1.1）主文件cgss.go 文件代码

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"

    "cg"
    "ipc"
)

var centerClient * cg.CenterClient

func startCenterService() error {
    server := ipc.NewIpcServer(&cg.CenterServer{})
    client := ipc.NewIpcClient(server)
    centerClient = &cg.CenterClient{client}

    return nil
}

func Help(args []string) int {
    fmt.Println(`
    Commands:
        login <userbane><level><exp>
        logout <username>
        send <message>
        listplayer
        quit(q)
        help(h)
    `)
    return 0
}

func Quit(args []string) int {
    return 1
}

func Logout(args []string) int {
    if len (args) != 2 {
        fmt.Println("USAGE: logout <username>")
        return 0
    }
    centerClient.RemovePlayer(args[1])

    return 0
}

func Login(args []string) int {
    if len(args) != 4 {
        fmt.Println("USAGE: login <username><level><exp>")
        return 0
    }

    level, err := strconv.Atoi(args[2])
    if err != nil {
        fmt.Println("Invaild Parameter : <level> should be an integer.")
        return 0
    }
    exp, err := strconv.Atoi(args[3])
    if err != nil {
        fmt.Println("Invaild Parameter : <exp> should be an integer.")
        return 0
    }
    player := cg.NewPlayer()
    player.Name = args[1]
    player.Level = level
    player.Exp = exp

    err = centerClient.AddPlayer(player)
    if err != nil {
        fmt.Println("Faild adding player", err)
    }

    return 0
}

func ListPlayer(args []string) int {
    ps , err := centerClient.ListPlayer("")
    if err != nil {
        fmt.Println("Faild. ", err)
    } else {
        for i, v := range ps {
            fmt.Println(i + 1, ":", v)
        }
    }
    return 0
}

func Send(args []string) int {
    message := strings.Join(args[1:], " ")

    err := centerClient.Broadcast(message)
    if err != nil {
        fmt.Println("Faild. ", err)
    }

    return 0
}

func GetCommandHandlers() map[string] func(args[]string) int {
    return map[string]func([]string) int {
        "help"    : Help,
        "h"        : Help,
        "quit"    : Quit,
        "q"        : Quit,
        "login"    : Login,
        "logout": Logout,
        "listplayer": ListPlayer,
        "send"    : Send,
    }
}

func main() {
    fmt.Println("Casual Game Server Soluion")

    startCenterService()

    Help(nil)

    r := bufio.NewReader(os.Stdin)

    handlers := GetCommandHandlers()

    for {
        fmt.Print("command> ")
        b, _, _ := r.ReadLine()
        line := string(b)

        tokens := strings.Split(line, " ")

        if handler, ok := handlers[tokens[0]]; ok {
            ret := handler(tokens)
            if ret != 0 {
                break
            }
        } else {
            fmt.Println("Unknown command : ", tokens[0])
        }
    }
}

　　1.2）cg 包的代码

　　　　1.2.1src/cg/centerclient.go 

package cg

import (
    "errors"
    "encoding/json"

    "ipc"
)

type CenterClient struct {
    *ipc.IpcClient
}

func (client * CenterClient)AddPlayer(player * Player)error {
    b, err := json.Marshal(*player)
    if err != nil {
        return err
    }

    resp, err := client.Call("addplayer", string(b))
    if err == nil && resp.Code == "200" {
        return nil
    }

    return err
}

func (client *CenterClient)RemovePlayer(name string) error {
    ret, _ := client.Call("removeplayer", name)
    if ret.Code == "200" {
        return nil
    }

    return errors.New(ret.Code)
}

func (client * CenterClient)ListPlayer(params string)(ps []*Player, err error) {
    resp, _ := client.Call("listplayer", params)
    if resp.Code != "200" {
        err = errors.New(resp.Code)
        return
    }

    err = json.Unmarshal([]byte(resp.Body), &ps)
    return
}

func (client * CenterClient)Broadcast(message string) error {
    m := &Message{Content:message}

    b, err := json.Marshal(m)
    if err != nil {
        return err
    }
    resp, _ := client.Call("broadcast", string(b))
    if resp.Code == "200" {
        return nil
    }

    return errors.New(resp.Code)
}

　　　　1.2.2）src/cg/center.go

package cg

import (
    "encoding/json"
    "errors"
    "sync"

    "ipc"
)

var _ ipc.Server = &CenterServer{}

type Message struct {
    From string "from"
    To string "to"
    Content string "content"
}

type Room struct {
}

type CenterServer struct {
    servers map[string] ipc.Server
    players []*Player
    rooms []*Room
    mutex sync.RWMutex
}

func NewCenterServer() * CenterServer {
    servers := make(map[string] ipc.Server)
    players := make([]*Player, 0)
    return  &CenterServer{servers:servers, players:players}
}

func (server * CenterServer)addPlayer(params string) error {
    player := NewPlayer()

    err := json.Unmarshal([]byte(params), &player)
    if err != nil {
        return err
    }

    server.mutex.Lock()
    defer server.mutex.Unlock()

    server.players = append(server.players, player)

    return nil
}

func (server * CenterServer)removePlayer(params string) error {
    server.mutex.Lock()
    defer server.mutex.Unlock()

    for i, v := range server.players {
        if v.Name == params {
            if len(server.players) == 1 {
                server.players = make([]*Player, 0)
            } else if i == len(server.players) - 1 {
                server.players = server.players[:i - 1]
            } else if i == 0 {
                server.players = server.players[1:]
            } else {
                server.players = append(server.players[:i - 1], server.players[:i + 1]...)
            }
            return nil
        }
    }

    return errors.New("Player not found")
}

func (server * CenterServer)listPlayer(params string)(players string , err error) {
    server.mutex.RLock()
    defer server.mutex.RUnlock()

    if len(server.players) > 0 {
        b, _ := json.Marshal(server.players)
        players = string(b)
    } else {
        err = errors.New("No play online.")
    }

    return
}

func (server * CenterServer)broadCast(params string) error {
    var message Message
    err := json.Unmarshal([]byte(params), &message)
    if err != nil {
        return err
    }

    server.mutex.Lock()
    defer server.mutex.Unlock()

    if len(server.players) > 0 {
        for _, player := range server.players {
            player.mq <- &message
        }
    } else {
        err = errors.New("No player online.")
    }

    return err
}

func (server * CenterServer)Handle(method, params string) *ipc.Response {
    switch method {
    case "addplayer" :
        err := server.addPlayer(params)
        if err != nil {
            return &ipc.Response{Code:err.Error()}
        }
    case "removeplayer" :
        err := server.removePlayer(params)
        if err != nil {
            return &ipc.Response{Code:err.Error()}
        }
    case "listplayer" :
        players, err := server.listPlayer(params)
        if err != nil {
            return &ipc.Response{Code:err.Error()}
        }
        return &ipc.Response{"200", players}
    case "broadcast" :
        err := server.broadCast(params)
        if err != nil {
            return &ipc.Response{Code:err.Error()}
        }
        return &ipc.Response{Code:"200"}
        default :
        return &ipc.Response{Code:"404", Body:method + ":" + params}
    }
    return &ipc.Response{Code:"200"}
}

func (server * CenterServer)Name() string {
    return "CenterServer"
}

　　　　1.2.3）src/cg/player.go

package cg

import (
    "fmt"
)

type Player struct {
    Name string    "name"
    Level int "level"
    Exp int "exp"
    Room int "room"

    mq chan * Message
}

func NewPlayer() * Player {
    m := make(chan * Message, 1024)
    player := &Player{"", 0, 0, 0, m}

    go func (p * Player) {
        for {
            msg := <-p.mq
            fmt.Println(p.Name, "received message :", msg.Content)
        }
    }(player)

    return player
}

　　1.3）ipc 包的代码

　　　　1.3.1）src/ipc/client.go

package ipc

import (
    "encoding/json"
)

type IpcClient struct {
    conn chan string
}

func NewIpcClient(server * IpcServer) * IpcClient {
    c := server.Connect()

    return &IpcClient{c}
}

func (client * IpcClient)Call(method, params string) (resp * Response, err error) {
    req := &Request{method, params}

    var b []byte
    b, err = json.Marshal(req)
    if err != nil {
        return
    }

    client.conn <- string(b)

    str := <-client.conn

    var resp1 Response
    err = json.Unmarshal([]byte(str), &resp1)
    resp = &resp1

    return
}

func (client * IpcClient)Clsoe() {
    client.conn <- "CLOSE"
}

　　　　1.3.2）src/ipc/ipc_test.go

package ipc

import (
    "testing"
)

type EchoServer struct {
}

func (server * EchoServer) Handle(request string) string {
    return "ECHO:" + request
}

func (server * EchoServer) Name() string {
    return "EchoServer"
}

func TestIpc (t * testing.T) {
    server := NewIpcServer(&EchoServer{})

    client1 := NewIpcClient(server)
    client2 := NewIpcClient(server)

    resq1 := client1.Call("From client1")
    resq2 := client1.Call("From client2")

    if resp1 != "ECHO:From client1" || resp2 != "ECHO:From client2" {
        t.Error("IpcClient.Call faild. resp1:", resp1, "resp2:", resp2)
    }
    client1.Close()
    client2.Close()
}

　　　　1.3.3）src/ipc/server.go

package ipc

import (
    "encoding/json"
    "fmt"
)

type Request struct {
    Method string "method"
    Params string "params"
}

type Response struct {
    Code string "code"
    Body string "body"
}

type Server interface {
    Name() string
    Handle(method, params string) *Response
}

type IpcServer struct {
    Server
}

func NewIpcServer(server Server) * IpcServer {
    return &IpcServer{server}
}

func (server * IpcServer)Connect() chan string {
    session := make(chan string, 0)

    go func(c chan string) {
        for{
            request := <-c
            if request == "CLOSE" {
                break
            }
            var req Request
            err := json.Unmarshal([]byte(request), &req)
            if err != nil {
                fmt.Println("Invalid request format:", request)
            }
            resp := server.Handle(req.Method, req.Params)

            b, err := json.Marshal(resp)
            c <- string(b)
        }
        fmt.Println("Session closed.")
    }(session)

    fmt.Println("A new session has been created successfully.")

    return session
}

2、编译及运行

　　2.1）编译

export GOPATH="/home/fengbo/cgss"
$ pwd
/home/fengbo/cgss
$ tree
.
├── cgss.go
└── src
    ├── cg
    │   ├── centerclient.go
    │   ├── center.go
    │   └── player.go
    └── ipc
        ├── client.go
        ├── ipc_test.go
        └── server.go
$ go build
$ tree
.
├── cgss
├── cgss.go
└── src
    ├── cg
    │   ├── centerclient.go
    │   ├── center.go
    │   └── player.go
    └── ipc
        ├── client.go
        ├── ipc_test.go
        └── server.go

　　2.2）运行

$ ./cgss 
Casual Game Server Soluion
A new session has been created successfully.

    Commands:
        login <userbane><level><exp>
        logout <username>
        send <message>
        listplayer
        quit(q)
        help(h)
    
command> login a 1 101
command> login b 2 202
command> listplayer
1 : &{a 1 101 0 <nil>}
2 : &{b 2 202 0 <nil>}
command> send Hello boy
a received message : Hello boy
b received message : Hello boy
command> logout a
command> listplayer
1 : &{b 2 202 0 <nil>}
command> logout b
command> listplayer
Faild.  No play online.
command> q

来源：《Go语言编程》一书的第四章，目录结构及代码与原书有差异