Redis（一）

概念： redis是一款高性能的NOSQL系列的非关系型数据库
1.1.什么是NOSQL

• NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
• 随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

  • 1.1.1. NOSQL和关系型数据库比较
    优点：

    • 成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
    • 查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
    • 存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
    • 扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。

    缺点：

    • 维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。
    • 不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
    • 不提供关系型数据库对事务的处理。

  • 1.1.2. 非关系型数据库的优势：

    • 性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
    • 可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。

  • 1.1.3. 关系型数据库的优势：

    • 复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
    • 事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

  • 1.1.4. 总结
    关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，让NoSQL数据库对关系型数据库的不足进行弥补。一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据

数据类型

1. 字符串类型 string
2. 哈希类型 hash
3. 列表类型 list
4. 集合类型 set
5. 有序集合类型 sortedset

redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等）
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜
• 网站访问统计
• 数据过期处理（可以精确到毫秒
• 分布式集群架构中的session分离

命令操作

字符串类型 string

• 存储： set key value
• 获取： get key
• 删除： del key

哈希类型 hash

• 存储： hset key field value
• 获取：
  • hget key field: 获取指定的field对应的值
  • hgetall key：获取所有的field和value
• 删除： hdel key field

列表类型 list:可以添加一个元素到列表的头部（左边）或者尾部（右边）

• 添加：
  • lpush key value: 将元素加入列表左表
  • rpush key value：将元素加入列表右边
• 获取：
  • lrange key start end ：范围获取
• 删除：
  • lpop key： 删除列表最左边的元素，并将元素返回
  • rpop key： 删除列表最右边的元素，并将元素返回

集合类型 set ： 不允许重复元素

• 存储：sadd key value
• 获取：smembers key:获取set集合中所有元素
• 删除：srem key value:删除set集合中的某个元素

有序集合类型 sortedset：不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

• 存储：zadd key score value
• 获取：zrange key start end [withscores]
• 删除：zrem key value

通用命令

• keys * : 查询所有的键
• type key ： 获取键对应的value的类型
• del key：删除指定的key value

Windows系统安装redis

1. 下载好redis的Windows版本，3.0之后的。
   github下载地址

2. 在安装目录或者解压目录里找到redis-server.exe，就可以启动单机模式的了。
   
   

3. 搭建redis集群，创建一个RedisCluster文件夹，将刚才单机模式的redis文件夹复制几份。
   

4. 修改每个文件夹中的redis.windows.conf配置,端口对应文件夹名字，区分开

   port 6380 //修改为与当前文件夹名字一样的端口号
   appendonly yes //指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。 yes表示：存储方式，aof，将写操作记录保存到日志中
   cluster-enabled yes //开启集群模式
   cluster-config-file nodes-6380.conf //保存节点配置,自动创建,自动更新
   cluster-node-timeout 15000 //集群超时时间，节点超过这个时间没反应就断定是宕机

5. 在每个redis目录下创建start.bat文件，用于启动redis。
   

6. 下载ruby设置集群
   

7. 为了方便看，安装到RedisCluster下

8. 默认安装的文件夹名称为RailsInstaller，在这个目录下使用命令安装

   gem install redis

9. 下载集群脚本构建工具redis-trip.rb。也可以自行百度
   

10. 运行所有的star.bat，不要关闭窗口。

11. 执行命令，创建主从节点

    ruby redis-trib.rb create --replicas 1 127.0.0.1:6380 127.0.0.1:6381 127.0.0.1:6382 127.0.0.1:6383 127.0.0.1:6384 127.0.0.1:6385
    

12. 在项目中使用的部分代码

application.properties

#redis 1连接信息
redis.ip1=127.0.0.1
redis.host1=6385
#redis 2连接信息
redis.ip2=127.0.0.1
redis.host2=6380
#redis 3连接信息
redis.ip3=127.0.0.1
redis.host3=6381
#redis 4连接信息
redis.ip4=127.0.0.1
redis.host4=6382
#redis 5连接信息
redis.ip5=127.0.0.1
redis.host5=6383
#redis 6连接信息
redis.ip6=127.0.0.1
redis.host6=6384
redis.commandTimeout=1000

applixation.yml

#redis集群
redis:
    clusterNodes: ${redis.ip1}:${redis.host1},${redis.ip2}:${redis.host2},${redis.ip3}:${redis.host3},${redis.ip4}:${redis.host4},${redis.ip5}:${redis.host5},${redis.ip6}:${redis.host6}
    #连接超时时间（毫秒）
    timeout: 10000
    #redis操作的超时时间
    commandTimeout: 10000
    pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 10
        #连接池中的最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 2
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 100

这两个配置文件可以整合到一块。
13. 代码
JedisClientService

public interface JedisClientService {
	
	/**
	 * 
	     * @Title: getClusterNodes
	     * @Description: 获取集群节点
	     * @param @param entries
	     * @param @return
	     * @param @throws Exception    参数
	     * @return List<Map<String, Object>>    返回类型
	     * @throws
	 */
	public List<Map<String, Object>> getClusterNodes() throws Exception;
	
	/**
	 * 
	     * @Title: getLogs
	     * @Description: 获取日志列表
	     * @param @param entries
	     * @param @return
	     * @param @throws Exception    参数
	     * @return List<Map<String, Object>>    返回类型
	     * @throws
	 */
	public List<Map<String, Object>> getLogs(String ip);

	/**
	 * 
	     * @Title: logEmpty
	     * @Description: 清空日志
	     * @param @return
	     * @param @throws Exception    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String logEmpty(String ip);

	/**
	 * 
	     * @Title: dbSize
	     * @Description: 获取占用内存大小
	     * @param @param ip
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Map<String, Object> dbSize(String ip);
	
	/**
	 * 
	     * @Title: set
	     * @Description: Redis SET命令用于在Redis键中设置一些字符串值
	     * @param @param key
	     * @param @param value
	     * @param @return    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String set(String key, String value);

	/**
	 * 
	     * @Title: get
	     * @Description: 根据key去查询相应的值
	     * @param @param key
	     * @param @return    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String get(String key);

	/**
	 * 
	     * @Title: exists
	     * @Description: 判断key在Redis缓存中是否存在
	     * @param @param key
	     * @param @return    参数
	     * @return Boolean    返回类型
	     * @throws
	 */
	public Boolean exists(String key);

	/**
	 * 
	     * @Title: expire
	     * @Description: 设置key的过期时间
	     * @param @param key
	     * @param @param seconds
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long expire(String key, int seconds);

	/**
	 * 
	     * @Title: ttl
	     * @Description: Redis TTL 命令以秒为单位返回 key 的剩余过期时间
	     * @param @param key
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long ttl(String key);

	/**
	 * 
	     * @Title: incr
	     * @Description: Redis Incr 命令将 key 中储存的数字值增一
	     * @param @param key
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long incr(String key);

	/**
	 * 
	     * @Title: hset
	     * @Description:  Redis Hset 命令用于为哈希表中的字段赋值 。 如果哈希表不存在，一个新的哈希表被创建并进行 HSET 操作。如果字段已经存在于哈希表中，旧值将被覆盖。
	     * @param @param key
	     * @param @param field
	     * @param @param value
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long hset(String key, String field, String value);

	/**
	 * 
	     * @Title: hget
	     * @Description: Redis Hget 命令用于返回哈希表中指定字段的值。
	     * @param @param key
	     * @param @param field
	     * @param @return    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String hget(String key, String field);

	/**
	 * 
	     * @Title: hdel
	     * @Description: Redis Hdel 命令用于删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。
	     * @param @param key
	     * @param @param field
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long hdel(String key, String... field);
	
	/**
	 * 
	     * @Title: del
	     * @Description: 删除给定的一个 key 不存在的 key 会被忽略。
	     * @param @param key
	     * @param @param field
	     * @param @return    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long del(String key);
	
	/**
	 * 
	     * @Title: getRedisInfo
	     * @Description: 获取redis 服务器信息
	     * @param @return
	     * @param @throws Exception    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String getRedisInfo();

	/**
	 * 
	     * @Title: getLogs
	     * @Description: 获取日志列表
	     * @param @param entries
	     * @param @return
	     * @param @throws Exception    参数
	     * @return List<Slowlog>    返回类型
	     * @throws
	 */
	public List<Slowlog> getLogs(long entries);

	/**
	 * 
	     * @Title: getLogsLen
	     * @Description: 获取日志条数
	     * @param @return
	     * @param @throws Exception    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long getLogsLen();

	/**
	 * 
	     * @Title: logEmpty
	     * @Description: 清空日志
	     * @param @return
	     * @param @throws Exception    参数
	     * @return String    返回类型
	     * @throws
	 */
	public String logEmpty();

	/**
	 * 
	     * @Title: dbSize
	     * @Description: 获取占用内存大小
	     * @param @return
	     * @param @throws Exception    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public Long dbSize();
	
	/**
	 * 
	     * @Title: delKeys
	     * @Description: 根据前缀进行删除
	     * @param @return
	     * @param @throws Exception    参数
	     * @return Long    返回类型
	     * @throws
	 */
	public void delKeys(String keysPattern);
}

JedisClientServiceImpl

@Service
public class JedisClientServiceImpl implements JedisClientService {
	
	@Autowired
	private JedisCluster jedisCluster;

	@Value("${redis.ip1}")  
    private String redisIp1;
	
	@Value("${redis.ip2}")
    private String redisIp2;

	@Value("${redis.ip3}")
    private String redisIp3;

	@Value("${redis.ip4}")
    private String redisIp4;

	@Value("${redis.ip5}")
    private String redisIp5;

	@Value("${redis.ip6}")
    private String redisIp6;

	@Override
	public String set(String key, String value) {
		return jedisCluster.set(key, value);
	}

	@Override
	public String get(String key) {
		return jedisCluster.get(key);
	}

	@Override
	public Boolean exists(String key) {
		return jedisCluster.exists(key);
	}

	@Override
	public Long expire(String key, int seconds) {
		return jedisCluster.expire(key, seconds);
	}

	@Override
	public Long ttl(String key) {
		return jedisCluster.ttl(key);
	}

	@Override
	public Long incr(String key) {
		return jedisCluster.incr(key);
	}

	@Override
	public Long hset(String key, String field, String value) {
		return jedisCluster.hset(key, field, value);
	}

	@Override
	public String hget(String key, String field) {
		return jedisCluster.hget(key, field);
	}

	@Override
	public Long hdel(String key, String... field) {
		return jedisCluster.hdel(key, field);
	}

	@Override
	public Long del(String key) {
        return jedisCluster.del(key);
	}
	
	@Override
	public void delKeys(String keysPattern) {
		Map<String, JedisPool> jedisPools = jedisCluster.getClusterNodes();
		Iterator<Map.Entry<String, JedisPool>> entries = jedisPools.entrySet().iterator();
		Jedis jedis = null;
		while (entries.hasNext()) {
			Entry<String, JedisPool> entry = entries.next();
			if(entry.getKey().indexOf(redisIp1) != -1 || entry.getKey().indexOf(redisIp2) != -1
					|| entry.getKey().indexOf(redisIp3) != -1 || entry.getKey().indexOf(redisIp4) != -1
					|| entry.getKey().indexOf(redisIp5) != -1 || entry.getKey().indexOf(redisIp6) != -1){
				jedis = entry.getValue().getResource();
				if (!jedis.info("replication").contains("role:slave")) {
					Set<String> keys = jedis.keys(keysPattern);
					if (keys.size() > 0) {
						Map<Integer, List<String>> map = new HashMap<>(6600);
						for (String key : keys) {
							int slot = JedisClusterCRC16.getSlot(key);
							// cluster模式执行多key操作的时候，这些key必须在同一个slot上，不然会报:JedisDataException: // CROSSSLOT // request // don't // hash to // the same // slot
							// 按slot将key分组，相同slot的key一起提交
							if (map.containsKey(slot)) {
								map.get(slot).add(key);
							} else {
								map.put(slot, Arrays.asList(key));
							}
						}
						for (Map.Entry<Integer, List<String>> integerListEntry : map.entrySet()) {
							jedis.del(integerListEntry.getValue().toArray(new String[integerListEntry.getValue().size()]));
						}
						jedis.close();
					}
				}
			}
		}
	}
	
	@Override
	public String getRedisInfo() {
		Jedis jedis = null;
		try {
			Map<String, JedisPool> jedisPools = jedisCluster.getClusterNodes();
			List<Map<String, Object>> ridMationList = new ArrayList<>();
			Iterator<Map.Entry<String, JedisPool>> entries = jedisPools.entrySet().iterator();
			while (entries.hasNext()) {
				Entry<String, JedisPool> entry = entries.next();
				if(entry.getKey().indexOf(redisIp1) != -1 || entry.getKey().indexOf(redisIp2) != -1
						|| entry.getKey().indexOf(redisIp3) != -1 || entry.getKey().indexOf(redisIp4) != -1
						|| entry.getKey().indexOf(redisIp5) != -1 || entry.getKey().indexOf(redisIp6) != -1){
					jedis = entry.getValue().getResource();
					Client client = jedis.getClient();
					client.info();
					String info = client.getBulkReply();
					jedis.close();
					List<Map<String, Object>> ridList = new ArrayList<>();
					Map<String, Object> redisMation = new HashMap<>();
					String[] strs = info.split("\n");
					Map<String, Object> bean = null;
					if (strs != null && strs.length > 0) {
						for (int i = 0; i < strs.length; i++) {
							String[] str = strs[i].split(":");
							if (str != null && str.length > 1) {
								bean = new HashMap<>();
								bean.put("key", str[0]);
								bean.put("value", str[1].replace("\n", "").replace("\r", ""));
								ridList.add(bean);
							}
						}
						redisMation.put("ip", entry.getKey());
						redisMation.put("mation", ridList);
						ridMationList.add(redisMation);
					}
				}
			}
			return JSONArray.fromObject(ridMationList).toString();
		} finally {
		}
	}

	@Override
	public List<Slowlog> getLogs(long entries) {
		return null;
	}

	@Override
	public Long getLogsLen() {
		return new Long(1);
	}

	@Override
	public String logEmpty() {
		return "";
	}

	@Override
	public Long dbSize() {
		return new Long(1);
	}

	@Override
	public List<Map<String, Object>> getClusterNodes() throws Exception {
		Map<String, JedisPool> jedisPools = jedisCluster.getClusterNodes();
		List<Map<String, Object>> ridPoolList = new ArrayList<>();
		Iterator<Map.Entry<String, JedisPool>> entries = jedisPools.entrySet().iterator();
		while (entries.hasNext()) {
			Entry<String, JedisPool> entry = entries.next();
			if(entry.getKey().indexOf(redisIp1) != -1 || entry.getKey().indexOf(redisIp2) != -1
					|| entry.getKey().indexOf(redisIp3) != -1 || entry.getKey().indexOf(redisIp4) != -1
					|| entry.getKey().indexOf(redisIp5) != -1 || entry.getKey().indexOf(redisIp6) != -1){
				Map<String, Object> redisPoolMation = new HashMap<>();
				redisPoolMation.put("ip", entry.getKey());
				ridPoolList.add(redisPoolMation);
			}
		}
		return ridPoolList;
	}

	@Override
	public List<Map<String, Object>> getLogs(String ip) {
		Jedis jedis = null;
		try {
			Map<String, JedisPool> jedisPools = jedisCluster.getClusterNodes();
			Iterator<Map.Entry<String, JedisPool>> entries = jedisPools.entrySet().iterator(); 
			while (entries.hasNext()) {
				Entry<String, JedisPool> entry = entries.next(); 
				if(entry.getKey().indexOf(ip) != -1){
					jedis = entry.getValue().getResource();
					long logLen = jedis.slowlogLen();
					List<Slowlog> logList = jedis.slowlogGet(logLen);
					jedis.close();
					List<Map<String, Object>> opList = null;
					Map<String, Object> op  = null;
					boolean flag = false;
					if (logList != null && !logList.isEmpty()) {
						opList = new LinkedList<>();
						for (Slowlog sl : logList) {
							String args = JSON.toJSONString(sl.getArgs());
							if (args.equals("[\"PING\"]") || args.equals("[\"SLOWLOG\",\"get\"]") || args.equals("[\"DBSIZE\"]") || args.equals("[\"INFO\"]")) {
								continue;
							}	
							op = new HashMap<>();
							flag = true;
							op.put("id", sl.getId());
							op.put("executeTime", ToolUtil.getDateStr(sl.getTimeStamp() * 1000));
							op.put("usedTime", sl.getExecutionTime()/1000.0 + "ms");
							op.put("args", args);
							opList.add(op);
						}
					} 
					if (flag) 
						return opList;
					else 
						return null;
				}
			}
		} finally {
		}
		return null;
	}

	@Override
	public String logEmpty(String ip) {
		return null;
	}

	@Override
	public Map<String, Object> dbSize(String ip) {
		Jedis jedis = null;
		try {
			Map<String, JedisPool> jedisPools = jedisCluster.getClusterNodes();
			Iterator<Map.Entry<String, JedisPool>> entries = jedisPools.entrySet().iterator(); 
			while (entries.hasNext()) {
				Entry<String, JedisPool> entry = entries.next(); 
				if(entry.getKey().indexOf(ip) != -1){
					jedis = entry.getValue().getResource();
					//配置redis服务信息
					Client client = jedis.getClient();
					client.dbSize();
					long dbSize = client.getIntegerReply();
					jedis.close();
					Map<String,Object> map = new HashMap<String, Object>();
					map.put("createTime", ToolUtil.getTimeAndToString());
					map.put("dbSize", dbSize);
					return map;
				}
			}
		} finally {
		}
		return null;
	}

}

RedisProperties

@Component
@ConfigurationProperties(prefix = "redis")
public class RedisProperties {
	
	private int expireSeconds;
	private String ip1;
	private String ip2;
	private String ip3;
	private String ip4;
	private String ip5;
	private String ip6;
	private String host1;
	private String host2;
	private String host3;
	private String host4;
	private String host5;
	private String host6;
	private int commandTimeout;

	public int getExpireSeconds() {
		return expireSeconds;
	}

	public void setExpireSeconds(int expireSeconds) {
		this.expireSeconds = expireSeconds;
	}

	public int getCommandTimeout() {
		return commandTimeout;
	}

	public void setCommandTimeout(int commandTimeout) {
		this.commandTimeout = commandTimeout;
	}

	public String getIp1() {
		return ip1;
	}

	public void setIp1(String ip1) {
		this.ip1 = ip1;
	}

	public String getIp2() {
		return ip2;
	}

	public void setIp2(String ip2) {
		this.ip2 = ip2;
	}

	public String getIp3() {
		return ip3;
	}

	public void setIp3(String ip3) {
		this.ip3 = ip3;
	}

	public String getIp4() {
		return ip4;
	}

	public void setIp4(String ip4) {
		this.ip4 = ip4;
	}

	public String getIp5() {
		return ip5;
	}

	public void setIp5(String ip5) {
		this.ip5 = ip5;
	}

	public String getIp6() {
		return ip6;
	}

	public void setIp6(String ip6) {
		this.ip6 = ip6;
	}

	public String getHost1() {
		return host1;
	}

	public void setHost1(String host1) {
		this.host1 = host1;
	}

	public String getHost2() {
		return host2;
	}

	public void setHost2(String host2) {
		this.host2 = host2;
	}

	public String getHost3() {
		return host3;
	}

	public void setHost3(String host3) {
		this.host3 = host3;
	}

	public String getHost4() {
		return host4;
	}

	public void setHost4(String host4) {
		this.host4 = host4;
	}

	public String getHost5() {
		return host5;
	}

	public void setHost5(String host5) {
		this.host5 = host5;
	}

	public String getHost6() {
		return host6;
	}

	public void setHost6(String host6) {
		this.host6 = host6;
	}
	
}

JedisClusterConfig

@Configuration
@ConditionalOnClass({JedisCluster.class})
public class JedisClusterConfig extends CachingConfigurerSupport{

	@Autowired
	private RedisProperties redisProperties;

	@Bean
	public JedisCluster getJedisCluster() {
		String[] serverArray = {redisProperties.getIp1() + ":" + redisProperties.getHost1(), redisProperties.getIp2() + ":" + redisProperties.getHost2()
								, redisProperties.getIp3() + ":" + redisProperties.getHost3(), redisProperties.getIp4() + ":" + redisProperties.getHost4()
								, redisProperties.getIp5() + ":" + redisProperties.getHost5(), redisProperties.getIp6() + ":" + redisProperties.getHost6()};
		Set<HostAndPort> nodes = new HashSet<>();

		for (String ipPort : serverArray) {
			String[] ipPortPair = ipPort.split(":");
			nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
		}
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxIdle(200);//最大空闲连接数
        jedisPoolConfig.setMinIdle(20);//最小空闲连接数
        jedisPoolConfig.setMaxTotal(400);//最大连接数
        jedisPoolConfig.setBlockWhenExhausted(true);
        jedisPoolConfig.setTestOnBorrow(true);
        //Idle时进行连接扫描
        jedisPoolConfig.setTestWhileIdle(true);
        //表示idle object evitor每次扫描的最多的对象数
        jedisPoolConfig.setNumTestsPerEvictionRun(10);
        //表示idle object evitor两次扫描之间要sleep的毫秒数
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
        //表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义
        jedisPoolConfig.setMinEvictableIdleTimeMillis(60000);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(60000);
        jedisPoolConfig.setMaxWaitMillis(100000);//最大阻塞等待时间，负值为无限制
		return new JedisCluster(nodes, redisProperties.getCommandTimeout(), 5000, 3, jedisPoolConfig);
	}
	
	/**
	 * 管理缓存
	 */
	@Bean
	public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
		RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory).build();
		return redisCacheManager;
	}

	@Bean
	@Override
	public CacheErrorHandler errorHandler() {
		// 异常处理，当Redis发生异常时，打印日志，但是程序正常
		CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
			@Override
			public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
				System.out.println(e);
			}

			@Override
			public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
				System.out.println(e);
			}

			@Override
			public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
				System.out.println(e);
			}

			@Override
			public void handleCacheClearError(RuntimeException e, Cache cache) {
				System.out.println(e);
			}
		};
		return cacheErrorHandler;
	}
}

******************************************************