spring集成redis配置单机和集群

迷南。 2021-09-23 14:16 741阅读 0赞

maven,第一个是spring自带的redis,第二个jedis配置

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>

application.yml

单机 
    redis:
        host: 192.168.1.165
        port: 63790
        database: 5
        password: 123456
        jedis:
          pool:
            min-idle: 8
            max-idle: 500
            max-active: 2000
            max-wait: 10000
        timeout: 0

集群
     redis:
        cluster:
          nodes: 192.168.10.22:7006,192.168.10.22:7007,192.168.10.33:7008,192.168.10.33:7009,192.168.10.34:7010,192.168.10.34:7011
        password: 123456
        timeout: 10000

config

package kit.pano.febs.common.config;
    
    import com.baomidou.mybatisplus.core.toolkit.StringPool;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.cache.CacheManager;
    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.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
    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.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.HostAndPort;
    import redis.clients.jedis.JedisCluster;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.io.IOException;
    import java.io.Serializable;
    import java.time.Duration;
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 
     */
    @Configuration
    public class RedisConfig extends CachingConfigurerSupport {
    
        //redis集群
    //
    //    @Value("${spring.redis.cluster.nodes}")
    //    private String nodes;
    //
    //    @Value("${spring.redis.password}")
    //    private String password;
    //
    //    @Value("${spring.redis.timeout}")
    //    private int timeout;
    //
    //    private int minIdle = 8;
    //
    //    private int maxIdle = 500;
    //
    //    private int maxWaitMillis = 10000;
    //
    //    @Bean
    //    public JedisCluster jedisCluster() {
    //        Set<HostAndPort> hostsAndPorts = new HashSet<HostAndPort>();
    //        String[] nodesArray = nodes.split(StringPool.COMMA);
    //        for (String arr : nodesArray) {
    //            String[] node = arr.split(StringPool.COLON);
    //            hostsAndPorts.add(new HostAndPort(node[0], Integer.parseInt(node[1])));
    //        }
    //
    //        JedisCluster jedisCluster = null;
    //        if (!hostsAndPorts.isEmpty()) {
    //            GenericObjectPoolConfig pool = new GenericObjectPoolConfig();
    //            pool.setMinIdle(minIdle);
    //            pool.setMaxIdle(maxIdle);
    //            pool.setMaxWaitMillis(maxWaitMillis);
    //            jedisCluster = new JedisCluster(hostsAndPorts, timeout, 1000, 2, password, pool);
    //        }
    //        return jedisCluster;
    //    }
    //    ······································
    
        //单机redis
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.port}")
        private int port;
    
        @Value("${spring.redis.password}")
        private String password;
    
        @Value("${spring.redis.timeout}")
        private int timeout;
    
        @Value("${spring.redis.jedis.pool.max-idle}")
        private int maxIdle;
    
        @Value("${spring.redis.jedis.pool.max-wait}")
        private long maxWaitMillis;
    
        @Value("${spring.redis.database:0}")
        private int database;
    
        @Bean
        public JedisPool redisPoolFactory() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
            if (StringUtils.isNotBlank(password)) {
                return new JedisPool(jedisPoolConfig, host, port, timeout, password, database);
            } else {
                return new JedisPool(jedisPoolConfig, host, port, timeout, null, database);
            }
        }
    
        @Bean
        JedisConnectionFactory jedisConnectionFactory() {
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setHostName(host);
            redisStandaloneConfiguration.setPort(port);
            redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
            redisStandaloneConfiguration.setDatabase(database);
    
            JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
            jedisClientConfiguration.connectTimeout(Duration.ofMillis(timeout));
            jedisClientConfiguration.usePooling();
            return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration.build());
        }
        //`````````````````````````````````````````````````````````````````
    
        @Bean(name = "redisTemplate")
        @SuppressWarnings({"rawtypes"})
        @ConditionalOnMissingBean(name = "redisTemplate")
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            //使用 fastjson 序列化
            JacksonRedisSerializer jacksonRedisSerializer = new JacksonRedisSerializer<>(Object.class);
            // value 值的序列化采用 fastJsonRedisSerializer
            template.setValueSerializer(jacksonRedisSerializer);
            template.setHashValueSerializer(jacksonRedisSerializer);
            // key 的序列化采用 StringRedisSerializer
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
    
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        /**
         * 缓存管理器
         */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
                    .fromConnectionFactory(redisConnectionFactory);
            return builder.build();
        }
    
        @Bean
        @ConditionalOnMissingBean(StringRedisTemplate.class)
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        @Bean
        public KeyGenerator wiselyKeyGenerator() {
            return (target, method, params) -> {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                Arrays.stream(params).map(Object::toString).forEach(sb::append);
                return sb.toString();
            };
        }
    
        @Bean
        public RedisTemplate<String, Serializable> limitRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Serializable> template = new RedisTemplate<>();
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    }
    
    class JacksonRedisSerializer<T> implements RedisSerializer<T> {
        private Class<T> clazz;
        private ObjectMapper mapper;
    
        JacksonRedisSerializer(Class<T> clazz) {
            super();
            this.clazz = clazz;
            this.mapper = new ObjectMapper();
            mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        }
    
        @Override
        public byte[] serialize(T t) throws SerializationException {
            try {
                return mapper.writeValueAsBytes(t);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        @Override
        public T deserialize(byte[] bytes) throws SerializationException {
            if (bytes.length <= 0) {
                return null;
            }
            try {
                return mapper.readValue(bytes, clazz);
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
        }
    }

IRedisService

package kit.pano.febs.common.service;
    
    import kit.pano.febs.common.domain.RedisInfo;
    import kit.pano.febs.common.exception.RedisConnectException;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     */
    public interface RedisService {
    
    
    //    单机redis放开下面三个方法
        /**
         * 获取 redis 的详细信息
         *
         * @return List
         */
        List<RedisInfo> getRedisInfo() throws RedisConnectException;
    
        /**
         * 获取 redis key 数量
         *
         * @return Map
         */
        Map<String, Object> getKeysSize() throws RedisConnectException;
    
        /**
         * 获取 redis 内存信息
         *
         * @return Map
         */
        Map<String, Object> getMemoryInfo() throws RedisConnectException;
    
    //    ·············································
    
    
        /**
         * 获取 key
         *
         * @param pattern 正则
         * @return Set
         */
        Set<String> getKeys(String pattern) throws RedisConnectException;
    
        /**
         * get命令
         *
         * @param key key
         * @return String
         */
        String get(String key) throws RedisConnectException;
    
        /**
         * set命令
         *
         * @param key   key
         * @param value value
         * @return String
         */
        String set(String key, String value) throws RedisConnectException;
    
        /**
         * set 命令
         *
         * @param key         key
         * @param value       value
         * @param milliscends 毫秒
         * @return String
         */
        String set(String key, String value, Long milliscends) throws RedisConnectException;
    
        /**
         * del命令
         *
         * @param key key
         * @return Long
         */
        Long del(String... key) throws RedisConnectException;
    
        /**
         * exists命令
         *
         * @param key key
         * @return Boolean
         */
        Boolean exists(String key) throws RedisConnectException;
    
        /**
         * pttl命令
         *
         * @param key key
         * @return Long
         */
        Long pttl(String key) throws RedisConnectException;
    
        /**
         * pexpire命令
         *
         * @param key         key
         * @param milliscends 毫秒
         * @return Long
         */
        Long pexpire(String key, Long milliscends) throws RedisConnectException;
    
    
        /**
         * zadd 命令
         *
         * @param key    key
         * @param score  score
         * @param member value
         */
        Long zadd(String key, Double score, String member) throws RedisConnectException;
    
        /**
         * zrangeByScore 命令
         *
         * @param key key
         * @param min min
         * @param max max
         * @return Set<String>
         */
        Set<String> zrangeByScore(String key, String min, String max) throws RedisConnectException;
    
        /**
         * zremrangeByScore 命令
         *
         * @param key   key
         * @param start start
         * @param end   end
         * @return Long
         */
        Long zremrangeByScore(String key, String start, String end) throws RedisConnectException;
    
        /**
         * zrem 命令
         *
         * @param key     key
         * @param members members
         * @return Long
         */
        Long zrem(String key, String... members) throws RedisConnectException;
    }

redisServiceImpl

package kit.pano.febs.common.service.impl;
    
    import kit.pano.febs.common.domain.RedisInfo;
    import kit.pano.febs.common.exception.RedisConnectException;
    import kit.pano.febs.common.function.JedisExecutor;
    import kit.pano.febs.common.service.RedisService;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.Client;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisCluster;
    import redis.clients.jedis.JedisPool;
    
    import javax.annotation.Resource;
    import java.util.*;
    
    /**
     * Redis 工具类，只封装了几个常用的 redis 命令，
     * 可根据实际需要按类似的方式扩展即可。
     *
     * 
     */
    @Service("redisService")
    public class RedisServiceImpl implements RedisService {
    
    
    //    单机redis放开下面代码
        private static String separator = System.getProperty("line.separator");
    
        @Resource
        JedisPool jedisPool;
    
        /**
         * 处理 jedis请求
         *
         * @param j 处理逻辑，通过 lambda行为参数化
         * @return 处理结果
         */
        private <T> T executeByJedis(JedisExecutor<Jedis, T> j) throws RedisConnectException {
            try (Jedis jedis = jedisPool.getResource()) {
                return j.excute(jedis);
            } catch (Exception e) {
                throw new RedisConnectException(e.getMessage());
            }
        }
    
        @Override
        public List<RedisInfo> getRedisInfo() throws RedisConnectException {
            String info = this.executeByJedis(
                    j -> {
                        Client client = j.getClient();
                        client.info();
                        return client.getBulkReply();
                    }
            );
            List<RedisInfo> infoList = new ArrayList<>();
            String[] strs = Objects.requireNonNull(info).split(separator);
            RedisInfo redisInfo;
            if (strs.length > 0) {
                for (String str1 : strs) {
                    redisInfo = new RedisInfo();
                    String[] str = str1.split(":");
                    if (str.length > 1) {
                        String key = str[0];
                        String value = str[1];
                        redisInfo.setKey(key);
                        redisInfo.setValue(value);
                        infoList.add(redisInfo);
                    }
                }
            }
            return infoList;
        }
    
        @Override
        public Map<String, Object> getKeysSize() throws RedisConnectException {
            Long dbSize = this.executeByJedis(
                    j -> {
                        Client client = j.getClient();
                        client.dbSize();
                        return client.getIntegerReply();
                    }
            );
            Map<String, Object> map = new HashMap<>();
            map.put("create_time", System.currentTimeMillis());
            map.put("dbSize", dbSize);
            return map;
        }
    
        @Override
        public Map<String, Object> getMemoryInfo() throws RedisConnectException {
            String info = this.executeByJedis(
                    j -> {
                        Client client = j.getClient();
                        client.info();
                        return client.getBulkReply();
                    }
            );
            String[] strs = Objects.requireNonNull(info).split(separator);
            Map<String, Object> map = null;
            for (String s : strs) {
                String[] detail = s.split(":");
                if ("used_memory".equals(detail[0])) {
                    map = new HashMap<>();
                    map.put("used_memory", detail[1].substring(0, detail[1].length() - 1));
                    map.put("create_time", System.currentTimeMillis());
                    break;
                }
            }
            return map;
        }
    
        @Override
        public Set<String> getKeys(String pattern) throws RedisConnectException {
            return this.executeByJedis(j -> j.keys(pattern));
        }
    //    单机redis代码到此
    
    //    集群打开下面方法
    //    @Resource
    //    JedisCluster jedisCluster;
    //
    //    /**
    //     * 处理 jedis请求
    //     *
    //     * @param j 处理逻辑，通过 lambda行为参数化
    //     * @return 处理结果
    //     */
    //    private <T> T executeByJedis(JedisExecutor<JedisCluster, T> j) throws RedisConnectException {
    //        try {
    //            return j.excute(jedisCluster);
    //        } catch (Exception e) {
    //            throw new RedisConnectException(e.getMessage());
    //        }
    //    }
    //
    //    @Override
    //    public Set<String> getKeys(String pattern) throws RedisConnectException {
    //        return this.executeByJedis(j -> j.hkeys(pattern));
    //    }
    //    ················································
    
        @Override
        public String get(String key) throws RedisConnectException {
            return this.executeByJedis(j -> j.get(key.toLowerCase()));
        }
    
        @Override
        public String set(String key, String value) throws RedisConnectException {
            return this.executeByJedis(j -> j.set(key.toLowerCase(), value));
        }
    
        @Override
        public String set(String key, String value, Long milliscends) throws RedisConnectException {
            String result = this.set(key.toLowerCase(), value);
            this.pexpire(key, milliscends);
            return result;
        }
    
        @Override
        public Long del(String... key) throws RedisConnectException {
            return this.executeByJedis(j -> j.del(key));
        }
    
        @Override
        public Boolean exists(String key) throws RedisConnectException {
            return this.executeByJedis(j -> j.exists(key));
        }
    
        @Override
        public Long pttl(String key) throws RedisConnectException {
            return this.executeByJedis(j -> j.pttl(key));
        }
    
        @Override
        public Long pexpire(String key, Long milliseconds) throws RedisConnectException {
            return this.executeByJedis(j -> j.pexpire(key, milliseconds));
        }
    
        @Override
        public Long zadd(String key, Double score, String member) throws RedisConnectException {
            return this.executeByJedis(j -> j.zadd(key, score, member));
        }
    
        @Override
        public Set<String> zrangeByScore(String key, String min, String max) throws RedisConnectException {
            return this.executeByJedis(j -> j.zrangeByScore(key, min, max));
        }
    
        @Override
        public Long zremrangeByScore(String key, String start, String end) throws RedisConnectException {
            return this.executeByJedis(j -> j.zremrangeByScore(key, start, end));
        }
    
        @Override
        public Long zrem(String key, String... members) throws RedisConnectException {
            return this.executeByJedis(j -> j.zrem(key, members));
        }
    
    }