Redis集群搭建，以及SpringBoot实现

最新推荐文章于 2024-04-13 10:11:19 发布
最新推荐文章于 2024-04-13 10:11:19 发布
阅读量387 收藏
点赞数 1
分类专栏： redis 随记 2、Redis 集群搭建以及SpringBoot实现 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AzFirst/article/details/107868127
版权

一、思路

  • Java Redis实现程序设计
  • Redis集群架构图
概念特别说明：
1、redis集群：
针对redis服务器搭建部署而言，多个redis-server构建一个redis集群环境，对外提供redis服务。key根据redis内部策略（主要是Hash 虚拟槽分区 slot），分配到不同的redis-server服务器中
2、redis主从同步：
为了避免单点故障，通常的做法是将数据库复制多个副本以部署在不同的服务器上，这样即使有一台服务器出现故障，其他服务器依然可以继续提供服务。为此， Redis 提供了复制（replication）功能，可以实现当一台数据库中的数据更新后，自动将更新的数据同步到其他数据库上。
3、区别：
主从服务器分工明确，主服务器用来写，从服务器用来读，一个主服务器，多个从服务器；集群就好比，多个主从服务器，比如：全国有多个主从服务器，分别处理各自区域的信息，这样可以减少单个主从服务器中主服务器的压力
4、slot特别说明
哈希槽的存在， 是为了能快速找到key所在的节点。一个redis集群包含2^16=16384个哈希槽，会分配给各个节点。可以通过槽的分配来控制不同节点的数据量和请求数。哈希槽通过顺时针来分片，即一个节点顺时针到下一个几点之间的槽属于下一个节点。
每一个key，通过公式slot=CRC16（key）/16384来计算属于哪个槽。
 
 

二、Redis集群部署具体实现

1、环境说明
本次Redis集群搭建部署是基于Windows开发环境
 
2、服务器规划
节点1：
127.0.0.1:6379  主   ok
127.0.0.1:6380  从   ok
 
节点2：
127.0.0.1:6479  主
 
节点3：
127.0.0.1:6579  主
 
3、部署步骤
（1）安装Redis
 
可以直接下载最近稳定版本的zip文件，无需进行安装，文件下载解压到目录：G:\MyPrivate\MyKit\Redis-x64-3.0.504
 
 
 
（2）修改Redis配置文件
 
A、以6379端口配置文件redis.windows.conf为例，其他端口6479配置文件redis.windows6479.conf、端口6579配置文件redis.windows6579.conf雷同
 
B、修改配置文件，关闭rdb内存快照方式，开启aof持久化方式，开启cluster
port 6379
 
#关闭rdb
#save 900 1
#save 300 10
#save 60 10000
dbfilename dump6379.rdb
 
#开启aof
appendonly yes
appendfilename "appendonly6379.aof"
appendfsync everysec
 
#配置集群信息
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes
 
（3）启动Redis服务器
依次打开Dos窗口，切换到Redis安装目录cd G:\MyPrivate\MyKit\Redis-x64-3.0.504
执行命令：
redis-server.exe redis.windows.conf
redis-server.exe redis.windows6380.conf
redis-server.exe redis.windows6479.conf
redis-server.exe redis.windows6579.conf
 
 
 
（4）下载并安装Ruby，下载地址： http://railsinstaller.org/en
  设置系统环境变量，把C:\RailsInstaller\Ruby2.3.3\bin添加到系统环境变量中
 
 
 
（5）安装完毕之后，下载Ruby环境下Redis的驱动，考虑到兼容性，这里下载的是3.2.2版本，下载地址： https://rubygems.org/gems/redis/versions/3.2.2
下载完毕放置Redis安装目录下G:\MyPrivate\MyKit\Redis-x64-3.0.504\redis-3.2.2.gem
 
（6）安装Ruby Redis驱动
gem install --local G:\MyPrivate\MyKit\Redis-x64-3.0.504\redis-3.2.2.gem
 
（7）下载Redis官网提供的Redis集群Ruby脚本redis-trib.rb，有两种方式：
 
下载的文件放在Redis安装目录下
 
（8）创建Redis集群
打开Dos窗口，进入到Redis安装目录 G:\MyPrivate\MyKit\Redis-x64-3.0.504，执行：ruby redis-trib.rb create --replicas 0 127.0.0.1:6379 127.0.0.1:6479 127.0.0.1:6579，当出现提示的时候，手动输入yes
 
校验是否创建成功，输入命令：ruby redis-trib.rb check 127.0.0.1:6379
 
 
补充： redis-trib.rb命令
支持的操作如下：
1. create：创建集群
2. check：检查集群
3. info：查看集群信息
4. fix：修复集群
5. reshard：在线迁移slot
6. rebalance：平衡集群节点slot数量
7. add-node：添加新节点
8. del-node：删除节点
9. set-timeout：设置节点的超时时间
10. call：在集群所有节点上执行命令
11. import：将外部redis数据导入集群
 
 
添加slave节点
给127.0.0.1:6379添加slave节点127.0.0.1:6380，命令如下所示。
注意：slave节点的特性，数据来自于主节点，可以进行读写操作，写操作默认都会在Master节点上面进行处理
 
G:\MyPrivate\MyKit\Redis-x64-3.0.504> ruby redis-trib.rb add-node --slave 127.0.0.1:6380 127.0.0.1:6379
>>> Adding node 127.0.0.1:6380 to cluster 127.0.0.1:6379
>>> Performing Cluster Check (using node 127.0.0.1:6379)
M: d2d52e9453b367a96ad0b89973851efbb0452c08 127.0.0.1:6379
   slots:0-5460 (5461 slots) master
   0 additional replica(s)
M: 36863046950bc37bd6462a6c977135f8d7c01449 127.0.0.1:6479
   slots:5461-10922 (5462 slots) master
   0 additional replica(s)
M: 9fa742639b82a080ac168b9a6c1943b54977371c 127.0.0.1:6579
   slots:10923-16383 (5461 slots) master
   0 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
Automatically selected master 127.0.0.1:6379
>>> Send CLUSTER MEET to node 127.0.0.1:6380 to make it join the cluster.
Waiting for the cluster to join...
>>> Configure node as replica of 127.0.0.1:6379.
[OK] New node added correctly.
 
G:\MyPrivate\MyKit\Redis-x64-3.0.504> ruby redis-trib.rb check 127.0.0.1:6379
>>> Performing Cluster Check (using node 127.0.0.1:6379)
M: d2d52e9453b367a96ad0b89973851efbb0452c08 127.0.0.1:6379
   slots:0-5460 (5461 slots) master
   1 additional replica(s)
M: 36863046950bc37bd6462a6c977135f8d7c01449 127.0.0.1:6479
   slots:5461-10922 (5462 slots) master
   0 additional replica(s)
S: d07c74d1bbdca97340867bed535259c4688a877d 127.0.0.1:6380
   slots: (0 slots) slave
   replicates d2d52e9453b367a96ad0b89973851efbb0452c08
M: 9fa742639b82a080ac168b9a6c1943b54977371c 127.0.0.1:6579
   slots:10923-16383 (5461 slots) master
   0 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
 
G:\MyPrivate\MyKit\Redis-x64-3.0.504> ruby redis-trib.rb info 127.0.0.1:6379
127.0.0.1:6379 (d2d52e94...) -> 3 keys | 5461 slots | 1 slaves.
127.0.0.1:6479 (36863046...) -> 5 keys | 5462 slots | 0 slaves.
127.0.0.1:6579 (9fa74263...) -> 3 keys | 5461 slots | 0 slaves.
[OK] 11 keys in 3 masters.
0.00 keys per slot on average.
 
 
4、测试验证
（1）进入任一集群节点，可以通过cluster info 查询集群节点状态
 
C:\Users\jiangjiabao> G:
 
G:\> cd G:\MyPrivate\MyKit\Redis-x64-3.0.504
 
G:\MyPrivate\MyKit\Redis-x64-3.0.504> redis-cli.exe -c -p 6379
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:3
cluster_size:3
cluster_current_epoch:3
cluster_my_epoch:1
cluster_stats_messages_sent:619
cluster_stats_messages_received:614
127.0.0.1:6379> info cluster
# Cluster
cluster_enabled:1
 
（2）设置key，切换到不同的集群节点查询key
127.0.0.1:6379> set name yubing
-> Redirected to slot [5798] located at 127.0.0.1:6479
OK
127.0.0.1:6479> set age 39
-> Redirected to slot [741] located at 127.0.0.1:6379
OK
127.0.0.1:6379> set height 171
-> Redirected to slot [8223] located at 127.0.0.1:6479
OK
127.0.0.1:6479> hset 1004user name yubing
(integer) 1
 
 
127.0.0.1:6479> get name
"yubing"
127.0.0.1:6479> get age
-> Redirected to slot [741] located at 127.0.0.1:6379
"39"
127.0.0.1:6379> mgetall 1004user
(error) ERR unknown command 'mgetall'
127.0.0.1:6379> hgetall 1004user
-> Redirected to slot [10116] located at 127.0.0.1:6479
1) "name"
2) "yubing"
 

三、Java SpringBoot之Redis集群实现

 
1、代码结构如下所示
 
2、代码说明
（1）pom.xml添加依赖
<dependencies>
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-data-redis </artifactId>
</dependency>
<!--lettuce pool 缓存连接池 -->
<dependency>
<groupId> org.apache.commons </groupId>
<artifactId> commons-pool2 </artifactId>
</dependency>
 
<!--springboot 依赖 -->
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter </artifactId>
</dependency>
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-web </artifactId>
</dependency>
 
<dependency>
<groupId> org.projectlombok </groupId>
<artifactId> lombok </artifactId>
<optional> true </optional>
</dependency>
 
<dependency>
<groupId> com.alibaba </groupId>
<artifactId> fastjson </artifactId>
<version> 1.2.66 </version>R
</dependency>
 
<dependency>
<groupId> org.springframework.boot </groupId>
<artifactId> spring-boot-starter-test </artifactId>
<scope> test </scope>
<exclusions>
<exclusion>
<groupId> org.junit.vintage </groupId>
<artifactId> junit-vintage-engine </artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
 
application.properties配置文件
spring.application.name = exec-data-redis
server.port = 8081
 
#redis 连接配置型
spring.redis.database = 0
#spring.redis.host=127.0.0.1
#spring.redis.port=6379
#spring.redis.password=
 
#redis 之 jedis 配置信息
## 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active = 8
## 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait = -1
## 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle = 8
## 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle = 0
## 连接超时时间（毫秒）
spring.redis.timeout = 1000
 
spring.redis.cluster.nodes = 192.168.8.196:6379,192.168.8.196:6479,192.168.8.196:6579,192.168.8.196:6380
spring.redis.cluster.max-redirects = 2
 
 
#redis 之 lettuce 方式配置信息
#spring.redis.lettuce.pool.max-active=8
#spring.redis.lettuce.pool.max-wait=-1
#spring.redis.lettuce.pool.max-idle=8
#spring.redis.lettuce.pool.min-idle=0
 
 
(2)RedisConfig.java
package com.darben.execdatareids.config ;
 
import com.fasterxml.jackson.annotation. JsonAutoDetect ;
import com.fasterxml.jackson.annotation.PropertyAccessor ;
import com.fasterxml.jackson.databind.ObjectMapper ;
import org.springframework.cache.annotation. EnableCaching ;
import org.springframework.context.annotation. Bean ;
import org.springframework.context.annotation. Configuration ;
import org.springframework.data.redis.connection.RedisConnectionFactory ;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory ;
import org.springframework.data.redis.core.* ;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer ;
import org.springframework.data.redis.serializer.StringRedisSerializer ;
 
/**
* @Desc redis 配置 类
* @Date 2020-03-09
* @Author Darben
*/
@Configuration
@EnableCaching
public class RedisConfig {
 
/**
* @Description:
* @Param:
* @return: org.springframework.data.redis.core.RedisTemplate < java.lang.String , java.lang.Object >
* @date: 2020/3/9
*/
@Bean
public RedisTemplate<String , Object> redisTemplate (RedisConnectionFactory factory){
 
RedisTemplate<String , Object> template = new RedisTemplate<>() ;
// 配置连接工厂
template.setConnectionFactory(factory) ;
 
// 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value 值（默认使用 JDK 的序列化方式）
Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object. class ) ;
 
ObjectMapper om = new ObjectMapper() ;
// 指定要序列化的域， field,get 和 set, 以及修饰符范围， ANY 是都有包括 private 和 public
om.setVisibility(PropertyAccessor. ALL , JsonAutoDetect .Visibility. ANY ) ;
om.enableDefaultTyping(ObjectMapper.DefaultTyping. NON_FINAL ) ;
jsonRedisSerializer.setObjectMapper(om) ;
 
template.setValueSerializer(jsonRedisSerializer) ;
template.setKeySerializer( new StringRedisSerializer()) ;
 
template.setHashValueSerializer(jsonRedisSerializer) ;
template.setHashKeySerializer( new StringRedisSerializer()) ;
template.afterPropertiesSet() ;
 
return template ;
}
 
/*@Bean
public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory factory){
 
RedisTemplate<String,Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
 
// 使用 Jackson2JsonRedisSerializer 来序列化和反序列化 redis 的 value 值（默认使用 JDK 的序列化方式）
Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 
ObjectMapper om = new ObjectMapper();
// 指定要序列化的域， field,get 和 set, 以及修饰符范围， ANY 是都有包括 private 和 public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jsonRedisSerializer.setObjectMapper(om);
 
template.setValueSerializer(jsonRedisSerializer);
template.setKeySerializer(new StringRedisSerializer());
 
template.setHashValueSerializer(jsonRedisSerializer);
template.setHashKeySerializer(new StringRedisSerializer());
template.afterPropertiesSet();
 
return template;
}*/
 
/* 以下 Bean 可以直接注入到 Service 中使用 */
 
/**
* @Description: 对 Redis 字符串 类 型操作
* @Param:
* @return:
* @date: 2020/3/9
*/
@Bean
public ValueOperations<String , Object> valueOperations (RedisTemplate<String , Object> redisTemplate){
return redisTemplate.opsForValue() ;
}
 
/**
* @Description: 对 List 链 表 类 型操作
* @Param:
* @return:
* @date: 2020/3/9
*/
@Bean
public ListOperations<String , Object> listOperations (RedisTemplate<String , Object> redisTemplate){
return redisTemplate.opsForList() ;
}
 
/**
* @Description: 对 无序集合 类 型 进 行操作
* @Param:
* @return:
* @date: 2020/3/9
*/
@Bean
public SetOperations<String , Object> setOperations (RedisTemplate<String , Object> redisTemplate){
return redisTemplate.opsForSet() ;
}
 
/**
* @Description: 对 有序集合 类 型 进 行操作
* @Param:
* @return:
* @date: 2020/3/9
*/
@Bean
public ZSetOperations<String , Object> zSetOperations (RedisTemplate<String , Object> redisTemplate){
return redisTemplate.opsForZSet() ;
}
 
/**
* @Description: 对 hash 类 型 进 行操作
* @Param:
* @return:
* @date: 2020/3/9
*/
@Bean
public HashOperations<String , String , Object> hashOperations (RedisTemplate<String , Object> redisTemplate){
return redisTemplate.opsForHash() ;
}
 
}
 
（3）RedisUtils.java
 
import lombok.extern.slf4j. Slf4j ;
import org.springframework.beans.factory.annotation. Autowired ;
import org.springframework.data.redis.core.RedisTemplate ;
import org.springframework.stereotype. Component ;
import org.springframework.util.CollectionUtils ;
import org.springframework.util.StringUtils ;
 
import java.util.List ;
import java.util.Map ;
import java.util.concurrent.TimeUnit ;
 
/**
* @description: Redis 帮 助 类组 件
* @author: darben
* @create: 2020-03-09 15:39
*/
@Component
@Slf4j
public class RedisUtils {
 
@Autowired
private RedisTemplate<String , Object> redisTemplate ;
 
public RedisUtils (RedisTemplate<String , Object> redisTemplate) {
this . redisTemplate = redisTemplate ;
}
 
/**
* @Description:
* @Param:
* key key 键
* time 失效 时间 ， 单 位秒
* @return:
* @date: 2020/3/9
*/
public boolean expire (String key ,long time){
try {
if (time> 0 ){
redisTemplate .expire(key , time , TimeUnit. SECONDS ) ;
}
return true;
}
catch (Exception e){
log .error( "-> 设置 redis key 失效时间异常 " + e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 查询 ke 过 期 时间
* @Param:
* @return: 时间 ( 秒 ) 返回 0 代表 为 永久有效
* @date: 2020/3/9
*/
public long getExpire (String key){
return redisTemplate .getExpire(key , TimeUnit. SECONDS ) ;
}
 
/**
* @Description: 删 除 缓 存
* @Param: 集合，多 个 一起 处 理
* @return:
* @date: 2020/3/9
*/
public void delKeys (String ... key){
if (key!= null && key. length > 0 ){
if (key. length == 1 ){
redisTemplate .delete(key[ 0 ]) ;
}
else {
redisTemplate .delete(CollectionUtils. arrayToList (key)) ;
}
}
}
 
/**
* @Description: 删 除 缓 存
* @Param: 单个进 行 删 除
* @return:
* @date: 2020/3/9
*/
public boolean del (String key){
if (!StringUtils. isEmpty (key)){
return redisTemplate .delete(key) ;
}
return true;
}
 
/**
* @Description: 持久化 key 的 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean persist (String key){
return redisTemplate .persist(key) ;
}
 
//String 结构类型处理
//..
 
/**
* @Description: 普通 缓 存 获 取
* @Param:
* @return:
* @date: 2020/3/9
*/
public Object get (String key){
return StringUtils. isEmpty (key)? null : redisTemplate .opsForValue().get(key) ;
}
 
/**
* @Description: 普通 缓 存存 储
* @Param:
* @return:
* @date: 2020/3/9
*/
public boolean set (String key , Object value){
try {
redisTemplate .opsForValue().set(key , value) ;
return true;
}
catch (Exception e){
log .error( "->set occur error " +e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 普通 缓 存存 储 + 设 置 过 期 时间
* @param key 键
* @param value 值
* @param time 时间 ( 秒 ) time 要大于 0 如果 time 小于等于 0 将设 置无限期
* @return:
* @date: 2020/3/9
*/
public boolean set (String key , Object value ,long time){
try {
redisTemplate .opsForValue().set(key , value , time , TimeUnit. SECONDS ) ;
return true;
}
catch (Exception e){
log .error( "->set occur error " +e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: incrby 递 增
* @Param:
* @return:
* @date: 2020/3/11
*/
public long incrby (String key ,long delta){
if (delta< 0 ){
throw new RuntimeException( " 递增因子必须大于 0" ) ;
}
return redisTemplate .opsForValue().increment(key , delta) ;
}
 
/**
* @Description: decryb 递减
* @Param:
* @return:
* @date: 2020/3/11
*/
public long decrby (String key ,long delta){
if (delta< 0 ){
throw new RuntimeException( " 递减因子必须大于 0" ) ;
}
return redisTemplate .opsForValue().decrement(key , -delta) ;
}
 
//list 链表结构类型处理
//..
 
/**
* @Description: 查询 key 对应 的 list 缓 存的 内 容
* @Param:
* @return:
* @date: 2020/3/11
*/
public List<Object> lGet (String key ,long start ,long end){
try {
return redisTemplate .opsForList().range(key , start , end) ;
}
catch (Exception e){
log .error( "lGet occur error. " +e) ;
e.printStackTrace() ;
return null;
}
}
 
/**
* @Description: 查询 List 对应 的 长 度
* @Param:
* @return:
* @date: 2020/3/11
*/
public long lGetListSize (String key){
try {
return redisTemplate .opsForList().size(key) ;
}
catch (Exception e){
log .error( "lGetListSize occur error." +e) ;
e.printStackTrace() ;
return 0 ;
}
}
 
/**
* @Description: 通 过 索引 找 到 list 中的 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public Object lGetByIndex (String key ,long index){
try {
return redisTemplate .opsForList().index(key , index) ;
}
catch (Exception e){
log .error( "lGetByIndex occur error. " +e) ;
e.printStackTrace() ;
return null;
}
}
 
/**
* @Description: 将数 据存 储 在 list 缓 存
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean rPush (String key , Object value){
try {
redisTemplate .opsForList().rightPush(key , value) ;
return true;
}
catch (Exception e){
log .error( "rPush occur error. " + e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description:
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean rPush (String key , Object value ,long time){
try {
redisTemplate .opsForList().rightPush(key , value) ;
if (time > 0 ){
expire(key , time) ;
}
return true;
}
catch (Exception e){
log .error( "rPush with expire occur error. " + e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 将 list 进 行存 储
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean rPush (String key , List<Object> list){
try {
redisTemplate .opsForList().rightPushAll(key , list) ;
return true;
}
catch (Exception e){
log .error( "rPushAll occur error. " + e) ;
return false;
}
}
 
/**
* @Description: 将 list 进 行存 储 + 过 期 时间
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean rPush (String key , List<Object> list ,long time){
try {
redisTemplate .opsForList().rightPushAll(key , list) ;
if (time> 0 ){
expire(key , time) ;
}
return true;
}
catch (Exception e){
log .error( "rPushAll occur error. " + e) ;
return false;
}
}
 
/**
* @Description: 根据索引修改 list 中的某 条数 据
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean lUpdateIndexValue (String key ,long index , Object value){
try {
redisTemplate .opsForList().set(key , index , value) ;
return true;
} catch (Exception e) {
log .error( "lUpdateIndexValue occur error." +e) ;
e.printStackTrace() ;
return false;
}
}
 
 
//HashMap 结构类型处理
//..
 
/**
* @Description: 获 取 key 对应 的 map 指定 profile 的 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public Object hGet (String key , String profile){
return redisTemplate .opsForHash().get(key , profile) ;
}
 
/**
* @Description: 获 取 key 对应 的 Hash 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public Map<Object , Object> hMget (String key){
return redisTemplate .opsForHash().entries(key) ;
}
 
/**
* @Description: 存 储值 HashMap
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean hMset (String key , Map<String , Object> map){
try {
redisTemplate .opsForHash().putAll(key , map) ;
return true;
}
catch (Exception e){
log .error( "->hmset occur error " +e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 存 储 HashMap + 过 期 时间
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean hMset (String key , Map<String , Object> map , long time){
try {
redisTemplate .opsForHash().putAll(key , map) ;
if (time> 0 ){
expire(key , time) ;
}
return true;
}
catch (Exception e){
log .error( "->hmset with expire time occur error " +e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 向一 张 hash 表中放入 数 据 , 如果不存在 将创 建
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean hSet (String key , String profiel , Object value , Long time){
try {
redisTemplate .opsForHash().put(key , profiel , value) ;
if (time != null && time.longValue()> 0 ){
expire(key , time) ;
}
return true;
}
catch (Exception e){
log .error( "->hset with expire time occur error " +e) ;
e.printStackTrace() ;
return false;
}
}
 
/**
* @Description: 删 除 Hash 表中的 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public void hDel (String key , Object ... profile){
redisTemplate .opsForHash().delete(key , profile) ;
}
 
/**
* @Description: 判 断 hash 表中是否有 key 值
* @Param:
* @return:
* @date: 2020/3/11
*/
public boolean hHasKey (String key , String profile){
return redisTemplate .opsForHash().hasKey(key , profile) ;
}
 
 
}
 
 
躲猫~的猫
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
blade使用之RedisLock 分布式锁的使用
u013862740的专栏
08-23 1102
blade官方提供的文档说明较为简单，顾把自己琢磨出来的做下记录和分享 1. 官方文档只介绍了分布式锁的简单使用，文档属于付费内容，这里不好做介绍 略 2. 实际项目中，最普遍的锁，需要传入指定参数，即分布式锁需要传入变量 官方文档介绍了参数可以通过 *** 表达式的形式传入，在实际的项目中的情况是只需要输入“{}”里面传入 “”#变量名” 即可，如图 ...
redis基本操作
weixin_40006394的博客
04-04 379
1、redis安装 wget http://download.redis.io/releases/redis-2.8.17.tar.gz tar -xzvf redis-2.8.17.tar.gz mv redis-2.8.17 redis cd /usr/local/redis make 2、redis主从复制 2.1、在redis...
Spring Boot 整合 Redis 集群详解
最新发布
weixin_42118323的博客
04-13 1510
分析结果，我们发现出现了一串字符串 “\xac\xed\x00\x05t\x00\x10”，这串字符串明显不是我们想要看到的，难道是 Redis 集成又出问题了吗，使用代码获取了缓存字符串，发现并没有这串奇奇怪怪的字符串，那是怎么回事呢？以上配置，会自动由 Spring Boot 自动装配，不需要再配置类，Spring Boot 会自动把这些配置参数加载后实例化连接池。本篇简单分享了 Spring Boot 项目集成 Redis 过程中可能会需要的一些问题，希望能够帮助到有需要的朋友。
bladeredis存入list数据类型结果为list＜list＜＞＞
weixin_45381461的博客
09-26 427
遇到一个bladex的大坑 bladeredis存入list数据类型结果为list<list<>> 解决方案 ：掉push方法的时候value定义为list 就正常了
RedisTemplate集合使用说明-opsForList(二）
weixin_48101276的博客
02-19 2735
   1、leftPush(K key, V value)     在变量左边添加元素值。   Java代码   redisTemplate.opsForList().leftPush("list","a");  redisTemplate.opsForList().leftP...
SpringBoot RedisTemplate opsForList
风信子
03-29 5582
SpringBoot RedisTemplate opsForList1 SpringBoot RedisTemplate spring-data-redis-2.6.2.jar @Autowired private RedisTemplate redisTemplate; /* * (non-Javadoc) * @see org.springframework.data.redis.core.RedisOperations#opsForList() */ @Override public Li
搭建springboot与redis集群关联操作.doc
05-27
搭建redis集群，springboot关联redis的配置，实例代码操作，及运行结果展示，包含某互联网教程书籍上面截图，完整详细讲解了redis三种模式，单机模式、哨兵模式、集群模式
redis集群的总结、搭建、 springboot整合测试
02-03
redis集群的总结、搭建、 springboot整合测试
redis-sentinel哨兵集群搭建并整合springboot
11-25
redis-sentinel哨兵集群搭建并整合springboot完美解决方案
阿里云redis集群搭建.docx
07-13
网上查找很多资源部署redis集群在云服务上，都是一样的说外网可用，但是使用到springboot去访问的时候都是连接不上的，而我经过多次测试找很多网上的帖子，在阿里云搭建了集群后，在外网使用springboot 2.1.6 是可以...
Redis集群模式搭建
01-20
最近学习springboot集成redis，因此本人打算在虚机上搭建一套redis集群 查阅相关资料，Redis集群中要求必须是奇数节点，所以至少要有三个节点。但是每个节点还需要一个备份节点，因此redis集群需要最低配置6个节点。...
RedisTemplate使用最详解（二）--- opsForList()
热门推荐
weixin_43658899的博客
10-29 5万+
1、leftPush(K key, V value) 从集合左边插入值 值重复无影响 先进先出 redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","b"); 2、leftPush(K key, V v, V v1) 从集合左边开始在v值后边插入新值v1 在集合中查
RedisTemplate常用集合使用说明-opsForList(三)
XinhuaShuDiao的博客
08-09 1万+
         基础配置介绍已经在前面的《RedisTemplate常用集合使用说明(一)》中已经介绍了，现在我们直接介绍opsForList()方法的使用：      1、leftPush(K key, V value)     在变量左边添加元素值。   redisTemplate.opsForList().leftPush("list","a"); redisTemplat...
知识积累：SpringBoot-data-Redis的RedisTemplate的opsForList，操作List＜Object＞集合的leftPushAll和rightAll问题；分页查询list
做技术，贵在学习与坚持！
10-15 2722
最近项目在用RedisTemplate的opsForList进行对象集合的存储并进行分页查询； 可是当使用 supportRedisTemplate.opsForList().rightPushAll(key, lists)； 默认走了Long rightPushAll(K var1, V… var2); 试了很多种方式， 将lists类型强转为Collection， 将lists转为String[]， 最后都没有成功。只会存储一个整体的对象，无法使用range(),来进行分页查询。 只能采取曲线救国的方案
RedisTemplate.opsForList()用法简介并举例
一起coding，一起嗨。
08-08 4909
是RedisTemplate类提供的用于操作List类型的方法。它可以用于对Redis中的List数据结构进行各种操作，如添加元素、获取元素、删除元素等。请注意，示例中的"mylist"是列表的键名，“value1”、"value2"等是要插入或获取的元素值。方法的常见用法，你可以根据具体的业务需求选择适合的方法进行操作。
Redis操作List
weixin_43961117的博客
03-02 4771
插入 redis对list操作分为左和右两种 redisTemplate.opsForList().leftPush() 实际调用的是lPush return connection.lPush(rawKey, new byte[][]{rawValue}); redisTemplate.opsForList().rightPush() 调用的是rPush 其实就是队列的左右 lPush将数据添加到key对应的现有数据的左边，也就是头部 rPush是将现有数据添加到现有数据的右边，也就是尾部，可以根据业务的
【Redis】Redis使用和RedisTemplate的方法介绍
别倒在黎明之前的博客
09-05 1715
leftPush ：从集合左边插入值 | | 从集合左边开始在v值后边插入新值v1leftPushAll ：从左边批量插入新值 | | 从左边批量插入新值(同上)leftPushIfPresent ：如果key存在，从左边插入新值leftPop ：默认移除key中最左的一个值| |指定过期时间后删除key最左的一个值rightPopAndLeftPush ：移除k1中最右的值，并将移除的值插入k2中最左侧| |指定过期时间后，移除k1中最右的值，并将移除的值插入k2中最左侧（同上）
docker怎么搭建redis集群 并且集成到springboot项目中
06-01
要搭建 Redis 集群，并将其集成到 Spring Boot 项目中，可以按照以下步骤进行操作： 1. 配置 Redis 集群 首先，需要搭建 Redis 集群，可以使用 Docker 容器来搭建。在终端中输入以下命令： ``` docker run -p ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值