简洁的并发TCP服务器

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

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

    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.             }
    57.             if err != nil {
    58.                 fmt.Println(err)
    59.             }
    60.         case "LOOKUP":
    61.             n := LOOKUP(tokens[1])
    62.             if n != nil {
    63.                 netData := fmt.Sprintf("%v\n", *n)
    64.                 c.Write([]byte(netData))
    65.             } else {
    66.                 netData := "Did not find key!\n"
    67.                 c.Write([]byte(netData))
    68.             }
    69.         case "CHANGE":
    70.             n := myElement{tokens[2], tokens[3], tokens[4]}
    71.             if !CHANGE(tokens[1], n) {
    72.                 netData := "Update operation failed!\n"
    73.                 c.Write([]byte(netData))
    74.             } else {
    75.                 netData := "Update operation successful!\n"
    76.                 c.Write([]byte(netData))
    77.             }
    78.             err = save()
    79.             if err != nil {
    80.                 fmt.Println(err)
    81.             }
    82.         default:
    83.             netData := "Unknown command - please try again!\n"
    84.             c.Write([]byte(netData))
    85.         }
    86.     }
    87. }

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

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

    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.     if ok {
    23.         n := DATA[k]
    24.         return &n
    26.         return nil
    27.     }
    28. }
    30. func CHANGE(k string, n myElement) bool {
    31.     DATA[k] = n
    32.     return true
    33. }

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

    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 将产生如下输出：

    为了这节的目的，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. STOP