docker部署redis集群并与springboot整合
一、redis集群部署方案
哨兵模式（Redis Sentinel）
Redis Sentinel 是 Redis 官方提供的高可用性方案，它通过对 Redis 的主从复制功能进行扩展，实现了 Redis 集群的高可用性。
哨兵模式的优点包括：
自动故障转移：当 Redis 主节点出现故障时，哨兵模式可以自动将一个从节点升级为主节点，从而实现自动故障转移。
自动恢复：当 Redis 主节点恢复正常时，哨兵模式可以自动将其重新加入到集群中，从而实现自动恢复。
监控功能：哨兵模式可以监控 Redis 集群中所有节点的状态，包括主节点和从节点，从而实现对 Redis 集群的全面监控。
哨兵模式的缺点包括：
性能损失：哨兵模式需要对 Redis 集群进行频繁的状态检查和故障转移操作，这会对 Redis 集群的性能产生一定的影响。
部署复杂：哨兵模式需要部署多个哨兵节点来实现高可用性，这会增加部署的复杂度。
因此，哨兵模式适用于对 Redis 集群的高可用性要求比较高的场景，但需要注意其对性能和部署复杂度的影响。如果对性能和部署复杂度要求较高，可以考虑使用其他的 Redis 集群方案，比如 Redis Cluster。
Redis Cluster
在项目中最常用的 Redis 集群部署方式是 Redis Cluster。Redis Cluster 是 Redis 官方提供的 Redis 集群方案，它通过对 Redis 的源码进行修改，实现了 Redis 集群的分布式功能。在 Redis Cluster 中，每个节点都可以处理读写请求，同时还可以将数据自动分片到不同的节点上，从而实现了 Redis 集群的高可用性和扩展性。
Redis Cluster 的优点包括：
高可用性：Redis Cluster 可以将数据自动分片到不同的节点上，从而实现了 Redis 集群的高可用性。当某个节点出现故障时，Redis Cluster 可以自动将请求转发到其他节点上，从而实现自动故障转移。
扩展性：Redis Cluster 可以将数据自动分片到不同的节点上，从而实现了 Redis 集群的扩展性。当需要扩展 Redis 集群的容量时，只需要增加节点即可，无需对现有节点进行修改。
性能：Redis Cluster 可以将读写请求分散到不同的节点上，从而实现了 Redis 集群的负载均衡。同时，Redis Cluster 还可以将数据自动分片到不同的节点上，从而实现了 Redis 集群的并行处理能力，从而提高了 Redis 集群的性能。
Redis Cluster 的缺点包括：
部署复杂：Redis Cluster 需要部署多个节点来实现高可用性和扩展性，这会增加部署的复杂度。
数据一致性：Redis Cluster 采用的是无中心化的分布式架构，因此在节点之间进行数据同步时，可能会出现数据不一致的情况。Redis Cluster 采用了 Gossip 协议来解决数据同步的问题。
二、docker部署Redis Cluster集群
安装docker参考官网https://docs.docker.com/desktop/install/linux-install/
我使用的是CentOS-7-x86_64-DVD-2009.iso
关闭防火墙
systemctl stop firewalld
systemctl disable firewalld设置固定ip
cd /etc/sysconfig/network-scripts
ll
vim ifcfg-ens33修改（有的修改，没有的添加）
BOOTPROTO=static
IPADDR="192.168.10.11"
NETMASK="255.255.255.0"
GATEWAY="192.168.10.1"
DNS1="114.114.114.114"重启网关
systemctl restart network拉取镜像
docker pull redis:6.2.10
主节点 |
从节点 |
|
第一集群 |
192.168.10.11:6379 |
192.168.10.12:6380 |
第二集群 |
192.168.10.12:6379 |
192.168.10.13:6380 |
第三集群 |
192.168.10.13:6379 |
192.168.10.11:6380 |
编写docker-compose.yml文件
主节点
version: '3.1'
services:
redis-master:
image: redis:6.2.10 # 创建容器时所需的镜像
container_name: redis-master # 服务名称
restart: always # 容器总是重新启动
network_mode: "host" # host 网络模式
command: redis-server /usr/local/etc/redis/redis.conf # 覆盖容器启动后默认执行的命令
volumes: # 数据卷，目录挂载
- ./redis.conf:/usr/local/etc/redis/redis.conf
- ./data:/data
ports:
- "6379:6379"
- "16379:16379"准备redis.conf文件
可自行在官网下载，需要修改的属性有如下：
port 6379 #端口，默认是6379
bind 0.0.0.0 #监听的IP，默认是本地127.0.0.1
protected-mode no #保护模式默认是开启状态，需要修改为no
cluster-enabled yes #开启集群
cluster-config-file nodes.conf #集群的配置
cluster-node-timeout 5000 #请求超时默认15秒，可自行设置
appendonly yes #开启aof持久化
requirepass ****** #密码
masterauth *****
daemonize no #开启守护线程，默认为no，可不开启执行docker compose up -d
从节点
version: '3.1'
services:
redis-master:
image: redis:6.2.10 # 创建容器时所需的镜像
container_name: redis-slave # 服务名称
restart: always # 容器总是重新启动
network_mode: "host" # host 网络模式
command: redis-server /usr/local/etc/redis/redis.conf # 覆盖容器启动后默认执行的命令
volumes: # 数据卷，目录挂载
- ./redis.conf:/usr/local/etc/redis/redis.conf
- ./data:/data
ports:
- "6380:6380"
- "16380:16380"准备redis.conf文件
可自行在官网下载，需要修改的属性有如下：
port 6380 #端口，默认是6379
bind 0.0.0.0 #监听的IP，默认是本地127.0.0.1
protected-mode no #保护模式默认是开启状态，需要修改为no
cluster-enabled yes #开启集群
cluster-config-file nodes.conf #集群的配置
cluster-node-timeout 5000 #请求超时默认15秒，可自行设置
appendonly yes #开启aof持久化
requirepass ****** #密码
masterauth *****
daemonize no #开启守护线程，默认为no，可不开启执行docker compose up -d
请先确保你的两台机器可以互相通信，然后随便进入一个容器节点，并进入 /usr/local/bin/ 目录：
# 进入容器
docker exec -it redis-master bash
# 切换至指定目录
cd /usr/local/bin/接下来我们就可以通过以下命令实现 Redis Cluster 集群的创建
redis-cli -a ***** --cluster create 192.168.10.11:6379 192.168.10.11:6380 192.168.10.12:6379 192.168.10.12:6380 192.168.10.13:6379 192.168.10.13:6380 --cluster-replicas 1*****对应密码
出现选择提示信息，输入 yes，结果如下所示：
成功后显示
可参考：https://www.cnblogs.com/pgyLang/p/16253803.html
三、springboot整合Redis Cluster集群
引入Redis依赖
org.springframework.boot
spring-boot-starter-data-redis
org.apache.commons
commons-pool2
编写配置文件
spring:
redis:
password: ****** #密码
lettuce: #lettuce连接池配置
pool:
max-active: 8
max-idle: 8
min-idle: 0
max-wait: 1000
shutdown-timeout: 100
cluster: #集群配置
nodes: 192.168.10.11:6379,192.168.10.11:6380,192.168.10.12:6379,192.168.10.12:6380,192.168.10.13:6379,192.168.10.13:6380
max-redirects: 3编写启动项
@Configuration
public class RedisCacheAutoConfiguration extends CachingConfigurerSupport {
@Value("${spring.redis.cluster.nodes}")
private String nodes;
@Value("${spring.redis.password}")
private String password;
//redis集群配置,6个ip以,分割，然后再以:分割
@Bean
public RedisClusterConfiguration redisClusterConfiguration(){
RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
String[] cNodes = nodes.split(",");
Set hp = new HashSet<>();
for (String node : cNodes) {
String[] split = node.split(":");
hp.add(new RedisNode(split[0].trim(),Integer.parseInt(split[1])));
}
redisClusterConfiguration.setPassword(password);
redisClusterConfiguration.setClusterNodes(hp);
return redisClusterConfiguration;
}
/**
* 注入RedisTemplate
* tips：泛型可以适用于各种类型的注入
*/
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory, RedisSerializer redisSerializer) {
// 指定序列化方式
RedisTemplate redisTemplate = new RedisTemplate<>();
redisTemplate.setKeySerializer(RedisSerializer.string());
redisTemplate.setHashKeySerializer(RedisSerializer.string());
redisTemplate.setValueSerializer(redisSerializer);
redisTemplate.setHashValueSerializer(redisSerializer);
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
/**
* 初始化Redis序列器，使用jackson
*/
@Bean
public RedisSerializer 编写工具类
@Component
public final class RedisClient {
@Autowired
private RedisTemplate redisTemplate;
/**
* 指定缓存失效时间
* (命令EXPIRE)
*
* @param key 键
* @param time 时间（秒）
* @param timeUnit 时间单位
* @return true / false
*/
public boolean expire(String key, long time, TimeUnit timeUnit) {
if (time > 0) {
return redisTemplate.expire(key, time, timeUnit);
}
return false;
}
/**
* 根据 key 获取过期时间
* (命令TTL)
*
* @param key 键
* @return 秒
*/
public long ttl(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断 key 是否存在
* (命令EXISTS)
*
* @param key 键
* @return true / false
*/
public boolean exists(String key) {
return redisTemplate.hasKey(key);
}
/**
* 删除缓存(不存在key不会抛异常)
* (命令 DEL)
*
* @param keys 集合
*/
public long delete(Collection keys) {
return redisTemplate.delete(keys);
}
/**
* 删除缓存
* (命令DEL)
*
* @param key 键（一个或者多个）
*/
public boolean delete(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
return redisTemplate.delete(key[0]);
} else {
return redisTemplate.delete(Arrays.asList(key)) > 0;
}
}
return true;
}
/**
* 按表达式删除缓存，使用scan命令实现，不会有太多性能影响
*
* @param pattern 表达式
*/
public long deleteAll(String pattern) {
if (pattern == null || pattern.length() == 0) {
throw new IllegalArgumentException("参数不正确");
}
return redisTemplate.delete(scan(pattern));
}
/**
* 查询所有满足表达式的key
* （命令KEYS，实际是利用SCAN命令实现，不会产生阻塞）
*
* @param pattern 表达式
* @return 符合表达式的key的集合
* @complexity O(n)
*/
public Set scan(String pattern) {
if (pattern == null || pattern.length() == 0) {
throw new IllegalArgumentException("参数不正确");
}
return redisTemplate.execute((RedisCallback>) connection -> {
Set keys = new HashSet<>();
Cursor cursor = connection.scan(ScanOptions.scanOptions().match(pattern).count(1000).build());
while (cursor.hasNext()) {
keys.add(new String(cursor.next()));
}
return keys;
}
);
}
// ============================== String ==============================
/**
* 放入缓存
* (命令 SET)
*
* @param key 键
* @param value 值
*/
public void set(String key, Object value, long timeout, TimeUnit timeUnit) {
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 放入缓存
* (命令 SET)
*
* @param key 键
* @param value 值
*/
public void set(String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 获取缓存（string数据结构） 通过泛型T指定缓存数据类型
* (命令 GET)
*
* @param key 键
* @return 值
* @see #hGetAll
*/
public T get(String key) {
return key == null ? null : (T) redisTemplate.opsForValue().get(key);
}
/**
* 获取缓存（string数据结构） 通过泛型T指定缓存数据类型
* (命令 GETSET)
*
* @param key 键
* @return 值
* @see #hGetAll
*/
public T getSet(String key, T newValue) {
return key == null ? null : (T) redisTemplate.opsForValue().getAndSet(key, newValue);
}
/**
* 缓存普通键值对，并设置失效时间
*
* @param key 键
* @param value 值
* @param seconds 时间（秒），如果 time <= 0 则不设置失效时间
*/
public void set(String key, Object value, int seconds) {
if (seconds > 0) {
redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
} else {
redisTemplate.opsForValue().set(key, seconds);
}
}
/**
* 当key不存在时放入键值对
* 如果已经存在key返回false
*
* @param key 键
* @param value 值
* @return true/false
*/
public boolean setNx(String key, Object value) {
return redisTemplate.opsForValue().setIfAbsent(key, value);
}
/**
* 当key不存在时放入键值对，并在指定时间后自动删除
* 如果已经存在key返回false
*
* @param key 键
* @param value 值
* @param time 时间
* @param timeUnit 时间单位
* @return true/false
*/
public boolean setNx(String key, Object value, long time, TimeUnit timeUnit) {
return redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
}
/**
* 递增
* 如果不存在key将自动创建
* (命令INCR)
*
* @param key 键
* @param increment 递增大小
* @return 递增后的值
*/
@SuppressWarnings("unchecked")
public T increment(String key, T increment) {
return (T) redisTemplate.opsForValue().increment(key, increment.doubleValue());
}
/**
* 递增1
* 如果不存在key将自动创建
* (命令INCR)
*
* @param key 键
* @return 递增后的值
*/
public long increment(String key) {
return redisTemplate.opsForValue().increment(key, 1);
}
/**
* 递减
* 如果不存在key将自动创建
* (命令DECR)
*
* @param key 键
* @param decrement 递减大小
* @return 递减后的值
*/
@SuppressWarnings("unchecked")
public T decrement(String key, T decrement) {
return (T) redisTemplate.opsForValue().increment(key, -decrement.longValue());
}
/**
* 递减1
* 如果不存在key将自动创建
* (命令DECR)
*
* @param key 键
* @return 递减后的值
*/
public long decrement(String key) {
return decrement(key, 1L);
}
// ============================== Map ==============================
/**
* 往指定HashMap中添加一对键值对，key不存在将自动创建
* (命令HSET)
*
* @param name HashMap的名字
* @param key 添加的键
* @param value 添加的值
*/
public void hSet(String name, String key, Object value) {
redisTemplate.opsForHash().put(name, key, value);
}
/**
* 往指定HashMap中添加另一个map
* (命令HSET)
*
* @param name HashMap的名字
* @param map 值
*/
public void hSet(String name, Map map) {
redisTemplate.opsForHash().putAll(name, map);
}
/**
* 从指定HashMap中获取指定key的值
* （命令HGET）
*
* @param mapName HashMap的名字（no null）
* @param key HashMap中的键（no null）
* @param 根据实际类型自定义
* @return 值
*/
@SuppressWarnings("unchecked")
public T hGet(String mapName, String key) {
return (T) redisTemplate.opsForHash().get(mapName, key);
}
/**
* 从指定HashMap中获取多个key的值
* （命令HMGET）
*
* @param mapName HashMap的名字（no null）
* @param key HashMap中的键，传多个（no null）
* @param 根据实际类型自定义
* @return list
*/
public List hMultiGet(String mapName, String... key) {
return redisTemplate.opsForHash().multiGet(mapName, Arrays.asList(key));
}
/**
* 获取指定的HashMap
* （命令HGETALL）
*
* @param mapName HashMap的名字（no null）
* @return HashMap
*/
public Map hGetAll(String mapName) {
return redisTemplate.opsForHash().entries(mapName);
}
/**
* 删除 HashMap 中的值
* (命令HDEL)
*
* @param mapName HashMap的名字
* @param keys HashMap中的key（可以多个，no null）
* @return 成功删除个数
*/
public long hDelete(String mapName, Object... keys) {
return redisTemplate.opsForHash().delete(mapName, keys);
}
/**
* map 递增1
* (命令 HINCRBY)
*
* @param hashMapName HashMap的名字（no null）
* @param key HashMap中的key（no null）
* @return true / false
*/
public long hIncrement(String hashMapName, String key) {
return redisTemplate.opsForHash().increment(hashMapName, key, 1);
}
/**
* map 递增指定值
* (命令 HINCRBY)
*
* @param hashMapName HashMap的名字（no null）
* @param key HashMap中的key（no null）
* @return true / false
*/
public Long hIncrementBy(String hashMapName, String key, long delta) {
return redisTemplate.opsForHash().increment(hashMapName, key, delta);
}
/**
* 是否存在hashkey
* (命令 HEXISTS)
*
* @param hashMapName HashMap的名字（no null）
* @param hashKey HashMap中的key（no null）
* @return true / false
*/
public boolean hExists(String hashMapName, Object hashKey) {
return redisTemplate.opsForHash().hasKey(hashMapName, hashKey);
}
/**
* 设置map中的值，只有当key不存在时，才能设置成功
* (命令 HSETNX)
*
* @param hashMapName HashMap的名字
* @param value value（no null）
* @return true / false
*/
public boolean hSetNx(String hashMapName, String key, Object value) {
return redisTemplate.opsForHash().putIfAbsent(hashMapName, key, value);
}
/**
* 获取map的大小
* (命令 HLEN)
*
* @param hashMapName HashMap的名字
* @return map size
*/
public Long hSize(String hashMapName) {
return redisTemplate.opsForHash().size(hashMapName);
}
/**
* 获取map中的所有key
* (命令 HKEYS)
*
* @param hashMapName HashMap的名字
* @return all keys
*/
public Set hKeys(String hashMapName) {
return redisTemplate.opsForHash().keys(hashMapName);
}
/**
* 获取map中的所有value
* (命令 HVALS)
*
* @param hashMapName HashMap的名字
* @return all values
*/
public List hValues(String hashMapName) {
return redisTemplate.opsForHash().values(hashMapName);
}
// ============================== zset ==============================
/**
* 添加zset元素 有则覆盖
*
* @param key
* @param v
* @param score
* @return
*/
public boolean zAdd(String key, T v, long score) {
return redisTemplate.opsForZSet().add(key, v, score);
}
/**
* 批量添加zset元素
* (命令 ZADD)
*
* @param key
* @param tuples
* @return
*/
public Long zAdd(String key, Set> tuples) {
return redisTemplate.opsForZSet().add(key, tuples);
}
/**
* 移除指定位置的zset元素
* (命令 ZREVRANGE)
*
* @param key
* @param start
* @param end
* @return
*/
public Long zRemoveRange(String key, long start, long end) {
return redisTemplate.opsForZSet().removeRange(key, start, end);
}
/**
* 添加zset元素 有则覆盖
* (命令 ZREM)
*
* @param key
* @return
*/
public Long zRemove(String key, Object... vs) {
return redisTemplate.opsForZSet().remove(key, vs);
}
/**
* zset 元素个数
* (命令 ZCARD)
*
* @param key
* @return
*/
public Long zSize(String key) {
return redisTemplate.opsForZSet().size(key);
}
/**
* zset中是否存在对应元素
*
* @param key
* @param v
* @return
*/
public boolean zExists(String key, T v) {
return redisTemplate.opsForZSet().rank(key, v) != null;
}
/**
* 自增zset score
* (命令 ZINCRBY)
*
* @param key
* @param v
* @param delta
* @return
*/
public Double zIncrementBy(String key, T v, Double delta) {
return redisTemplate.opsForZSet().incrementScore(key, v, delta);
}
/**
* 获取指定key的所有元素
*
* @param key
* @param
* @return
*/
public LinkedHashSet zAll(String key) {
return (LinkedHashSet) redisTemplate.opsForZSet().range(key, 0, -1);
}
/**
* 获取指定位置元素
*
* @param key
* @param index
* @param
* @return
*/
public T zGet(String key, int index) {
Set 测试
@SpringBootTest
class TestApplicationTests {
@Autowired
private RedisClient redisClient;
@Test
void contextLoads() {
List students = new ArrayList<>();
Student student1 = new Student("java", 22, "Chinese");
Student student2 = new Student("go", 11, "USA");
Student student3 = new Student("js", 20, "Japan");
Student student4 = new Student("python", 16, "Thailand");
Student student5 = new Student("php", 33, "Chinese");
Student student6 = new Student("php", 16, "Chinese");
Student student7 = new Student("java", 16, "Thailand");
students.add(student1);
students.add(student2);
students.add(student3);
students.add(student4);
students.add(student5);
students.add(student6);
students.add(student7);
redisClient.set("student", students);
}
} 结果显示
