Spring整合Redis-sentinel集群实现03

最新推荐文章于 2022-06-30 14:02:06 发布
最新推荐文章于 2022-06-30 14:02:06 发布
阅读量615 收藏 1
点赞数
分类专栏： Redis 文章标签： RedisTemplate spring Redis Sentinel 集群

一、Redis Sentinel集群解决方案简介

Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，当用Redis做Master-slave的高可用方案时，假如master宕机了，Redis本身(包括它的很多客户端)都没有实现自动进行主备切换，而Redis-sentinel本身也是一个独立运行的进程，它能监控多个master-slave集群，发现master宕机后能进行自懂切换。


它的主要功能有以下几点
=》不时地监控redis是否按照预期良好地运行;
=》如果发现某个redis节点运行出现状况，能够通知另外一个进程(例如它的客户端);
=》能够进行自动切换。当一个master节点不可用时，能够选举出master的多个slave(如果有超过一个slave的话)中的一个来作为新的master,其它的slave节点会将它所追随的master的地址改为被提升为master的slave的新地址。

=》sentinel采用投票方式进行故障切换，而投票方式下原则是少数服从多数，所以sentinel一般至少是3台

Sentinel 机制与用法（参考）：Redis Sentinel机制与用法


二、redis server sentinel服务端配置(windows下演示)

2.1 下载Redis

     参考该地址教程下载配置：http://www.runoob.com/redis/redis-install.html


2.2 HA配置

我们采用一主(master)二从(slave)三sentinel的架构模式来做演示

[java]  view plain  copy
  1. master ip:127.0.0.1 port:6379  
  2. slave1 ip:127.0.0.1 port:6380  
  3. slave2 ip:127.0.0.1 port:6381  

2.3、新建和修改配置文件

1、修改redis.conf配置文件

由于我们采用的是一主二从三sentinel的模式，所以我们需要6个配置文件，拷贝2份redis.conf配置文件，分别命名为redis6380.conf和redis6381.conf，其中修改redis.conf配置文件的如下几个参数：

[java]  view plain  copy
  1. port 6379  
  2. bind 127.0.0.1  

修改redis6380.conf配置文件的如下几个参数：

[java]  view plain  copy
  1. port 6380  
  2. bind 127.0.0.1  
  3. slaveof 127.0.0.1 6379  // 设置master服务器为6379  

同理修改redis6381.conf配置文件

2、redis.conf同目录下创建并修改sentinel.conf

该模式使用了3sentinel，所以我们需要复制3份sentinel.conf配置文件，并分别命名为sentinel26479.conf和sentinel26579.conf,其中修改sentinel.conf配置文件中的如下几个参数：

[java]  view plain  copy
  1. port 26379 // 当前Sentinel服务运行的端口  
  2. sentinel monitor mymaster  127.0.0.1 6379 2   
  3. sentinel down-after-milliseconds mymaster 5000  
  4. sentinel parallel-syncs mymaster  1  
  5. sentinel failover-timeout mymaster  15000  

同理，修改另外的两个配置文件

配置文件说明：

[java]  view plain  copy
  1. 1. port :当前Sentinel服务运行的端口  
  2. 2.sentinel monitor mymaster  127.0.0.1 6379 2:Sentinel去监视一个名为mymaster 的主redis实例，这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，而将这个主实例判断为失效至少需要2个 Sentinel进程的同意，只要同意Sentinel的数量不达标，自动failover就不会执行  
  3. 3.sentinel down-after-milliseconds mymaster 5000:指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。只有一个 Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行  
  4. 4.sentinel parallel-syncs mymaster 1：指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长  
  5. 5.sentinel failover-timeout mymaster 15000：如果在该时间（ms）内未能完成failover操作，则认为该failover失败  

2.4、启动服务器

1、打开不同的cmd窗口，分别启动master，slave1，slave2

启动命令分别如下：

[java]  view plain  copy
  1. redis-server.exe redis.conf  
  2. redis-server.exe redis6380.conf  
  3. redis-server.exe redis6381.conf  

2、分别启动sentinel1，sentinel2，sentinel3

启动命令分别如下：

[java]  view plain  copy
  1. redis-server.exe sentinel.conf --sentinel  
  2. redis-server.exe sentinel26479.conf --sentinel  
  3. redis-server.exe sentinel26579.conf --sentinel  

服务启动成功后，界面显示如下：


3、查看redis服务器状态


4、查看sentinel的状态


2.5、测试服务器


这里只做简单的测试

2.6、redis主从自动failover测试

1、停止master服务器

2、查看剩余服务器的状态


从上图中可以看出来，master的服务器端口从6379变成了6380，也就是说redis自动的实现了主从切换，我们可以在查看下sentinel的状态，如下：


我们发现sentinel监控到127.0.0.1:6379已经无法ping通了，切换master服务器为127.0.0.1:6380，经过以上测试，说明集群模式已经正常运行，我们可以开始客户端代码配置了。


三、配置客户端（Spring项目）

3.1pom配置

<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<springframework.version>4.3.13.RELEASE</springframework.version>
		<redis.version>2.9.0</redis.version>
		<spring.redis.version>2.0.2.RELEASE</spring.redis.version>
		<commons-lang.version>2.6</commons-lang.version>
		<commons-beanutils.version>1.9.0</commons-beanutils.version>
		<commons-collections.version>3.2.1</commons-collections.version>
		<commons-io.version>2.4</commons-io.version>
		<commons-logging.version>1.1.1</commons-logging.version>
		<commons-codec.version>1.10</commons-codec.version>
		<slf4j.version>1.7.7</slf4j.version>
		<log4j.version>1.2.16</log4j.version>
		<logback.version>1.1.2</logback.version>

	</properties>

	<repositories>
		<!-- 有了仓库的组的概念, 我们只需要做一次引用就可以了 -->
		<!-- Nexus中预设了2个仓库组,public repositories和public snapshot repositories -->
		<repository>
			<id>nexus</id>
			<name>Team Nexus Repository</name>
			<url>http://mvnrepository.com</url>
			<releases>
				<enabled>true</enabled>
			</releases>
			<snapshots>
				<enabled>true</enabled>
			</snapshots>

		</repository>

	</repositories>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>${commons-lang.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>${commons-collections.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-beanutils</groupId>
			<artifactId>commons-beanutils</artifactId>
			<version>${commons-beanutils.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>${commons-logging.version}</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>${commons-codec.version}</version>
		</dependency>

		<!--logger begin -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
				<exclusion>
					<groupId>oro</groupId>
					<artifactId>oro</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!-- logger end -->

		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>${redis.version}</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.8.9.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${springframework.version}</version>
		</dependency>
	</dependencies>

3.2 application.properties配置 

#\u6700\u5927\u5206\u914D\u7684\u5BF9\u8C61\u6570  
redis.pool.maxActive=1024  
#\u6700\u5927\u80FD\u591F\u4FDD\u6301idel\u72B6\u6001\u7684\u5BF9\u8C61\u6570  
redis.pool.maxIdle=200  
#\u5F53\u6C60\u5185\u6CA1\u6709\u8FD4\u56DE\u5BF9\u8C61\u65F6\uFF0C\u6700\u5927\u7B49\u5F85\u65F6\u95F4  
redis.pool.maxWait=1000  
#\u5F53\u8C03\u7528borrow Object\u65B9\u6CD5\u65F6\uFF0C\u662F\u5426\u8FDB\u884C\u6709\u6548\u6027\u68C0\u67E5  
redis.pool.testOnBorrow=true 
redis.pool.testWhileIdle=true
redis.pool.timeBetweenEvictionRunsMillis=60000
  
#IP  
redis.ip=127.0.0.1 
#Port  
redis.port=6379


3.3 applicationContext-sentinel.xml 配置 


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context-4.1.xsd"
	default-autowire="byName">
	<!--以下为sentinel 多redis配置 -->
	<!-- 加载配置文件 -->
	<context:property-placeholder location="classpath:application.properties" />

	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxTotal" value="2048" />
		<property name="maxIdle" value="200" />
		<property name="numTestsPerEvictionRun" value="1024" />

		<property name="minEvictableIdleTimeMillis" value="-1" />
		<property name="softMinEvictableIdleTimeMillis" value="10000" />
		<property name="maxWaitMillis" value="1500" />
		<property name="testOnReturn" value="false" />
		<property name="jmxEnabled" value="true" />
		<property name="blockWhenExhausted" value="false" />
		<!-- 三个配置配合设置，可以起到以下三点作用： (1)、保证每次获取的连接都是可用的 (2)、定时清理失效连接，补充新连接，提高效率 -->
		<property name="testOnBorrow" value="true" />
		<property name="testWhileIdle" value="true" />
		<property name="timeBetweenEvictionRunsMillis" value="30000" />
	</bean>

	<!-- 采用sentinel模式的redis:
	     redis server sentinel配置：http://blog.csdn.net/liuchuanhong1/article/details/53206028
	              此处只需要配置master节点名称以及三个sentinel（哨兵）即可，JedisSentinelPool.initSentinels执行时，
	              遍历多个sentinels，一个一个连接到sentinel，去询问关于masterName的消息，
	              可以看到是通过jedis.sentinelGetMasterAddrByName()方法去连接sentinel，并询问当前的master的地址
	             参考地址：https://segmentfault.com/a/1190000002690506
	 -->
	<bean id="redisSentinelConfiguration"
		class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
		<property name="master">
			<bean class="org.springframework.data.redis.connection.RedisNode">
			    <!--master名称 sentinel.conf里面配置的主节点名称:
			        name的值必须和redis server端sentinel（sentinel.conf）配置的值一致
			      -->
				<property name="name" value="redis-sentinel" />
			</bean>
		</property>
		<!--此处为sentinel(哨兵配置，非redis server配置) -->
		<!-- sentinel为投票模式,至少设置三台reis -->
		<property name="sentinels">
			<set>
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="127.0.0.1" />
					<constructor-arg name="port" value="26379" />
				</bean>
				
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="127.0.0.1" />
					<constructor-arg name="port" value="26479" />
				</bean>
				<bean class="org.springframework.data.redis.connection.RedisNode ">
					<constructor-arg name="host" value="127.0.0.1" />
					<constructor-arg name="port" value="26579" />
				</bean>
			</set>
		</property>
	</bean>
	<bean id="sentinelJedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="poolConfig" ref="jedisPoolConfig" />
		<constructor-arg name="sentinelConfig" ref="redisSentinelConfiguration" />
	</bean>
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="sentinelJedisConnectionFactory" />
		<property name="keySerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
		</property>
		<!-- <property name="hashKeySerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashValueSerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property> -->
	</bean>
</beans>

3.4 实体类 

public class User  implements Serializable {  
  
    private static final long serialVersionUID = -1267719235225203410L;  
  
    private String uid;  
  
    private String address;

    private String mobile;  
    
    private String postCode;  
    
    
	public String getUid() {
		return uid;
	}

	public void setUid(String uid) {
		this.uid = uid;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getMobile() {
		return mobile;
	}

	public void setMobile(String mobile) {
		this.mobile = mobile;
	}

	public String getPostCode() {
		return postCode;
	}

	public void setPostCode(String postCode) {
		this.postCode = postCode;
	}

	@Override
	public String toString() {
		return "User [uid=" + uid + ", address=" + address + ", mobile="
				+ mobile + ", postCode=" + postCode + "]";
	}
}

3.5 Redis-Sentinel集群测试类 

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

/**
 * 目前redis并未实现集群技术，redis3.0之后版本可能出现集群技术,拭目以待
 * 
 * spring-data-redis已经对jedis、jredis进行了封装，
 * （1）完美兼容redis sentinel部署模式、
 *    --sentinel采用投票方式进行故障切换，而投票方式下原则是少数服从多数，所以sentinel一般至少是3台
 *    --参考：https://www.cnblogs.com/aliyunblogs/p/5728861.html
 *    --Redis-Sentinel作为官方推荐的HA解决方案：https://segmentfault.com/a/1190000002690506
 *    --redis server sentinel配置：http://blog.csdn.net/liuchuanhong1/article/details/53206028
 *      --在测试sentinel集群之前，需要在redis服务端进行sentinel模式配置
 * （2）兼容redis-cluster部署模式
 * （3）单节点redis部署模式，
 * 提供统一的API(RedisTemplate)来调用不同的部署模式，完全不用担心redis部署模式变化导致redis客户端代码做调整
 * 
 * 参考案例：http://aperise.iteye.com/blog/2342615
 * 
 * sentinel配置顺序：
 * 1、配置redis server sentinel，参考：http://blog.csdn.net/liuchuanhong1/article/details/53206028
 * 2、配置java项目：http://aperise.iteye.com/blog/2342615
 * 此种方式下搭建的sentinel集群（主从方式），能够实现故障切换；故障节点修复重启后，也可以自动融入集群，作为master的从数据库
 * 
 * @Description:
 * @Create:  2017年12月28日 下午3:50:01 
 * @Modification History
 * @Date Author Version Description
 */
public class SpringJedisSentinelTest {
	
	private static ApplicationContext context = null;
	private static RedisTemplate<String, User> redisTemplate = null;

	static {
		context = new ClassPathXmlApplicationContext(
				"classpath*:applicationContext-sentinel.xml");
		redisTemplate = (RedisTemplate) context.getBean("redisTemplate");
	}
	
	public static void main(String[] args) {
		User user = new User();
		user.setUid("11112222322233");
		user.setAddress("上海市");
		user.setMobile("mobile");
		user.setPostCode("postcode");
		
		save(user);
		
		System.out.println(read(user));
	}
	
	
	public static void save(User user) {
		redisTemplate.opsForValue().set(user.getUid(), user);
	}

	public static User read(User user) {
		return redisTemplate.opsForValue().get(user.getUid());
	}

	public static void listSave(User user) {
		List<User> users = new ArrayList<User>();
		users.add(user);
		redisTemplate.opsForList().leftPushAll(
				"user.list.ops." + user.getUid(), users);
	}

	public static void listRead(User user) {
		List<User> users = redisTemplate.opsForList().range(
				"user.list.ops." + user.getUid(), 0, -1);
		for (Iterator iterator = users.iterator(); iterator.hasNext();) {
			User user1 = (User) iterator.next();
			System.out.println(user1);
		}
	}

	public static void hashSave(User user) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("address", user.getAddress());
		map.put("mobile", user.getMobile());
		map.put("postCode", user.getPostCode());
		redisTemplate.opsForHash()
				.putAll("user.hash.ops." + user.getUid(), map);
	}

	public static void hashRead(User user) {
		Map<Object, Object> map = redisTemplate.opsForHash().entries(
				"user.hash.ops." + user.getUid());
		Iterator<Entry<Object, Object>> it = map.entrySet().iterator();
		while (it.hasNext()) {
			Entry<Object, Object> type = it.next();
			System.out.println("key:" + type.getKey() + ",value:"
					+ type.getValue());
		}
	}

	public static void setSave(User user) {

		/*
		 * 竟然没有批量新增方法？？？？ 
		 */
		redisTemplate.opsForSet().add("user.set.ops." + user.getUid(), user);
	}

	public static void setRead(User user) {
		Set<User> sets = redisTemplate.opsForSet().members(
				"user.set.ops." + user.getUid());
		for (Iterator iterator = sets.iterator(); iterator.hasNext();) {
			User user1 = (User) iterator.next();
			System.out.println("user1:" + user1);
		}
	}

	public static void zsetSave(User user) {
        Set<TypedTuple<User>> zsets=new HashSet<TypedTuple<User>>();
        TypedTuple<User> tuple0=new DefaultTypedTuple(user, 1d);
        zsets.add(tuple0);
		redisTemplate.opsForZSet().add("user.zset.ops." + user.getUid(), zsets);
	}
	
	public static void zsetRead(User user) {
        Set<TypedTuple<User>> zsets=new HashSet<TypedTuple<User>>();
        TypedTuple<User> tuple0=new DefaultTypedTuple(user, 1d);
        zsets.add(tuple0);
		Set<User> users=redisTemplate.opsForZSet().range("user.zset.ops." + user.getUid(), 0, -1);
		for (Iterator iterator = users.iterator(); iterator.hasNext();) {
			User user2 = (User) iterator.next();
			System.out.println("user2:"+user2);
		}
	}

}
以上便是Sentinel集群的简单实现了，大家可以按demo跑一跑，然后查一下集群的各个节点数据有没有同步，如果没问题，那你就成功了，兄弟我也在研究阶段，各种百度学习，如果有不读的地方，大家可以留言提醒下。
项目代码地址： https://github.com/TaavettiTao/Redis.git

Mrs陶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis 客户端整合：spring + redis + sentinel（注解方式配置）
03-20 7166
Redis 客户端整合：spring + redis + sentinel（注解方式配置）
Redis哨兵机制原理详解
粉丝头子的故事
05-03 912
Redis哨兵机制原理详解 一、什么是哨兵模式： 1、哨兵模式的架构： 2、什么是哨兵模式： 在主从模式下（主从模式就是把上图的所有哨兵去掉），master节点负责写请求，然后异步同步给slave节点，从节点负责处理读请求。如果master宕机了，需要手动将从节点晋升为主节点，并且还要切换客户端的连接数据源。这就无法达到高可用，而通过哨兵模式就可以解决这一问题。 哨兵模式是Redis的高可用方式，哨.
spring boot整合redis主从sentinel
热门推荐
牛奋lch
01-18 7万+
一、一主二从三sentinel配置 1、master:127.0.0.1:6379 2、slave1:127.0.0.1:6380 3、slave2:127.0.0.1:6381 4、sentinel1:127.0.0.1:26379 5、sentinel2:127.0.0.1:26479 6、sentinel3:127.0.0.1:26579 7、监听的主机名:mymaster
redis一主二从三sentinel配置
星猿
08-27 1140
前言 应用redis的sentinel技术，做到redis的高可用 环境 操作系统为 CentOS Linux release 7.9.2009 Redis 版本为 Redis server 6.2.5 三台虚拟机，CPUx4 4G，ip地址为 10.1.1.200 ~ 202 安装 安装Redis 在三台服务器，安装 Redis ，参考在CentOS7中使用yum方式安装redis 三台一样操作。 三台服务器和三个Redis-server的关系 Server1: 10.1.1.200 Redis 10.
Spring+SpringMVC做Redis集群(Sentinel模式)
kity9420的专栏
12-11 1万+
研究Redis也有一段时间了，在前面的Redis系列文章中，介绍了Redis的安装，集群配置，及节点的增加和删除，但是并未实际的使用到项目中，趁这周末时间，参照项目中实际的使用场景，做了一个Redis集群Spring整合的案例，在介绍案例之前，先简单介绍下Redis集群的方式有哪些 1、单机版 不解释 2、Sentinel 哨兵模式 3、Redis Cluster Redis官方集群
springboot2.2 集成redis哨兵
scanklm的专栏
06-29 933
springboot版本2.2.0.RELEASE jedis版本 3.1.0 一、pom依赖： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.1.0</version> </dependency> <dependency> ...
redis-sentinel哨兵集群搭建并整合springboot
11-25
在本文中，我们将讨论如何搭建一个 Redis Sentinel 集群，并将其与 SpringBoot 应用程序进行整合。首先，我们来看一下搭建 Redis Sentinel 集群的基本步骤。 1. **Docker 安装与配置** Docker 是一种轻量级的容器...
java使用 redis-sentinel
05-01
通过以上配置，我们可以实现Java应用对Redis Sentinel集群的访问，实现高可用的数据存储和读取。同时，Sentinel还提供了监控、通知和自动故障恢复等功能，增强了整个系统的稳定性。在实际应用中，还需要注意Sentinel...
springboot整合redis集群过程解析
08-25
Spring Boot 整合 Redis 集群是当前流行的技术栈之一，本文将详细介绍 Spring Boot 如何与 Redis 集群集成，包括依赖项配置、连接池配置、Sentinel 配置、Redis 服务实现、控制器实现等方面的内容。 依赖项配置 ...
redis-session-manager-redis-session-manager-2.0.3.zip
最新发布
06-02
1. **高可用性**：Redis支持主从复制和哨兵(Sentinel)集群，确保会话数据的可靠性。 2. **高性能**：Redis的数据操作在内存中完成，提供极快的读写速度。 3. **可扩展性**：通过Redis集群，可以轻松扩展以应对高并发...
Spring-Data-Redis:学习Spring Data Redis
04-07
Spring Data Redis 支持 Redis Sentinel 以实现高可用性，以及 Redis Cluster 以实现数据分片和故障转移。 10. **最佳实践** - 使用连接池管理 Redis 连接，以提高性能和资源利用率。 - 选择合适的序列化策略，...
使用Spring-data-redis操作Redis的Sentinel
王浩的技术博客
04-10 3万+
介绍 Spring-Data-Redis项目（简称SDR）是对Redis的Key-Value数据存储操作提供了更高层次的抽象，提供了一个对几种主要的redis的Java客户端（例如：jedis，jredis，jdbc-redis等）的抽象，使开发中可以几乎完全屏蔽具体使用客户端的影响，使业务代码保持较强的稳定性。 Spring-Data-Redis提供了一个基础的泛型RedisTemplate
Spring-Redis实现分布式环境下主子域名Session共享
LabDNirvana的博客
09-20 1393
Spring@Configuration中关于Environment与@Value的相关分析 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 背景： 之前一直采用通过注解的方式配置SSM框架，但是Spring官网推荐采用代码的方式进行配置，所以自己开始尝试通过代码的方式配...
南瑞SysKeeper-2000 配置手册
码灵的博客
09-29 5323
一． 配置前 准备工作 1. 笔记本 安装 jdk 或者 jre ，配置 好环境变量 注意： jdk 或者 jre 版本必须 是 1.5 -1.7 否则 连接 时会报 错， 如图 ​ 2. 将笔记本 IP 设置为 11.22.33.43 子网掩码 255.255.255.0 。 3. 将 笔记本与SysKeeper装置 内网 3 口用网线 连接。 4. 用笔记 ping 11.22.33.44 l 996 看 是否能够 ping 通 如果 不成功检查 IP 设置及网线连接 。 5. 笔记本 安装如图配置
redis Sentinel 部署以及spring boot集成
xichen97的博客
03-22 830
Sentinel sentinel(哨兵) 是一种redis的解决方案，可以由多个Sentinel实例组成的Sentinel系统可以监视多个主服务器，以及这些主服务器之下的从服务器，同时如果主服务器下线之后，就会通过推举将从服务器升级为主服务器。 这里不推荐在一个机器上使用docker来搭建一个redis Sentinel系统，只要是考虑到使用docker之后，之后集成到spring boot之后，sentinel得到了一个内网地址，spring boot无法连接 redis 主从 修改主配置文件 po
Spring整合redis，通过sentinel进行主从切换。
江宁山人的专栏
03-24 1万+
实现功能描述： redis服务器进行Master-slaver-slaver-....主从配置，通过2台sentinel进行failOver故障转移，自动切换，采用该代码完全可以直接用于实际生产环境。 题外话： 一般来说这样的部署足以支持数以百万级的用户，但如果数量实在是太高，此时redis的Master-Slaver主从不一...
springboot整合Redis哨兵模式
m0_67402236的博客
04-08 628
Redis高可用哨兵模式搭建 一主二从三哨兵模式 Redis安装 1、Redis下载 wget http://download.redis.io/releases/redis-4.0.11.tar.gz 2、解压 tar zxcf redis-4.0.11.tar.gz 3、进入目录 cd redis-4.0.11/ 4、安装 cd src make yum install -y tcl make test make install PREFIX=/home/redis-se
Redis学习篇-Springboot+redis哨兵模式(sentinel)
smile
05-13 3万+
目录： Redis学习篇-windows下redis主从模式搭建 Redis学习篇-windows下哨兵模式 前言： 通过结合前篇的redis sentinel与springboot达到增加理解的效果。本文采取1master2slave3sentinel. 一.预备工作 先启动master和两个slave,然后再启动sentinel. redis端口依次为6379,6380,6381，sentinel依次是10001,10002,10003 二.创建springboot项目 ..
Spring Cloud Alibaba——Sentinel持久化和集群流控
jjc4261的博客
06-30 1754
本文已参与「新人创作礼」活动，一起开启掘金创作之路。Sentinel提供了这几种持久化方案储存到文件 使用Redis储存 使用Nacos存储 使用Zookeeper存储 使用Apollo存储 下面将使用同为Spring Cloud Alibaba开发套件中的Naocs作为持久化方案，因为在前期已经将Nacos持久化到MySQL数据库1.1 导入依赖 1.2 修改配置 1.3 Nacos配置 （1）测试配置流控规则 各字段含义：resource：表示资源名称 limitApp：表示要限制来自哪些来源的调用，d
spring redis 主从集群配置
11-17
以下是Spring Boot集成Redis主从集群的配置方法： 1.在pom.xml文件中添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 2.在application.properties...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值