Redis 中文文档

Redeo


The high-performance Swiss Army Knife for building redis-protocol compatible servers/services.

Parts


This repository is organised into multiple components:

root package contains the framework for building redis-protocol compatible, high-performance servers.
resp implements low-level primitives for dealing with RESP (REdis Serialization Protocol), client and server-side. It contains basic wrappers for readers and writers to read/write requests and responses.
client contains a minimalist pooled client.

For full documentation and examples, please see the individual packages and the official API documentation: https://godoc.org/github.com/bsm/redeo.

Examples


A simple server example with two commands:

  1. ``` go
  2. package main

  4. import (
  5.   "net"

  7.   "github.com/bsm/redeo/v2"
  8. )

  10. func main() {
  11. srv := redeo.NewServer(nil)

  13. // Define handlers
  14. srv.HandleFunc("ping", func(w resp.ResponseWriter, _ *resp.Command) {
  15.   w.AppendInlineString("PONG")
  16. })
  17. srv.HandleFunc("info", func(w resp.ResponseWriter, _ *resp.Command) {
  18.   w.AppendBulkString(srv.Info().String())
  19. })

  21. // More handlers; demo usage of redeo.WrapperFunc
  22. srv.Handle("echo", redeo.WrapperFunc(func(c *resp.Command) interface{} {
  23.   if c.ArgN() != 1 {
  24.    return redeo.ErrWrongNumberOfArgs(c.Name)
  25.   }
  26.   return c.Arg(0)
  27. }))

  29. // Open a new listener
  30. lis, err := net.Listen("tcp", ":9736")
  31. if err != nil {
  32.   panic(err)
  33. }
  34. defer lis.Close()

  36. // Start serving (blocking)
  37. srv.Serve(lis)
  38. }
  39. ```

More complex handlers:

  1. ``` go
  2. func main() {
  3. mu := sync.RWMutex{}
  4. data := make(map[string]string)
  5. srv := redeo.NewServer(nil)

  7. srv.HandleFunc("set", func(w resp.ResponseWriter, c *resp.Command) {
  8.   if c.ArgN() != 2 {
  9.    w.AppendError(redeo.WrongNumberOfArgs(c.Name))
  10.    return
  11.   }

  13.   key := c.Arg(0).String()
  14.   val := c.Arg(1).String()

  16.   mu.Lock()
  17.   data[key] = val
  18.   mu.Unlock()

  20.   w.AppendInt(1)
  21. })

  23. srv.HandleFunc("get", func(w resp.ResponseWriter, c *resp.Command) {
  24.   if c.ArgN() != 1 {
  25.    w.AppendError(redeo.WrongNumberOfArgs(c.Name))
  26.    return
  27.   }

  29.   key := c.Arg(0).String()
  30.   mu.RLock()
  31.   val, ok := data[key]
  32.   mu.RUnlock()

  34.   if ok {
  35.    w.AppendBulkString(val)
  36.    return
  37.   }
  38.   w.AppendNil()
  39. })
  40. }
  41. ```

Redeo also supports command wrappers:

  1. ``` go
  2. func main() {
  3. mu := sync.RWMutex{}
  4. data := make(map[string]string)
  5. srv := redeo.NewServer(nil)

  7. srv.Handle("set", redeo.WrapperFunc(func(c *resp.Command) interface{} {
  8.   if c.ArgN() != 2 {
  9.    return redeo.ErrWrongNumberOfArgs(c.Name)
  10.   }

  12.   key := c.Arg(0).String()
  13.   val := c.Arg(1).String()

  15.   mu.Lock()
  16.   data[key] = val
  17.   mu.Unlock()

  19.   return 1
  20. }))

  22. srv.Handle("get", redeo.WrapperFunc(func(c *resp.Command) interface{} {
  23.   if c.ArgN() != 1 {
  24.    return redeo.ErrWrongNumberOfArgs(c.Name)
  25.   }

  27.   key := c.Arg(0).String()
  28.   mu.RLock()
  29.   val, ok := data[key]
  30.   mu.RUnlock()

  32.   if ok {
  33.    return val
  34.   }
  35.   return nil
  36. }))
  37. }
  38. ```