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

r囧r小猫 2022-03-15 05:10 400阅读 0赞

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

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>springboot-redis-cluster</groupId>
        <artifactId>redis-cluster</artifactId>
        <version>1.0-SNAPSHOT</version>
        <description>springboot连接redis-cluster集群</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.2.RELEASE</version>
            <relativePath/>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.9.0</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

**第二步**，编写配置文件

spring:
      application:
        name: redis-cluster
      redis:
        cluster:
          nodes: 192.168.1.10:7001,192.168.1.10:7004,192.168.1.11:7002,192.168.1.11:7005,192.168.1.12:7003,192.168.1.12:7006
          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

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

package com.config;
    
    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.JdkSerializationRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * Created by Administrator on 2019/2/28.
     */
    @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;
        @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
         * @throws
         */
        @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;
        }
    
        /**
         * @param
         * @return
         * @Description:redis连接工厂类
         * @date 2018/10/25 19:45
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory() {
            //集群模式
            JedisConnectionFactory  factory = new JedisConnectionFactory(redisClusterConfiguration(),getJedisPoolConfig());
            factory.setDatabase(0);
            factory.setTimeout(timeout);
            factory.setUsePool(true);
            return factory;
        }
    
        /**
         * 实例化 RedisTemplate 对象
         *
         * @return
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            initDomainRedisTemplate(redisTemplate);
            return redisTemplate;
        }
    
        /**
         * 设置数据存入 redis 的序列化方式,并开启事务
         * 使用默认的序列化会导致key乱码
         *
         */
        private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
            //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            //这个地方有一个问题，这种序列化器会将value序列化成对象存储进redis中，如果
            //你想取出value，然后进行自增的话，这种序列化器是不可以的，因为对象不能自增；
            //需要改成StringRedisSerializer序列化器。
            redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
            redisTemplate.setEnableTransactionSupport(false);
            redisTemplate.setConnectionFactory(jedisConnectionFactory());
        }
    }

**第四步**，编写Controller

@RestController
    public class TestController {
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @GetMapping("/test")
        public void test(){
            System.out.println(redisTemplate.hasKey("name"));
            redisTemplate.opsForValue().set("name","123214");
            String name = (String) redisTemplate.opsForValue().get("name");
            System.out.println(name);
            redisTemplate.opsForValue().set("name2","123214");
            String name2 = (String) redisTemplate.opsForValue().get("name");
            System.out.println(name2);
            redisTemplate.opsForValue().set("name3","123214");
            String name3 = (String) redisTemplate.opsForValue().get("name");
            System.out.println(name3);
            redisTemplate.opsForValue().set("name4","123214");
            String name4 = (String) redisTemplate.opsForValue().get("name");
            System.out.println(name4);
            HashOperations<String,String,String> hashOperations = redisTemplate.opsForHash();
            hashOperations.put("user","test","测试");
            System.out.println(hashOperations.get("user","test"));
        }
    }

**第五步**，启动项目测试，控制台打印

true
    123214
    123214
    123214
    123214
    测试