springboot连接远程Redis

最新推荐文章于 2024-07-25 14:56:54 发布
最新推荐文章于 2024-07-25 14:56:54 发布
阅读量1.6k 收藏 6
点赞数 1
文章标签： spring boot redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/persist_z/article/details/123239369
版权

springboot项目需要添加数据到远程的redis报错

 Unable to connect to Redis; nested exception is io.lettuce.core.RedisConnectionException: Unable to connect to

排查发现需要在控制台放行还需要在linux服务器的防火墙放行所需端口，

  1. springboot项目添加redis依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
  1. 配置application配置文件
spring:
 redis:
   database: 0
   # Redis服务器地址 写你的ip
   host: 182.61.5.203
   # Redis服务器连接端口
   port: 6379
   # Redis服务器连接密码（默认为空）
   password:
   # 连接池最大连接数（使用负值表示没有限制  类似于mysql的连接池
   jedis:
     pool:
       max-active: 200
       # 连接池最大阻塞等待时间（使用负值表示没有限制） 表示连接池的链接拿完了 现在去申请需要等待的时间
       max-wait: -1
       # 连接池中的最大空闲连接
       max-idle: 10
       # 连接池中的最小空闲连接
       min-idle: 0
   # 连接超时时间（毫秒） 去链接redis服务端
   timeout: 6000
  1. 在服务器的控制台，安全组添加放行端口
    在这里插入图片描述
  2. 在linux服务器编辑redis.conf配置文件，取消本地绑定，开启远程访问
// 找到配置文件redis.conf，修改配置文件
//开启远程连接（注释掉代表允许所有人访问）
#bind 127.0.0.1 -::1

//开启远程连接（允许所有人访问，由yes修改为no）
protected-mode no
  1. 在linux服务器开启防火墙端
1、开启防火墙 
   systemctl start firewalld

2、开放指定端口（redis的默认port=6379）
firewall-cmd --zone=public --add-port=6379/tcp --permanent
命令含义：
--zone #作用域
--add-port=1935/tcp  #添加端口，格式为：端口/通讯协议
--permanent  #永久生效，没有此参数重启后失效

3、重启防火墙
     firewall-cmd --reload

4、查看端口号
netstat -ntlp   //查看当前所有tcp端口·
  1. 编写java代码，一般的RedisUtil工具类
package com.luguz.util;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

/**
* Redis工具类
* @author Guz
* @create 2022-02--25 21:33
*/
@Component
public final class RedisUtil {

   @Autowired
   private RedisTemplate<String, Object> redisTemplate;

   // =============================common============================
   /**
    * 指定缓存失效时间
    * @param key 键
    * @param time 时间(秒)
    * @return
    */
   public boolean expire(String key, long time) {
       try {
           if (time > 0) {
               redisTemplate.expire(key, time, TimeUnit.SECONDS);
           }
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 根据key 获取过期时间
    * @param key 键 不能为null
    * @return 时间(秒) 返回0代表为永久有效
    */
   public long getExpire(String key) {
       return redisTemplate.getExpire(key, TimeUnit.SECONDS);
   }

   /**
    * 判断key是否存在
    * @param key 键
    * @return true 存在 false不存在
    */
   public boolean hasKey(String key) {
       try {
           return redisTemplate.hasKey(key);
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 删除缓存
    * @param key 可以传一个值 或多个
    */
   @SuppressWarnings("unchecked")
   public void del(String... key) {
       if (key != null && key.length > 0) {
           if (key.length == 1) {
               redisTemplate.delete(key[0]);
           } else {
               redisTemplate.delete(CollectionUtils.arrayToList(key));
           }
       }
   }

   // ============================String=============================
   /**
    * 普通缓存获取
    * @param key 键
    * @return 值
    */
   public Object get(String key) {
       return key == null ? null : redisTemplate.opsForValue().get(key);
   }

   /**
    * 普通缓存放入
    * @param key 键
    * @param value 值
    * @return true成功 false失败
    */
   public boolean set(String key, Object value) {
       try {
           redisTemplate.opsForValue().set(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }

   }

   /**
    * 普通缓存放入并设置时间
    * @param key 键
    * @param value 值
    * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    * @return true成功 false 失败
    */
   public boolean set(String key, Object value, long time) {
       try {
           if (time > 0) {
               redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
           } else {
               set(key, value);
           }
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 递增
    * @param key 键
    * @param delta 要增加几(大于0)
    * @return
    */
   public long incr(String key, long delta) {
       if (delta < 0) {
           throw new RuntimeException("递增因子必须大于0");
       }
       return redisTemplate.opsForValue().increment(key, delta);
   }

   /**
    * 递减
    * @param key 键
    * @param delta 要减少几(小于0)
    * @return
    */
   public long decr(String key, long delta) {
       if (delta < 0) {
           throw new RuntimeException("递减因子必须大于0");
       }
       return redisTemplate.opsForValue().increment(key, -delta);
   }

   // ================================Map=================================
   /**
    * HashGet
    * @param key 键 不能为null
    * @param item 项 不能为null
    * @return 值
    */
   public Object hget(String key, String item) {
       return redisTemplate.opsForHash().get(key, item);
   }

   /**
    * 获取hashKey对应的所有键值
    * @param key 键
    * @return 对应的多个键值
    */
   public Map<Object, Object> hmget(String key) {
       return redisTemplate.opsForHash().entries(key);
   }

   /**
    * HashSet
    * @param key 键
    * @param map 对应多个键值
    * @return true 成功 false 失败
    */
   public boolean hmset(String key, Map<String, Object> map) {
       try {
           redisTemplate.opsForHash().putAll(key, map);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * HashSet 并设置时间
    * @param key 键
    * @param map 对应多个键值
    * @param time 时间(秒)
    * @return true成功 false失败
    */
   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) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 向一张hash表中放入数据,如果不存在将创建
    * @param key 键
    * @param item 项
    * @param value 值
    * @return true 成功 false失败
    */
   public boolean hset(String key, String item, Object value) {
       try {
           redisTemplate.opsForHash().put(key, item, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 向一张hash表中放入数据,如果不存在将创建
    * @param key 键
    * @param item 项
    * @param value 值
    * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    * @return true 成功 false失败
    */
   public boolean hset(String key, String item, Object value, long time) {
       try {
           redisTemplate.opsForHash().put(key, item, value);
           if (time > 0) {
               expire(key, time);
           }
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 删除hash表中的值
    * @param key 键 不能为null
    * @param item 项 可以使多个 不能为null
    */
   public void hdel(String key, Object... item) {
       redisTemplate.opsForHash().delete(key, item);
   }

   /**
    * 判断hash表中是否有该项的值
    * @param key 键 不能为null
    * @param item 项 不能为null
    * @return true 存在 false不存在
    */
   public boolean hHasKey(String key, String item) {
       return redisTemplate.opsForHash().hasKey(key, item);
   }

   /**
    * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    * @param key 键
    * @param item 项
    * @param by 要增加几(大于0)
    * @return
    */
   public double hincr(String key, String item, double by) {
       return redisTemplate.opsForHash().increment(key, item, by);
   }

   /**
    * hash递减
    * @param key 键
    * @param item 项
    * @param by 要减少记(小于0)
    * @return
    */
   public double hdecr(String key, String item, double by) {
       return redisTemplate.opsForHash().increment(key, item, -by);
   }

   // ============================set=============================
   /**
    * 根据key获取Set中的所有值
    * @param key 键
    * @return
    */
   public Set<Object> sGet(String key) {
       try {
           return redisTemplate.opsForSet().members(key);
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       }
   }

   /**
    * 根据value从一个set中查询,是否存在
    * @param key 键
    * @param value 值
    * @return true 存在 false不存在
    */
   public boolean sHasKey(String key, Object value) {
       try {
           return redisTemplate.opsForSet().isMember(key, value);
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 将数据放入set缓存
    * @param key 键
    * @param values 值 可以是多个
    * @return 成功个数
    */
   public long sSet(String key, Object... values) {
       try {
           return redisTemplate.opsForSet().add(key, values);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }

   /**
    * 将set数据放入缓存
    * @param key 键
    * @param time 时间(秒)
    * @param values 值 可以是多个
    * @return 成功个数
    */
   public long sSetAndTime(String key, long time, Object... values) {
       try {
           Long count = redisTemplate.opsForSet().add(key, values);
           if (time > 0)
               expire(key, time);
           return count;
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }

   /**
    * 获取set缓存的长度
    * @param key 键
    * @return
    */
   public long sGetSetSize(String key) {
       try {
           return redisTemplate.opsForSet().size(key);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }

   /**
    * 移除值为value的
    * @param key 键
    * @param values 值 可以是多个
    * @return 移除的个数
    */
   public long setRemove(String key, Object... values) {
       try {
           Long count = redisTemplate.opsForSet().remove(key, values);
           return count;
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }
   // ===============================list=================================

   /**
    * 获取list缓存的内容
    * @param key 键
    * @param start 开始
    * @param end 结束 0 到 -1代表所有值
    * @return
    */
   public List<Object> lGet(String key, long start, long end) {
       try {
           return redisTemplate.opsForList().range(key, start, end);
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       }
   }

   /**
    * 获取list缓存的长度
    * @param key 键
    * @return
    */
   public long lGetListSize(String key) {
       try {
           return redisTemplate.opsForList().size(key);
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }

   /**
    * 通过索引 获取list中的值
    * @param key 键
    * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    * @return
    */
   public Object lGetIndex(String key, long index) {
       try {
           return redisTemplate.opsForList().index(key, index);
       } catch (Exception e) {
           e.printStackTrace();
           return null;
       }
   }

   /**
    * 将list放入缓存
    * @param key 键
    * @param value 值
    * @param time 时间(秒)
    * @return
    */
   public boolean lSet(String key, Object value) {
       try {
           redisTemplate.opsForList().rightPush(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 将list放入缓存
    * @param key 键
    * @param value 值
    * @param time 时间(秒)
    * @return
    */
   public boolean lSet(String key, Object value, long time) {
       try {
           redisTemplate.opsForList().rightPush(key, value);
           if (time > 0)
               expire(key, time);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 将list放入缓存
    * @param key 键
    * @param value 值
    * @param time 时间(秒)
    * @return
    */
   public boolean lSet(String key, List<Object> value) {
       try {
           redisTemplate.opsForList().rightPushAll(key, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 将list放入缓存
    *
    * @param key 键
    * @param value 值
    * @param time 时间(秒)
    * @return
    */
   public boolean lSet(String key, List<Object> value, long time) {
       try {
           redisTemplate.opsForList().rightPushAll(key, value);
           if (time > 0)
               expire(key, time);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 根据索引修改list中的某条数据
    * @param key 键
    * @param index 索引
    * @param value 值
    * @return
    */
   public boolean lUpdateIndex(String key, long index, Object value) {
       try {
           redisTemplate.opsForList().set(key, index, value);
           return true;
       } catch (Exception e) {
           e.printStackTrace();
           return false;
       }
   }

   /**
    * 移除N个值为value
    * @param key 键
    * @param count 移除多少个
    * @param value 值
    * @return 移除的个数
    */
   public long lRemove(String key, long count, Object value) {
       try {
           Long remove = redisTemplate.opsForList().remove(key, count, value);
           return remove;
       } catch (Exception e) {
           e.printStackTrace();
           return 0;
       }
   }
}
  1. java测试
    在这里插入图片描述 9. 插入成功，在启动查询的时候报错
远程redis 你的主机中的软件中止了一个已建立的连接。

将xshell连接关闭以后重试，成功获取。

luguz
关注
SpringBoot链接远程Redis
Luck
04-11 2079
Redis可以说在项目中是刚需了，几乎都要用到。下面就很简洁的记录下在我们的SpringBoot中如何去整合Redis，以及其中过程中碰到的小问题，希望有帮助到你。 首先，在创建项目时，添加我们需要的依赖： 大家注意，这里添加了一个Spring Security的依赖。这是因为从springboot2.1.5开始，如果需要远程链接redis，这个依赖是必须有的。另外提一点，redis在5版本之后...
SpringBoot+Redis哨兵模式
wl_Honest的博客
04-14 8618
最近学习到了Redis的哨兵模式，光看视频还不行，需要自己动手实现一遍才能加深映像，特此记录。 由于没有真实的服务器可以供我操作，所以在虚拟机上启动了3个redis服务，分别占用7001、7002、7003端口。 Redis下载安装不多赘述，只在这里记录一下配置。 首先在tmp目录下创建3个文件夹: cd /tmp mkdir 7001 7002 7003 然后将redis的配置文件redis.conf拷贝到刚刚创建的3个文件夹下 cp redis-6.2.6/redis.conf
基于SpringBoot集成测试远程连接Redis服务的教程详解
08-19
主要介绍了基于SpringBoot集成测试远程连接的Redis服务的相关知识，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
Springboot 整合redis 入门示例
cui163007的博客
10-05 294
Springboot 整合redis 入门示例 工具 eclipse mar jkd1.8 maven3.5.3 springboot2.1.0 1 添加redis依赖(当springBoot的版本为1.4.7 以上的时候,需要引入下边的版本) <!-- 引入redis依赖 --> <dependency> ...
SpringBoot连接Redis且解决乱码
最新发布
李长渊的博客
07-25 886
SpringBoot连接Redis且解决乱码
springboot远程连接redis
qq_45100750的博客
08-23 670
单机版 第一步 先配置好单机版的配置文件 在单机版redis的配置文件/usr/local/redis/bin/redis.conf 文件中 将daemonize修改为yes 将protected-mode修改为no 要是没有protected-mode自行添加 这里的bind也应该是注释状态 第二步 新建redis模块 这里是他所需要的依赖 <dependencies> <!-- Spring Session 分布式事务 ，在登录时使用 -->
SpringBoot连接远程服务器redis
weixin_51713937的博客
01-18 811
进入redis安装地址，我这里安装的是 /usr/local/src/redis-6.2.6先copy一份配置文件然后修改配置文件信息启动redis去云服务器安全组中开放端口重启防火墙查看6379的防火墙状态。
Springboot项目远程连接Redis
July的博客
03-30 536
查看redis安装目录 whereis redis-server redis配置文件中修改 protected-mode no 以及 注释掉 bind 127.0.0.1 在redis安装目录下执行 redis-server /路径/redis.conf & 启动redis redis-cli 进入客户端
springboot连接远程redis
03-16
要连接远程Redis，需要在Spring Boot应用程序中添加Redis客户端依赖项。可以使用Jedis或Lettuce作为Redis客户端。然后，在应用程序的配置文件中配置Redis连接信息，包括主机名、端口号、密码等。最后，在应用程序中...
SpringBoot远程访问redis服务器问题剖析
08-30
在使用SpringBoot连接Redis服务器之前，需要在pom文件中添加Redis依赖。可以在pom文件中添加以下依赖项： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-redis ``` 二、配置...
Springboot远程连接redis服务器（仅连接上）
qiuhalouha_1的博客
03-19 1220
1. 导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2.配置连接（这里只需配置password 和 host） spring:
springboot连接redis简单示例
10-24
springboot连接redis简单示例。其中含连接redis的dao层和controller层，可以通过页面访问进行测试。
springboot项目连接数据库及redis实例
01-23
使用springboot搭建，连接mysql数据库以及redis缓存。需要修改数据库和redis配置才能正常运行。
项目中集成redis
Java—wang的博客
07-30 629
!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- spring2.X集成redis所需common-pool2--> <dependency..
springboot远程连接云服务redis服务端
各位多多关照
04-25 1004
springboot redis 远程连接 服务器
springboot配置远程redis
qq_43709763的博客
12-29 809
springboot配置远程redis在云服务器上配置redisredis进行下载安装进行redis的配置配置redis 的启动，将其设为服务。在springboot的项目中对于redis进行相关的配置读取配置文件中的配置：RedisConfig建立redis的连接池工厂RedisPoolFactory建立redis的服务RedisService 在云服务器上配置redis redis进行下载安装 首先去腾讯云或者阿里云租一个服务器，楼主这里选择的是1核 2GB 1Mbps的小型云服务器，一个月9元，很便宜
Spring Boot中连接远程Redis的方法
大强的专栏
03-05 4569
Redis是目前业界使用最广泛的内存数据存储。相比memcached，Redis支持更丰富的数据结构，例如hashes, lists, sets等，同时支持数据持久化。除此之外，Redis还提供一些类数据库的特性，比如事务，HA，主从库。可以说Redis兼具了缓存系统和数据库的一些特性，因此有着丰富的应用场景。本文介绍Redis在Spring Boot中两个典型的应用场景。如何使用 1、引入spr...
SpringBoot远程访问Linux中Redis服务器
Code-Zhao
11-12 2697
首先在linux中安装Redis 将下载好的包解压到指定目标。（这里是根目录下的app文件夹） tar -zxvf redis-4.0.11.tar.gz -C /app 进入Redis安装文件夹 /app/redis-4.0.11  PS：新安装的linux系统没有安装gcc环境、需要安装gcc，为了方便采取一键安装方式  # yum install gcc 验证gcc是否安装成功：#...
SpringBoot远程访问redis服务器
夜闯秋名山吃瓜皮
04-23 4193
springboot redis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值