Go语言与Redis：探索高性能数据处理的无限可能

小新x
62 阅读19分钟

引言

Redis是一种高性能的键值存储数据库，它支持多种数据结构，包括字符串、列表、哈希、集合和有序集合等。Redis具有快速的读写速度、灵活的数据结构和丰富的命令集等特点，因此在Web应用程序中得到广泛应用。

Go语言是一种快速、简单、安全和高效的编程语言，它具有垃圾回收机制和并发编程能力等特点，因此非常适合构建高性能的Web应用程序。

Go语言提供了许多Redis客户端库，可以方便地在Go语言中操作Redis。与其他编程语言相比，Go语言与Redis交互的优点在于它具有良好的并发性能、内置的HTTP服务器和简单易学的语法等。

因此，使用Go语言操作Redis可以帮助开发人员更轻松地构建高性能、可靠和安全的Web应用程序。

Redis客户端库

在Go语言中，有许多不同的Redis客户端库可供选择。下面介绍一些常用的Redis客户端库：

go-redis/redis

"go-redis/redis"：这是一个流行的Redis客户端库，它提供了一个简单而强大的API来操作Redis。它支持常见的Redis命令和数据类型，并提供了一些高级功能，如连接池、发布/订阅和事务等。

安装方式：

go get github.com/go-redis/redis

使用示例：

import "github.com/go-redis/redis"

func main() {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    err := client.Set("key", "value", 0).Err()
    if err != nil {
        panic(err)
    }

    val, err := client.Get("key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val)
}

redigo

"redigo"：这是一个轻量级的Redis客户端库，它提供了与Redis交互的底层原语。这使得它非常适合那些需要控制更多细节的开发人员。它还提供了连接池、管道和事务等高级功能。

安装方式：

go get github.com/gomodule/redigo/redis

使用示例：

import "github.com/gomodule/redigo/redis"

func main() {
    conn, err := redis.Dial("tcp", "localhost:6379")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    _, err = conn.Do("SET", "key", "value")
    if err != nil {
        panic(err)
    }

    val, err := redis.String(conn.Do("GET", "key"))
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val)
}

radix.v2

"radix.v2"：这是一个简单而高效的Redis客户端库，它提供了一个类似于标准库的API，易于使用和理解。它支持连接池和管道等高级功能。

安装方式：

go get github.com/mediocregopher/radix/v2

使用示例：

import "github.com/mediocregopher/radix/v3"

func main() {
    conn, err := radix.Dial("tcp", "localhost:6379")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    err = conn.Do(radix.Cmd(nil, "SET", "key", "value"))
    if err != nil {
        panic(err)
    }

    var val string
    err = conn.Do(radix.Cmd(&val, "GET", "key"))

Redis事务

事务的概念和用途

在数据库管理系统中，事务通常被定义为一个独立的工作单位，它可以包含一系列的操作，这些操作要么全部执行，要么全部不执行（原子性）。如果在执行过程中发生错误，那么将进行回滚操作，保证数据的一致性。

Redis的事务与传统的关系型数据库事务有一些不同。在Redis中，事务提供了一种方式，让我们能够一次执行多个命令，而且在执行过程中不会被其他客户端发送的命令打断。这就保证了这些命令的原子性。然而，需要注意的是，Redis的事务不支持回滚。

Redis事务的一个重要用途就是保证一系列命令的原子性。这在许多场景下都非常有用，例如在更新一些需要同时改变的数据时。

在Go中执行Redis事务

在Go中，我们可以使用go-redis库来执行Redis事务。这个库提供了TxPipeline函数来创建一个事务，然后我们可以将需要在事务中执行的命令添加到这个事务中，最后调用Exec函数来执行这个事务。

以下是一个简单的例子，展示了如何在Go中使用go-redis执行Redis事务：

package main

import (
	"fmt"
	"github.com/go-redis/redis/v8"
	"golang.org/x/net/context"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	ctx := context.Background()

	// 开始一个新的事务
	pipe := rdb.TxPipeline()

	// 在事务中执行一些命令
	incr := pipe.Incr(ctx, "pipeline_counter")
	pipe.Expire(ctx, "pipeline_counter", time.Hour)

	// 执行事务
	_, err := pipe.Exec(ctx)
	if err != nil {
		fmt.Printf("pipeline failed: %v\n", err)
		return
	}

	fmt.Printf("pipeline_counter value: %v\n", incr.Val())
}

在上述代码中，我们首先创建了一个Redis客户端，然后创建了一个事务。在这个事务中，我们执行了两个命令：首先是对键pipeline_counter执行INCR命令，然后是对这个键设置一个过期时间。最后，我们执行了这个事务。

如果在执行事务的过程中发生错误，Exec函数会返回一个错误。如果事务成功执行，那么每个命令会返回一个对应的结果，我们可以通过这些结果来获取命令的返回值。

if err != nil {
    panic(err)
}
fmt.Println("key", val)

}


# 连接Redis
在Go语言中连接Redis非常简单，只需要使用Redis客户端库提供的连接函数即可。下面是连接Redis的一些基本步骤：

1. 导入Redis客户端库：

```go
import "github.com/go-redis/redis"
  1. 创建Redis客户端：
client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "", // Redis无密码，可以为空字符串
    DB:       0,  // 默认使用0号数据库
})

其中，Addr参数是Redis服务器的地址和端口号，Password参数是Redis服务器的密码，DB参数是选择要使用的Redis数据库编号。

  1. 测试连接是否成功：
pong, err := client.Ping().Result()
if err != nil {
    panic(err)
}
fmt.Println(pong) // 输出PONG

在上述代码中，我们使用Redis客户端库提供的Ping()函数来测试连接是否成功。如果连接成功，Ping()函数将返回"PONG"字符串。

完整示例代码：

import (
    "fmt"
    "github.com/go-redis/redis"
)

func main() {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // Redis无密码，可以为空字符串
        DB:       0,  // 默认使用0号数据库
    })

    pong, err := client.Ping().Result()
    if err != nil {
        panic(err)
    }
    fmt.Println(pong)
}

Redis数据类型操作

Redis支持多种不同的数据类型，包括字符串、列表、哈希、集合和有序集合等。下面将介绍如何在Go语言中使用go-redis/redis库来操作这些数据类型。

  1. 字符串

字符串是Redis中最简单的数据类型，它可以保存任何类型的数据。下面是一些常见的字符串操作：

  • 设置字符串：使用Set()函数来设置一个字符串。
err := client.Set("mykey", "myvalue", 0).Err()
if err != nil {
    panic(err)
}
  • 获取字符串：使用Get()函数来获取一个字符串。
val, err := client.Get("mykey").Result()
if err == redis.Nil {
    fmt.Println("mykey does not exist")
} else if err != nil {
    panic(err)
} else {
    fmt.Println("mykey", val)
}
  • 更新字符串：使用Set()函数来更新一个字符串。
err := client.Set("mykey", "newvalue", 0).Err()
if err != nil {
    panic(err)
}
  • 删除字符串：使用Del()函数来删除一个字符串。
err := client.Del("mykey").Err()
if err != nil {
    panic(err)
}
  1. 列表

列表是一组有序的字符串元素，可以进行插入、删除和查询操作。下面是一些常见的列表操作：

  • 在列表中插入元素：使用LPush()函数在列表的左端插入一个元素。
err := client.LPush("mylist", "one").Err()
if err != nil {
    panic(err)
}
  • 获取列表中的元素：使用LRange()函数获取列表中的元素。
vals, err := client.LRange("mylist", 0, -1).Result()
if err != nil {
    panic(err)
}
for _, val := range vals {
    fmt.Println(val)
}
  • 在列表中删除元素：使用LRem()函数删除列表中的元素。
err := client.LRem("mylist", 0, "one").Err()
if err != nil {
    panic(err)
}
  1. 哈希

哈希是一组键值对，其中键和值都是字符串。下面是一些常见的哈希操作：

  • 设置哈希中的元素：使用HSet()函数设置哈希中的一个键值对。
err := client.HSet("myhash", "field1", "value1").Err()
if err != nil {
    panic(err)
}
  • 获取哈希中的元素：使用HGet()函数获取哈希中的一个键值对。
val, err := client.HGet("myhash", "field1").Result()
if err == redis.Nil {
    fmt.Println("field1 does not exist")
} else if err != nil {
    panic(err)
} else {
    fmt.Println("field1", val)
}
  • 删除哈希中的元素：使用HDel()函数删除哈希中的一个键值对。
err := client.HDel("myhash", "field1").Err()
if err != nil {
    panic(err)
}
  1. 集合是一个无序的字符串集合，可以进行添加、删除和查询操作。下面是一些常见的集合操作：
  • 添加元素到集合：使用SAdd()函数将元素添加到集合中。
err := client.SAdd("myset", "one").Err()
if err != nil {
    panic(err)
}
  • 获取集合中的元素：使用SMembers()函数获取集合中的所有元素。
members, err := client.SMembers("myset").Result()
if err != nil {
    panic(err)
}
for _, member := range members {
    fmt.Println(member)
}
  • 从集合中删除元素：使用SRem()函数从集合中删除一个元素。
err := client.SRem("myset", "one").Err()
if err != nil {
    panic(err)
}
  1. 有序集合

有序集合是一组有序的字符串元素，每个元素都关联有一个分数，可以进行插入、删除和查询操作。下面是一些常见的有序集合操作：

  • 添加元素到有序集合：使用ZAdd()函数将元素添加到有序集合中。
err := client.ZAdd("myzset", &redis.Z{
    Score:  1.0,
    Member: "one",
}).Err()
if err != nil {
    panic(err)
}
  • 获取有序集合中的元素：使用ZRange()函数获取有序集合中的元素。
vals, err := client.ZRange("myzset", 0, -1).Result()
if err != nil {
    panic(err)
}
for _, val := range vals {
    fmt.Println(val)
}
  • 从有序集合中删除元素：使用ZRem()函数从有序集合中删除一个元素。
err := client.ZRem("myzset", "one").Err()
if err != nil {
    panic(err)
}

Redis高级操作

除了基本的数据类型操作外，Redis还提供了许多高级操作，如发布/订阅、事务和Lua脚本。下面将介绍如何在Go语言中使用go-redis/redis库来操作这些高级操作。

  1. 发布/订阅

发布/订阅是一种基于消息的通信模式，它允许消息的发送者向多个接收者发送消息。在Redis中，发布者通过向频道发布消息来发送消息，而订阅者则通过订阅这些频道来接收消息。下面是一些常见的发布/订阅操作：

  • 发布消息到频道：使用Publish()函数向指定的频道发布消息。
err := client.Publish("mychannel", "hello").Err()
if err != nil {
    panic(err)
}
  • 订阅频道：使用Subscribe()函数订阅指定的频道。
pubsub := client.Subscribe("mychannel")
defer pubsub.Close()

// 循环读取消息
for {
    msg, err := pubsub.ReceiveMessage()
    if err != nil {
        panic(err)
    }
    fmt.Println(msg.Channel, msg.Payload)
}
  1. 事务

Redis的事务功能允许在一次请求中执行多个命令，这些命令要么全部执行，要么全部不执行。如果在执行命令期间出现错误，则中断执行并回滚所有已执行的命令。下面是一个事务的示例：

// 使用TxPipeline()函数创建事务对象
pipe := client.TxPipeline()
defer pipe.Close()

// 在事务中执行多个命令
pipe.Incr("counter")
pipe.Expire("counter", time.Hour)

// 执行事务
_, err := pipe.Exec()
if err != nil {
    panic(err)
}

在上面的示例中，我们使用TxPipeline()函数创建了一个事务对象。然后，我们在事务对象中执行了两个命令：Incr()和Expire()。最后，我们调用Exec()函数来执行事务。

  1. Lua脚本

Redis允许使用Lua脚本执行复杂的操作，这些操作可以组合多个命令，并且具有原子性和高效性。下面是一个使用Lua脚本执行操作的示例：

// 定义Lua脚本
script := redis.NewScript(`
    return redis.call("incr", KEYS[1])
`)

// 使用EvalSha()函数执行Lua脚本
result, err := script.Run(client, []string{"mycounter"}).Result()
if err != nil {
    panic(err)
}
fmt.Println(result) // 输出计数器的新值

在上述示例中，我们首先定义了一个Lua脚本，它使用incr命令增加指定键的计数器的值。然后，我们使用Run()函数来执行Lua脚本，并传递了要操作的键的名称。最后，我们打印了计数器的新值。

上述示例代码涵盖了在Go语言中操作Redis的一些高级操作，包括发布/订阅、事务和Lua脚本。当然，这里只是提供了一些示例，您可以根据自己的需求进行适当的修改和扩展。在使用这些高级操作时，您需要更加小心谨慎，以确保数据的完整性和一致性。

Redis在实际应用中的使用

Redis在Web应用程序中可以被用来实现许多功能，如缓存、会话管理、排行榜和消息队列等。下面我们将介绍如何在Go语言的Web应用程序中使用Redis实现缓存和会话管理功能。

  1. 缓存

缓存是将一些经常访问的数据保存在内存中，以加快数据访问速度的技术。在Web应用程序中，我们可以使用Redis作为缓存存储。下面是一个使用Redis作为缓存的示例：

var cacheDuration = 10 * time.Minute

func expensiveCalculation() string {
    // 长时间运行的计算
    time.Sleep(5 * time.Second)
    return "result"
}

func getResultFromCache(key string) (string, error) {
    result, err := client.Get(key).Result()
    if err == redis.Nil {
        return "", nil // 缓存中没有数据
    } else if err != nil {
        return "", err // 发生错误
    } else {
        return result, nil // 返回缓存中的数据
    }
}

func setResultToCache(key string, value string) error {
    return client.Set(key, value, cacheDuration).Err()
}

func getResult(key string) (string, error) {
    // 尝试从缓存中获取结果
    result, err := getResultFromCache(key)
    if err != nil {
        return "", err
    }
    if result != "" {
        return result, nil
    }

    // 缓存中没有数据，运行计算并将结果存入缓存
    result = expensiveCalculation()
    if err := setResultToCache(key, result); err != nil {
        return "", err
    }
    return result, nil
}

在上述示例中，我们定义了一个getResult()函数，它首先尝试从缓存中获取结果，如果缓存中有结果，则返回缓存中的结果；如果缓存中没有结果，则运行计算并将结果存入缓存。我们使用Get()函数从Redis中获取缓存数据，并使用Set()函数将结果存入Redis中。

  1. 会话管理

会话管理是Web应用程序中非常重要的功能，它允许用户跨多个请求保持状态。在Go语言的Web应用程序中，我们可以使用Redis来存储会话数据。下面是一个使用Redis存储会话数据的示例：

var sessionDuration = 24 * time.Hour

func getSessionKey(req *http.Request) (string, error) {
    cookie, err := req.Cookie("session_id")
    if err == http.ErrNoCookie {
        // 创建一个新的session ID
        uuid, err := uuid.NewRandom()
        if err != nil {
            return "", err
        }
        return uuid.String(), nil
    } else if err != nil {
        return "", err
    } else {
        return cookie.Value, nil
    }
}

func getSessionData(key string) (map[string]string, error) {
    data, err := client.HGetAll(key).Result()
    if err == redis.Nil {
        return nil, nil // 会话不存在
    } else if err != nil {
        return nil, err
       } else {
        return data, nil
    }
}

func setSessionData(key string, data map[string]string) error {
    values := make([]interface{}, 0, len(data)*2)
    for k, v := range data {
        values = append(values, k, v)
    }
    return client.HMSet(key, values...).Err()
}

func setSessionCookie(w http.ResponseWriter, key string) {
    cookie := &http.Cookie{
        Name:     "session_id",
        Value:    key,
        HttpOnly: true,
        MaxAge:   int(sessionDuration / time.Second),
    }
    http.SetCookie(w, cookie)
}

func sessionMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
        // 获取会话ID
        key, err := getSessionKey(req)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // 获取会话数据
        data, err := getSessionData(key)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }

        // 将会话数据存储到上下文中
        ctx := context.WithValue(req.Context(), "session_data", data)
        req = req.WithContext(ctx)

        // 继续处理下一个请求
        next.ServeHTTP(w, req)

        // 保存会话数据
        data, ok := req.Context().Value("session_data").(map[string]string)
        if ok {
            if err := setSessionData(key, data); err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return
            }
            setSessionCookie(w, key)
        }
    })
}

Redis事务

事务的概念和用途

在数据库管理系统中，事务通常被定义为一个独立的工作单位，它可以包含一系列的操作，这些操作要么全部执行，要么全部不执行（原子性）。如果在执行过程中发生错误，那么将进行回滚操作，保证数据的一致性。

Redis的事务与传统的关系型数据库事务有一些不同。在Redis中，事务提供了一种方式，让我们能够一次执行多个命令，而且在执行过程中不会被其他客户端发送的命令打断。这就保证了这些命令的原子性。然而，需要注意的是，Redis的事务不支持回滚。

Redis事务的一个重要用途就是保证一系列命令的原子性。这在许多场景下都非常有用，例如在更新一些需要同时改变的数据时。

在Go中执行Redis事务

在Go中，我们可以使用go-redis库来执行Redis事务。这个库提供了TxPipeline函数来创建一个事务，然后我们可以将需要在事务中执行的命令添加到这个事务中，最后调用Exec函数来执行这个事务。

以下是一个简单的例子，展示了如何在Go中使用go-redis执行Redis事务：

package main

import (
	"fmt"
	"github.com/go-redis/redis/v8"
	"golang.org/x/net/context"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	ctx := context.Background()

	// 开始一个新的事务
	pipe := rdb.TxPipeline()

	// 在事务中执行一些命令
	incr := pipe.Incr(ctx, "pipeline_counter")
	pipe.Expire(ctx, "pipeline_counter", time.Hour)

	// 执行事务
	_, err := pipe.Exec(ctx)
	if err != nil {
		fmt.Printf("pipeline failed: %v\n", err)
		return
	}

	fmt.Printf("pipeline_counter value: %v\n", incr.Val())
}

在上述代码中，我们首先创建了一个Redis客户端，然后创建了一个事务。在这个事务中，我们执行了两个命令：首先是对键pipeline_counter执行INCR命令，然后是对这个键设置一个过期时间。最后，我们执行了这个事务。

如果在执行事务的过程中发生错误，Exec函数会返回一个错误。如果事务成功执行，那么每个命令会返回一个对应的结果，我们可以通过这些结果来获取命令的返回值。

Redis的发布/订阅模式

发布/订阅模式的概念和用途

发布/订阅（Pub/Sub）模式是一种消息传递模式，其中发送消息的一方（发布者）不会发送消息直接到特定的接收者（订阅者），而是发布消息到一个中间组件（主题）。订阅了这个主题的所有订阅者都会收到这个消息。

Redis的发布/订阅模式提供了一种实时的消息通知机制。当一个客户端发布消息到一个频道（channel）时，所有订阅了这个频道的客户端都会收到这个消息。

Redis的发布/订阅模式可以用于很多场景，例如：

  • 实时消息系统：聊天室，实时推送更新等。
  • 事件通知系统：当某个事件发生时，通知所有的订阅者。
  • 分布式系统的解耦：不同的系统组件通过发布/订阅消息进行通信，而不是直接互相调用。

在Go中实现Redis的发布/订阅功能

在Go中，我们可以使用go-redis库来实现Redis的发布/订阅功能。这个库提供了Subscribe函数来订阅一个或多个频道，Publish函数来发布消息到一个频道。

以下是一个简单的例子，展示了如何在Go中使用go-redis实现Redis的发布/订阅功能：

package main

import (
	"fmt"
	"github.com/go-redis/redis/v8"
	"golang.org/x/net/context"
	"time"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
	})

	ctx := context.Background()

	// 订阅一个频道
	pubsub := rdb.Subscribe(ctx, "mychannel")
	defer pubsub.Close()

	// 在一个goroutine中接收消息
	go func() {
		for {
			// 获取消息
			msg, err := pubsub.ReceiveMessage(ctx)
			if err != nil {
				fmt.Println(err)
				return
			}

			// 打印消息
			fmt.Println("Received message: ", msg.Payload)
		}
	}()

	// 发布一条消息到这个频道
	err := rdb.Publish(ctx, "mychannel", "hello").Err()
	if err != nil {
		panic(err)
	}

	// 等待一会儿，让goroutine有时间接收消息
	time.Sleep(time.Second)
}

在上述代码中，我们首先创建了一个Redis客户端，然后订阅了一个频道。然后我们在一个goroutine中接收这个频道的消息。最后，我们发布了一条消息到这个频道。

如果在接收消息的过程中发生错误，ReceiveMessage函数会返回一个错误。如果成功接收到一条消息，我们就打印这条消息的内容。

Redis连接池

连接池的概念及其优点

连接池是一个预先创建并存储的数据库连接的缓存，这些连接在需要的时候可以被应用程序重复利用。当应用程序需要与数据库交互时，它可以从连接池中获取一个现有的连接，而不是创建一个新的连接。完成交互后，连接被返回到连接池，而不是被关闭，以便后续的重复使用。

使用连接池有许多优点：

  1. 性能提升：预先创建的连接可以消除创建新连接的开销，大大提高应用程序的响应速度。

  2. 资源优化：通过重复使用现有连接，可以节省系统资源，如内存和CPU。

  3. 连接数控制：连接池可以限制系统中的最大并发连接数，避免因过多的连接导致系统资源耗尽。

在Go中配置和使用Redis连接池

在Go中，我们可以使用go-redis库来与Redis进行交互。这个库内部已经实现了连接池，我们只需要配置一些参数，就可以控制这个连接池的行为。

以下是一个简单的例子，展示了如何在Go中使用go-redis配置和使用Redis连接池：

package main

import (
	"fmt"
	"github.com/go-redis/redis/v8"
	"golang.org/x/net/context"
)

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "", // no password set
		DB:       0,  // use default DB
		PoolSize: 100, // 连接池的大小
		MinIdleConns: 10, // 最小空闲连接数
	})

	ctx := context.Background()

	// 使用连接执行一个命令
	val, err := rdb.Get(ctx, "key").Result()
	if err != nil {
		panic(err)
	}

	fmt.Println("key", val)
}

在上述代码中，我们首先创建了一个Redis客户端，设置了连接池的大小（PoolSize）和最小空闲连接数（MinIdleConns）。然后我们使用这个客户端执行了一个命令。

通过适当的配置连接池，我们可以控制系统中的并发连接数，优化系统资源使用，提高应用程序的响应速度。

总结

在本文中，我们介绍了使用Go操作Redis的一些基础知识和高级功能，包括Redis的基本操作，如何使用Go进行Redis事务，发布/订阅模式，以及如何配置和使用Redis连接池。

Go语言因其出色的性能和并发处理能力，成为了操作Redis的理想选择。同时，go-redis库提供了丰富的API，使得在Go程序中操作Redis变得简单易行。无论是简单的键值操作，复杂的事务处理，还是实时的消息发布和订阅，Go都能轻松应对。

Go操作Redis的使用场景非常广泛，包括但不限于：缓存数据，实现高速访问；作为消息队列，进行任务的异步处理；作为发布/订阅系统，实现实时消息通知等。

学习和掌握Go操作Redis，不仅可以提高你的编程技能，也可以帮助你更好地理解Redis和Go在现代Web应用程序中的重要性和应用场景。

希望本文能为你提供一些启发和帮助，鼓励你继续学习和尝试Go操作Redis，探索更多的可能性。

avatar
文章
阅读
粉丝