简洁的并发TCP服务器

尽管上节的并发 TCP 服务器运作良好，但是它还不能为实际应用提供服务。因此，在这节您将学到怎样把第四章中的 keyValue.go 文件对于复杂类型的使用转化为一个功能齐全的并发 TCP 应用。

为了能够和网络中的 key-value 存储交互，我们创建自定义的 TCP 协议。您将需要为 key-value 存储的每一个函数定义关键字。为简单起见，每个关键字都跟着相关数据。大多数命令的结果将是成功或失败消息。

设计您自己的 TCP 或 UDP 协议不是一个简单的工作。这意味着设计一个新协议时，您必须特别细致小心。这里的关键是在您开始编写生产代码之前文档化所有内容。

这个主题使用的工具命名为 kvTCP.go，它被分为六个部分。

kvTCP.go 的第一部分如下：

  1. package main
  3. import (
  4.     "bufio"
  5.     "encoding/gob"
  6.     "fmt"
  7.     "net"
  8.     "os"
  9.     "strings"
  10. )
  12. type myElement struct {
  13.     Name string
  14.     Surname string
  15.     Id string
  16. }
  18. const welcome = "Welcome to the Key-value store!\n"
  20. var DATA = make(map[string]myElement)
  21. var DATAFILE = "/tmp/dataFile.gob"

kvTCP.go 的第二部分如下：

  1. func handleConnection(c net.Conn) {
  2.     c.Write([]byte(welcome))
  3.     for {
  4.         netData, err := bufio.NewReader(c).ReadString('\n')
  5.         if err != nil {
  6.             fmt.Println(err)
  7.             return
  8.         }
  9.         command := strings.TrimSpace(string(netData))
  10.         tokens := strings.Fields(command)
  11.         switch len(tokens) {
  12.         case 0:
  13.             continue
  14.         case 1:
  15.             tokens = append(tokens, "")
  16.             tokens = append(tokens, "")
  17.             tokens = append(tokens, "")
  18.             tokens = append(tokens, "")
  19.         case 2:
  20.             tokens = append(tokens, "")
  21.             tokens = append(tokens, "")
  22.             tokens = append(tokens, "")
  23.         case 3:
  24.             tokens = append(tokens, "")
  25.             tokens = append(tokens, "")
  26.         case 4:
  27.             tokens = append(tokens, "")
  28.         }
  30.         switch tokens[0] {
  31.         case "STOP":
  32.             err = save()
  33.             if err != nil {
  34.                 fmt.Println(err)
  35.             }
  36.             c.Close()
  37.             return
  38.         case "PRINT":
  39.             PRINT(c)
  40.         case "DELETE":
  41.             if !DELETE(tokens[1]) {
  42.                 netData := "Delete operation failed!\n"
  43.                 c.Write([]byte(netData))
  44.             }else{
  45.                 netData := "Delete operation successful!\n"
  46.                 c.Write([]byte(netData))
  47.             }
  48.         case "ADD":
  49.             n := myElement{tokens[2], tokens[3], tokens[4]}
  50.             if !ADD(tokens[1], n) {
  51.                 netData := "Add operation failed!\n"
  52.                 c.Write([]byte(netData))
  53.             } else {
  54.                 netData := "Add operation successful!\n"
  55.                 c.Write([]byte(netData))
  56.             }
  57.             err = save()
  58.             if err != nil {
  59.                 fmt.Println(err)
  60.             }
  61.         case "LOOKUP":
  62.             n := LOOKUP(tokens[1])
  63.             if n != nil {
  64.                 netData := fmt.Sprintf("%v\n", *n)
  65.                 c.Write([]byte(netData))
  66.             } else {
  67.                 netData := "Did not find key!\n"
  68.                 c.Write([]byte(netData))
  69.             }
  70.         case "CHANGE":
  71.             n := myElement{tokens[2], tokens[3], tokens[4]}
  72.             if !CHANGE(tokens[1], n) {
  73.                 netData := "Update operation failed!\n"
  74.                 c.Write([]byte(netData))
  75.             } else {
  76.                 netData := "Update operation successful!\n"
  77.                 c.Write([]byte(netData))
  78.             }
  79.             err = save()
  80.             if err != nil {
  81.                 fmt.Println(err)
  82.             }
  83.         default:
  84.             netData := "Unknown command - please try again!\n"
  85.             c.Write([]byte(netData))
  86.         }
  87.     }
  88. }

handleConnection() 函数和每个 TCP 客户端交互并解析客户端的输入。

kvTCP.go 的第三部分包含如下代码：

  1. func save() error {
  2.     fmt.Println("Saving", DATAFILE)
  3.     err := os.Remove(DATAFILE)
  4.     if err != nil {
  5.         fmt.Println(err)
  6.     }
  8.     saveTo, err := os.Create(DATAFILE)
  9.     if err != nil {
  10.         fmt.Println("Cannot create", DATAFILE)
  11.         return err
  12.     }
  13.     defer saveTo.Close()
  15.     encoder := gob.NewEncoder(saveTo)
  16.     err = encoder.Encode(DATA)
  17.     if err != nil {
  18.         fmt.Println("Cannot save to", DATAFILE)
  19.         return err
  20.     }
  21.     return nil
  22. }
  24. func load() error {
  25.     fmt.Println("Loading", DATAFILE)
  26.     loadFrom, err := os.Open(DATAFILE)
  27.     defer loadFrom.Close()
  28.     if err != nil {
  29.         fmt.Println("Empty key/value store!")
  30.         return err
  31.     }
  33.     decoder := gob.NewDecoder(loadFrom)
  34.     decoder.Decode(&DATA)
  35.     return nil
  36. }

kvTCP.go 的第四段如下：

  1. func ADD(k string, n myElement) bool {
  2.     if k == "" {
  3.         return false
  4.     }
  6.     if LOOKUP(k) == nil {
  7.         DATA[k] = n
  8.         return true
  9.     }
  10.     return false
  11. }
  13. func DELETE(k string) bool {
  14.     if LOOKUP(k) != nil {
  15.         delete(DATA, k)
  16.         return true
  17.     }
  18.     return false
  19. }
  21. func LOOKUP(k string) *myElement {
  22.     _, ok := DATA[k]
  23.     if ok {
  24.         n := DATA[k]
  25.         return &n
  26.     } else {
  27.         return nil
  28.     }
  29. }
  31. func CHANGE(k string, n myElement) bool {
  32.     DATA[k] = n
  33.     return true
  34. }

上面的这些函数实现与 keyValue.go 一样。它们没有直接和 TCP 客户端交互。

kvTCP.go 的第五部分包含代码如下：

  1. func PRINT(c net.Conn) {
  2.     for k, d := range DATA {
  3.         netData := fmt.Sprintf("key: %s value: %v\n", k, d)
  4.         c.Write([]byte(netData))
  5.     }
  6. }

PRINT() 函数直接发送数据给 TCP 客户端，一次一行。

这个程序的剩余代码如下：

  1. func main() {
  2.     arguments := os.Args
  3.     if len(arguments) == 1 {
  4.         fmt.Println("Please provide a port number!")
  5.         return
  6.     }
  8.     PORT := ":" + arguments[1]
  9.     l, err := net.Listen("tcp", PORT)
  10.     if err != nil {
  11.         fmt.Println(err)
  12.         return
  13.     }
  14.     defer l.Close()
  16.     err = load()
  17.     if err != nil {
  18.         fmt.Println(err)
  19.     }
  21.     for {
  22.         c, err := l.Accept()
  23.         if err != nil {
  24.             fmt.Println(err)
  25.             os.Exit(100)
  26.         }
  27.         go handleConnection(c)
  28.     }
  29. }

执行 kvTCP.go 将产生如下输出：

  1. $ go run kvTCP.go 9000
  2. Loading /tmp/dataFile.gob
  3. Empty key/value store!
  4. open /tmp/dataFile.gob: no such file or directory
  5. Saving /tmp/dataFile.gob
  6. remove /tmp/dataFile.gob: no such file or directory
  7. Saving /tmp/dataFile.gob
  8. Saving /tmp/dataFile.gob

为了这节的目的，netcat(l) 工具用来作为 kvTCP.go 的客户端：

  1. $ nc localhost 9000
  2. Welcome to the Key-value store!
  3. PRINT
  4. LOOKUP 1
  5. Did not find key!
  6. ADD 1 2 3 4
  7. Add operation successful!
  8. LOOKUP 1
  9. {2 3 4}
  10. ADD 4 -1 -2 -3
  11. Add operation successful!
  12. PRINT
  13. key: 1 value: {2 3 4}
  14. key: 4 value: {-1 -2 -3}
  15. STOP

kvTCP.go 文件是一个使用 goroutines 的并发应用，它能够同时服务多个 TCP 客户端。然而，所有的 TCP 客户端共享相同的数据！