在实际的项目开发过程中，我们常常会遇到这样的情况：同一个项目部署在不同的环境下，所需要的配置会存在明显差异。当涉及到服务器集群搭建时，从众多客户的需求反馈来看，绝大多数客户都会明确要求采用 redis 集群配置。这主要是因为 redis 集群在高并发场景下，能够通过分布式的架构，有效提升数据读取和写入的效率，保障系统的高性能和高可用性，满足大规模业务数据处理的需求。然而，当项目仅仅部署在单个服务器上时，情况则大不相同，此时客户更多会要求使用单机配置。单机配置相对简单，成本较低，对于业务量较小、并发程度不高的场景而言，完全能够满足需求。

为了能够同时兼容这两种截然不同的情况，我们经过深思熟虑和技术论证，决定采用代码加配置的方式来加以区分解决。通过在代码层面编写灵活的逻辑判断，依据不同的配置文件信息，来动态地切换和适配对应的 redis 配置模式。这样一来，无论是面对复杂的服务器集群环境，还是较为简单的单个服务器场景，我们的项目都能够稳定、高效地运行，极大地提升了项目的适用性和可扩展性 。

redis:
  read_timeout: 0.2s  
  write_timeout: 0.2s  
  password: 123456  
  # 单列模式  
  addr: 192.168.0.1:6379  
  # 集群模式  
  cluster: false  
  cluster_addr:
    - 192.168.0.23:6379    
    - 192.168.0.24:6379    
    - 192.168.0.25:6379    
    - 192.168.0.26:6379    
    - 192.168.0.27:6379    
    - 192.168.0.28:6379

func newClusterClient(redisConfig *common.Data_Redis) *redis.ClusterClient {
    if !redisConfig.GetCluster() {
       return nil    
     }

    rdb := redis.NewClusterClient(&redis.ClusterOptions{Addrs: redisConfig.GetClusterAddr(), Password: redisConfig.GetPassword(), PoolSize: 20 * runtime.NumCPU(),})
    ctx := context.Background()
    if err := rdb.Ping(ctx).Err(); nil != err {
       log.Error(err.Error())
       return nil    
    }
    rdb.ReloadState(ctx)
    return rdb
}

支持集群和单例，所以这边使用该包。

func newClient(redisConfig *common.Data_Redis) *redis.Client {
    addr := redisConfig.GetAddr()
    if addr == "" {
       return nil    }
    rdb := redis.NewClient(&redis.Options{
       Addr: addr,Password:redisConfig.GetPassword(),DB: 0,MaxActiveConns: 10 * runtime.NumCPU(), })
    pong, err := rdb.Ping(context.Background()).Result()
    if err != nil {
       log.Error(err.Error())
       return nil    }
    log.Info(pong)
    return rdb
}

var cacheStorage *CacheStorage

func DB() *CacheStorage {
    return cacheStorage}

// cache storage//// 优先级： redisCluster > redis > local
type CacheStorage struct {
    local   *gcache.Cache    
    redis   *redis.Client    
    cluster *redis.ClusterClient
}

func NewCacheStorage(redisConfig *common.Data_Redis) error {
    cacheStorage = &CacheStorage{
       local: gcache.New(),    }
    if rdbc := newClusterClient(redisConfig); rdbc != nil {
       cacheStorage.cluster = rdbc       
       log.Info("using redis cluster")
    } else if rdb := newClient(redisConfig); rdb != nil {
       cacheStorage.redis = rdb       
       log.Info("using redis single")
    } else {
       log.Info("using local cache")
    }
    return nil
}

统一数据接入口，通过配置判断启动的模式。

func (s *CacheStorage) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) {
    var err error    
    if s.cluster != nil {
       err = s.cluster.Set(ctx, key, value, expiration).Err()
    } else if s.redis != nil {
       err = s.redis.Set(ctx, key, value, expiration).Err()
    } else {
       err = s.local.Set(ctx, key, value, expiration)
    }
    if err != nil {
       log.Error(err.Error())
    }
}

func (s *CacheStorage) Get(ctx context.Context, key string) string {
    var cmd *redis.StringCmd    
    if s.cluster != nil {
       cmd = s.cluster.Get(ctx, key)
    } else if s.redis != nil {
       cmd = s.redis.Get(ctx, key)
    } else {
       gVal, _ := s.local.Get(ctx, key)
       if gVal != nil {
          if val, ok := gVal.Val().(string); ok {
             return val          }
          if buff, err := json.Marshal(gVal.Val()); err == nil {
             return string(buff)
          }
       }
       return ""    }
    str, err := cmd.Result()
    if err != redis.Nil && err != nil {
       log.Error(err.Error())
    }
    return str}

func (s *CacheStorage) Remove(ctx context.Context, keys ...string) {
    log.Info("清理缓存：%v", keys)
    var err error    
    if s.cluster != nil {
       err = s.cluster.Del(ctx, keys...).Err()
    } else if s.redis != nil {
       err = s.redis.Del(ctx, keys...).Err()
    } else {
       for _, key := range keys {
          _, err = s.local.Remove(ctx, key)
       }
    }
    if err != nil {
       log.Error(err.Error())
    }
}

在 Go 语言开发项目的过程中，我们会频繁地与数据库或者缓存进行交互，实现数据的增删查操作。这些操作虽然基础，但却贯穿于项目的各个业务模块之中。然而，在不同的部署环境下，比如本地开发环境、单例模式部署以及集群模式部署，数据存储和访问的方式往往存在显著差异。

在本地环境中，通常为了方便调试和开发，我们会采用较为简单的配置，可能会使用轻量级的本地数据库或者单节点的缓存服务。单例模式部署则适用于业务规模较小、对资源需求不高的场景，这种模式下系统相对独立，数据的读写操作较为直接。而集群模式部署主要针对高并发、大数据量的生产环境，它通过多个节点的协同工作来提高系统的性能和可用性，数据的存储和访问需要考虑分布式环境下的一致性、负载均衡等问题。

在传统的开发方式中，如果不进行有效的处理，开发者在编写增删查接口时，就需要时刻关注当前的部署环境。每当项目从本地开发环境迁移到单例模式部署，或者进一步升级到集群模式部署时，开发者都不得不对代码进行相应的更改，以适配不同环境下的数据访问方式。这不仅增加了开发的工作量，还容易引入人为的错误，降低了开发的效率和代码的稳定性。

为了解决这个问题，我们决定统一每一个增删查接口。具体来说，就是通过封装底层的数据访问逻辑，在代码层面构建一个抽象层。这个抽象层会根据预先配置的环境信息，自动选择合适的数据访问方式，无论是本地环境的简单操作，还是集群环境下复杂的分布式处理，都由这个抽象层来完成。这样一来，开发者在使用这些增删查接口时，就无需再理会当前是本地、单例还是集群模式，只需要专注于业务代码逻辑的实现。开发者可以将更多的精力投入到如何优化业务流程、提升用户体验等核心问题上，大大提高了开发的效率和质量，同时也使得代码更加简洁、易于维护。

在Go项目开发中，不同部署环境（本地、单例、集群）下数据存储和访问方式差异大。传统开发里，开发者编写增删查接口时需因环境变化改代码，增加工作量、易出错且降低效率与稳定性。为此，我们统一增删查接口，构建抽象层封装底层数据访问逻辑，它会依环境信息自动选合适访问方式，让开发者专注业务逻辑，提升开发效率和代码质量，使代码更简洁易维护。 

go实现redis集群和单机快速切换

背景在实际的项目开发过程中，我们常常会遇到这样的情况：同一个项目部署在不同的环境下，所需要的配置会存在明显差异。当涉及到服务器集群搭建时，从众多客户的需求反馈来看，绝大多数客户都会明确要求采用 redis 集群配置。这主要是因为 redis 集群在高并发场景下，能够通过分布式的架构，有效提升数据读取和写入的效率，保障系统的高性能和高可用性，满足大规模业务数据处理的需求。然而，当项目仅仅部署在单个服

后端

数据库

负载均衡

数据存储

大数据

服务器

2025春季采购节

tencentdb-catalog

cdcs

bigdata-class

4位行业大咖将分享DeepSeek × 技术创作者：10倍速构建专业影响力讲座，助你抢占AI红利窗口！点击报名到场/直播预约：<a href="https://cloud.tencent.com/developer/salon/salon-2328" target="_blank">https://cloud.tencent.com/developer/salon/salon-2328</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/3b8f3fb01c22a358ef9f87c7ffbddb3b.jpg"/>

腾讯技术创作特训营

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯云AI代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

文章&问答评论现已支持表情

在实际的项目开发过程中，我们常常会遇到这样的情况：同一个项目部署在不同的环境下，所需要的配置会存在明显差异。当涉及到服务器集群搭建时，从众多客户的需求反馈来看，绝大多数客户都会明确要求采用 redis 集群配置。这主要是因为 redis 集群在高并发场景下，能够通过分布式的架构，有效提升数据读取和写入的效率，保障系统的...

go实现redis集群和单机快速切换

go实现redis集群和单机快速切换

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐