SpringBoot + redis cluster集群搭建

系统管理员 2023-07-05 14:57 1阅读 0赞

## SpringBoot + redis cluster集群搭建 ##

**前言**：本文针对另一篇[Redis集群策略及集群实例（集群节点新增、删除、重新分配slot实战）][Redis_slot]博文搭建的Java项目用于redis集群完整流程的学习，仅供参考；  
***本文代码参考与码云开源项目相关资料***  
**1. 环境**  
（1）.springboot 2.0  
（2）.redis 4.0.10  
**2.相关代码**  
一，pom.xml文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.4.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>spring.boot</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
        <name>jpa</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <start-class>org.tdcg.Application</start-class>
            <java.version>1.8</java.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.6</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
            </dependency>
            
            <dependency>
                <groupId>org.bgee.log4jdbc-log4j2</groupId>
                <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
                <version>1.16</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
            
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <exclusions>
                    <exclusion>
                        <groupId>io.lettuce</groupId>
                        <artifactId>lettuce-core</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            
            
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.31</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.3.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
            <finalName>SpringBootJap</finalName>
        </build>
    </project>

二，配置文件 application.properties

#datasource#mysql数据库#
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/study-jpa?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    spring.datasource.username = root
    spring.datasource.password = 123456
    spring.datasource.driverClassName = com.mysql.cj.jdbc.Driver
    spring.datasource.max-active=20
    spring.datasource.max-idle=8
    spring.datasource.min-idle=8
    spring.datasource.initial-size=10
    # server
    server.port: 8081

三，redis配置文件 redis.properties

#代表redis多个节点的ip与端口号，多个节点需要使用“，”隔开。
    spring.redis.cluster.nodes=192.168.0.108:8001,192.168.0.108:8002,192.168.0.108:8003,192.168.0.108:8004,192.168.0.108:8005,192.168.0.108:8006
    # 最大的要重定向的次数（由于集群中数据存储在多个节点所以，在访问数据时需要通过节点进行转发）
    # 连接超时的时间
    spring.redis.cluster.timeout=5000
    #最大的连接重试次数
    spring.redis.cluster.max-attempts=3
    #读取数据超时
    spring.redis.cluster.soTimeout=3000
    spring.redis.cluster.max-redirects=3

三，创建文件夹redis配置，依此创建redis初始化配置RedisConfiguration ，JedisClusterFactory工厂类，自定义缓存接口ICacheManager 以及redis客户端实现类JedisCacheManager

（一）redis初始化配置RedisConfiguration

package spring.boot.jpa.redis;
    
    
    import com.google.common.collect.Sets;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    
    import java.util.Collections;
    import java.util.Set;
    
    /** * @Title: RedisConfiguration * @Description: redis初始化配置 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    @Configuration
    
    @PropertySource("classpath:redis.properties")
    public class RedisConfiguration extends CachingConfigurerSupport { 
    
        @Bean(name = "jedisCluster")
        public JedisClusterFactory jedisCluster(
                @Value("${spring.redis.cluster.nodes}") String host,
                @Value("${spring.redis.cluster.timeout}") int connectionTimeout,
                @Value("${spring.redis.cluster.soTimeout}") int soTimeout) { 
            JedisClusterFactory jedisClusterFactory = new JedisClusterFactory();
            jedisClusterFactory.setConnectionTimeout(connectionTimeout);
           // jedisClusterFactory.setMaxRedirections(maxRedirections);
            jedisClusterFactory.setSoTimeout(soTimeout);
            String[] split = host.split(",");
            Set<String> hosts = Sets.newHashSet();
            Collections.addAll(hosts, split);
            jedisClusterFactory.setJedisClusterNodes(hosts);
            return jedisClusterFactory;
        }
    }

（二）JedisClusterFactory工厂类

package spring.boot.jpa.redis;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.FactoryBean;
    import org.springframework.beans.factory.InitializingBean;
    import redis.clients.jedis.HostAndPort;
    import redis.clients.jedis.JedisCluster;
    import java.text.ParseException;
    import java.util.HashSet;
    import java.util.Set;
    
    /** * @Title: JedisClusterFactory * @Description: 工厂类 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean { 
    	private GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
    	private JedisCluster jedisCluster;
    	private int connectionTimeout = 2000;
    	private int soTimeout = 3000;
    	private int maxRedirections = 5;
    	private Set<String> jedisClusterNodes;
    	@Override
    	public void afterPropertiesSet() throws Exception { 
    		if (jedisClusterNodes == null || jedisClusterNodes.size() == 0) { 
    			throw new NullPointerException("jedisClusterNodes is null.");
    		}
    		Set<HostAndPort> haps = new HashSet<HostAndPort>();
    		for (String node : jedisClusterNodes) { 
    			String[] arr = node.split(":");
    			if (arr.length != 2) { 
    				throw new ParseException("node address error !",node.length()-1);
    			}
    			haps.add(new HostAndPort(arr[0], Integer.valueOf(arr[1])));
    		}
    		jedisCluster = new JedisCluster(haps, connectionTimeout, soTimeout, maxRedirections, genericObjectPoolConfig);
    	}
    	@Override
    	public JedisCluster getObject() throws Exception { 
    		return jedisCluster;
    	}
    	@Override
    	public Class<?> getObjectType() { 
    		return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
    	}
    	@Override
    	public boolean isSingleton() { 
    		return true;
    	}
    
    	public GenericObjectPoolConfig getGenericObjectPoolConfig() { 
    		return genericObjectPoolConfig;
    	}
    	public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) { 
    		this.genericObjectPoolConfig = genericObjectPoolConfig;
    	}
    
    	public JedisCluster getJedisCluster() { 
    		return jedisCluster;
    	}
    
    	public void setJedisCluster(JedisCluster jedisCluster) { 
    		this.jedisCluster = jedisCluster;
    	}
    
    	public int getConnectionTimeout() { 
    		return connectionTimeout;
    	}
    
    	public void setConnectionTimeout(int connectionTimeout) { 
    		this.connectionTimeout = connectionTimeout;
    	}
    
    	public int getSoTimeout() { 
    		return soTimeout;
    	}
    
    	public void setSoTimeout(int soTimeout) { 
    		this.soTimeout = soTimeout;
    	}
    
    	public int getMaxRedirections() { 
    		return maxRedirections;
    	}
    
    	public void setMaxRedirections(int maxRedirections) { 
    		this.maxRedirections = maxRedirections;
    	}
    
    	public Set<String> getJedisClusterNodes() { 
    		return jedisClusterNodes;
    	}
    
    	public void setJedisClusterNodes(Set<String> jedisClusterNodes) { 
    		this.jedisClusterNodes = jedisClusterNodes;
    	}
    }

(三) 自定义缓存操作接口ICacheManager

package spring.boot.jpa.redis;
    
    import java.io.Serializable;
    import java.util.List;
    import java.util.Map;
    
    /** * @Title: ICacheManager * @Description: 缓存接口，定义方法 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    public interface ICacheManager { 
    
        /** * 根据缓存key获取值 * * @param cacheKey * @return */
        public Object getCache(Serializable cacheKey);
    
        /** * 设置缓存数据的key-value，并设置失效时间，单位为秒 * * @param cacheKey * @param objValue * @param expiration * @return */
        public boolean putCache(Serializable cacheKey, Object objValue, int expiration);
    
        /** * 清除缓存 * * @param cacheKey */
        public Long removeCache(Serializable cacheKey);
    
        /** * 向指定list集合中添加对象，在list尾部添加对象 * * @param cacheKey * @param objValue * @return */
        public boolean putListCache(Serializable cacheKey, Object objValue);
    
        /** * 向指定list集合中添加对象，并指定位置坐标 * * @param cacheKey * @param objValue * @param index * @return */
        public boolean putListCache(Serializable cacheKey, Object objValue, int index);
    
        /** * 根据坐标，返回一段集合 * * @param cacheKey * @param start 起始坐标 头部为0 * @param end 结束坐标 尾部为-1 * @return */
        public List<Object> getListCache(Serializable cacheKey, int start, int end);
    
        /** * 返回结合 * * @param cacheKey * @return */
        public List<Object> getListCache(Serializable cacheKey);
    
        /** * 裁剪list集合 * * @param cacheKey * @param start 起始坐标 * @param end 结束坐标 * @return */
        public boolean trimListCache(Serializable cacheKey, int start, int end);
    
        /** * 添加map集合 * * @param cacheKey * @param map * @return */
        public boolean putMapCache(Serializable cacheKey, Map<Object, Object> map);
    
        /** * 删除map中的键值 * * @param cacheKey * @param mapKey * @return */
        public boolean deleteMapCache(Serializable cacheKey, Serializable mapKey);
    
    
        /** * 获取map中的值 * * @param cacheKey * @param mapKey * @return */
        public Object getMapValueCache(Serializable cacheKey, Serializable mapKey);
    }

（四）redis客户端实现类JedisCacheManager

package spring.boot.jpa.redis.impl;
    
    import com.alibaba.druid.util.StringUtils;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.JedisCluster;
    import spring.boot.jpa.redis.ICacheManager;
    import spring.boot.jpa.redis.SerializingUtil;
    
    import javax.annotation.Resource;
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    /** * @Title: JedisCacheManager * @Description: 接口实现 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    @Service("iCacheManager")
    public class JedisCacheManager implements ICacheManager { 
    
        private static final String JEDIS_SET_RETURN_OK = "OK";
    
        @Resource
        private JedisCluster jedisCluster;
    
        @Override
        public Object getCache(Serializable cacheKey) { 
            return SerializingUtil.deserialize((byte[]) jedisCluster.get(SerializingUtil.serialize(cacheKey)));
        }
    
        @Override
        public boolean putCache(Serializable cacheKey, Object objValue, int expiration) { 
            String result = jedisCluster.setex(SerializingUtil.serialize(cacheKey), expiration, SerializingUtil.serialize(objValue));
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
                return true;
            }
            return false;
        }
    
        @Override
        public Long removeCache(Serializable cacheKey) { 
            return jedisCluster.del(SerializingUtil.serialize(cacheKey));
        }
    
        @Override
        public boolean putListCache(Serializable cacheKey, Object objValue) { 
            Long num = jedisCluster.rpush(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(objValue));
            if (num > 0) { 
                return true;
            }
            return false;
        }
    
        @Override
        public boolean putListCache(Serializable cacheKey, Object objValue, int index) { 
            String result = jedisCluster.lset(SerializingUtil.serialize(cacheKey), index, SerializingUtil.serialize(objValue));
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
                return true;
            }
            return false;
        }
    
        @Override
        public List<Object> getListCache(Serializable cacheKey, int start, int end) { 
            List<byte[]> list = jedisCluster.lrange(SerializingUtil.serialize(cacheKey), start, end);
            if (null != list && list.size() > 0) { 
                List<Object> objList = new ArrayList<Object>();
                for (byte[] b : list) { 
                    objList.add(SerializingUtil.deserialize(b));
                }
                return objList;
            }
            return null;
        }
    
        @Override
        public List<Object> getListCache(Serializable cacheKey) { 
            return getListCache(cacheKey, 0, -1);
        }
    
        @Override
        public boolean trimListCache(Serializable cacheKey, int start, int end) { 
            String result = jedisCluster.ltrim(SerializingUtil.serialize(cacheKey), start, end);
            if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
                return true;
            }
            return false;
        }
    
        @Override
        public boolean putMapCache(Serializable cacheKey, Map<Object, Object> map) { 
            if (null != map && !map.isEmpty()) { 
                Map<byte[], byte[]> byteMap = new HashMap<byte[], byte[]>();
                for (Entry<Object, Object> entry : map.entrySet()) { 
                    byteMap.put(SerializingUtil.serialize(entry.getKey()), SerializingUtil.serialize(entry.getValue()));
                }
                String result = jedisCluster.hmset(SerializingUtil.serialize(cacheKey), byteMap);
                if (StringUtils.equals(JEDIS_SET_RETURN_OK, result)) { 
                    return true;
                }
                return true;
            }
            return false;
        }
    
        @Override
        public boolean deleteMapCache(Serializable cacheKey, Serializable mapKey) { 
            Long result = jedisCluster.hdel(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
            if (result > 0) { 
                return true;
            }
            return false;
        }
    
    
        @Override
        public Object getMapValueCache(Serializable cacheKey, Serializable mapKey) { 
            List<byte[]> list = jedisCluster.hmget(SerializingUtil.serialize(cacheKey), SerializingUtil.serialize(mapKey));
            if (null != list && list.size() > 0) { 
                return SerializingUtil.deserialize(list.get(0));
            }
            return null;
        }
    
    }

(五) 序列化工具类

package spring.boot.jpa.redis;
    import org.apache.log4j.Logger;
    import org.springframework.cache.CacheManager;
    import java.io.*;
    /** * @Title: SerializingUtil * @Package: org.tdcg.util * @Description: 序列化工具类，负责byte[]和Object之间的相互转换. * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    public class SerializingUtil { 
    
        private static final Logger logger = Logger.getLogger(CacheManager.class);
    
        /** * 功能简述: 对实体Bean进行序列化操作. * * @param source 待转换的实体 * @return 转换之后的字节数组 * @throws Exception */
        public static byte[] serialize(Object source) { 
            ByteArrayOutputStream byteOut = null;
            ObjectOutputStream ObjOut = null;
            try { 
                byteOut = new ByteArrayOutputStream();
                ObjOut = new ObjectOutputStream(byteOut);
                ObjOut.writeObject(source);
                ObjOut.flush();
            } catch (IOException e) { 
                logger.error(source.getClass().getName() + " serialized error !", e);
            } finally { 
                try { 
                    if (null != ObjOut) { 
                        ObjOut.close();
                    }
                } catch (IOException e) { 
                    ObjOut = null;
                }
            }
            return byteOut.toByteArray();
        }
    
        /** * 功能简述: 将字节数组反序列化为实体Bean. * * @param source 需要进行反序列化的字节数组 * @return 反序列化后的实体Bean * @throws Exception */
        public static Object deserialize(byte[] source) { 
            ObjectInputStream ObjIn = null;
            Object retVal = null;
            try { 
                ByteArrayInputStream byteIn = new ByteArrayInputStream(source);
                ObjIn = new ObjectInputStream(byteIn);
                retVal = ObjIn.readObject();
            } catch (Exception e) { 
                logger.error("deserialized error !", e);
            } finally { 
                try { 
                    if (null != ObjIn) { 
                        ObjIn.close();
                    }
                } catch (IOException e) { 
                    ObjIn = null;
                }
            }
            return retVal;
        }
    }

(五) 测试类

package spring.boot.jpa;
    
    
    import com.google.common.collect.Maps;
    import org.junit.FixMethodOrder;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.MethodSorters;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    import spring.boot.jpa.entity.User;
    import spring.boot.jpa.redis.impl.JedisCacheManager;
    
    import javax.annotation.Resource;
    import java.util.List;
    import java.util.Map;
    
    
    /** * @Title: JedisCacheManagerTest * @Description: 测试类，测试方法有顺序要求 * 添加@FixMethodOrder(MethodSorters.NAME_ASCENDING) 以使执行方法按名称顺序执行 * @Author: zyq * @date: 2020/02/12 * @Version: V1.0 */
    //Junit4运行环境
    @RunWith(SpringJUnit4ClassRunner.class)
    //单元测试时需要执行的SpringBoot启动类（根据需要引入执行）
    @SpringBootTest(classes={ JpaApplication.class})// 指定启动类
    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
    //如果是Web项目，Junit需要模拟ServletContext获取web等配置
    //@WebAppConfiguration
    public class JedisCacheManagerTest { 
    
        private final int expiration = 3600;
    
        @Resource
        private JedisCacheManager jedisCacheManager;
    
        @Test
        public void testAPutCache() throws Exception { 
            boolean test = jedisCacheManager.putCache("test", "welocme redis cluster! created by tdcg!", expiration);
            assert(test);
        }
        @Test
        public void testBGetCache() throws Exception { 
            Object test = jedisCacheManager.getCache("test");
            System.out.println(test);
            assert(test.equals("welocme redis cluster! created by tdcg!"));
        }
        @Test
        public void testCRemoveCache() throws Exception { 
            Long test = jedisCacheManager.removeCache("test");
            assert(test == 1L);
        }
     }

***至此redis集群代码层面基本实现，仅供参考，欢迎指教！！！！！！***

[Redis_slot]: https://blog.csdn.net/iT_MaNongking/article/details/104301854