分类 redis 下的文章

2024-09-04

在Redis中，你可以使用MEMORY USAGE命令来查看一个特定key所占用的内存大小。这个命令在Redis 4.0及以上版本中可用。




MEMORY USAGE key [SAMPLES count]

这里是一个例子：




redis-cli MEMORY USAGE mykey

这将返回键mykey所占用的内存大小，单位是字节。如果你想要获取多个样本来估算内存使用情况，可以使用SAMPLES选项。

请注意，MEMORY命令提供的信息可能会有一些不准确，因为它不是为了精确测量内存而设计的，而是为了给你一个大概的认识。如果你需要精确的内存使用数据，考虑使用Redis的内置Replication Features或者外部工具如redis-stat或redis-memory-for-key。

- 阅读更多 -

Redis数据读取与存储

System

2024-09-04

所有,redis

在Redis中，数据的存储主要是通过多种类型的数据结构来实现的，而数据的读取则主要是通过Redis提供的命令来进行。

以下是一些基本的Redis数据存储和读取的例子：

字符串(String)类型的存储与读取：

存储：




import redis
r = redis.Redis(host='localhost', port=6379, db=0)
r.set('key', 'value')

读取：




value = r.get('key')
print(value)

列表(List)类型的存储与读取：

存储：




r.lpush('list_key', 'value1')
r.lpush('list_key', 'value2')

读取：




list_values = r.lrange('list_key', 0, -1)
print(list_values)

集合(Set)类型的存储与读取：

存储：




r.sadd('set_key', 'value1')
r.sadd('set_key', 'value2')

读取：




set_values = r.smembers('set_key')
print(set_values)

有序集合(Sorted Set)类型的存储与读取：

存储：




r.zadd('zset_key', {'value1': 1, 'value2': 2})

读取：




zset_values = r.zrange('zset_key', 0, -1)
print(zset_values)

哈希(Hash)类型的存储与读取：

存储：




r.hset('hash_key', 'field1', 'value1')
r.hset('hash_key', 'field2', 'value2')

读取：




hash_values = r.hgetall('hash_key')
print(hash_values)

以上代码都是使用Python的redis模块来操作Redis的。在实际应用中，你需要确保Redis服务器正在运行，并且已经安装了redis模块。如果没有安装，可以通过pip install redis来安装。

System

2024-09-04

所有,redis




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
 
import java.util.HashSet;
import java.util.Set;
 
@Configuration
public class RedisConfig {
 
    // 提供一个默认的RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory);
        return template;
    }
 
    // 提供一个StringRedisTemplate
    @Bean
    public StringRedisTemplate stringRedisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(lettuceConnectionFactory);
        return template;
    }
 
    // 当使用Redis哨兵模式时，需要如下配置
    @Bean
    public LettuceConnectionFactory redisSentinelConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("127.0.0.1", 26379)
                .sentinel("127.0.0.1", 26380);
 
        return new LettuceConnectionFactory(sentinelConfig);
    }
 
    // 当使用Redis Cluster模式时，需要如下配置
    @Bean
    public LettuceConnectionFactory redisClusterConnectionFactory() {
        Set<String> clusterNodes = new HashSet<>();
        clusterNodes.add("127.0.0.1:6379");
        clusterNodes.add("127.0.0.1:6380");
        clusterNodes.add("127.0.0.1:6381");
 
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration(clusterNodes);
 
        return new LettuceConnectionFactory(clusterConfig);
    }
}

这个配置类提供了创建多个LettuceConnectionFactory的Bean，分别用于连接Redis的哨兵模式和集群模式。同时，它还提供了两个RedisTemplate的Bean，一个用于Key和Value都是String类型的操作，另一个用于Key是String，Value是Object的操作。这样，开发者可以根据实际需求选择合适的连接方式和操作方式。

- 阅读更多 -

安装pythonRedis、mongoDB

System

2024-09-04

所有,redis

在Linux系统中安装Python3、Redis和MongoDB可以通过包管理器来完成。以下是基于Debian/Ubuntu系统的安装命令：




# 更新包索引
sudo apt-update
 
# 安装Python3
sudo apt-get install -y python3
 
# 安装Redis
sudo apt-get install -y redis-server
 
# 安装MongoDB
sudo apt-get install -y mongodb

对于Redis和MongoDB，服务通常会自动启动。您可以通过运行以下命令来检查它们的状态：




# 检查Redis服务状态
sudo systemctl status redis-server
 
# 启动Redis服务
sudo systemctl start redis-server
 
# 检查MongoDB服务状态
sudo systemctl status mongodb
 
# 启动MongoDB服务
sudo systemctl start mongodb

请注意，这些命令假定您正在使用基于Debian的系统（如Ubuntu）。对于其他Linux发行版（如Fedora、CentOS等），您可能需要使用其相应的包管理器（如dnf或yum）和服务管理命令（如systemctl或init）。

- 阅读更多 -

【Redis】如何保证缓存和数据库的一致性

System

2024-09-04

所有,redis

为了保证缓存和数据库的一致性，可以采用以下策略：

写入数据库后删除缓存：
先写数据库，成功后删除缓存。这种方式简单，但可能存在数据不一致的情况，因为删除缓存可能失败。
写入数据库前删除缓存：
先删除缓存，再写数据库。这种方式能保证一致性，但可能存在并发问题。
使用事务：
将数据库操作和缓存操作放在同一个事务中。这种方式能保证原子性，一旦事务提交，数据库和缓存状态就会保持一致。

示例代码（使用Python和Redis）：




import redis
import sqlalchemy
from sqlalchemy.orm import sessionmaker
 
# 初始化数据库会话
engine = sqlalchemy.create_engine('sqlite:///mydatabase.db')
Session = sessionmaker(bind=engine)
session = Session()
 
# 初始化Redis连接
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 删除缓存
def delete_cache(key):
    r.delete(key)
 
# 写入数据库并删除相应的缓存
def write_to_db_and_delete_cache(key, value):
    # 假设有一个模型Model和对应的表
    class Model(Base):
        __tablename__ = 'my_table'
        id = Column(Integer, primary_key=True)
        data = Column(String)
    
    # 写入数据库
    new_item = Model(data=value)
    session.add(new_item)
    session.commit()
    
    # 删除缓存
    delete_cache(key)
 
# 使用示例
key = 'my_key'
value = 'my_value'
write_to_db_and_delete_cache(key, value)

在实际应用中，可能需要结合具体的业务场景来选择最合适的策略。例如，可以使用锁或者队列来处理并发问题，或者采用更复杂的策略如延迟双删策略（延迟删除缓存直到数据更新操作完成）等。

- 阅读更多 -

Redis常见的数据类型和应用场景

System

2024-09-04

所有,redis

Redis 提供了五种不同类型的数据结构，每种数据结构有着特定的应用场景：

String：字符串是最基本的 key-value 结构。常用于存储用户信息、会话信息、配置参数等。
应用场景：
```
# 设置用户信息
redis.set('user:100:name', 'Alice')
# 获取用户信息
name = redis.get('user:100:name')
```

Hash：Hash 是键值对的集合。常用于存储用户信息、配置参数等。

应用场景：




# 设置用户信息
redis.hset('user:100', 'name', 'Alice')
redis.hset('user:100', 'age', '25')
# 获取用户信息
user_info = redis.hgetall('user:100')

List：列表是顺序的字符串列表，可以添加删除元素。常用于消息队列、文章列表等。

应用场景：




# 添加文章到列表
redis.lpush('user:100:posts', 'post1', 'post2', 'post3')
# 获取文章列表
posts = redis.lrange('user:100:posts', 0, -1)

Set：集合是无序的字符串集合，可以添加删除元素。常用于去重、共同好友、共同兴趣等。

应用场景：




# 添加好友
redis.sadd('user:100:friends', 'friend1', 'friend2', 'friend3')
# 获取所有好友
friends = redis.smembers('user:100:friends')

Sorted Set：有序集合是有分数的集合，可以根据分数排序。常用于排行榜、延时任务调度等。

应用场景：




# 添加用户分数
redis.zadd('leaderboard', {'user1': 100, 'user2': 200})
# 获取排行榜前10名
leaderboard = redis.zrange('leaderboard', 0, 9)

以上是 Redis 数据类型的简单介绍和使用示例，实际应用中可能还会涉及更复杂的使用方法，如事务处理、发布订阅等。

System

2024-09-04

所有,redis

在计算机科学中，LRU是一种缓存置换算法，目的是减少数据访问的时间开销。LRU算法的核心是“如果数据最近被访问过，那么在将来被访问的可能性也较高”。

Redis作为一种内存数据库，其中的数据都保存在内存中，为了保证Redis的性能，Redis会根据数据的访问情况来决定是否保留数据。在Redis中，LRU算法被用于决定何时淘汰不常使用的键。

Redis的LRU算法实现主要在redis.c文件中的freeMemoryIfNeeded函数中，该函数会在执行命令之前被调用，以确保Redis的内存使用量不超过配置的最大内存量。

以下是Redis中实现LRU算法的核心函数部分：




/* 在需要的情况下释放内存 */
void freeMemoryIfNeeded(void) {
    /* 如果超出最大内存限制，则开始清除键 */
    while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) {
        int samples = 5;
        int j, k;
        /* 在一定的样本数内，选择一个最近未被访问的键 */
        for (j = 0; j < samples; j++) {
            k = rand() % dbTotalSize;
            dictEntry *de = dictGetRandomKey(dbDict + k);
            redisDb *db = dbDict[k];
            robj *key = dictGetKey(de);
            robj *val = dictGetVal(de);
            time_t when = val->lru;
 
            /* 更新LRU时间 */
            val->lru = server.lruclock;
            /* 将键值对保存到一个临时的数据库中 */
            db->expires[k] = db->expires_cursor;
            db->expires_cursor = de;
            /* 将键值对从当前数据库移动到临时数据库 */
            dictAdd(db->dict, key, val);
            dictAdd(db->expires, key, val);
            dictUnlink(db->dict, key);
            dictUnlink(db->expires, key);
 
            /* 如果找到了一个最近未被访问的键，则释放其空间，并停止搜索 */
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
                freeObjFromDb(db, key, val);
            }
        }
    }
}

在这个函数中，Redis会随机选取一些键，检查它们的最后一次被访问的时间，并根据这个时间来决定是否释放它们的空间。如果选取的键已经很长时间没有被访问，它们将被释放，从而保证了Redis的内存使用量不会超过配置的最大内存量。

这只是Redis中实现LRU算法的一个简化示例，实际的Redis实现要复杂得多，包括了多线程和更复杂的内存管理策略。

- 阅读更多 -

Docker安装配置Redis

System

2024-09-04

所有,redis

以下是一个简单的示例，展示如何使用Docker安装和配置Redis服务：

创建一个名为 docker-compose.yml 的文件，内容如下：




version: '3'
services:
  redis:
    image: redis:latest
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - net
 
networks:
  net:
 
volumes:
  redis-data:
    driver: local

在包含该 docker-compose.yml 文件的目录中，运行以下命令来启动Redis服务：




docker-compose up -d

确认Redis服务运行：




docker ps

这将下载最新的Redis Docker镜像，将6379端口从Docker容器映射到主机，并启动Redis服务器。它还将数据卷用于持久化存储，并启用了追加模式。

- 阅读更多 -

springboot 缓存框架Cache整合redis组成二级缓存

System

2024-09-04

所有,redis

要在Spring Boot项目中使用Redis作为二级缓存，你可以使用Spring Cache抽象层以及spring-boot-starter-data-redis依赖。以下是整合Redis作为二级缓存的步骤和示例代码：

添加依赖到pom.xml：




<dependencies>
    <!-- Spring Boot Data Redis Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Spring Boot Cache Abstraction -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Redis连接：




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

在Spring Boot应用中启用缓存：




import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableCaching
public class CacheConfig {
}

使用缓存注解：




import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
 
@Service
public class SomeService {
 
    @Cacheable(value = "secondaryCache", key = "#key", condition = "#key.length() < 10")
    public String someMethod(String key) {
        // 实现逻辑
        return "result";
    }
}

在上述代码中，@Cacheable注解被用来指定someMethod的返回结果应该被缓存。缓存的名字是secondaryCache，并且使用key作为缓存的键。condition属性用于指定只有当key的长度小于10时才会缓存结果。

确保你的Redis服务器正在运行并且配置正确，这样Spring Boot应用就会自动将数据缓存到Redis中，作为二级缓存来使用。

- 阅读更多 -

nosql----redis三主三从集群部署

System

2024-09-04

所有,redis

为了部署一个Redis三主三从集群，你需要准备六个Redis节点，三个主节点和三个从节点。以下是部署Redis集群的基本步骤：

安装Redis并确保每个节点上的Redis版本一致。
配置每个Redis实例的redis.conf文件，设置不同的端口和持久化文件路径。
使用Redis的--slaveof参数配置主从关系。

以下是示例配置：

redis-6379.conf (主节点)




port 6379
dir /var/lib/redis

redis-6380.conf (主节点)




port 6380
dir /var/lib/redis

redis-6381.conf (主节点)




port 6381
dir /var/lib/redis

redis-6382.conf (从节点)




port 6382
dir /var/lib/redis
slaveof 127.0.0.1 6379

redis-6383.conf (从节点)




port 6383
dir /var/lib/redis
slaveof 127.0.0.1 6380

redis-6384.conf (从节点)




port 6384
dir /var/lib/redis
slaveof 127.0.0.1 6381

启动每个Redis实例：




redis-server /path/to/redis-6379.conf
redis-server /path/to/redis-6380.conf
redis-server /path/to/redis-6381.conf
redis-server /path/to/redis-6382.conf
redis-server /path/to/redis-6383.conf
redis-server /path/to/redis-6384.conf

确保防火墙和安全组设置允许相应端口的流量。

这样就部署了一个基本的Redis三主三从集群。为了更高的可用性和数据一致性，你可能还需要考虑使用Redis Sentinel或者Redis Cluster。

- 阅读更多 -