SpringBoot集成redisCluster(redis集群)实现发布订阅、消息队列

SpringBoot+redisCluster封装RedisTemplate，通过RedisTemplate操作Redis,并简单的实现消息队列、发布订阅的功能；

首先导入Maven:

 
            redis.clients
            jedis
 

在springboot的application.properties配置文件中配置redis集群的地址：

#redis
spring.redis.cluster.nodes=10.2.102.244:6379,10.2.102.244:6380,10.2.102.244:6381

下图是我的一个项目结构：

使用@Configuration注解初始化redisCluter配置，返回出一个封装后的RedisTemplate和一个JedisCluster对象用来操作我们redis集群和封装redis的操作命令：RedisCluterConfig类

package pers.ly.learn.redisCluster.config;

import java.lang.reflect.Field;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonAutoDetect;

import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisCluterConfig extends CachingConfigurerSupport{
	
	@Value("${spring.redis.cluster.nodes}")
	private String clusterNodes;
	
	
	@Bean(name="clusterConfig")
    public RedisClusterConfiguration clusterConfig(){
    	RedisClusterConfiguration config = new RedisClusterConfiguration();
    	String[] nodes = clusterNodes.split(",");
    	for(String node : nodes){
    		String[] host =  node.split(":");
    		RedisNode redis = new RedisNode(host[0], Integer.parseInt(host[1]));
    		config.addClusterNode(redis);
    	}
    	return config;
    }
	
    @Bean(name="factory")
    public RedisConnectionFactory factory(RedisClusterConfiguration clusterConfig){
        JedisConnectionFactory redisConnectionFactory=new JedisConnectionFactory(clusterConfig);
//        String redisPassword = password;
//    	redisConnectionFactory.setPassword(redisPassword);
        redisConnectionFactory.setPoolConfig(createJedisPoolConfig());
        redisConnectionFactory.setTimeout(30000);
        redisConnectionFactory.setUsePool(true);  
        return redisConnectionFactory;  
    }
    
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
    	StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
    
    /**
	 * 通过反射获取JedisCluster
	 * @param factory
	 * @return
	 */
	@Bean
	public JedisCluster redisCluster(RedisConnectionFactory factory){
		Object object =null;
		try {
			object= getFieldValueByObject(factory,"cluster");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (JedisCluster)object;

	}
	
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
			StringBuilder sb = new StringBuilder();
			sb.append(target.getClass().getName());
			sb.append(method.getName());
			for (Object obj : params) {
				sb.append(obj.toString());
			}
			return sb.toString();
		};
    }
	
	public  Object getFieldValueByObject (Object object , String targetFieldName) throws Exception {
		// 获取该对象的Class
		Class objClass = object.getClass();
		// 获取所有的属性数组
		Field[] fields = objClass.getDeclaredFields();
		for (Field field:fields) {
			// 属性名称
			field.setAccessible(true);
			String currentFieldName = field.getName();
			if(currentFieldName.equals(targetFieldName)){
				return field.get(object); // 通过反射拿到该属性在此对象中的值(也可能是个对象)
			}
		}
		return null;
	}
	 
	 
	 public JedisPoolConfig createJedisPoolConfig(){
	   	 JedisPoolConfig config = new JedisPoolConfig();
	   	 //连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
	   	 config.setBlockWhenExhausted(false);
	   	  
	   	 //设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
	   	 config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
	   	  
	   	 //是否启用pool的jmx管理功能, 默认true
	   	 config.setJmxEnabled(true);
	   	  
	   	 //MBean ObjectName = new ObjectName("org.apache.commons.pool2:type=GenericObjectPool,name=" + "pool" + i); 默 认为"pool", JMX不熟,具体不知道是干啥的...默认就好.
	   	 config.setJmxNamePrefix("pool");
	   	  
	   	 //是否启用后进先出, 默认true
	   	 config.setLifo(true);
	   	  
	   	 //最大空闲连接数, 默认8个
	   	 config.setMaxIdle(2000);
	   	  
	   	 //最大连接数, 默认8个
	   	 config.setMaxTotal(5000);
	   	 
	   	 //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
	   	 config.setMaxWaitMillis(10000);
	   	  
	   	 //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
	   	 config.setMinEvictableIdleTimeMillis(1800000);
	   	  
	   	 //最小空闲连接数, 默认0
	   	 config.setMinIdle(0);
	   	  
	   	 //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
	   	 config.setNumTestsPerEvictionRun(3);
	   	  
	   	 //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)   
	   	 config.setSoftMinEvictableIdleTimeMillis(1800000);
	   	  
	   	 //在获取连接的时候检查有效性, 默认false
	   	 config.setTestOnBorrow(false);
	   	  
	   	 //在空闲时检查有效性, 默认false
	   	 config.setTestWhileIdle(false);
	   	  
	   	 //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
	   	 config.setTimeBetweenEvictionRunsMillis(-1);
	   	 
	   	 return config;
	   }

}

通过@Autowired注入RedisTemplate自己封装一个redis操作的一个辅助类，当然这个可以根据自己的需要来封装：RedisOperationHepler类：

package pers.ly.learn.redisCluster.hepler;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

/**
 * redis辅助类
 * @author banma
 */
@Component
public class RedisOperationHepler {
	
	@Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
    
    /**
     * 批量删除key
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set keys = redisTemplate.keys(pattern);
        if (keys.size() > 0){
        	redisTemplate.delete(keys);
        }
    }
    /**
     * 删除对应的value
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    /**
     * 哈希 添加
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value){
        HashOperations hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }
    /**
     * 哈希 获取哈希的key集合
     * @param key
     * @return
     */
    public Set