2024-08-27

以下是一个简化的RedisUtils类示例,展示了如何在Spring Boot 3项目中引入Redis并封装常用操作。




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
 
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
@Component
public class RedisUtils {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    // 存储数据
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
 
    // 存储数据并设置过期时间
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }
 
    // 获取数据
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
 
    // 删除数据
    public void delete(String key) {
        redisTemplate.delete(key);
    }
 
    // 批量删除数据
    public void delete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }
 
    // 批量获取数据
    public List<Object> multiGet(Collection<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }
 
    // 判断数据是否存在
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }
 
    // 获取过期时间
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
 
    // 设置过期时间
    public void setExpire(String key, long timeout, TimeUnit unit) {
        redisTemplate.expire(key, timeout, unit);
    }
 
    // 自增操作
    public Long increment(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }
 
    // 自减操作
    public Long decrement(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, -delta);
    }
 
    // Hash操作
    public void hSet(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
 
    public Object hGet(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }
 
    public void hDelete(String ke
2024-08-27

Redis的配置文件是一个文本文件,通常名为redis.conf。它包含了Redis服务器的各种配置指令,比如设置Redis监听的端口、设置数据库的数量、设置持久化策略等。

以下是一个基本的redis.conf配置文件的例子:




# Redis配置文件示例
 
# 设置Redis监听的端口,默认为6379
port 6379
 
# 设置Redis监听的网络接口,如果需要让Redis服务器监听所有接口,请使用0.0.0.0
# bind 127.0.0.1
 
# 设置Redis是否以守护进程方式运行
daemonize no
 
# 设置Redis的日志文件路径
logfile "/var/log/redis/redis-server.log"
 
# 设置数据库数量,默认16个数据库 (0...15)
databases 16
 
# 设置密码认证,要启用此功能,需要将此行改为 "requirepass yourpassword"
# requirepass foobared
 
# 设置持久化策略
save 900 1
save 300 10
save 60 10000
 
# 设置快照文件名
dbfilename dump.rdb
 
# 设置快照文件和AOF文件的目录
dir ./
 
# 设置Redis最大内存使用量,达到上限时会触发键的淘汰策略
maxmemory <bytes>
 
# 设置Redis的主从复制配置
# slaveof <masterip> <masterport>
 
# 设置Redis连接密码,主服务器设置该项后,从服务器连接主服务器时需要使用该密码
# masterauth <master-password>
 
# 其他配置项...

要修改Redis的配置,你可以直接编辑redis.conf文件,然后重启Redis服务。例如,要改变监听端口,你可以找到port 6379这一行,然后将6379改为你想要的端口号。

注意:在生产环境中,应该通过Redis的命令行接口或者使用CONFIG SET命令来设置配置项,而不是直接编辑配置文件,因为这样可以在不中断服务的情况下动态更新配置。

2024-08-27



import redis
 
# 连接到Redis服务器
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
 
# 订阅频道
channel = "chat"
pubsub = redis_client.pubsub()
pubsub.subscribe(channel)
 
print(f"订阅频道 {channel} 成功,等待消息...")
 
try:
    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"接收到消息: {message['data'].decode()}")
except KeyboardInterrupt:
    pubsub.unsubscribe(channel)
    print(f"取消订阅频道 {channel}")

这段代码演示了如何使用redis-py库来订阅一个Redis频道,并在收到消息时进行处理。当运行这段代码时,它会连接到Redis服务器,订阅指定的频道,并打印接收到的消息。按下Ctrl+C可以取消订阅并退出程序。

2024-08-27

使用Redis的SETNX命令实现分布式锁是一个常见的方案。SETNX是"SET if Not eXists"的缩写,也就是只有当键不存在时才设置值。这个特性使得它可以被用作锁的机制。

以下是一个使用Python和redis-py库实现的示例:




import redis
import time
import uuid
 
def acquire_lock(conn, lock_name):
    identifier = str(uuid.uuid4())  # 生成一个唯一的ID
    end = time.time() + 10  # 设置超时时间
 
    while time.time() < end:
        if conn.setnx(lock_name, identifier):  # 尝试获取锁
            return identifier
        time.sleep(0.001)
 
    return False
 
def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False
 
# 使用示例
redis_conn = redis.StrictRedis(host='localhost', port=6379, db=0)
lock_name = "my_lock"
identifier = acquire_lock(redis_conn, lock_name)
if identifier:
    try:
        # 在这里执行需要互斥访问的代码
        print("Lock acquired")
    finally:
        # 确保释放锁
        if release_lock(redis_conn, lock_name, identifier):
            print("Lock released")
else:
    print("Could not acquire lock")

在这个示例中,acquire_lock 函数尝试获取锁,如果在10秒内未能获得锁,则返回Falserelease_lock 函数尝试释放锁,如果锁的标识符匹配,则删除键释放锁。这里使用了UUID生成唯一的锁标识符,避免了由于锁释放出现问题。

2024-08-27

处理Redis中的大Key和热Key问题通常涉及到优化键的设计、监控和预防。以下是一些处理策略和示例代码:

  1. 优化键的设计:

    • 使用带有前缀或命名空间的键,以分隔不同功能或模块的数据。
    • 避免使用大的键,如包含大量数据的哈希或列表。
    • 对于需要过期的数据,设置合理的过期时间。
  2. 监控和预防:

    • 使用Redis的INFO命令和MONITOR命令来监控键的数量和大小。
    • 设置键的最大大小限制,如max-key-size
    • 使用SCAN命令迭代键,而不是KEYS命令,以避免大键查询阻塞服务器。
  3. 代码示例(使用redis-py客户端):



import redis
 
# 连接Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 监控键的数量
info = r.info('keyspace')
print(info)
 
# 使用SCAN迭代键
for key in r.scan_iter("*"):
    print(key)
 
# 设置键的过期时间
r.expire("your_key", 3600)
 
# 设置键的最大大小
# 注意:这需要Redis的配置支持,并且可能需要重启Redis服务
# r.config_set("max-key-size", 1024)

确保在生产环境中测试这些策略,并在必要时对Redis的性能和可用性进行监控。

2024-08-27

Redis中的ZSET(Sorted Set)是一种存储唯一元素并且每个元素都关联一个分数的有序集合。元素的排序依据分数的大小,分数可以重复,但元素不可以。ZSET的实现是基于一种称为跳跃列表(skiplist)的数据结构,并且每个元素都是一个字符串。

ZSET的主要操作包括添加元素、删除元素、获取元素的分数和排名、范围查询等。

以下是一些基本的ZSET操作命令:

  • ZADD key score member: 添加元素到ZSET,如果成功会返回添加的个数。
  • ZREM key member: 删除ZSET中的元素,如果成功会返回1。
  • ZSCORE key member: 获取ZSET中元素的分数。
  • ZRANK key member: 获取ZSET中元素的排名(从0开始)。
  • ZRANGE key start stop [WITHSCORES]: 按照索引范围(按排名)获取元素列表。
  • ZREVRANGE key start stop [WITHSCORES]: 按照索引范围(按分数从大到小)获取元素列表。
  • ZCOUNT key min max: 计算分数在指定范围内的元素个数。

示例代码(使用redis-py客户端):




import redis
 
# 连接Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 添加元素到ZSET
r.zadd('myzset', {'member1': 1, 'member2': 2})
 
# 获取元素的分数
score = r.zscore('myzset', 'member1')
print(score)  # 输出: 1
 
# 获取元素的排名
rank = r.zrank('myzset', 'member1')
print(rank)  # 输出: 0
 
# 获取排名在指定范围内的元素
members = r.zrange('myzset', 0, -1)
print(members)  # 输出: [b'member1', b'member2']
 
# 删除ZSET中的元素
r.zrem('myzset', 'member1')

以上代码展示了如何使用redis-py客户端操作Redis中的ZSET数据结构。

2024-08-27



import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
 
import java.util.concurrent.TimeUnit;
 
public class RedissonLockExample {
 
    public static void main(String[] args) {
        // 配置Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redisson = Redisson.create(config);
 
        // 获取锁对象实例
        RLock lock = redisson.getLock("myLock");
 
        try {
            // 尝试获取锁,最多等待100秒,锁定之后最多持有锁10秒
            boolean isLocked = lock.tryLock(100, 10, TimeUnit.SECONDS);
            if (isLocked) {
                // 业务逻辑
                System.out.println("Lock acquired");
                // 处理完业务逻辑后释放锁
            } else {
                System.out.println("Lock not acquired");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                System.out.println("Lock released");
            }
        }
 
        // 关闭Redisson客户端
        redisson.shutdown();
    }
}

这段代码展示了如何使用Redisson框架来获取和释放分布式锁。它首先配置了Redisson客户端,然后尝试获取名为"myLock"的锁对象。如果在指定的等待时间内成功获取锁,它将执行被锁保护的代码,并在完成后释放锁。最后,它关闭了Redisson客户端以释放资源。这个例子简单明了地展示了如何在Java中使用Redisson进行分布式锁操作。

2024-08-27

以下是在CentOS上安装Docker并使用Docker命令安装MySQL、Redis、MinIO、MongoDB、RabbitMQ、Nacos和Seata的步骤:

  1. 安装Docker:



sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce docker-ce-cli containerd.io
sudo systemctl start docker
sudo systemctl enable docker
  1. 安装MySQL:



sudo docker pull mysql:5.7
sudo docker run --name mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:5.7
  1. 安装Redis:



sudo docker pull redis
sudo docker run --name redis -d redis
  1. 安装MinIO:



sudo docker pull minio/minio
sudo docker run -p 9000:9000 -p 9001:9001 --name minio \
  -e "MINIO_ROOT_USER=minioadmin" \
  -e "MINIO_ROOT_PASSWORD=minioadmin" \
  -v /mnt/data:/data \
  minio/minio server /data --console-address ":9001"
  1. 安装MongoDB:



sudo docker pull mongo
sudo docker run --name mongodb -d -p 27017:27017 mongo
  1. 安装RabbitMQ:



sudo docker pull rabbitmq:3-management
sudo docker run --name rabbitmq -p 5672:5672 -p 15672:15672 -d rabbitmq:3-management
  1. 安装Nacos:



sudo docker pull nacos/nacos-server
sudo docker run --name nacos -e MODE=standalone -p 8848:8848 -d nacos/nacos-server
  1. 安装Seata:



sudo docker pull seataio/seata-server
sudo docker run --name seata-server -p 8091:8091 seataio/seata-server

每个命令都应在CentOS的终端中执行,并确保在执行每个命令之前,您已经安装了Docker并且正在运行。这些命令将会从Docker Hub拉取相应的镜像,并且运行容器。您可以通过访问相应的默认端口来使用这些服务。

2024-08-27

Redis的内存策略主要是指当Redis的内存达到某一个阈值后,它会使用哪些策略来决定如何回收内存中的数据。主要的策略包括:

  1. 全局键替换:Redis会根据一定的策略来替换内存中的某些键,以释放内存。
  2. volatile-lru:从设置了过期时间的键中选择最近最少使用的键进行淘汰。
  3. allkeys-lru:从所有键中选择最近最少使用的键进行淘汰。
  4. volatile-random:从设置了过期时间的键中随机选择一些键进行淘汰。
  5. allkeys-random:从所有键中随机选择一些键进行淘汰。
  6. volatile-ttl:从设置了过期时间的键中选择剩余时间(TTL)最短的键进行淘汰。
  7. noeviction:不进行任何淘汰,当内存不足时,新写入命令会报错。

在配置文件中设置内存策略:




maxmemory-policy allkeys-lru

在运行时动态设置内存策略:




CONFIG SET maxmemory-policy allkeys-lru

在实际应用中,根据业务需求和数据的重要程度,可以选择合适的内存策略以达到最优的内存使用效率。

2024-08-27



import redis
 
# 连接到Redis服务器
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 生产者:往List中插入数据
def produce(list_name, data):
    r.lpush(list_name, data)
 
# 消费者:从List中取出数据
def consume(list_name):
    while True:
        # 使用BLPOP阻塞地从List取出数据,超时时间为5秒
        data = r.blpop(list_name, timeout=5)
        if data:
            # 处理数据
            print(f"消费者取出数据: {data[1].decode()}")
        else:
            # 如果在指定时间内没有数据,循环结束
            print("超时,循环结束")
            break
 
# 测试代码
produce('mylist', 'data1')
produce('mylist', 'data2')
consume('mylist')

这段代码展示了如何使用Redis的List数据结构来实现一个简单的消息队列。生产者使用lpush将数据推入List,消费者使用blpop阻塞地从List取出数据。这里的List用作FIFO(First-In, First-Out)队列,保证了数据处理的顺序。