redis使用，及整合进springboot

最新推荐文章于 2022-06-30 00:20:36 发布
最新推荐文章于 2022-06-30 00:20:36 发布
阅读量92 收藏
点赞数
分类专栏： 工作日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/misakakagami/article/details/103239963
版权

redis官方不支持windows，win版本的链接现在删了，微软的维护团队16年也跑路了，现在只有这个github的存货

https://github.com/microsoftarchive/redis/releases

linux版本的去官网下

 

一 安装和启动服务

win：

压缩包解压，在解压目录打开cmd，命令 redis-server.exe redis.windows.conf 启动。关闭窗口即会关闭redis服务。

linux：

待补充

 

二 管理

win：

解压目录打开cmd，命令 redis-cli.exe 进入管理。

linux：

待补充

可视化：

待补充

 

三 springboot整合

1 maven添加依赖（版本需要对应，否则会冲突）

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

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.4.RELEASE</version>
        </dependency>

application.properties

#访问地址
spring.redis.host=127.0.0.1
#访问端口
spring.redis.port=6379
#注意，如果没有password，此处不设置值，但这一项要保留
spring.redis.password=

#最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
spring.redis.pool.max-Idle=300
spring.redis.pool.min-idle=0
#连接池的最大数据库连接数。设为0表示无限制
spring.redis.pool.max-active=600
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
spring.redis.pool.max-Wait=1000
#连接超时时间
spring.redis.timeout=1000

2 config类

package com.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<String,Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

3 工具类

package com.component;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

@Component
public class RedisService {

    private Logger log = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private final RedisTemplate<String,Object> redisTemplate;

    public RedisService(RedisTemplate<String,Object> redisTemplate){
        this.redisTemplate = redisTemplate;
    }

    /*设置失效时间*/
    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 error: ",e);
            return false;
        }
    }

    /*获取key的过期时间，0为永久有效*/
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /*判断key是否存在*/
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*删除*/
    @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));
            }
        }
    }

    /*获取*/
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /*缓存放入*/
    public boolean set(String key,Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 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) {
            log.error("redis error: ",e);
            return false;
        }
    }

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

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

    /*获得map*/
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key,item);
    }

    /*获取map*/
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /*放入map*/
    public boolean hmset(String key,Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*放入map并设置过期时间*/
    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("redis error: ",e);
            return false;
        }
    }

    /*放入map元素*/
    public boolean hset(String key,String item,Object value){
        try {
            redisTemplate.opsForHash().put(key,item,value);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*放入map元素并设置过期时间*/
    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) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*删除map中值*/
    public void hdel(String key,Object... item){
        redisTemplate.opsForHash().delete(key, item);
    }

    /*判断map中有无*/
    public boolean hHasKey(String key,String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    /*hash递增*/
    public double hincr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,by);
    }

    /*hash递减*/
    public double hdecr(String key,String item,double by){
        return redisTemplate.opsForHash().increment(key,item,-by);
    }

    /*获取set*/
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*查询set元素是否存在*/
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key,value);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*放入set*/
    public long sSet(String key,Object... values){
        try {
            return redisTemplate.opsForSet().add(key,values);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*放入set设置过期时间*/
    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) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*获得set长度*/
    public long sGEtSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*移除*/
    public long setRemove(String key,Object... values){
        try {
            Long count = redisTemplate.opsForSet().remove(key,values);
            return count;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*获取list内容*/
    public List<Object> lGet(String key,long start,long end){
        try {
            return redisTemplate.opsForList().range(key,start,end);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*获取list长度*/
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*根据index取list元素*/
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key,index);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*放入list*/
    public boolean lSet(String key,Object value){
        try {
            redisTemplate.opsForList().rightPush(key,value);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*放入list并设置过期时间*/
    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) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*list放入list*/
    public boolean lSet(String key,List<Object> value){
        try {
            redisTemplate.opsForList().rightPushAll(key,value);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*list放入list并设置过期时间*/
    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) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*根据index修改list元素*/
    public boolean lUpdateIndex(String key,long index,Object value){
        try {
            redisTemplate.opsForList().set(key,index,value);
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*删除n个值为value*/
    public long lRemove(String key,long count,Object value){
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return 0;
        }
    }

    /*有序集合添加元素*/
    public boolean zadd(String key,Object member,double score,long time){
        try {
            redisTemplate.opsForZSet().add(key,member,score);
            if(time>0){
                expire(key,time);
            }
            return true;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return false;
        }
    }

    /*返回区间内成员*/
    public Set<Object> zRangeByScore(String key,double minScore,double maxScore){
        try {
            return redisTemplate.opsForZSet().rangeByScore(key,minScore,maxScore);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*返回元素分数*/
    public Double zscore(String key,Object member){
        try {
            return redisTemplate.opsForZSet().score(key, member);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*返回元素索引*/
    public Long zrank(String key,Object member){
        try {
            return redisTemplate.opsForZSet().rank(key, member);
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }

    /*迭代有序集合*/
    public Cursor<ZSetOperations.TypedTuple<Object>> zscan(String key){
        try {
            Cursor<ZSetOperations.TypedTuple<Object>> cursor = redisTemplate.opsForZSet().scan(key, ScanOptions.NONE);
            return cursor;
        } catch (Exception e) {
            log.error("redis error: ",e);
            return null;
        }
    }
}

（工具类中的RedisTemplate需要由config类创建实例）

4 测试

...
@Autowired
private RedisService redisService;
...

...
redisService.set("a",1);
System.out.println(redisService.get("a"));
...

 

御坂镜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
spring和redis整合异常整理
JAVA_HIGHNESS的专栏
09-14 7236
记录 1、Unable to validate object异常信息如下：org.springframework.data.redis.RedisConnectionFailureException: Cannot get Jedis connection; nested exception is redis.clients.jedis.exceptions.JedisException: Coul
SSM系类代码：org.springframework.data.redis.core
BLOG域名:programb.blog.csdn.net
06-23 1971
package com.ssm.chapter17.jedis; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; public class JedisTest { public void testJedis() { Jedis jedis = testPool().getResource(); // Jedi
RedisTemplate 实现 scan 方法（最新版 spring-redis-data 已于 2022.02.23 支持了 scan 方法）
weixin_58195194的博客
06-30 5610
RedisTemplate 实现 scan 方法
SpringBoot项目技术集成
m0_60413225的博客
02-08 476
package com.yk.code.aspect; import com.github.pagehelper.Page; import com.github.pagehelper.PageHelper; import com.github.pagehelper.PageInfo; import com.yk.code.util.PageBean; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.ProceedingJoinPoint.
Redis SortedSet 例子
热门推荐
01-31 4万+
Redis SortedSet 例子 import java.util.HashSet; import java.util.Iterator; import java.util.Set; import org.springframework.data.redis.connection.DefaultTuple; import org.springframework.data.redis.connection.RedisConnection; import org.springframework.d.
Redis不常用操作指南（基于SpringBoot2.3.2代码实现）
weixin_64314555的博客
12-20 1092
1 前言 通常程序员在学习Redis的安装到使用是非常快速的，因为Redis的大部分操作都等同于Map的操作逻辑，只要了解大部分api结合百度能够快速的投入到CRUD的工作中去,所以今天来一期Redis不常用操作指南，当然这里的不常用更多是不会天天用，但是在项目中还是会有应用到的地方。 2 安装Redis 安装及原生命令 3 SpringBoot2整合Redis（有现成环境的可以略过） 3.1 相关依赖 <!-- 单元测试 --> <dependency> ..
06.`spring boot`集成`redis`
rmy_20的博客
09-05 323
SpringBoot集成redis
Redis 【第三篇】Redis缓存穿透、击穿、雪崩与相对应的解决方案，以及跳跃表实现原理
NanYII_的博客
11-04 747
文章目录一、Jdeis概述1、简单介绍2、 基本使用二、RedisUtil工具类总结 一、Jdeis概述 1、简单介绍   (1) Jedis是Redis官方推荐的Java连接开发工具。要在Java开发中使用好Redis中间件，必须对Jedis熟悉才能写成漂亮的代码 2、 基本使用   2.1- 单实例连接   导入依赖 <dependencies> <!-- 单元测试--> <dependency>
在RedisTemplate中使用scan代替keys指令
weixin_30301449的博客
08-30 6809
keys * 这个命令千万别在生产环境乱用。特别是数据庞大的情况下。因为Keys会引发Redis锁，并且增加Redis的CPU占用。很多公司的运维都是禁止了这个命令的 当需要扫描key，匹配出自己需要的key时，可以使用 scan 命令 scan操作的Helper实现 import java.io.IOException; import java.nio.charset.Standard...
SpringBoot整合Redis大全
04-20
包含springBoot对redis操作的方法，包括测试，测试在test包里
springboot整合spring-data-redis遇到的坑
08-30
使用springboot整合redis,使用默认的序列化配置,然后使用redis-client去查询时查询不到相应的key.问题出在哪，怎么解决呢？下面小编给大家带来了springboot整合spring-data-redis遇到的坑，需要的的朋友参考下吧
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
springboot整合redis集群零配置
07-28
Springboot整合Redis集群,零配置方式;另外用AOP实现了操作缓存的三套自定义注解,有兴趣的小伙伴可以试试看.
feign分布式事务
Rabbit House
12-19 1万+
一 问题： 微服务中，某事务内通过feign调用多个api，但Transcational注解的事务只对本服务的流程有效，feign调用的接口不会回滚。为使feign调用目标参与事务，需使用分布式锁。 二 结构 原有结构：注册中心、调用者、被调用者 需新增：tx微服务，配套的一个数据库表，配套的redis服务，不需注册至注册中心。调用者、被调用者使用指定注解实现分布式锁。 三 原理 tx...
一个java获取当前项目路径的方法
Rabbit House
05-27 5002
java路径很麻烦，网上很多人总结，不多说 这里说其中一种，System.getProperty("user.dir"); 这个方法有很多种参数，user.dir是获得当前工作路径。 我遇到的问题：在j2ee项目中，前台上传excel文件，后台读取文件数据，再在前台显示。我懒得找前台excel插件，现在看来变得更麻烦了。上传还好，路径写相对路径就能正确传到webroot/WEB-IN
java获取当前时间12/24小时制
Rabbit House
07-04 4302
一个小细节 使用Date d = new Date(); SimpleDateFormat格式化时间时，会用yyyymmddhhmmss等 yyyy年 MM月 dd日 hh小时（*注意 hh为12小时制，HH为24小时制） ss秒
多表连接与聚合函数的查询问题
Rabbit House
05-22 2230
场景： 用户表，用户详情表，说说表。用户表和详情表一一对应，因此在这里视为一个表就行。由于一个用户可以发布多个说说，现在要显示用户情况列表，因此需要查询用户的详情，以及每个用户发布说说的数量统计。 这里除了查询用户表的字段，还要在每行有说说表中当前用户的发言的统计。 绕了一天，总想用左连接连起来查，结果当然是用户总量、说说总量、说说中各用户发言量之类，最后想起嵌套查询
long类型数值溢出
Rabbit House
05-17 1454
msOfDay = 86400000 msOfWeek = 604800000 msOf30Days = -1702967296 计算日期差时分母可能要1000*3600*24*30，这时分母是月，结果就是第三个溢出的值，因为这4个乘数都是int型 解决方法是1000换成1000L，直接用long类型 http://www.blogjava.net/aoxj/ar
redis主从集群整合springboot
最新发布
09-26
在使用Spring Boot整合Redis主从集群时，需要在application.yml（或application.properties）文件中配置相应的节点信息。下面提供了两种配置方式。 第一种是整合哨兵集群的配置方式，示例如下： ``` spring: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值