SpringBoot整合连接Redis集群

灰太狼 2022-11-30 04:27 218阅读 0赞

# **第一步**，新建项目maven项目，添加依赖 #

（1）本文所采用的SpringBoot的版本如下

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath /> 
    </parent>

（2）加入Redis相关依赖

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

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

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**第二步**，application.yml加入redis相关配置

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

spring:
      application:
        name: redis-cluster
      redis:
        cluster:
          nodes: 192.168.0.102:6379,192.168.0.103:6379,192.168.0.105:6379
          max-redirects: 6
    redis:
      timeout: 10000 #客户端超时时间单位是毫秒 默认是2000
      maxIdle: 300 #最大空闲数
      maxTotal: 1000 #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
      maxWaitMillis: 1000 #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
      minEvictableIdleTimeMillis: 300000 #连接的最小空闲时间 默认1800000毫秒(30分钟)
      numTestsPerEvictionRun: 1024 #每次释放连接的最大数目,默认3
      timeBetweenEvictionRunsMillis: 30000 #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
      testOnBorrow: true #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
      testWhileIdle: true #在空闲时检查有效性, 默认false
      password: 123456 #密码
    server:
      port: 8080

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**第三步**，编写配置类

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

package com.qxj.redis;
    
    import java.util.HashSet;
    import java.util.Set;
    
    import org.springframework.beans.factory.annotation.Value;
    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.RedisNode;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    
    import redis.clients.jedis.JedisPoolConfig;
    
    @Configuration
    public class RedisClusterConfig {
    
        @Value("${spring.redis.cluster.nodes}")
        private String clusterNodes;
        @Value("${spring.redis.cluster.max-redirects}")
        private int maxRedirects;
        @Value("${redis.password}")
        private String password;
        @Value("${redis.timeout}")
        private int timeout;
        @Value("${redis.maxIdle}")
        private int maxIdle;
        @Value("${redis.maxTotal}")
        private int maxTotal;
        @Value("${redis.maxWaitMillis}")
        private int maxWaitMillis;
        @Value("${redis.minEvictableIdleTimeMillis}")
        private int minEvictableIdleTimeMillis;
        @Value("${redis.numTestsPerEvictionRun}")
        private int numTestsPerEvictionRun;
        @Value("${redis.timeBetweenEvictionRunsMillis}")
        private int timeBetweenEvictionRunsMillis;
        @Value("${redis.testOnBorrow}")
        private boolean testOnBorrow;
        @Value("${redis.testWhileIdle}")
        private boolean testWhileIdle;
    
        /**
         * Redis连接池的配置
         * 
         * @return JedisPoolConfig
         */
        @Bean
        public JedisPoolConfig getJedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            // 最大空闲数
            jedisPoolConfig.setMaxIdle(maxIdle);
            // 连接池的最大数据库连接数
            jedisPoolConfig.setMaxTotal(maxTotal);
            // 最大建立连接等待时间
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
            // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
            // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestOnBorrow(testOnBorrow);
            // 在空闲时检查有效性, 默认false
            jedisPoolConfig.setTestWhileIdle(testWhileIdle);
            return jedisPoolConfig;
        }
    
        /**
         * Redis集群的配置
         * 
         * @return RedisClusterConfiguration
         */
        @Bean
        public RedisClusterConfiguration redisClusterConfiguration() {
            RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
            // Set<RedisNode> clusterNodes
            String[] serverArray = clusterNodes.split(",");
            Set<RedisNode> nodes = new HashSet<RedisNode>();
            for (String ipPort : serverArray) {
                String[] ipAndPort = ipPort.split(":");
                nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
            }
            redisClusterConfiguration.setClusterNodes(nodes);
            redisClusterConfiguration.setMaxRedirects(maxRedirects);
            redisClusterConfiguration.setPassword(RedisPassword.of(password));
            return redisClusterConfiguration;
        }
    
        /**
         * redis连接工厂类
         * 
         * @return JedisConnectionFactory
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory() {
            // 集群模式
            JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration(), getJedisPoolConfig());
            return factory;
        }
    
        /**
         * 实例化 RedisTemplate 对象
         * 
         * @return RedisTemplate<String, Object>
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            // Template初始化
            initDomainRedisTemplate(redisTemplate);
            return redisTemplate;
        }
    
        /**
         * 设置数据存入 redis 的序列化方式 使用默认的序列化会导致key乱码
         */
        private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
            // 开启redis数据库事务的支持
            redisTemplate.setEnableTransactionSupport(true);
            redisTemplate.setConnectionFactory(jedisConnectionFactory());
    
            // 如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to
            // String！
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            redisTemplate.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
    
            // jackson序列化对象设置
            Jackson2JsonRedisSerializer<Object> 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);
    
            // value序列化方式采用jackson
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    
            redisTemplate.afterPropertiesSet();
        }
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**第四步**，编写Controller测试类

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

package com.qxj.application;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class TestController {
    
        @Autowired
        private RedisTemplate<String, Object> template;
    
        @RequestMapping("/test")
        public String test() {
            template.opsForValue().set("demo", "hello world! 你好，世界");
            String str = (String) template.opsForValue().get("demo");
            return str;
        }
    
    }

**参考文献：https://blog.csdn.net/WYA1993/article/details/88046628**

[https://www.cnblogs.com/wps54213/p/12608777.html][https_www.cnblogs.com_wps54213_p_12608777.html]

在springboot使用搭建好的redis集群----lettuce方式

## 添加redis和连接池依赖 ##

<dependency>
               <groupId>org.apache.commons</groupId>
               <artifactId>commons-pool2</artifactId>
           </dependency>
           
    
           
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
               <version>2.2.6.RELEASE</version>
           </dependency>

## 在配置文件中配置连接池和sentinel ##

ip: 39.97.234.52
    spring:
      redis:
        lettuce:
          pool:
            max-active: 10
            max-idle: 8
            max-wait: -1ms
            min-idle: 0
        sentinel:
          master: mymaster
          nodes: ${ip}:26379,${ip}:26380,${ip}:26381
        password: test@dbuser2018

## 添加redis配置类,修改springboot默认的redis序列化方式 ##

@Configuration
    public class RedisConfig {
        /**
         * 把任何数据保存到redis时，都需要进行序列化，默认使用JdkSerializationRedisSerializer进行序列化。
         * 默认的序列化会给所有的key,value的原始字符前，都加了一串字符（例如：\xAC\xED\x00\），不具备可读性
         * 所以需要配置jackson序列化方式
         */
        @Bean
        public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory factory){
            RedisTemplate<String,Object> template=new RedisTemplate<>();
            template.setConnectionFactory(factory);
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            //key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            //value采用jackson序列化方式
            template.setValueSerializer(jackson2JsonRedisSerializer);
            //hash的key采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            //hash的value采用String的序列化方式
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    }

## 创建redis服务 ##

@Service
        public class RedisServiceImpl implements RedisService {
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @Override
        public boolean put(String key, Object value, long seconds) throws JsonProcessingException {
            redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
            return true;
        }
    
        @Override
        public <T> T get(String key, Class<T> clazz) throws IOException {
            Object o = redisTemplate.opsForValue().get(key);
            if (o != null) {
                String json = String.valueOf(o);
                T t = JsonUtil.stringToObject(json, clazz);
                return t;
            }
            return null;
        }
        }

## 创建redisController测试redis服务 ##

@RestController
        public class RedisController {
    
            @Autowired
            private RedisService redisService;
    
            @PostMapping(value = "put")
            public String put(String key,String value,long seconds){
    
                redisService.put(key,value,seconds);
                return "ok";
            }
    
            @GetMapping(value = "get")
            public Object get(String key){
    
                Object o=redisService.get(key);
                if(o!=null){
                    return String.valueOf(o);
                }
                return "not_ok";
            }
        }

[aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]: /images/20221124/07d70f3ca924446590bd445e8ef67034.png
[https_www.cnblogs.com_wps54213_p_12608777.html]: https://www.cnblogs.com/wps54213/p/12608777.html

发表评论取消回复

表情：

评论列表（有 0 条评论，218人围观）

还没有评论，来说两句吧...

相关阅读

相关 springboot连接redis集群，springboot整合redis

1、案例说明重点说明1：很多人redis集群已经配置成功了，并且可以正常使用，但是springboot工程无法连接。情况1：linux系统没有开发端口，需要开放

快来打我*/ 2023年09月25日 22:32/ 0 赞/ 141 阅读

相关 SpringBoot整合连接Redis集群

第一步，新建项目maven项目，添加依赖（1）本文所采用的SpringBoot的版本如下 <parent> <groupId>org.s

灰太狼/ 2022年11月30日 04:27/ 0 赞/ 219 阅读

相关 Springboot整合redis及redis集群

1、maven依赖 <dependency> <groupId>org.springframework.boot</grou

深碍√TFBOYSˉ_/ 2022年06月04日 07:48/ 0 赞/ 318 阅读

相关 SpringBoot整合Redis集群

1.在pom.xml中加入redis的依赖 2.在application.properties加入整合redis的配置。（spring.redis.cluster.n

系统管理员/ 2022年05月30日 03:38/ 0 赞/ 225 阅读

相关 SpringBoot整合Redis、和Redis集群

一、SpringBoot整合Redis 步骤：1.添加依赖：  <dependency> <groupId>org.

水深无声/ 2022年05月14日 00:22/ 0 赞/ 326 阅读

相关 SpringBoot整合Redis集群

目的 > 使用SpringBoot 1.5.8.RELEASE版本整合Redis 4.0.11，实现Redis Pool操作Redis集群引入依赖 <!

曾经终败给现在/ 2022年05月12日 08:54/ 0 赞/ 286 阅读

相关 springboot连接redis集群

1.创建maven工程，导入依赖，pom文件内容如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xml

刺骨的言语ヽ痛彻心扉/ 2022年04月15日 06:16/ 0 赞/ 443 阅读

相关 SpringBoot整合redis集群

一：缓存的应用场景 1：什么是缓存？在互联网场景下，尤其 2C 端大流量场景下，需要将一些经常展现和不会频繁变更的数据，存放在存取速率更快的地方。缓存就是一个存储器，在技

叁歲伎倆/ 2022年04月03日 14:18/ 0 赞/ 357 阅读

相关 Redis集群——SpringBoot连接Redis集群(带密码)

第一步，新建项目maven项目，添加依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="htt

r囧r小猫/ 2022年03月15日 05:10/ 0 赞/ 472 阅读

相关 springboot整合redis集群

一、redis集群原理 redis集群中的所有节点彼此互联，节点内部采用二进制协议优化传输速度和带宽，每个节点都可以与Java客户端连接。redis集群的数据分配采用哈希

以你之姓@/ 2022年03月10日 11:46/ 0 赞/ 358 阅读