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语言编程》一书的第四章，目录结构及代码与原书有差异