Redis

发表于 | 分类于 | | 本文总阅读量 次
字数统计: 5.6k | 阅读时长 ≈ 23

Redis介绍

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。

Redis性能

读:11.2万/秒
写:8.6万/秒
平均: 10万/秒 吞吐量

Redis安装和使用

安装redis

要求:命令的执行值redis的根目录中运行.

命令:
​ 1.make 表示编译文件
​ 2.make install 表示安装redis服务.

修改配置文件

vim redis.conf

去除IP绑定

#bind 127.0.0.1（69行左右）

关闭保护模式

protected-mode no(88行左右)

开启后台启动

daemonize yes(136行左右)

VIM常见报错

报错演示：

报错原因:在vim编辑状态下.程序异常外退出导致Linux程序启动保护模式.导致异常.

解决方案:
1. 根据选项 点击 D
2. 利用删除指令 直接删除临时文件 rm –rf .xxxxxx.swap

Redis运行命令

启动命令

Redis-server 忽略 一切加载都是默认项
Redis-server redis.conf 目的读取配置文件

进入客户端

redis-cli –p 6379(端口号)
exit 退出客户端
ctrl + c 退出
简化:如果Redis默认的端口号为6379则命令可以简化
redis-cli

Redis关闭

redis-cli –p 6379（端口号） shutdown
kill -9 PID PID2
redis-cli shutdown 简化命令

Redis入门案例

linux防火墙操作密令

连接虚拟机Redis要确保虚拟机防火墙关闭
1 关闭防火墙—–service iptables stop
2 启动防火墙—–service iptables start
3 重启防火墙—–service iptables restart
4 查看防火墙状态——service iptables status
5 永久关闭防火墙——chkconfig iptables off
6 永久关闭后启用——chkconfig iptables on

添加jar包文件

1
2
3
4
5
6
7
8
9
10
11
12
<!-- jedis -->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>${jedis.version}</version>
</dependency>
<!--添加spring-datajar包  -->
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
	<version>1.4.1.RELEASE</version>
</dependency>

入门案例——String

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 连接单台redis  
 * 参数介绍:
 * 	redisIP地址.
 *  redis:6379
 */
@Test
public void test01(){
	Jedis jedis = new Jedis("192.168.126.166",6379);
	jedis.set("redis", "redis入门案例");
	System.out.println("获取redis中的数据:"+jedis.get("redis"));
	//为数据设定超时时间  单位秒
	jedis.setex("1804", 100, "1804班");
}

入门案例——hash

1
2
3
4
5
6
7
8
9
10
@Test
public void test01(){
	Jedis jedis = new Jedis("192.168.126.148", 6379);
	jedis.hset("user", "id", "1");
	jedis.hset("user", "name", "tomcat");
	jedis.hset("user", "age", "18");
	System.out.println("操作完成!!!"+jedis.hget("user", "id"));
	Map<String,String> map = jedis.hgetAll("user");
	System.out.println(map);
}

入门案例——List

1
2
3
4
5
6
7
8
@Test
public void test02(){
	Jedis jedis = new Jedis("192.168.126.148", 6379);
	Long number = jedis.lpush("list", "a","b","c","d","e");
	System.out.println("获取数据"+number);
	List<String> list= jedis.lrange("list", 0, -1);
	System.out.println("获取参数:"+list);
}

SpringBoot整合Redis

导入jar包

1
2
3
4
5
6
7
8
9
<!--spring整合redis -->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
</dependency>

入门案例

1
2
3
4
5
6
7
8
9
//String类型操作方式   配置文件3处  防火墙
//IP:端口号
@Test
public void testString() {
	Jedis jedis = new Jedis("192.168.175.129",6379);
	jedis.set("1902","1902班");
	jedis.expire("1902", 10);
	System.out.println(jedis.get("1902"));	
}

超时时间定时

1
2
3
4
5
6
7
8
9
10
11
12
//设定数据的超时方法
//分布式锁!!!!!
@Test
public void testTimeOut() throws InterruptedException {
	Jedis jedis = new Jedis("192.168.175.129",6379);
	jedis.setex("aa", 2, "aa");
	System.out.println(jedis.get("aa"));
	Thread.sleep(3000);
	//当key不存在时操作正常.当key存在时,则操作失败
	Long result = jedis.setnx("aa","bb");
	System.out.println("获取输出数据:"+result+":"+jedis.get("aa"));
}

对象转化JSON

转化说明

利用ObjectMapper实现对象的转化.

1
2
3
4
5
ObjectMapper mapper = new ObjectMapper();
//对象转化为JSON
String json串 = mapper.writeValueAsString(对象);
//JSON转化为对象
对象  T =  mapper.readValue(json, 对象.class);
对象与JSON互转
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 3.利用Redis保存业务数据  数据库
 *  数据库数据:  对象 Object
 *  String类型要求只能存储字符串类型
 *  item ~~~  JSON  ~~~ 字符串
 */
@Test
public void objectToJSON() throws IOException {
	ItemDesc itemDesc = new ItemDesc();
	itemDesc.setItemId(1000L)
			.setItemDesc("测试方法")
			.setCreated(new Date())
			.setUpdated(new Date());
	ObjectMapper mapper = new ObjectMapper();
	//转化JSON时必须 get/set方法
	String json =mapper.writeValueAsString(itemDesc);
	System.out.println(json);
	//将json串转化为对象
	ItemDesc desc2 = mapper.readValue(json, ItemDesc.class);
	System.out.println("测试对象:"+desc2);
}
List与JSON互转
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//实现List集合与JSON转化
@SuppressWarnings("unused")
@Test
public void listTOJSON() throws IOException {
	ItemDesc itemDesc1 = new ItemDesc();
	itemDesc1.setItemId(1000L).setItemDesc("测试方法");
	ItemDesc itemDesc2 = new ItemDesc();
	itemDesc2.setItemId(1000L).setItemDesc("测试方法");
	List<ItemDesc> list = new ArrayList<ItemDesc>();
	list.add(itemDesc1);
	list.add(itemDesc2);
	ObjectMapper mapper = new ObjectMapper();
	String json = mapper.writeValueAsString(list);
	System.out.println("集合转化为JSON"+json);
	//将数据保存到redis中
	Jedis jedis = new Jedis("192.168.175.129",6379);
	jedis.set("itemDescList", json);		
	//从redis中获取数据
	String result = jedis.get("itemDescList");
	List<ItemDesc> descList = mapper.readValue(result,list.getClass());
	System.out.println(descList);
}

编辑pro文件

jedis.host=192.168.175.129
jedis.port=6379

编辑配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
//表示redis配置类
@Configuration
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
	@Value("${jedis.host}")
	private String  host;
	@Value("${jedis.port}")
	private Integer port;
	@Bean
	public Jedis jedis() {
		return new Jedis(host, port);
	}
}

设定虚拟机静态IP

检查当前IP

检查网关地址

配置静态IP

Redis分片机制

Redis单台问题

1. 使用redis单台时内存会明显不足.如果一味的扩容内存,则运行的效率低.
2. 如果redis单台服务器宕机.

Redis分片（分区）介绍

核心特点:实现了redis内存的扩容.
说明:使用多个redis节点,共同为用户提供服务.内存空间翻倍.
​ 用户使用时当做一个整体.并且内存保存的数据不一.

分片搭建

创建新文件

在Redis根目录下创建一个新的文件夹

复制配置文件

复制配置文件到新建的文件夹里
[root@localhost redis-5.0.4]# cp redis.conf shards/redis-6379.conf
[root@localhost redis-5.0.4]# cp redis.conf shards/redis-6380.conf
[root@localhost redis-5.0.4]# cp redis.conf shards/redis-6381.conf

修改端口号

可以使用:/port快速定位数据

将6380.conf中端口号改为6380.

同理 修改其他配置文件

启动多台Redis

启动Redis

redis-server redis-6379.conf
redis-server redis-6380.conf
redis-server redis-6381.conf

检查redis服务

ps -ef | grep redis

Redis分片测试

入门案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 操作时需要将多台redis当做1台使用.
 */
@Test
public void testShards() {
	List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
	JedisShardInfo info1 = new JedisShardInfo("192.168.175.129",6379);
	JedisShardInfo info2 = new JedisShardInfo("192.168.175.129",6380);
	JedisShardInfo info3 = new JedisShardInfo("192.168.175.129",6381);
	shards.add(info1);
	shards.add(info2);
	shards.add(info3);
	//操作分片 redis对象工具类
	ShardedJedis shardedJedis = new ShardedJedis(shards);
	shardedJedis.set("1902","1902班");
	System.out.println(shardedJedis.get("1902"));
}

Hash一致性算法

概念

概念:同一个字符串hash值是一致的.

Hash一致性说明

Hash一致性——特性

问题说明

因为所有节点都是通过ip地址加算法计算获取的,则可能会出现节点分配不均的问题.导致数据丢失.

均衡性

说明:均衡性要求节点中的数据尽可能的平均.
措施:引入虚拟节点概念

单调性

说明:当节点新增时,能够实现数据的自动的迁移.
补充说明:如果节点一旦丢失,则导致内存丢失则整个分片无法使用.

分散性

概念:由于分布式原因,导致系统不能获取全部的内存空间.导致一个key有多个位置.

负载

概念:由于分布式原因,系统不能获取全部的内存地址.导致同一个位置保存多个数据

Spring整合Redis分片

编辑properties文件

redis.nodes=ip:端口，ip:端口，……
redis.nodes=192.168.175.129:6379,192.168.175.129:6380,192.168.175.129:6381

编辑配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//表示redis配置类
@Configuration
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
	@Value("${redis.nodes}")
	private String redisNodes; //node1,node2,node3
	@Bean
	public ShardedJedis shardedJedis() {
		List<JedisShardInfo> shards = new ArrayList<>();
		//ip:端口,ip:端口
		String[] nodes = redisNodes.split(",");
		for (String node : nodes) {
			String host = node.split(":")[0];
			int port = Integer.parseInt(node.split(":")[1]);
			JedisShardInfo info = new JedisShardInfo(host, port);
			shards.add(info);
		}
		return new ShardedJedis(shards);
	}
}

Redis持久化策略

说明

Redis中的数据都在内存中,如果断电宕机则内存数据丢失.其中数据应该持久化保存.不允许丢失.
持久化策略:
1. RDB模式
2. AOF模式

Redis持久化工作原理

说明:按照配置的时间,定期将内存数据保存到redis中的持久化文件中.
当redis服务器宕机之后重启时,首先读取指定的持久化文件,恢复内存数据,方便用户使用.

RDB模式

概念:
​ RDB模式是Redis中默认的持久化策略.保存的是redis的内存快照。占用的资源少.持久化效率最高的.
RDB特点:
​ 1.RDB模式能够定期持久化,但是有丢失数据的风险.
​ 2.Redis中默认的持久化策略
​ 3.RDB模式做内存的快照. 效率高
​ 4.占用磁盘空间较小.

RDB模式配置

1. 修改持久化文件名称

2.持久化文件目录设定

3.持久化策略
save 900 1 用户在900秒内做1次set操作时持久化1次
save 300 10 用户在300秒内做10次set草时持久化1次
save 60 10000 60秒内做10000次set 持久化一次

使用save持久化化时,如果执行持久化操作,则程序陷入阻塞.用户不能执行set.

AOF模式

特点:
1. AOF模式可以实现数据的实时持久化.
2. 记录的是用户的操作过程.
3. 持久化文件会比较大.
4. 持久化效率低.
5. AOF模式默认是关闭的
6. AOF模式持久化是异步的.

AOF模式持久化策略

1.开启AOF模式

2.修改持久化文件名称

3.持久化策略
# appendfsync always 只要用户执行”更新”命令则持久化一次
appendfsync everysec 每秒持久化一次.
# appendfsync no 由默认的操作系统决定什么时候持久化.

Redis缓存策略说明

1. 如果有并发查询时.如果缓存服务器宕机/缓存失效.则查询数据库.可能导致数据库宕机. 俗称缓存雪崩
2. 如果用户,高并发查询一个不存在的数据时.后台数据库有宕机的风险，俗称缓存穿透
限流 直至封杀IP地址. IP模拟器
3. 如果高并发条件下.当某一个热点的key,超时或者失效时.数据库有宕机的风险.俗称:缓存击穿

Redis内存机制

业务需求

Redis中的数据都保存内存中.内存中的数据如果一味的新增,不删除则内存数据很快存满.导致新的数据保存错误.
需求:用户每次都能存储数据,但是内存大小是可控的.要求动态维护内存大小.

Redis中内存策略

LRU算法

内存管理的一种页面置换算法，对于在内存中但又不用的数据块（内存块）叫做LRU，操作系统会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。

LFU算法

LFU（least frequently used (LFU) page-replacement algorithm）。即最不经常使用页置换算法，要求在页置换时置换引用计数最小的页，因为经常使用的页应该有一个较大的引用次数。但是有些页在开始时使用次数很多，但以后就不再使用，这类页将会长时间留在内存中，因此可以将引用计数寄存器定时右移一位，形成指数衰减的平均使用次数。

LFU:根据数据使用的次数多少删除数据.

内存优化策略

1. volatile-lru设定超时时间的数据采用LRU算法删除数据.
2. allkeys-lru所有的数据采用LRU算法删除数据
3. volatile-lfu设定了超时时间的数据采用LFU删除数据
4. allkeys-lfu所有的数据采用LFU算法删除数据
5. volatile-random设定了超时时间的随机删除
6. allkeys-random所有key随机删除
7. volatile-ttl设定了超时时间的数据排序.将马上要超时的数据提前删除.
8. Noeviction不删除数据.如果内存数据存满则报错返回. 该策略是默认策略

Redis主从同步

高可用介绍(HA)

“高可用性”（High Availability）通常来描述一个系统经过专门的设计，从而减少停工时间，而保持其服务的高度可用性。
概括:利用技术手段实现了当服务器宕机,自动的实现故障的迁移.

业务说明

Redis的最终形态必须实现高可用,实现高可用的前提必须满足主从同步.
当发生故障,由于从机与主机的数据是相同的,所以可以非常灵活实现数据的故障迁移.

主从同步搭建

复制文件

说明:将分片文件夹shards复制为sentinel.（shards文件参考上方分片）
cp –r shards sentinel

检查主从关系

进入Redis-6379客户端，输入info replication

实现主从挂载

说明:6379当主机, 6380/6381当从机.
命令:在客户端中cli端 执行指令 ** **saveof IP 端口

挂载情况

主从测试

当在6379中写入数据时,从机80/81也同步了数据.

主从同步持久性

问题说明:通过slaveof指令可以指定主从关系.如果从机关闭之后重启问情况如何??
回答:
​ 当6381重启之后,发现主从结构不存在了.6381变为主机.
如何解决该问题:
​ 需求:当6381为从机时,当重启服务器依然是从机.
​ 需要人为的动态修改redis.conf配置文件.

Redis哨兵实现高可用

Redis中哨兵的作用

分片作用:redis分片实现了redis内存扩容.
Redis哨兵:主要实现了redis节点的高可用.

Redis哨兵实现步骤

1. redis哨兵会监听redis主节点.
目的1:检查主节点是否存活
目的2:获取连接主节点的从机. IP:端口
2. 当利用ping-pong检测机制.检查主节点是否存活,当哨兵连续3次检测都没有数据返回.则表明主节点宕机.
3. 哨兵根据从主节点获取的从节点信息,进行推选.从中挑选一台新的从节点当做现在的主节点.将新的主从关系写入其他节点的redis.conf文件中.
4. 当服务器重启后,能够了解当前主从关系,实现了redis高可用.

Redis哨兵配置

复制哨兵配置文件

cp sentinel.conf sentinel/

编辑sentinel配置文件

1. 关闭保护模式 17行

2.开启哨兵后台启动 26行

3.修改哨兵监控 84行
sentinel monitor mymaster 127.0.0.1 6379 1
mymaster:当前主机的变量
IP:端口: redis主节点的IP和端口
投票生效票数: ** **规则:超半数即可,哨兵的数量是奇数.

4.主机宕机后多久进行推选.

5.修改哨兵推选失败超时时间.

Redis哨兵测试

1. 启动redis哨兵
redis-sentinel sentinel.conf

2. 当关闭redis-6379之后等10秒之后.检查主从结构是否正确.

Spring整合哨兵

入门案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//测试哨兵get/set操作
@Test
public void test01() {
	//masterName 代表主机的变量名称
	//sentinels  Set<String>  IP:端口
	Set<String> sentinels = new HashSet<>();
	sentinels.add("192.168.175.129:26379");
	JedisSentinelPool sentinelPool = 
	new JedisSentinelPool("mymaster", sentinels);
	Jedis jedis = sentinelPool.getResource();
	jedis.set("z", "dd");
	System.out.println(jedis.get("z"));
	jedis.close();	//关闭链接
}
Spring整合哨兵思路

1. 利用配置类,封装JedisSentinelPool.
2. 利用工具API封装2个方法.set/get

编辑pro文件

redis.sentinels=192.168.175.129:26379
redis.sentinel.masterName=mymaster

编辑配置类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//表示redis配置类
@Configuration //xml
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
	@Value("${redis.sentinels}")   
	private String jedisSentinelNodes;
	@Value("${redis.sentinel.masterName}")
	private String masterName;
	@Bean		
	public JedisSentinelPool jedisSentinelPool() {
		Set<String> sentinels = new HashSet<>();
		sentinels.add(jedisSentinelNodes);
		return new JedisSentinelPool(masterName, sentinels);
	}
}
编辑工具API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class RedisService {
	@Autowired(required = false)//调用时才注入
	private JedisSentinelPool sentinelPool;
	//封装方法  get
	public String get(String key) {
		Jedis jedis = sentinelPool.getResource();
		String result = jedis.get(key);
		jedis.close();
		return result;
	}
	public void set(String key,String value) {
		Jedis jedis = sentinelPool.getResource();
		jedis.set(key, value);
		jedis.close();
	}	
	public void setex(String key,int seconds,String value) {
		Jedis jedis = sentinelPool.getResource();
		jedis.setex(key, seconds, value);
		jedis.close();
	}
}
编辑RedisAOP配置项

项目测试

说明:重启tomcat服务器.检查程序调用是否正确.当redis节点宕机时.检查是否影响用户操作redis.

Redis集群

背景

1. Redis分片
用户通过API利用hash一致性算法,实现了数据存储.利用分片机制实现了内存的扩容!!!
缺点:如果一个节点宕机.,则违反单调性要求,分片失效.
2. Redis哨兵
哨兵基于心跳检测机制.实现redis节点高可用.但是前提必须配置主从.
哨兵缺点:
1. 操作的redis依然是单台,内存无法扩容.
2. Redis哨兵也有可能宕机.

分片:没有高可用效果.
哨兵:哨兵本身没有高可用需要借助第三方. 内存没有扩容.

Redis集群介绍

说明:搭建redis集群可以实现redis分片和哨兵的全部功能!!!.Redis集群中所有的主节点参与选举.redis集群中全部的节点都能互相通信.所有的节点都有投票权(发现某个节点宕机投票数+1)

集群搭建

集群设计

最小的集群单位3个主节点,从机不做要求,搭建策略一主一从
主机3台
​ 端口:7000/7001/7002
从机3台
​ 端口:7003/7004/7005

准备集群文件

1.准备集群文件夹

redis根目录下Mkdir cluster

2.在cluster文件夹中分别创建7000-7005文件夹
mkdir 7000 7001 7002 7003 7004 7005

复制配置文件

说明:
将redis根目录中的redis.conf文件复制到cluster/7000/ 并以原名保存
cp redis.conf cluster/7000/

编辑配置文件

1. 注释本地绑定IP地址

2.关闭保护模式

3.修改端口号

4. 启动后台启动

5. 修改pid文件

6. 修改持久化文件路径

7. 设定内存优化策略

8. 关闭AOF模式

9. 开启集群配置

10. 开启集群配置文件，保存集群中的状态信息.谁是主机,谁是从机

11. 修改集群超时时间

复制修改后的配置文件

说明:将7000文件夹下的redis.conf文件分别复制到7001-7005中

1
2
3
4
5
[root@localhost cluster]# cp 7000/redis.conf  7001/
[root@localhost cluster]# cp 7000/redis.conf  7002/
[root@localhost cluster]# cp 7000/redis.conf  7003/
[root@localhost cluster]# cp 7000/redis.conf  7004/
[root@localhost cluster]# cp 7000/redis.conf  7005/

批量修改

说明:分别将7001-7005文件中的7000改为对应的端口号的名称,
修改时注意方向键的使用

通过脚本编辑启动/关闭命令

1. 创建启动脚本 vim start.sh

2.编辑关闭的脚本 vim shutdown.sh

3.启动redis节点sh start.sh

4.检查redis节点启动是否正常

ps ef | grep redis

创建redis集群

#5.0版本执行 使用C语言内部管理集群
redis-cli --cluster create --cluster-replicas 1 192.168.35.130:7000 192.168.35.130:7001 192.168.35.130:7002 192.168.35.130:7003 192.168.35.130:7004 192.168.35.130:7005


Redis高可用测试

1. 关闭redis主机.检查是否自动实现故障迁移.
2. 再次启动关闭的主机.检查是否能够实现自动的挂载.
一般情况下 能够实现主从挂载
个别情况: 宕机后的节点重启,可能挂载到其他主节点中(7001-7002) 正确的

Redis集群工作原理

数据存储原理

分片数据存储原理: 根据hash一致性算法实现数据存储.
Hash一致性运算发生在服务器端.
在存储数据前已经计算完成存储到哪台redis服务器中.
分片中存在的问题:
*​ 分片的数据是用户通过服务器程序计算进行存储.用户也可以利用redis的客户端进行非法的操作.修改分片中的数据!!! *

集群中数据存储：1.当在从节点中存储数据时.不允许操作,只有主节点能够set/get数据。2.Redis集群与分片明显不同.存储数据必须满足条件.

Redis集群储存条件：


说明:redis集群一共有16384个槽位.这些操作会均匀的分配给主节点.
当数据进行存取时首先根据key进行计算.计算槽位的位置.之后从节点中获取数据.

Crc16算法

Redis集群宕机条件

宕机条件:Redis集群宕机的条件是主节点宕机则集群奔溃
例子:9个redis节点 3主6从 节点宕机多少次集群奔溃
5-7台集群奔溃

条件说明:Redis集群中当节点宕机后,由主节点进行推选.如果当前节点没有从节点时.从其他主节点中借用多余的从节点

SpringBoot整合Redis集群

测试案例

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void test01() {
	Set<HostAndPort> sets = new HashSet<>();
	sets.add(new HostAndPort("192.168.175.129",7000));
	sets.add(new HostAndPort("192.168.175.129",7001));
	sets.add(new HostAndPort("192.168.175.129",7002));
	sets.add(new HostAndPort("192.168.175.129",7003));
	sets.add(new HostAndPort("192.168.175.129",7004));
	sets.add(new HostAndPort("192.168.175.129",7005));
	JedisCluster cluster = new JedisCluster(sets);
	cluster.set("1902", "集群搭建完成");
	System.out.println("获取集群数据:"+cluster.get("1902"));
}

编辑pro文件

redis.nodes=192.168.175.129:7000,192.168.175.129:7001,192.168.175.129:7002,192.168.175.129:7003,192.168.175.129:7004,192.168.175.129:7005

编辑配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//表示redis配置类
@Configuration //xml
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
//redis.nodes=192.168.175.129:7000,192.168.175.129:7001,192.168.175.129:7002,192.168.175.129:7003,192.168.175.129:7004,192.168.175.129:7005
	@Value("${redis.nodes}")
	private String redisNodes;
	@Bean
	public JedisCluster jedisCluster() {
		Set<HostAndPort> nodes = new HashSet<>();
		//1.根据,号拆分为多个node
		String[] strNode = redisNodes.split(",");
		//IP:端口
		for (String node : strNode) {
			String host = node.split(":")[0];
			int port = Integer.parseInt(node.split(":")[1]);
			HostAndPort hostAndPort = 
					new HostAndPort(host, port);
			nodes.add(hostAndPort);
		}		
		return new JedisCluster(nodes);
	}
}

修改AOP切面

-------------本文结束❤️感谢您的阅读-------------
ボ wechat
扫描二维码，可获得菜鸡一枚
打赏测试
0%