前言
一般的小项目，比如几百人左右访问的项目，访问量几万的项目，如果想用缓存，单机实例完全够用。小黄图就是用的阿里云256MB配置的Redis缓存，日几千的访问量是妥妥够用的了。
Redis号称可以支撑10w+qps，当然这也给机器配置有一定的关系，如果单实例满足不了需求，想追求更高的性能和稳定性，可以选择主从、哨兵已经更好的解决方案Redis-Cluster 集群。
架构
集群部署
如题，我们这里直接使用 Redis-Cluster 高可用集群。
Redis-Cluster集群采用无中心结构,它的特点如下：
所有的redis节点彼此互联(PING-PONG机制)，内部使用二进制协议优化传输速度和带宽。
节点的fail是通过集群中超过半数的节点检测失效时才生效。
客户端与redis节点直连，不需要中间代理层，客户端不需要连接集群所有节点，连接集群中任何一个可用节点即可。
生产环境redis集群至少需要一个备份节点，才能更好的保证集群的高可用。一个集群里面有 M1-S1、M2-S2、M3-S3 六个主从节点，其中节点 M1 包含 0-5500号哈希槽，节点 M2 包含5501-11000 号哈希槽，节点 M3 包含11001-16384号哈希槽。如果是 M1 宕掉，集群便会选举S1 为新节点继续服务，整个集群还会正常运行。当 M1、S1 都宕掉了，这时候集群就不可用了。
建议使用至少六台单独的服务器进行部署，这里为了搭建方便，撸主在一台服务器上进行实操。
下载最新版本：
wget http://download.redis.io/releases/redis-6.0.5.tar.gz
升级基础组件，否则编译安装会报错：
# 升级到gcc 9.3：
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
scl enable devtoolset-9 bash
# 需要注意的是scl命令启用只是临时的，退出shell或重启就会恢复原系统gcc版本。
# 如果要长期使用gcc 9.3的话：
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile
编译安装：
make && make install
创建集群配置：
mkdir redis-cluster
创建集群文件夹，然后在该文件夹下创建6个文件，同redis.conf配置一致，7001.conf、7002.conf、7003.conf、7004.conf、7005.conf、7006.conf
然后修改各个配置：
port 700x // 端口700X
bind 内网ip // 需要改为其他节点机器可访问的ip 否则创建集群时无法访问对应的端口，无法创建集群
daemonize yes // redis后台运行
pidfile /var/run/redis_700x.pid // pidfile文件对应7001,7002
cluster-enabled yes // 开启集群 把注释#去掉
cluster-config-file nodes_700x.conf // 集群的配置 配置文件首次启动自动生成 7001,7002
cluster-node-timeout 15000 // 请求超时 默认15秒，可自行设置
appendonly yes // # AOF 持久化，按需要选择是否开启
启动服务：
redis-server ../redis-cluster/7001.conf
redis-server ../redis-cluster/7002.conf
redis-server ../redis-cluster/7003.conf
redis-server ../redis-cluster/7004.conf
redis-server ../redis-cluster/7005.conf
redis-server ../redis-cluster/7006.conf
创建集群：
--replicas参数指定集群中每个主节点配备几个从节点，这里设置为1。
redis-cli --cluster create 172.17.1.218:7001 172.17.1.218:7002 172.17.1.218:7003 172.17.1.218:7004 172.17.1.218:7005 172.17.1.218:7006 --cluster-replicas 1
查看集群：
redis-cli --cluster check 172.17.1.218:7001
172.17.1.218:7002 (406a1d6e...) -> 0 keys | 5461 slots | 1 slaves.
172.17.1.218:7003 (85df8dc9...) -> 0 keys | 5462 slots | 1 slaves.
172.17.1.218:7004 (54f13720...) -> 2 keys | 5461 slots | 1 slaves.
[OK] 2 keys in 3 masters.
0.00 keys per slot on average.
>>> Performing Cluster Check (using node 172.17.1.218:7001)
S: 2d589d0077771ca9a7b2909b351e350aa69bea45 172.17.1.218:7001
slots: (0 slots) slave
replicates 54f13720da944d3dcc75351c4042fcaf3b2300e0
M: 406a1d6e9bcc760501c6b8f71f9151e020b247bd 172.17.1.218:7002
slots:[10923-16383] (5461 slots) master
1 additional replica(s)
S: e52eda05e4df779e15437f7f42522459a3e26b27 172.17.1.218:7005
slots: (0 slots) slave
replicates 85df8dc9b649e02740fa0f932aa1df135d44953e
M: 85df8dc9b649e02740fa0f932aa1df135d44953e 172.17.1.218:7003
slots:[5461-10922] (5462 slots) master
1 additional replica(s)
M: 54f13720da944d3dcc75351c4042fcaf3b2300e0 172.17.1.218:7004
slots:[0-5460] (5461 slots) master
1 additional replica(s)
S: 60f49255085936fbcf682bafc81319f9393150c9 172.17.1.218:7006
slots: (0 slots) slave
replicates 406a1d6e9bcc760501c6b8f71f9151e020b247bd
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
从集群信息，我们可以看出有三组主从关系：
7004(主)-7001(从)
7003(主)-7005(从)
7002(主)-7006(从)
其实一开始7001是主，为了测试主从切换，把7001杀掉，由7004接管，然后重启7001变为从服务。
整合
pom.xml 引入：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
配置文件 bootstrap.yml：
spring:
redis:
timeout: 30000
password: 123456
cluster:
nodes:
- 172.17.1.218:7001
- 172.17.1.218:7002
- 172.17.1.218:7003
- 172.17.1.218:7004
- 172.17.1.218:7005
- 172.17.1.218:7006
max-redirects: 3
lettuce:
max-active: 1000
max-idle: 10
max-wait: -1
min-idle: 5
开发者可以对 RedisTemplate 进行一个简单的封装成 RedisUtil ，可参考下面的缓存工具类。
小结
这就是微服务版本的 Redis 高可用集群，是不是有点简单。不过，生产环境建议配置内网地址，开启防火墙，配置必要的鉴权访问机制，这玩意一旦被嗅探到可以会被老板扣工资的。还有一点，一定要搭建有效的监控预警系统，这样可以针对性的对其进行扩容、修复。
package com.tools.common.util;
import net.coobird.thumbnailator.Thumbnails;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* redisTemplate封装
* 爪哇笔记：https://blog.52itstyle.vip
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public static String PREFIX = "cloud:bed:";
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key,long time){
try {
if(time>0){
redisTemplate.expire(PREFIX+key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key){
return redisTemplate.getExpire(PREFIX+key,TimeUnit.SECONDS);
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(PREFIX+key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String ... key){
if(key!=null&&key.length>0){
if(key.length==1){
redisTemplate.delete(PREFIX+key[0]);
}else{
redisTemplate.delete(CollectionUtils.arrayToList(PREFIX+key));
}
}
}
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
public Object get(String key){
return PREFIX+key==null?null:redisTemplate.opsForValue().get(PREFIX+key);
}
/**
* 普通缓存放入
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key,Object value) {
try {
redisTemplate.opsForValue().set(PREFIX+key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key,Object value,long time){
try {
if(time>0){
redisTemplate.opsForValue().set(PREFIX+key, value, time, TimeUnit.SECONDS);
}else{
set(PREFIX+key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta){
if(delta<0){
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(PREFIX+key, delta);
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta){
if(delta<0){
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(PREFIX+key, -delta);
}
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key,String item){
return redisTemplate.opsForHash().get(PREFIX+key, item);
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object,Object> hmget(String key){
return redisTemplate.opsForHash().entries(PREFIX+key);
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String,Object> map){
try {
redisTemplate.opsForHash().putAll(PREFIX+key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String,Object> map, long time){
try {
redisTemplate.opsForHash().putAll(PREFIX+key, map);
if(time>0){
expire(PREFIX+key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key,String item,Object value) {
try {
redisTemplate.opsForHash().put(PREFIX+key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key,String item,Object value,long time) {
try {
redisTemplate.opsForHash().put(PREFIX+key, item, value);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item){
redisTemplate.opsForHash().delete(PREFIX+key,item);
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item){
return redisTemplate.opsForHash().hasKey(PREFIX+key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item,double by){
return redisTemplate.opsForHash().increment(PREFIX+key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item,double by){
return redisTemplate.opsForHash().increment(PREFIX+key, item,-by);
}
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set<Object> sGet(String key){
try {
return redisTemplate.opsForSet().members(PREFIX+key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key,Object value){
try {
return redisTemplate.opsForSet().isMember(PREFIX+key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object...values) {
try {
return redisTemplate.opsForSet().add(PREFIX+key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key,long time,Object...values) {
try {
Long count = redisTemplate.opsForSet().add(PREFIX+key, values);
if(time>0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key){
try {
return redisTemplate.opsForSet().size(PREFIX+key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object ...values) {
try {
Long count = redisTemplate.opsForSet().remove(PREFIX+key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end){
try {
return redisTemplate.opsForList().range(PREFIX+key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key){
try {
return redisTemplate.opsForList().size(PREFIX+key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key,long index){
try {
return redisTemplate.opsForList().index(PREFIX+key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(PREFIX+key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(PREFIX+key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(PREFIX+key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(PREFIX+key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index,Object value) {
try {
redisTemplate.opsForList().set(PREFIX+key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key,long count,Object value) {
try {
Long remove = redisTemplate.opsForList().remove(PREFIX+key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 模糊查询获取key值
* @param pattern
* @return
*/
public Set keys(String pattern){
return redisTemplate.keys(pattern);
}
/**
* 使用Redis的消息队列
* @param channel
* @param message 消息内容
*/
public void convertAndSend(String channel, Object message){
redisTemplate.convertAndSend(channel,message);
}
/**
*将数据添加到Redis的list中（从右边添加）
* @param listKey
* @param time 有效期
* @param values 待添加的数据
*/
public void addToListRight(String listKey, long time, TimeUnit timeUnit, Object... values) {
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
//插入数据
boundValueOperations.rightPushAll(values);
//设置过期时间
boundValueOperations.expire(time,timeUnit);
}
/**
* 根据起始结束序号遍历Redis中的list
* @param listKey
* @param start 起始序号
* @param end 结束序号
* @return
*/
public List<Object> rangeList(String listKey, long start, long end) {
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
//查询数据
return boundValueOperations.range(start, end);
}
/**
* 弹出右边的值 --- 并且移除这个值
* @param listKey
*/
public Object rifhtPop(String listKey){
//绑定操作
BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
return boundValueOperations.rightPop();
}
public static void main(String[] args) throws IOException {
String fromPic = "D:\\1239d1b727874bf09f3127d2ed498f0e.png";
File file = new File(fromPic);
File toPic = new File("D:\\1239d1b727874bf09f3127d2ed498f0e_1.png");
Thumbnails.of(file).scale(0.5f).outputQuality(1f).toFile(toPic);
}
}
