在Redis中，您可以使用EXPIRE命令来设置键的过期时间，该命令接受两个参数：键名和过期时间（以秒为单位）。还可以使用PEXPIRE命令设置以毫秒为单位的过期时长。
例如，要设置一个键mykey在300秒后过期，可以执行以下命令：
EXPIRE mykey 300如果您想要设置具体的过期时间点（UNIX时间戳表示），可以使用EXPIREAT命令，该命令接受键名和UNIX时间戳（秒为单位）作为参数。
另外，SETEX命令可以在设置键的值的同时设置过期时间（秒），例如：
SETEX mykey 300 "value"如果需要以毫秒设置过期时间，可以使用PSETEX命令：
PSETEX mykey 300000 "value"要检查键的剩余生存时间，可以使用TTL命令查看键的剩余时间（秒），或者使用PTTL查看剩余时间（毫秒）。
TTL mykey
PTTL mykey如果想要删除键的过期时间使其变成永久的，可以使用PERSIST命令：
PERSIST mykeyRedis 是一个开源的使用 C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。
Redis 与其他数据库解决方案的不同之处在于它支持的存储值的类型相对更多，如字符串、列表、集合、有序集合、哈希表等。
Redis 支持数据的持久化，可以将内存中的数据保存在硬盘中，重启的时候可以再次加载进行使用。
Redis 不仅提供了 Python，Ruby，Erlang 等操作接口，而且支持客户端分片和复制，这使得 Redis 能够为较大的应用提供服务。
Redis 的主要优势在于其速度和易用性，它是高性能应用的理想选择。
分布式系统是由一组计算机组成，这些计算机在网络中相互连接，它们共享资源，并且根据某种策略协同工作。
分布式系统的主要优点包括：
以下是一个简单的 Python 示例，演示如何使用 redis-py 客户端与 Redis 进行交互：
import redis
# 连接到 Redis
r = redis.Redis(host='localhost', port=6379, db=0)
# 设置键值对
r.set('foo', 'bar')
# 获取键的值
print(r.get('foo'))在这个例子中，我们首先导入了 redis 模块，然后创建了一个 Redis 对象来连接到运行在本地的 Redis 服务器。然后我们使用 set 方法来设置一个键值对，使用 get 方法来获取一个键的值。
注意：在运行这个例子之前，你需要确保 Redis 服务器正在运行，并且 Python 环境中已经安装了 redis 模块，可以通过 pip install redis 命令来安装。
由于原代码中存在的问题较多，以下是一个简化版的示例，展示如何在CentOS 7上使用Docker部署Redis集群，以及如何使用Docker打包Spring Boot微服务。
# 安装Docker
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce
sudo systemctl start docker && sudo systemctl enable docker
# 部署Redis集群
# 创建Redis配置文件目录
mkdir -p /etc/redis
# 创建Redis集群配置文件
for port in `seq 7000 7005`; do
cat << EOF > /etc/redis/${port}.conf
port ${port}
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly.aof"
dbfilename dump.rdb
dir /data
EOF
done
# 创建并启动Redis容器
for port in `seq 7000 7005`; do
docker run -d --name redis-${port} \
-v /etc/redis/${port}.conf:/usr/local/etc/redis/redis.conf \
-v /var/redis/${port}:/data \
-p ${port}:${port} \
redis redis-server /usr/local/etc/redis/redis.conf
done
# 使用Redis Cluster命令创建集群
docker run -it --rm --net=host redis redis-cli --cluster create \
$(for port in `seq 7000 7005`; do echo -n "127.0.0.1:${port} "; done) \
--cluster-replicas 1
# 打包Spring Boot微服务
# 假设你的Spring Boot项目名为myapp
cd /path/to/myapp
./mvnw clean package -Dmaven.test.skip=true
# 创建Dockerfile
echo "FROM openjdk:8-jdk-alpine
ADD target/myapp.jar /app.jar
CMD ["java", "-jar", "/app.jar"]
EXPOSE 8080" > Dockerfile
# 构建Docker镜像
docker build -t myapp .
# 运行微服务容器
docker run -d -p 8080:8080 --name myapp-instance myapp这个示例展示了如何简洁地使用Docker命令在CentOS 7上部署Redis集群和打包Spring Boot微服务。注意，这里的Redis Cluster创建命令需要根据实际的IP地址和端口进行调整。
为了实现Redis两台服务器间的主从自动切换高可用，你可以使用Redis Sentinel。以下是配置Redis Sentinel的基本步骤：
配置Redis主服务器（Master）:
编辑 redis.conf 文件，确保有如下设置：
port 6379
bind your-master-ip配置Redis从服务器（Slave）:
编辑 redis.conf 文件，确保有如下设置：
port 6379
bind your-slave-ip
slaveof your-master-ip 6379配置Redis Sentinel:
创建 sentinel.conf 文件，并添加以下内容：
port 26379
dir /tmp
sentinel monitor mymaster your-master-ip 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000其中 mymaster 是主节点的名字，可以自定义；your-master-ip 是主服务器的IP地址；5000 是判断主服务器失效的毫秒数；180000 是故障转移的超时时间。
启动Redis Sentinel:
在Sentinel配置文件所在目录下运行：
redis-sentinel sentinel.conf当主服务器出现故障时，Sentinel会自动将从服务器提升为新的主服务器，并重新配置其他从服务器以复制新的主服务器。这个过程是自动的，不需要人工干预。
import redis
# 假设已经有了Redis连接对象`redis_conn`
class FansService:
def __init__(self, redis_conn):
self.redis_conn = redis_conn
def add_fans(self, user_id, fans_id):
"""为用户添加粉丝"""
key = f"user:{user_id}:fans"
self.redis_conn.sadd(key, fans_id)
def remove_fans(self, user_id, fans_id):
"""为用户移除粉丝"""
key = f"user:{user_id}:fans"
self.redis_conn.srem(key, fans_id)
def get_fans(self, user_id):
"""获取用户的粉丝ID列表"""
key = f"user:{user_id}:fans"
return self.redis_conn.smembers(key)
def get_followers(self, user_id):
"""获取用户的关注者ID列表"""
key = f"user:{user_id}:followers"
return self.redis_conn.smembers(key)
# 使用示例
# 假设`redis_conn`是已经连接到Redis的对象
redis_conn = redis.StrictRedis(host='localhost', port=6379, db=0)
fans_service = FansService(redis_conn)
# 添加粉丝
fans_service.add_fans('user123', 'fans456')
# 获取粉丝列表
fans_list = fans_service.get_fans('user123')
print(fans_list) # 输出粉丝ID的集合这个代码示例展示了如何使用Redis的Set数据结构来实现用户粉丝的关注与取关功能。代码中的FansService类封装了与粉丝关系相关的操作，通过Redis连接对象与Redis服务器进行交互。使用时，首先创建FansService的实例，然后调用相应的方法来管理用户的粉丝关系。
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 RedisDistributedLockExample {
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("lockKey");
try {
// 尝试获取锁，最多等待100秒，锁定之后最多持有锁10秒
boolean isLocked = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (isLocked) {
// 业务逻辑
System.out.println("获取锁成功，执行业务逻辑");
// 模拟耗时操作
Thread.sleep(2000);
} else {
// 获取锁失败
System.out.println("获取锁失败，其他线程已获取锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放锁
if (lock.isHeldByCurrentThread()) {
lock.unlock();
System.out.println("锁已释放");
}
}
// 关闭Redisson客户端
redisson.shutdown();
}
}这段代码使用Redisson框架模拟了一个简单的抢单操作。它首先配置了Redisson客户端，然后尝试获取名为"lockKey"的锁。如果在指定的等待时间内获取到锁，则执行业务逻辑，并在完成后释放锁；如果未能获取锁，则输出相应信息，并在最后确保释放了Redisson客户端资源。
在Spring Boot中配置Redis的StringRedisTemplate和RedisTemplate通常涉及到序列化器的配置，因为Redis需要将Java对象转换为字节流以便存储。以下是一个配置示例：
@Configuration
public class RedisConfig {
@Bean
public LettuceConnectionFactory redisConnectionFactory() {
return new LettuceConnectionFactory(); // 配置你的Redis连接信息
}
@Bean
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory connectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
template.afterPropertiesSet();
return template;
}
@Bean
public StringRedisTemplate stringRedisTemplate(LettuceConnectionFactory connectionFactory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(connectionFactory);
return template;
}
}在这个配置中，我们定义了两个Bean：redisTemplate和stringRedisTemplate。redisTemplate使用GenericJackson2JsonRedisSerializer作为值的序列化器，这意味着我们可以存储任何可以被Jackson序列化的对象。StringRedisTemplate仅用于存储字符串。
请根据你的项目需求和环境（例如使用的序列化库和连接池）来调整配置细节。
在Spring Data Redis中，RedisTemplate提供了对Redis数据结构的操作支持。默认情况下，RedisTemplate使用JdkSerializationRedisSerializer作为默认的序列化器。但是，这种方式可能会有性能问题和兼容性问题。
为了提高性能和兼容性，通常建议使用更有效的序列化方法，如Jackson JSON序列化器或者使用更轻量级的序列化器如StringRedisSerializer和GenericJackson2JsonRedisSerializer。
以下是如何配置RedisTemplate以使用Jackson JSON序列化器的示例：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>YourJacksonVersion</version>
</dependency>RedisTemplate以使用Jackson作为序列化器：
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 使用Jackson2JsonRedisSerializer来序列化和反序列化对象
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
// 配置序列化和反序列化的方式
template.setDefaultSerializer(jackson2JsonRedisSerializer);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}在这个配置中，我们使用Jackson2JsonRedisSerializer来序列化和反序列化存储在Redis中的对象。同时，我们将键和哈希键序列化为StringRedisSerializer以确保它们是有效的Redis键。
这样配置后，你就可以使用RedisTemplate来操作Redis，并且它会使用Jackson来序列化和反序列化对象了。
Redis 高可用性通常通过哨兵(Sentinel)模式来实现。哨兵是Redis的高可用性解决方案：它是一个分布式系统，可以监控主服务器和其从服务器，并在主服务器下线时自动进行故障转移。
以下是一个基本的哨兵配置实例：
首先，配置一个基本的Redis主服务器（redis.conf）：
bind 0.0.0.0
port 6379然后，配置一个或多个Redis从服务器（redis.conf），指向主服务器：
slaveof <master-ip> <master-port>接下来，设置哨兵配置（sentinel.conf）：
sentinel monitor mymaster <master-ip> <master-port> 2
sentinel down-after-milliseconds mymaster 3000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000在这个配置中：
sentinel monitor mymaster <master-ip> <master-port> 2 指定主服务器和监控它的哨兵数量。sentinel down-after-milliseconds mymaster 3000 指定如果3秒内无法联系主服务器，则认为主服务器已下线。sentinel parallel-syncs mymaster 1 指定在故障转移期间，可以有几个从服务器同时进行同步。sentinel failover-timeout mymaster 180000 指定故障转移的超时时间。启动哨兵：
redis-sentinel /path/to/sentinel.conf启动Redis服务器：
redis-server /path/to/redis.conf当主服务器不可用时，哨兵会选举一个从服务器作为新的主服务器，并将其他的从服务器配置为指向新的主服务器。这个过程是自动的，并且对于最终用户是透明的。
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
// 序列化value的时候使用jackson
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
}这段代码定义了一个配置类RedisConfig，其中创建了一个RedisTemplate的Bean实例，并设置了key和value的序列化方式。这样，在Spring Boot应用中，你就可以通过依赖注入来注入这个RedisTemplate，进而使用Redis来存储和检索数据。