在 go-zero 框架内，如在 rpc 的应用 service 中，其内部已经预置了 redis 的应用，所以我们只需要在配置中加入相关字段即可，另外，在 svcContext 声明 redis client 后即可在具体的业务逻辑处理中应用。

但这里有个问题，如我用的是 go-zero 1.5.0 版本，从源码分析来看，redis 的连接并没用到 连接池，虽然在 go-zero/redis 已经为我们声明了足够的 redis 操作接口，但如果你有 连接池 的需求，还有另外一条路径，自己在应用中声明 连接池，但是具体的操作，也需要自己去写。

下面就从上面说的两个方面分享下 redis 的两种使用姿势吧。

框架内置的 redis

我们假设你已经生成了 rpc 的应用，然后接下来就是这样的一些主要工作：

• 1.config.go 文件定义你的 redis 配置结构体并放入 config 结构体中, 由于 zrpc.RpcServerConf 含有 Redis 的定义，直接跳转下步
• 2.yaml配置文件中，声明你的配置
• 3.在 svcContext 加入 redisClient
• 4.业务逻辑处理中加入 redis 作为缓存

完成以上，你就完成了通过框架内置的 redis 接口的使用。

定义你的 redis 结构体

internal/config/config.go

type Config struct {
	zrpc.RpcServerConf
}

go-zero/zrpc/config.go

// A RpcServerConf is a rpc server config.
type RpcServerConf struct {
		service.ServiceConf
		ListenOn      string
		Etcd          discov.EtcdConf    `json:",optional,inherit"`
		Auth          bool               `json:",optional"`
		Redis         redis.RedisKeyConf `json:",optional"`  // 这里就是预置的字段
		StrictControl bool               `json:",optional"`
		// setting 0 means no timeout
		Timeout      int64 `json:",default=2000"`
		CpuThreshold int64 `json:",default=900,range=[0:1000]"`
		// grpc health check switch
		Health      bool `json:",default=true"`
		Middlewares ServerMiddlewaresConf
	}

go-zero/core/stores/redis/conf.go

type (
	// A RedisConf is a redis config.
	RedisConf struct {
		Host string
		Type string `json:",default=node,options=node|cluster"`
		Pass string `json:",optional"`
		Tls  bool   `json:",optional"`
	}

	// A RedisKeyConf is a redis config with key.
	RedisKeyConf struct {
		RedisConf
		Key string `json:",optional"`
	}
)

声明配置

结合上面的内容，你只需要在 yaml 文件中注明下面内容：

Redis:
  Host: xx.xx.xx.xx:6379
  Type: node
  Tls: false

在 svcContext 加入 redisClient

直接看代码

package svc

import (
	"userrpcv1/internal/config"
    
    zeroRds "github.com/zeromicro/go-zero/core/stores/redis"
)

type ServiceContext struct {
	Config config.Config
	// claim ur redis client in here
	RedisClient *zeroRds.Redis
}

func NewServiceContext(c config.Config) *ServiceContext {
	//conf := c.Redis
	redisClient := zeroRds.MustNewRedis(conf.Redis)

	return &ServiceContext{
		Config: c,
		RedisClient: redisClient,
	}
}

业务逻辑应用

你的某个接口业务逻辑处理

    //logx.Info("Set Redis cache now")
	//err := l.svcCtx.RedisClient.Setex(fmt.Sprintf("Sum:%d:%d", in.A, in.B), fmt.Sprintf("Result:%d time:%v", sum, time.Now().Format(time.RFC3339)), ttl)
	//if err != nil {
	//	logx.Errorf("Rpc A9Sum set cache error: %v", err)
	//}

到这里你就成功了，直接拿去用吧。

通过自定义 redis 连接池

这里与上面有些不同，我们会自定义 redis 的结构体，自定义连接池的配置，自定义 client ，以及对应的一些操作，步骤如下：

• 自定义 redis 配置结构体
• yaml文件中声明配置信息
• 编写连接池等的初始化
• 编写连接池的接口
• 业务逻辑处理中使用连接池

自定义 redis 配置结构体

依然还是你的 config.py 中加入以下：

package config

import "github.com/zeromicro/go-zero/rest"

type Config struct {
	rest.RestConf
	CacheConf CacheConf
}

type CacheConf struct {
	Password string `json:",optional"`
	Host     string `json:",optional"`
	Port     int64  `json:",optional"`
	DBName   int    `json:",optional"`

	MaxIdle     int   `json:",optional"`
	MaxActive   int   `json:",optional"`
	IdleTimeout int64 `json:",optional"`
}

yaml文件中声明配置信息

Name: limit
Host: 0.0.0.0
Port: 8888
MaxConns: 100000

CacheConf:
  Password: ""
  Host: 172.30.3.57
  Port: 6379
  DBName: 15
  MaxIdle: 2
  MaxActive: 5
  IdleTimeout: 1000000000

编写连接池等的初始化

package redis

import (
	"fmt"
	"math"
	"time"

	"demo24/micro_svc/zero-limit/internal/config"

	"github.com/gomodule/redigo/redis"
	"github.com/zeromicro/go-zero/core/logx"
)

var (
	pool   *redis.Pool
	client redis.Conn
)

func InitRedis(conf config.CacheConf) {
	pool = &redis.Pool{
		MaxActive:   conf.MaxActive,
		MaxIdle:     conf.MaxIdle,
		IdleTimeout: time.Duration(conf.IdleTimeout),
		Dial: func() (redis.Conn, error) {
			addr := fmt.Sprintf("%s:%s", conf.Host, conf.Port)
			conn, err := redis.Dial("tcp", addr, redis.DialDatabase(conf.DBName))
			if err != nil {
				logx.Errorf("Create redis pool conn failed, err: %v", err)
				return nil, err
			}

			return conn, nil
		},
	}

	client = pool.Get()
	_, err := redis.String(client.Do("ping"))
	if err != nil {
		logx.Errorf("redis conn pool init failed, err: %v.", err)
	}
}

编写连接池的接口

func GetRDB() redis.Conn {
	if pool == nil {
		logx.Errorf("get redis instance failed, err: pool is nil.")
		return nil
	}

	return pool.Get()
}

type Cache struct {
	client redis.Conn
}

func NewCache() *Cache {
	return &Cache{
		client: GetRDB(),
	}
}

func (cache *Cache) Set(key string, value interface{}, nx int) {
	if nx == 0 {
		nx = math.MaxInt32
	}
	_, err := cache.client.Do("SET", key, value, "NX", nx)
	if err != nil {
		logx.Errorf("set key failed, err: %v", err)
	}
}

func (cache *Cache) Get(key string) (val interface{}, err error) {
	value, err := cache.client.Do("GET", key)
	if err != nil {
		logx.Errorf("get cache err, err: %v", err)
		return nil, err
	}
	return value, nil
}

// TODO, u can implement ur cache operations

业务逻辑处理中使用连接池

...
    // redis pool
	//cache := redis.NewCache()
	//_, err = cache.Get(fmt.Sprintf("Sum:%d:%d", in.A, in.B))
	//if err != nil {
	//	logx.Errorf("Rpc A9Sum get cache error: %v", err)
	//}
...

通过以上流程，你可以实现这两种 go-zero 的使用 redis 作为缓存的方法，希望对你有用。