redis(七)之springboot整合redis

最新推荐文章于 2022-02-23 09:51:35 发布
最新推荐文章于 2022-02-23 09:51:35 发布
阅读量220 收藏
点赞数
分类专栏： redis内存数据库 java-spring系列 文章标签： redis springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40351478/article/details/88723763
版权

1.使用redisTemplate的方式

1.pom.xml

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2.application.properties里面添加

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接超时时间（毫秒）
spring.redis.timeout=3000
#最大空闲数
redis.maxIdle=300  
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
#redis.maxActive=600
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
redis.maxTotal=1000  
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWaitMillis=1000  
#连接的最小空闲时间 默认1800000毫秒(30分钟)
redis.minEvictableIdleTimeMillis=300000  
#每次释放连接的最大数目,默认3
redis.numTestsPerEvictionRun=1024  
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
redis.timeBetweenEvictionRunsMillis=30000  
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
redis.testOnBorrow=true  
#在空闲时检查有效性, 默认false
redis.testWhileIdle=true

3.创建RedisUtil类

package cn.itcast.ssm.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
 * @author wsw
 * @Package cn.itcast.ssm.util
 * @Description:
 * @date 19-3-21 上午11:30
 */

@Service
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    private static double size = Math.pow(2, 32);


    /**
     * 写入缓存
     *
     * @param key
     * @param offset   位 8Bit=1Byte
     * @return
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.setBit(key, offset, isShow);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.getBit(key, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存并设置有效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean settime(final String key, Object value,long time) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value,time,TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }


    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }
    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPushtime(String k, Object v,long time) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v,time);
    }
  /*  *//**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSetlist(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        redisTemplate.opsForValue();
        return zset.rangeByScore(key, scoure, scoure1);
    }


    //第一次加载的时候将数据加载到redis中
    public void saveDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        boolean availableUsers = setBit("availableUsers", indexLong, true);
    }

    //第一次加载的时候将数据加载到redis中
    public boolean getDataToRedis(String name) {

        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        return getBit("availableUsers", indexLong);
    }

    /**
     * 有序集合获取排名
     *
     * @param key 集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key,value);
    }


    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key,value);
    }


    /**
     * 有序集合添加分数
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }


    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }

    }

4.在service中使用

	@Autowired
    CropMapper cropMapper;
    @Autowired
    RedisUtil redisUtil;
    @Override
    public List<Crop> selectAllCropName() {
        //从缓存中获取
        List namelist= redisUtil.lRange("namelist",0,-1);
        //如果缓存中没有，则从mysql中获取
        if(namelist.size()==0){
            List list=cropMapper.selectByExample(null);
            for(Object crop:list){
                Crop crop1=(Crop)crop;
                namelist.add(crop1.getName());
            }
        }
        //加入缓存中并设置过期时间120s
        redisUtil.lSetlist("namelist",namelist,120);
        return  namelist;
    }

2.springboot整合redis缓存注解@Cacheable、@CacheEvict、@CachePut

@Cacheable：

主要用来配置方法，能够根据方法的请求参数对其结果进行缓存。即当重复使用相同参数调用方法的时候，方法本身不会被调用执行，即方法本身被略过了，取而代之的是方法的结果直接从缓存中找到并返回了。
参数：
value：缓存的名字，必须指定至少一个。
key:缓存的key，可以为空，如果指定要按照SpEL表达式编写；如果不指定，则缺省按照方法的所有参数进行组合。
condition：缓存的条件，可以为空，使用SpEL编写，返回true或者false，只有为true才能缓存。

@CachePut：

这个注释可以确保方法被执行，同时方法的返回值也被记录到缓存中，用于更新缓存与数据库。
参数同上。

@CacheEvict

删除缓存。参数:allEntries：true表示清除value中的全部缓存，默认为false。其余参数同上
1.pom.xml依赖

 	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
	</dependency>

2.RedisConfig


@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String,String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
    //自定义key
    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");

            return stringBuilder.toString();
        };
    }
    //默认缓存时间
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(60), // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }
    //自定义缓存时间
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
    /*    redisCacheConfigurationMap.put("SelectMax_T", this.getRedisCacheConfigurationWithTtl(30));*/
        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> 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);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

}

3.使用

 @Override
    @CachePut(value = "Max_T",key="'CropId:'+#p0")
    public double UpdateMax_T(int CropId,double Max_T) {
        List list=parameterMapper.selectByExample(null);
        for(Object parameter_:list){
            Parameter parameter=(Parameter) parameter_;
            if(parameter.getCropId()==CropId){
               parameter.setMaxT(Max_T);
               parameterMapper.updateByExample(parameter, new ParameterExample());
            }
        }
        return Max_T;
    }

    @Override
    @Cacheable(value = "Max_T",key="'CropId:'+#p0")
    public double SelectMax_T(int CropId) {
        Double Max_T=0.0;
        List list=parameterMapper.selectByExample(null);
        for(Object parameter_:list){
            Parameter parameter=(Parameter) parameter_;
            if(parameter.getCropId()==CropId){
                Max_T=parameter.getMaxT();
            }
        }
        return Max_T;
    }
杉杉来吃·
关注
专栏目录
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
redis九大数据类型及场景案例实现
qq_14946371的博客
03-28 174
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多 种类型的数据结构，如 字符串（strings）、散列（hashes）、 列表（lists）、 集合（sets）、 有序集合（sorted sets）等。
redis工具类
qq_37469931的博客
03-18 316
1、整合spring boot ，在pom.xml里加入 maven坐标 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 2、创建配置文件 application.yml spring: redis:
springboot使用redis（StringRedisTemplate的常用方法）
写bug的小哥哥
03-23 1万+
1、在springboot 中使用StringRedisTemplate，首先需要添加maven依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId...
redis分页查询案例
y1433的博客
07-10 2143
redis的分页查询利用到了sortset 和 hash的两个数据类型，这两个互相配合使用才能完美的完成分页，思想都在都在代码中 1.初始逻辑 @Override public List<User> selectAll() { long page = 2; long pageSize = 4; String key = "user_key_"; List<User> users = new ArrayList&l
Springboot+Mybatis+Redis简单案例展示
weixin_42209881的博客
05-19 1510
MySQL数据库： DROP TABLE IF EXISTS `student`; CREATE TABLE `student` ( `id` int(11) NOT NULL AUTO_INCREMENT, `num` varchar(11) DEFAULT NULL, `name` varchar(255) DEFAULT NULL, `gender` varchar(255) DEFAULT NULL, `age` int(11) DEFAULT NULL, PRIMARY K
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
springboot整合redis动态切换每个数据库
06-20
springboot整合redis动态切换每个数据库，
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
redis做方法缓存
断掉的手环
11-24 4687
redis做方法缓存 为什么要拿redis做缓存？ ​ redis是一个完全基于内存、数据结构简单、采用单线程的工作方式（避免了不必要的上下文切换）、使用IO多路复用的一个key-value类型的数据库。查询速度要远比mysql这种关系型数据库要快得多。 ​ 系统绝大多数场景下都是读多写少，而mysql能够承受的并发量在每秒两三千（百度得到的数据）的时候就会面临宕机的风险了，并且查询速度极慢。 1、查询流程 ​ 在请求达到后端之后，对需要进行缓存的接口，会先去redis中找有无数据，没有的话会继续走正常
Redis mysql查询结果_Redis Select 命令
weixin_42500279的博客
02-05 429
Redis Select 命令 - 切换到指定的数据库Redis Select 命令用于切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。语法redis Select 命令基本语法如下：redis 127.0.0.1:6379> SELECT index可用版本>= 1.0.0返回值总是返回 OK 。实例redis 127.0.0.1:6379>...
【坑】Springboot+Redis序列化坑
林老师带你学编程
07-25 1万+
今天在测试springboot整合redis的时候遇到下面这个坑，百度来百度去发现提示都是ajax的问题，真的是醉了，错误提示如下所示，不信大家可以直接复制百度一下答案是什么（流泪中。。。。），错误如下： org.springframework.data.redis.serializer.SerializationException: Could not read JSON: Unrecogni...
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
Java知音
12-25 1341
作者：陈彦斌cnblogs.com/chenyanbin/p/13515268.html创建SpringBoot项目 在线创建方式网址：https://start.spring.io/然...
SpringBoot高级篇Redis之ZSet数据结构使用姿势
热门推荐
小灰灰blog的专栏
12-14 1万+
Redis的五大数据结构，目前就剩下最后的ZSET，可以简单的理解为带权重的集合；与前面的set最大的区别，就是每个元素可以设置一个score，从而可以实现各种排行榜的功能 I. 基本使用 在开始之前，序列化的指定需要额外处理，前面List这一篇已经提及，相关内容可以参考： 181109-SpringBoot高级篇Redis之List数据结构使用姿势 1. 新增元素 新增元素时，用起来和se...
mysql布隆过滤器_布隆过滤器
weixin_39581571的博客
02-09 353
@Servicepublic classRedisService {@AutowiredprivateRedisTemplate redisTemplate;private static double size = Math.pow(2, 32);/*** 写入缓存**@paramkey*@paramoffset 位 8Bit=1Byte*@return*/public boolean setBi...
SpringBoot+Redis简单实现文章浏览量记录
wl_Honest的博客
02-23 5455
现在做的大部分项目都用到了SpringBoot和Redis，不过实际开发中，Redis只存了Token之类的数据，大部分的增删改查还是直接走的MySQL数据库。这2天逛论坛发现其实很多场景其实更需要Redis这样的存在，于是参考网上的代码简单做了个文章浏览量记录的Demo。 首先放出maven依赖： <dependencies> <dependency> <groupId>junit</groupId> <artif
RedisTemplate常用集合使用说明-opsForZSet(六)
别抢我蓝buff
03-06 1万+
1、add(K key, V value, double score)   添加元素到变量中同时指定元素的分值。   Java代码   redisTemplate.opsForZSet().add("zSetValue","A",...
redis hash结构springboot整合redis
最新发布
06-26
在 Spring Boot 中整合 Redis，你可以使用 Spring Data Redis 库，它简化了与 Redis 的交互。 Spring Boot 整合 Redis 的步骤如下： 1. 添加依赖：在你的 `pom.xml` 或 `build.gradle` 文件中添加 Spring Data ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值