springboot整合redis

已于 2024-02-28 10:31:39 修改
阅读量664 收藏 2
点赞数
分类专栏： springcloud springboot redis 文章标签： spring boot redis spring
于 2021-08-09 14:58:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41695138/article/details/119538014
版权
springboot 同时被 3 个专栏收录
46 篇文章 0 订阅
订阅专栏
springcloud
17 篇文章 0 订阅
订阅专栏
redis
7 篇文章 0 订阅
订阅专栏

项目地址（gitee）: https://gitee.com/qinenqi/online
springboot整合redis实现数据缓存

  1. 引入依赖 （依赖放在了common公共服务中）
 <!--    redis    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
  1. 修改配置文件、添加redis的配置（新建 application.yml）
spring:
  redis:
    open: true  # 是否开启redis缓存  true开启   false关闭
    database: 0
    host: 192.168.8.132
    port: 6379
    password:    # 密码（默认为空）
    timeout: 6000ms  # 连接超时时长（毫秒）
    jedis:
      pool:
        max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms      # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接
  1. 启动类添加注解： @EnableCaching
    这个注解是为了触发一个post processor，这会扫描每一个spring bean，查看是否已经存在注解对应的缓存。如果找到了，就会自动创建一个代理拦截方法调用，使用缓存的bean执行处理。小编的理解是：添加了这个注解，就可以使用一些springboot提供的缓存注解了，如：@CacheConfig @Cacheable @CachePut @CacheEvict
  2. 新建redis的配置文件： RedisConfig.java

import org.springframework.beans.factory.annotation.Autowired;
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.*;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 * Redis 数据类型: String（字符串）  Hash（哈希）  List（列表）   Set（集合）   zset(sorted set：有序集合)
 *
 */
@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     *  Hash（哈希）
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     *  String（字符串）
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     *  List（列表）
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     *  Set（集合）
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     *   zset(sorted set：有序集合)
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}
  1. 新建 CouponServiceImpl.java

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.onlinecoupon.utils.RedisUtils;
import com.example.onlinecoupon.entry.CouponEntity;
import com.example.onlinecoupon.mapper.CouponMapper;
import com.example.onlinecoupon.service.CouponService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 *  1. 缓存穿透 是指用户查询数据，在数据库没有，自然在缓存中也不会有。这样就导致用户查询的时候， 在缓存中找不到对应key的value，每次都要去数据库再查询一遍，然后返回空(相当于进行了两次 无用的查询)。这样请求就绕过缓存直接查数据库。
 *      解决方案：缓存空值
 *  2. 缓存击穿 是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。
 *      解决方案：加互斥锁
 *
 *  3. 缓存雪崩 假如很多的缓存同一时刻失效，此时正好大量的请求进来了，有可能会发生同一时刻都去查询数据库，因此就发生了缓存雪崩问题
 *      解决： 设置不同的过期时间
 *
 *   4. redis分布式锁： 当次服务部署多个时， 结合gateway，则会出现 redis 分部署 访问问题
 *      解决： 添加分布式锁
 */
@Service
@Slf4j
public class CouponServiceImpl extends ServiceImpl<CouponMapper, CouponEntity> implements CouponService {


    @Autowired
    private CouponMapper couponMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private ValueOperations<String, String> valueOperations;

    @Autowired
    private HashOperations<String, String, String> hashOperations;

    @Autowired
    private RedisUtils redisUtils;

    /**
     * 新增一条 优惠券信息
     * @param couponEntity
     */
    public void insertOne(CouponEntity couponEntity){
        couponMapper.insert(couponEntity);
    }



    /**
     * 根据id 查询数据
     *  ValueOperations<String, String>
     * @param id
     * @return
     */
    public CouponEntity selectById01(Long id){
        CouponEntity couponEntity = couponMapper.selectById(id);
        String key = id.toString();
        String value = redisUtils.objectParseString(couponEntity);
        if(couponEntity != null){
            valueOperations.set(key, value);
        }
        return couponEntity;
    }
    /**
     * 根据id 查询数据
     *  HashOperations<String, String, String>
     * @param id
     * @return
     */
    public CouponEntity selectById02(Long id){
        String redisKey = "couponEntity";
        String key = id.toString();
        Boolean aBoolean = hashOperations.hasKey(redisKey, key);
        CouponEntity couponEntity = new CouponEntity();

        if(!aBoolean){
            couponEntity = couponMapper.selectById(id);
            if(couponEntity != null){
                String value = redisUtils.objectParseString(couponEntity);
                hashOperations.put(redisKey, key, value);
            }
        }else{
            String valueRedis = hashOperations.get(redisKey, key);
            couponEntity = (CouponEntity) redisUtils.stringParseObject(valueRedis, couponEntity);
        }
        return couponEntity;
    }


    /**
     * 根据id 查询数据 放入缓存
     *  ValueOperations<String, String>
     * @param id
     * @return
     */
    public CouponEntity selectById03(Long id){
        String key = "couponEntity#" + id.toString();
        CouponEntity couponEntity = new CouponEntity();

        String valueReids = valueOperations.get(key);
        if(StringUtils.isEmpty(valueReids)){
            couponEntity = couponMapper.selectById(id);
            log.info("我查询了数据库");
            if(couponEntity != null){
                String value = redisUtils.objectParseString(couponEntity);
                valueOperations.set(key, value, 60, TimeUnit.MINUTES);
            }
        }else{
            log.info("我查询了redis缓存");
            couponEntity = (CouponEntity) redisUtils.stringParseObject(valueReids, couponEntity);
        }
        return couponEntity;
    }


    /**
     * 根据id 查询数据
     *  缓存击穿(加入某个缓存到期了，此时正好有1000个请求进来了， 就会出现缓存缓存击穿问题,Jmeter测试1000个请求，出现了9个请求查询数据库)
     *  解决 加互斥锁， 加上锁之后， jmeter测试1000个请求，只要一个请求了数据库，解决了缓存击穿问题
     *  ValueOperations<String, String>
     * @param id
     * @return
     */
    public CouponEntity selectById04(Long id){
        String key = "couponEntity#" + id.toString();
        CouponEntity couponEntity = new CouponEntity();

        String valueReids = valueOperations.get(key);
        if(StringUtils.isEmpty(valueReids)){
            synchronized (this){
                valueReids = valueOperations.get(key);
                if(StringUtils.isEmpty(valueReids)){
                    couponEntity = couponMapper.selectById(id);
                    log.info("我查询了数据库");
                    // 如果couponEntity是 null, 则存入缓存10分钟，防止此id，一直查询数据库
                    if(couponEntity == null){
                        String value = redisUtils.objectParseString(couponEntity);
                        valueOperations.set(key, value, 10, TimeUnit.MINUTES);
                    }else{
                        String value = redisUtils.objectParseString(couponEntity);
                        valueOperations.set(key, value, 60, TimeUnit.MINUTES);
                    }
                }else{
                    log.info("获取锁之后，我查询了redis缓存");
                    couponEntity = (CouponEntity) redisUtils.stringParseObject(valueReids, couponEntity);
                }
            }
        }else{
            log.info("我查询了redis缓存");
            couponEntity = (CouponEntity) redisUtils.stringParseObject(valueReids, couponEntity);
        }
        return couponEntity;
    }



    /**
     * 根据id 查询数据
     *  缓存雪崩
     *  解决 设置不同的过期时间
     *  ValueOperations<String, String>
     * @param id
     * @return
     */
    public CouponEntity selectById05(Long id){
        synchronized (this){
            String key = "couponEntity#" + id.toString();
            CouponEntity couponEntity = new CouponEntity();

            String valueReids = valueOperations.get(key);
            if(StringUtils.isEmpty(valueReids)){
                    valueReids = valueOperations.get(key);
                    if(StringUtils.isEmpty(valueReids)){
                        couponEntity = couponMapper.selectById(id);
                        log.info("我查询了数据库");
                        // 取 10 -20 中的随机数
                        int number = (int)(10 + Math.random()*(20 - 10  + 1));
                        long time = Long.parseLong(number+"");
                        if(couponEntity == null){ // 如果couponEntity是 null, 则存入缓存10分钟，防止此id，一直查询数据库
                            String value = redisUtils.objectParseString(couponEntity);
                            valueOperations.set(key, value, time, TimeUnit.MINUTES);
                        }else{
                            String value = redisUtils.objectParseString(couponEntity);
                            valueOperations.set(key, value, time, TimeUnit.MINUTES);
                        }
                    }else{
                        log.info("获取锁之后，我查询了redis缓存");
                        couponEntity = (CouponEntity) redisUtils.stringParseObject(valueReids, couponEntity);
                    }
            }else{
                log.info("我查询了redis缓存");
                couponEntity = (CouponEntity) redisUtils.stringParseObject(valueReids, couponEntity);
            }
            return couponEntity;
        }
    }


    /**
     * 根据id 查询数据
     *  redis分布式锁
     *      解决： 添加分布式锁
     * @param id
     * @return
     */
    public CouponEntity selectById(Long id){
        CouponEntity couponEntity = new CouponEntity();
        String key = "lock";
        String uuid = UUID.randomUUID().toString().replaceAll("-", "");
        // 1. 占分布式锁，去redis中占坑  置过期时间和占位必须是原子的
        Boolean flag = valueOperations.setIfAbsent(key, uuid, 30, TimeUnit.SECONDS);
        if(flag){  // 加锁成功
            try {   // 加锁成功，执行业务
                couponEntity = selectById05(id);
            }finally {
                String value = valueOperations.get(key);
                if(uuid.equals(value)){
                    redisTemplate.delete(key); // 删除锁
                }

//                String script = "if redis.call('get', KEYS[1])== ARGV[1] then returnredis.call('del', KEYS[1])else return 0 end";
//                //删除锁
//                Long lock1 = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
            }
        }else{ // 加锁失败，重试， synchronized
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            couponEntity = selectById(id);
        }
        return couponEntity;
    }
}

selectById03() 解决缓存穿透问题
selectById04() 解决缓存击穿问题
selectById05() 解决缓存雪崩问题
selectById() 解决分布式情况下，redis的访问问题

  1. 注解方式实现缓存
    6.1 在启动类上添加注解
@EnableCaching  //开启注解式缓存

6.2 新建 CouponAnnotationServiceImpl.java


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.onlinecoupon.entry.CouponEntity;
import com.example.onlinecoupon.mapper.CouponMapper;
import com.example.onlinecoupon.service.CouponAnnotationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


@Service
@Slf4j
public class CouponAnnotationServiceImpl extends ServiceImpl<CouponMapper, CouponEntity> implements CouponAnnotationService {

    @Autowired
    private CouponMapper couponMapper;


    /**
     *  用注解的方式 新增一条 优惠券信息
     * @param couponEntity
     */
    @Override
    public void insertOne(CouponEntity couponEntity) {
        couponMapper.insert(couponEntity);
    }

    /**
     * 用注解的方式 根据id 查询数据
     * @param id
     * @return
     */
    @Override
    @Cacheable(cacheNames = "selectById")
    public CouponEntity selectById(Long id) {
        log.info("缓存注解  我查询了数据库");
        CouponEntity couponEntity = couponMapper.selectById(id);
        return couponEntity;
    }

    
    /**
     *   用注解的方式 根据id 更新数据
     * @param couponEntity
     */
    @CachePut(value="selectById",key = "#couponEntity.id")
    public CouponEntity updateCouponEntityById(CouponEntity couponEntity){
        int i = couponMapper.updateById(couponEntity);
        couponEntity = couponMapper.selectById(couponEntity.getId());
        return couponEntity;
    }


    /**
     *   根据id 删除缓存
     *   @CacheEvict(value="selectById", key = "#id")  删除对应的缓存
     *   @CacheEvict(value="selectById",allEntries = true,beforeInvocation = true)
     *      allEntries = true （是否删除该缓存名中所有数据，默认为false）
     *      beforeInvocation = true（缓存清除是否在方法之前执行，默认false，代表在方法执行之后执行）
     * @param id
     */
//    @CacheEvict(value="selectById", key = "#id")
    @CacheEvict(value="selectById",allEntries = true,beforeInvocation = true)
    public void deleteById(Long id){
        int i = couponMapper.deleteById(id);
    }
}

@Cacheable(cacheNames = “selectById”) 作用是主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 。（凡是你想要使用缓存的地方，加上该注解就能缓存）
cacheNames:一般是方法名 value:一般不写，默认是参数值
@CachePut：@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。
@CachePut(value=“selectById”,key = “#couponEntity.id”) 需要指定key,要不然是不能更新缓存的
详细信息可以参考@CachePut 注解
@CacheEvict：作用是主要针对方法配置，能够根据一定的条件对缓存进行清空
详细信息可以参考 @CacheEvict 注解

秋叶清风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Spring Boot 项目 中对 Redis的 使用
qq_15145603的博客
07-26 417
Redis全称是REmote DIctionary ServerRedis是一个开源的使用ANSI C语言编写（这也是为什么make的时候要下c语言支持）、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。（节选官方中文文档）
Java及SpringBoot对redis的使用
qq_50896786的博客
08-02 967
springboot对redis的操作封装了两个StringRedisTemplate和RedisTemplate类，StringRedisTemplate是RedisTemplate的子类，StringRedisTemplate它只能存储字符串类型，无法存储对象类型。还有就是放行对应的端口：6001、6002、6003、6004、6005、6006，因为之前放行的实在10000端口，注意以上两点，才可以使用idea创建成功。该类把对每种数据类型的操作，单独封了相应的内部类。(1) 引入相关的依赖。...
Java 、Springboot 连接整合 redis
DDHuao的博客
04-25 1061
1. 连 接 redis默认有三种方式连接redis.第一种:jedis---传统的项目--ssm第二种:lettuce:---->刚出现没有多久就被springboot整合进来。第三种:springboot连接redis1.1 jedis操作redis服务器（1）引入jedis依赖（2）编写相关的代码1.2 .测试jedis使用和不使用连接池的效率配置连接池(1.) 不使用连接池（2.）使用连接池结论：使用连接池 比没用要快很多2. springboot 整合redis。
如何使用Spring Boot框架整合Redis：超详细案例教程
最新发布
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-14 2638
成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。是用于 Lettuce 连接池配置的依赖。目录下，添加 Redis 连接池的配置。确保你的项目包含了以下依赖。，这里就无需再次添加。类以支持连接池即可。
java连接redis及springboot连接redis
m0_73809543的博客
04-27 704
springboot在整合reids时提供两个模板类，StringRedisTemplate和RedisTemplate，以后对redis的操作都在该模板类中。是StringRedisTemplate的父类，类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。有请求先查询缓存是否缓存命中 如果命中直接返回响应 如果未命中查询数据库 拿到结果后把查到数据存入缓存中并把数据返回响应。第一种：jedis --- 传统的项目 --- ssm。--- 提高系统的性能。
【Java】SpringBoot快速整合Redis
m0_64210833的博客
01-18 1623
SpringBoot快速整合Redis， 测试从数据查询和从redis缓存中查询的效率差别。
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
SpringBoot整合Redis
01-17
**SpringBoot整合Redis** 在现代Web开发中，缓存机制是提高系统性能的关键技术之一，而Redis作为一款高性能的键值存储系统，被广泛应用在数据缓存领域。SpringBoot简化了与各种技术的集成，包括Redis。下面我们将...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
Spring Boot整合Redis
热门推荐
梁辰兴的博客
06-16 2万+
Redis是一个开源（BSD许可）的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件，并提供多种语言的API。Redis支持多种类型的数据结构，如 字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）与范围查询、bitmaps、 hyperloglogs 和 地理空间（geospatial）、索引半径查询。
java系列之SpringBoot整合redis
m0_61027348的博客
11-24 645
srpingboot整合redis,包括自定义配置，序列化解决和工具类封装、测试
SpringBoot集成Redis
qq_39093474的博客
03-19 3402
Redis是我们Java开发中，使用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用使用场景，可以做缓存，分布式锁，自增序列等，使用redis的方式和我们使用数据库的方式差不多，首先我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在程序中进行集成，然后通过客户端完成对redis的增删改查操作。
java整合redis(二)
酷酷的馫博客
11-09 1751
springboot整合redis(图文详解)
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
SpringBoot RedisUtil
qq_18453581的博客
09-30 807
1.引入redis依赖 2.redis Bean import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConne...
快速入门 - Spring Boot 集成 Redis 配置及使用
CYK_byte的博客
03-27 9605
Spring Boot 集成 Redis 配置及使用 （代码+详细注释）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值