redis集群搭建，以及spring boot整合redis集群

最新推荐文章于 2024-05-11 17:12:48 发布
最新推荐文章于 2024-05-11 17:12:48 发布
阅读量578 收藏 2
点赞数
分类专栏： spring boot reids
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32157851/article/details/88167024
版权

redis的集群搭建非常简单，我使用的是redis 4.0.10在centos 7.2 上搭建的，按照配置文件搭建就可以，并且前面的博客收藏了集群搭建的链接。

搭建完以后就是项目中整合redis集群，这里有个小推荐，使用jedis整合redis集群非常简单，下面是整合的步骤：

一、单机版和集群版的redis整合

1）首先在pom.xml中导入jar包

<!-- redis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>

说明：这里导入的jar包是2.9的jedis，由于我使用的是4.0.10版本，版本比较新，所以至少要使用2.9或以上版本，不然启动的过程中会报错，抛出的异常是 java.lang.NumberFormatException:   6004@16004    类似这样的异常。 

2）单机版的配置文件 需要写在  application.properties 如下

#Redis Pool ============================================================================================================

jedis.pool.host=127.0.0.1
jedis.pool.port=6379
jedis.pool.timeout=30000
jedis.pool.password=password123


jedis.pool.dbIndex=0
jedis.pool.maxTotal=300
jedis.pool.maxIdle=10
jedis.pool.maxWaitMillis=30000

3) 集群版的配置文件需要在  resources  下新建一个文件  redis.properties,内容如下

#redis cluster
xyy.redis.pool.nodes=192.168.3.141:6000,192.168.3.141:6001,192.168.3.141:6002,192.168.3.143:6003,192.168.3.143:6004,192.168.3.143:6005,192.168.3.144:6006,192.168.3.144:6007,192.168.3.144:6008
xyy.redis.pool.timeout=3000
xyy.redis.pool.soTimeout=1500
xyy.redis.pool.maxAttempts=5
xyy.redis.pool.password=password23

4）实现单机版的jedis连接 redis 代码

package com.qzt.common.redis;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.qzt.util.PubFunc;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Slf4j
@Configuration
public class RedisConfiguration {
	
	@Primary
	@Bean(name="jedisPool")
	public JedisPool jedisPool(@Qualifier("jedisPoolConfig") JedisPoolConfig config, 
			@Value("${jedis.pool.host}")String host, 
			@Value("${jedis.pool.port}")int port, 
			@Value("${jedis.pool.timeout}")int timeout, 
			@Value("${jedis.pool.password}")String passowrd, 
			@Value("${jedis.pool.dbIndex}")int dbIndex){
		log.info("init redis pool -------------->host:{},port:{},dbIndex",host,port,dbIndex);
		if(PubFunc.isNull(passowrd)){
			passowrd = null;
		}
		return new JedisPool(config,host,port,timeout,passowrd,dbIndex);
	}
	@Primary
	@Bean(name="jedisPoolConfig")
	public JedisPoolConfig jedisPoolConfig(@Value("${jedis.pool.maxTotal}")int maxTotal, 
			@Value("${jedis.pool.maxIdle}")int maxIdle, 
			@Value("${jedis.pool.maxWaitMillis}")int maxWaitMillis){
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(maxTotal);
		config.setMaxIdle(maxIdle);
		config.setMaxWaitMillis(maxWaitMillis);
		return config;
	}
}

5）实现集群版的jedis连接 redis 代码，需要写两个类来实现 一个  RedisProperties.java  ,一个JedisClusterConfig.java

RedisProperties.java 类内容如下：

package com.qzt.common.redis;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * redis集群配置文件
 * @ClassName: RedisProperties
 * @author suziqing
 */
@Data
@Component
@ConfigurationProperties(prefix = "xyy.redis.pool")
@PropertySource("classpath:redis.properties")
public class RedisProperties {
    /** redis集群节点 */
    private String nodes;
    /** 连接超时时间 */
    private int timeout;
    /** 重连次数 */
    private int maxAttempts;
    private String password;
    //读取数据超时时间
    private int   soTimeout;
 
    public RedisProperties() {
    }
 
	public RedisProperties(String nodes, int timeout, int maxAttempts, String password, int soTimeout) {
	this.nodes = nodes;
	this.timeout = timeout;
	this.maxAttempts = maxAttempts;
	this.password = password;
	this.soTimeout = soTimeout;
}


}

JedisClusterConfig.java 代码如下：

package com.qzt.common.redis;

import java.util.HashSet;

/**
 * 生成JedisCluster对象
 * @ClassName: JedisClusterConfig
 * @author suziqing
 * @date 2018年7月10日18:07:04
 */
@Slf4j
@Configuration
public class JedisClusterConfig {
    @Autowired
    private RedisProperties redisProperties;
 
    /**
     * 注意：
     * 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用
     * @return
     */
    @Bean
    public JedisCluster getJedisCluster() {
    	log.info("---------getJedisCluster-----");
        String[] serverArray = redisProperties.getNodes().split(",");//获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        log.info("---------getTimeout-----"+redisProperties.getTimeout()+"------getMaxAttempts-----"+redisProperties.getMaxAttempts());
        try{
        	for (String ipPort : serverArray) {
                String[] ipPortPair = ipPort.split(":");
                log.info("----ipPortPair[0]----------"+ipPortPair[0]+"----ipPortPair[1]----------"+ipPortPair[1]);
                nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
            }
		}catch (Exception e){
			log.info("-------------exception--------222----------");
		}
//        soTime  读取数据超时间
        return new JedisCluster(nodes, redisProperties.getTimeout(), redisProperties.getSoTimeout(), redisProperties.getMaxAttempts(), redisProperties.getPassword(), new GenericObjectPoolConfig());
    }
}

 

6）集成单机版和集群版的工具类

package com.qzt.manager;

import java.io.IOException;

@Slf4j
@Component
public class JedisManager {

	@Autowired
	public JedisPool jedisPool;
	public static JedisManager jedisManager;
	
	@Autowired
	private  JedisClusterConfig jedisClusterConfig;

	@PostConstruct
	public void init() {
		jedisManager = this;
		if (PubPara.isCloud){//平台端就使用 集群版配置
			jedisManager.jedisClusterConfig = this.jedisClusterConfig;
		}else{//设备端就是用单机版
			jedisManager.jedisPool = this.jedisPool;
		}
		
	}

	public static void set(String key, String value) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
				log.info("-------jedisClusterConfig---------"+jedisManager.jedisClusterConfig);
				jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
				jedisCluster.set(key, value);
			}else{
				log.info("-------jedis---333333333------"+jedisManager.jedisClusterConfig);
				jedis = jedisManager.jedisPool.getResource();
				jedis.set(key, value);
			}
			
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			//这里不需要关闭，我们使用的是redis3.0的集群，
//			用jedis的JedisCluster.close()方法造成的集群连接关闭的情况。 
//			jedisCluster内部使用了池化技术，
//			每次使用完毕都会自动释放Jedis因此不需要关闭。如果调用close方法后再调用jedisCluster的api进行操作时就会出现如上错误
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static String get(String key) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
				jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
				return  jedisCluster.get(key);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				return jedis.get(key);
			}
			 
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return null;
	}

	public static void del(String key) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			}else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					jedis.del(key);
				}
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}
	public static void hdel(String key,List<String> fields) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				for(String field:fields){
					jedisCluster.hdel(key, field);
				}
			}
			}else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					for (String field : fields){
						jedis.hdel(key, field);
					}
				}
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}
	
	public static void hdelOne(String key,String fields) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				jedisCluster.hdel(key, fields);
			}
			}
			else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					jedis.hdel(key, fields);
				}
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}
	
	public static void hmset(String key, Map<String, String> map) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			jedisCluster.hmset(key, map);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					jedis.del(key);
				}
				jedis.hmset(key, map);
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static Map<String, String> hmget(String key) {
		Map<String, String> map = new HashMap<String, String>();
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				Set<String> keys = jedisCluster.hkeys(key);
				for (String k : keys) {
					map.put(k, jedisCluster.hmget(key, k).get(0));
				}
			}
			}else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					Set<String> keys = jedis.hkeys(key);
					for (String k : keys){
						map.put(k, jedis.hmget(key, k).get(0));
					}
				}
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}

		return map;
	}
	
	public static Map<String, String> hmget(String key,String name) {
		Map<String, String> map = new HashMap<String, String>();
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			if (jedisCluster.exists(key)) {
				Set<String> keys = jedisCluster.hkeys(key);
				for (String k : keys) {
					if(k.contains(name)){
						map.put(k, jedisCluster.hmget(key, k).get(0));
					}
				}
			}
			}else{
				jedis = jedisManager.jedisPool.getResource();
				if (jedis.exists(key)){
					Set<String> keys = jedis.hkeys(key);
					for (String k : keys){
						if (k.contains(name)){
							map.put(k, jedis.hmget(key, k).get(0));
						}
					}
				}
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}

		return map;
	}

	public static boolean exists(String key) {
		boolean flag = false;
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			flag = jedisCluster.exists(key);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				flag = jedis.exists(key);
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return flag;
	}
	public static boolean hexists(String key,String field) {
		boolean flag = false;
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			flag = jedisCluster.hexists(key, field);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				flag = jedis.hexists(key, field);
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return flag;
	}
	
	public static void hmsetNoDel(String key, Map<String, String> map) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			jedisCluster.hmset(key, map);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				jedis.hmset(key, map);
			}
		} catch (Exception e) {
			log.info("jedis error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static void subscribe(RedisMsgPubSubListener listener,
			String redisChat) {

		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			/**
			 * 注意：subscribe是一个阻塞的方法，在取消订阅该频道前，会一直阻塞在这，只有当取消了订阅才会执行下面的other code，
			 * 参考上面代码，我在onMessage里面收到消息后，调用了this.unsubscribe();
			 * 来取消订阅，这样才会执行后面的other code redisChat 频道名称
			 */
			jedisCluster.subscribe(listener, redisChat);
			// 如果没有取消订阅,方法将一直堵塞在此处不会向下执行
			// to do others
			}else{
				jedis = jedisManager.jedisPool.getResource();
				jedis.subscribe(listener, redisChat);
			}
		} catch (Exception e) {
			log.error("bbbbbbbbbbberror:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static void sendToC(String redisChat, String value) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			jedisCluster.publish(redisChat, value);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				jedis.publish(redisChat, value);
			}
		} catch (Exception e) {
			log.error("error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static void hset(String key, String field, String value) {
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			jedisCluster.hset(key, field, value);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				jedis.hset(key, field, value);
			}
		} catch (Exception e) {
			log.error("error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
	}

	public static String hget(String key, String field) {
		String result = "";
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			result = jedisCluster.hget(key, field);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				result = jedis.hget(key, field);
			}
		} catch (Exception e) {
			log.error("error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return result;
	}

	public static long lpush(String key, String field) {
		long count = 0;
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			count = jedisCluster.lpush(key, field);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				count = jedis.lpush(key, field);
			}
		} catch (Exception e) {
			log.error("error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return count;
	}

	public static List<String> lrange(String key, long start, long end) {
		List<String> result = null;
		JedisCluster jedisCluster = null;
		Jedis  jedis = null;
		try {
			if (PubPara.isCloud){
			jedisCluster = jedisManager.jedisClusterConfig.getJedisCluster();
			result = jedisCluster.lrange(key, start, end);
			}else{
				jedis = jedisManager.jedisPool.getResource();
				result = jedis.lrange(key, start, end);
			}
		} catch (Exception e) {
			log.error("error:", e);
		} finally {
			if (!PubPara.isCloud){
				jedis.close();
			}
		}
		return result;
	}

}

 

7)测试类测试  在一个controller中写如下代码进行测试

@RequestMapping("/jedis/test")
	public void testLicense(){
		
		JedisCluster jedisCluster = jedisClusterConfig.getJedisCluster();
		
//		 String className = jedisCluster.get("class");
//       log.info("班级="+className);
//       String age = jedisCluster.get("age");
//       log.info("年龄="+age);
//       jedisCluster.set("yanzhenma","87878");
//       String yanzhenma = jedisCluster.get("yanzhenma");
//       log.info("验证码="+yanzhenma);
//       List<String> list = jedisCluster.lrange("list", 0, -1);
//         for (String string : list){
//			log.info("-------result------"+string);
//		}
//		
         JedisManager.set("feiyi", "kunhua");
         String string = JedisManager.get("feiyi");
         log.info("---------string---------"+string);
         
         JedisManager.hset("qwe", "www", "eee");
         String hget = JedisManager.hget("qwe", "www");
         log.info("----hget-------"+hget);
}

注：在整合的过程中遇到一些问题：

1）第一个就是启动不了的问题，老是报 数字转化异常 ，日志打印出来都是数字没有问题得，上网找了以后明白了是jedis版本过低导致的，将jedis改为  2.9 就可以了

2）第二个问题就是使用集群版的时候  我写了这么一句：  jedisCluster.close(); 导致使用使用jedis操作redis的时候报错，抛出JedisNoReachableClusterNodeException异常(No reachable node in cluster)  ，通过网上查询明白jedisCluster内部使用了池化技术， 每次使用完毕都会自动释放Jedis因此不需要关闭。如果调用close方法后再调用jedisCluster的api进行操作时就会出现如上错误。 

3）第三个就是我们需要将单机版和集群版在一个项目中都还可以使用，通过配置文件来控制使用集群版还是单机版。为了这个需求就有了上面工具类中的判断是否为平台端的代码。

4）前面说了推荐使用jedis 来连接redis，好处就是连接方便简单，最后测试证明单机版和集群版都可以在一套代码中实现

 

 

 

 

非衣鲲化
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 配置redis集群
TechnicianWang的博客
04-28 3万+
applcation.yml # redis 配置 redis: server: pattern: cluster nodes: 127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003,127.0.0.1:3004,127.0.0.1:3005 password: maxIdle: 8 minIdle: 4 maxTotal: 8 maxWaitMillis: 6000
SpringBoot配置Redis多集群数据源
TheOne的博客
12-10 3017
Redis 三大客户端 简介 Jedis：是Redis 老牌的Java实现客户端，提供了比较全面的Redis命令的支持， Redisson：实现了分布式和可扩展的Java数据结构。 Lettuce：高级Redis客户端，用于线程安全同步，异步和响应使用，支持集群，Sentinel，管道和编码器。 优点： Jedis：比较全面的提供了Redis的操作特性 Redisson：促使使用者对Redis的关注分离，提供很多分布式相关操作服务，例如分布式锁，分布式集合，可通过Redis支持延迟队列 Le..
SpringBoot集成Redis环境搭建及配置详解
最新发布
2301_79351943的博客
05-11 1718
Redis作为当前最火的NoSQL数据库，支持很多语言客户端操作Redis。而SpringBoot作为java当前最火的开发框架，提供了Spring-data-redis框架实现对Redis的各种操作。在springboot1.5.x版本的默认的Redis客户端都是Jedis实现的，springboot 2.x版本中默认的客户端是用lettuce实现的。
springboot整合redis集群
m0_68574821的博客
04-01 6015
发现写是写成功了但是出现了乱码的问题（因为springboot默认的序列化会出现乱码，我们要的key要使用string的方式序列化，value要使用json的方式序列化）7.在主启动类上加上@EnableSwagger2注解。11.在RedisConfig配置类上面配置。2.创建测试类（lettuceDemo）4.编辑OrderService业务类。12.再次启动主动类且在插入数据。1.修改pom.xml配置文件。1.修改pom.xml 文件。6.修改Swagger配置类。1.修改pom.xml。
Spring Boot 整合 Redis 集群详解
weixin_42118323的博客
04-13 3782
分析结果，我们发现出现了一串字符串 “\xac\xed\x00\x05t\x00\x10”，这串字符串明显不是我们想要看到的，难道是 Redis 集成又出问题了吗，使用代码获取了缓存字符串，发现并没有这串奇奇怪怪的字符串，那是怎么回事呢？以上配置，会自动由 Spring Boot 自动装配，不需要再配置类，Spring Boot 会自动把这些配置参数加载后实例化连接池。本篇简单分享了 Spring Boot 项目集成 Redis 过程中可能会需要的一些问题，希望能够帮助到有需要的朋友。
springboot使用redis的keys替代方案
qq_37670457的博客
03-28 3041
最近项目中需要获取指定前缀的key, 然后删除这些key, 作为对redis命令不太深入了解的我第一想法就是redis的keys命令, 只需keys prefix + * 就可以了, 在测试环境这样开发没有问题, 由于项目对redis依赖比较大, 就网上找了一些关于redis的keys命令, 得知keys命令执行的时候会严重阻塞线上其它命令的正常请求, 于是做了以下替代方案 /** *...
springcloud部署redis集群
09-20
配置SpringCloud以连接Redis集群，你需要在Spring Boot的`application.yml`或`application.properties`中设置Redis连接信息。由于是集群模式，因此需要指定`cluster.nodes`属性，如下所示： ```yaml spring: data:...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
springboot整合redis集群零配置
07-28
本篇文章将深入探讨如何在Spring Boot中实现对Redis集群的零配置整合，并介绍使用AOP实现的自定义缓存注解。 首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-...
springboot整合redis集群过程解析
08-25
Spring Boot 整合 Redis 集群过程解析 Spring Boot 整合 Redis 集群是当前流行的技术栈之一，本文将详细介绍 Spring Boot 如何与 Redis 集群集成，包括依赖项配置、连接池配置、Sentinel 配置、Redis 服务实现、...
redis集群的总结、搭建、 springboot整合测试
02-03
本文将深入探讨Redis集群的原理、搭建过程以及如何在SpringBoot应用中进行整合测试。 首先，Redis集群通过分片（Sharding）技术实现数据分散在多个节点上，每个节点负责一部分数据。当客户端向集群发送请求时，根据...
redis-cluster集群搭建（3主3从），并使用springboot整合
weixin_52443523的博客
08-15 1122
以客户端端口为6380的为例：分别开放 6380 和 16380端口（16380为集群总线端口）服务器A：vim /myredis/cluster/redisCluster6381.conf。服务器B：vim /myredis/cluster/redisCluster6383.conf。服务器C：vim /myredis/cluster/redisCluster6385.conf。并执行：mkdir -p /myredis/cluster。没有安装好redis的这里可以参考我以前写的。
SpringBoot多redis集群配置
鸟哥哥的专栏
04-12 3860
SpringBoot多redis集群配置
springcloud gateway 限流
qq_36382225的博客
10-21 603
yml配置转发规则 spring: cloud: gateway: discovery: locator: lowerCaseServiceId: true enabled: true routes: # =====================================...
springboot项目中操作redis，常见操作
m0_52765511的博客
07-29 898
springboot项目中操作redis
SpringBoot整合Redis集群
你要十分努力，才能看起来毫不费力！
11-10 4246
一、Windows下搭建Redis Cluster 下载Redis-Windows版本 https://github.com/microsoftarchive/redis/releases 下载后解压，目录如下： 1、集群节点目录： 拷贝开始下载的redis解压后的目录，并修改文件名（比如按集群下redis端口命名）如下： 在节点目录下新建文件，输入（举例在6380文件夹下新建文件） title redis-6380; redis-server.exe redis.windows.conf 保存为st
Redis（十二）SpringBoot集群搭建redis【主从复制&哨兵模式】
Vinjcent
07-10 6574
使用springboot框架搭建redis集群，并实现哨兵模式以及主从复制
springBoot整合redisCluster(redis集群)模式。
热门推荐
南君宇的博客
06-15 11万+
最近准备弄一个springBoot电商秒杀的demo项目，在搭建后台框架时，非关系型数据库准备整合redis，之前用的是单机版，因为是电商demo后面用jmeter压力测试的情况下效果可能不好，于是想试试redisCluster集群模式，看看并发qps变化效果，在网上看了很多博客吸取到了很多干货，但是很多都不全只是写了代码这块怎么整合的例子，并没有指出redis部署集群的教程，所以摸索成功之后觉得...
spring boot 整合Redis集群配置
04-13
好的，关于 Spring Boot 整合 Redis 集群配置，你可以按照以下步骤进行： 1. 配置 Redis 集群 2. 在项目中引入 Redis 相关依赖 3. 配置 RedisTemplate 和 RedisCacheManager 4. 将 Redis 相关的配置信息添加到 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值