Redis 使用小记

最新推荐文章于 2024-07-07 21:22:23 发布

多喝氧烷_

最新推荐文章于 2024-07-07 21:22:23 发布

阅读量1k

点赞数 7

文章标签： http 服务器

本文链接：https://blog.csdn.net/m0_61472414/article/details/137720740

版权

Redis提供了五种主要的数据结构，每种都有其特定的用途和一系列操作。以下是每种数据结构及其常见操作的概述：

String（字符串）:
- 基本操作: SET, GET, DEL 等。
- 用于存储文本或二进制数据。
- 支持的操作包括设置、获取、删除字符串值，以及更复杂的操作如追加(APPEND), 截取(GETRANGE), 和设置带过期时间的值(SETEX)。
List（列表）:
- 基本操作: LPUSH, RPUSH, LPOP, RPOP 等。
- 用于存储有序的字符串序列。
- 支持的操作包括从列表两端推入或弹出元素，访问或修改特定索引的元素(LINDEX, LSET)，以及截取列表的一部分(LRANGE)。
Set（集合）:
- 基本操作: SADD, SREM, SMEMBERS, SISMEMBER 等。
- 用于存储无序且唯一的字符串集合。
- 支持的操作包括添加、删除元素，检查元素是否存在，以及执行集合间的运算如并集(SUNION), 交集(SINTER), 差集(SDIFF)。
Sorted Set（有序集合）:
- 基本操作: ZADD, ZREM, ZRANGE, ZREVRANGE 等。
- 类似于集合，但每个元素都关联了一个分数，用于排序。
- 支持的操作包括添加、删除元素，根据分数或字典序获取元素范围，以及计算排名(ZRANK, ZREVRANK)。
Hash（哈希表）:
- 基本操作: HSET, HGET, HDEL, HMGET 等。
- 用于存储键值对集合，类似于Java中的Map。
- 支持的操作包括添加、获取、删除键值对，以及获取所有键(HKEYS)或值(HVALS)。

每种数据结构都设计有丰富的命令来满足不同的应用场景需求。例如，您可以使用字符串来存储简单的键值对，使用列表来实现队列或栈，使用集合来处理不重复的元素集，使用有序集合来维护一个按分数排序的元素集，或者使用哈希表来存储对象的多个字段和值。

在Redis中，哈希（Hash）和字符串（String）是两种基本的数据结构，它们各自有不同的性能特点和适用场景。

字符串是最基本的数据类型，可以存储文本、数字或二进制数据。它的操作通常很简单，如设置（SET）、获取（GET）和删除（DEL）。字符串适合存储单个的大型数据对象或简单的键值对。

哈希则类似于关联数组或字典，可以存储多个字段和对应的值。哈希表适合存储对象的属性或配置信息，支持对每个字段进行单独的操作，如添加（HSET）、获取（HGET）和删除（HDEL）。

性能方面，对于小型对象，RAM的速度和内存带宽对全局性能的影响不太明显。但是，对于大型对象（大于10KB），这种影响可能会变得明显。哈希在内存使用上通常比字符串更加高效，尤其是当你可以利用特殊编码时。例如，当哈希、列表、集合由纯整数组成，并且元素数量小于一定数目时，Redis会使用一种非常内存高效的编码方式，这可以节省多达10倍的内存（平均节省5倍内存）。

然而，这并不是没有代价的，因为ziplist（一种用于小型哈希、列表和有序集合的内部编码方式）在CPU使用上可能会有所折衷。此外，你不能部分地让哈希字段过期，而字符串可以单独设置过期时间。

总的来说，如果你需要存储和操作多个键值对，并且需要对单独的键/值对执行操作，那么哈希可能是更好的选择。但是，如果你只需要简单地存储一个大的字符串或二进制数据，那么字符串可能更合适。在实际应用中，最好根据具体需求进行基准测试，以确定哪种数据结构更适合你的用例 1 2 3。

为了使用Go语言实现染色配置的增删改查功能，我们可以设计一个RESTful API服务。以下是一个可能的项目目录结构和文件设计：

dyeConfigService/
|-- cmd
|   |-- main.go
|-- internal
|   |-- handler
|   |   |-- handler.go
|   |-- service
|   |   |-- service.go
|   |-- repository
|   |   |-- repository.go
|-- pkg
|   |-- redisclient
|   |   |-- redisclient.go
|-- go.mod
|-- go.sum

在这个结构中：

cmd/main.go 是程序的入口点，它启动HTTP服务器。
internal/handler/handler.go 包含处理HTTP请求和响应的逻辑。
internal/service/service.go 包含业务逻辑，它调用repository层。
internal/repository/repository.go 包含与Redis交互的逻辑。
pkg/redisclient/redisclient.go 包含初始化Redis客户端的代码。
go.mod 和 go.sum 是Go的模块依赖文件。

现在，让我们来看一下handler.go中处理HTTP请求的代码示例：

package handler

import (
    "encoding/json"
    "net/http"
    "dyeConfigService/internal/service"
)

type Handler struct {
    Service *service.Service
}

func NewHandler(s *service.Service) *Handler {
    return &Handler{Service: s}
}

func (h *Handler) GetDyeConfig(w http.ResponseWriter, r *http.Request) {
    // 解析HTTP参数
    userID := r.URL.Query().Get("userid")
    adPosID := r.URL.Query().Get("adposid")
    adID := r.URL.Query().Get("adid")

    // 调用service方法
    config, err := h.Service.GetDyeConfig(userID, adPosID, adID)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 序列化JSON
    jsonResponse, err := json.Marshal(config)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 返回响应
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    w.Write(jsonResponse)
}

// 其他的增删改方法类似...

在service.go中，我们可以定义业务逻辑：

package service

import (
    "dyeConfigService/internal/repository"
)

type Service struct {
    Repo *repository.Repository
}

func NewService(r *repository.Repository) *Service {
    return &Service{Repo: r}
}

func (s *Service) GetDyeConfig(userID, adPosID, adID string) (*DyeConfig, error) {
    // 访问Redis
    return s.Repo.GetDyeConfig(userID, adPosID, adID)
}

// 其他的增删改方法类似...

在repository.go中，我们定义与Redis交互的代码：

package repository

import (
    "dyeConfigService/pkg/redisclient"
)

type Repository struct {
    Redis *redisclient.Client
}

func NewRepository(redis *redisclient.Client) *Repository {
    return &Repository{Redis: redis}
}

func (r *Repository) GetDyeConfig(userID, adPosID, adID string) (*DyeConfig, error) {
    // 构建key
    key := buildKey(userID, adPosID, adID)
    // 从Redis获取数据
    data, err := r.Redis.Get(key).Result()
    if err != nil {
        return nil, err
    }
    // 解析数据
    var config DyeConfig
    err = json.Unmarshal([]byte(data), &config)
    if err != nil {
        return nil, err
    }
    return &config, nil
}

func buildKey(userID, adPosID, adID string) string {
    // 根据参数构建key
    // ...
}

// 其他的增删改方法类似...

最后，在main.go中，我们初始化服务并启动HTTP服务器：

package main

import (
    "dyeConfigService/internal/handler"
    "dyeConfigService/internal/repository"
    "dyeConfigService/internal/service"
    "dyeConfigService/pkg/redisclient"
    "net/http"
)

func main() {
    // 初始化Redis客户端
    redis := redisclient.NewClient()

    // 初始化repository
    repo := repository.NewRepository(redis)

    // 初始化service
    svc := service.NewService(repo)

    // 初始化handler
    hdl := handler.NewHandler(svc)

    // 设置路由
    http.HandleFunc("/dyeconfig", hdl.GetDyeConfig)
    // 其他路由...

    // 启动HTTP服务器
    http.ListenAndServe(":8080", nil)
}

这只是一个简单的示例，实际项目中可能需要更多的错误处理、日志记录、配置管理等。此外，还需要添加身份验证、授权和其他中间件来保护API。

多喝氧烷_

关注

7
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Redis 使用小记

性能方面，对于小型对象，RAM的速度和内存带宽对全局性能的影响不太明显。例如，当哈希、列表、集合由纯整数组成，并且元素数量小于一定数目时，Redis会使用一种非常内存高效的编码方式，这可以节省多达10倍的内存（平均节省5倍内存）。然而，这并不是没有代价的，因为ziplist（一种用于小型哈希、列表和有序集合的内部编码方式）在CPU使用上可能会有所折衷。哈希表适合存储对象的属性或配置信息，支持对每个字段进行单独的操作，如添加（（String）是两种基本的数据结构，它们各自有不同的性能特点和适用场景。
复制链接

扫一扫