redis缓存&&分布式锁

已于 2022-01-24 16:24:46 修改
阅读量184 收藏
点赞数 1
文章标签： spring boot redis 缓存
于 2021-01-16 00:12:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45081813/article/details/112690221
版权
本文介绍了如何在Spring Boot项目中集成Redis作为缓存，并提供了缓存操作的封装示例。此外，还展示了使用Redisson实现分布式锁的详细步骤，包括配置、主启动类、Redis配置类、接口实现等，以确保同一时刻只有一个请求处理关键业务，避免数据冲突。
摘要由CSDN通过智能技术生成

redis简单缓存

1.引入redis依赖

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

2.在配置文件中配置相关信息

spring:
  redis:
    host: localhost
    port: 6379
    database: 0

3.封装使用redis的方法到一个类中

@Slf4j
public class RedisCache implements Cache {

    private String id;

    public RedisCache(String id) {
        log.info("当前缓存id:[{}]", id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    //放入redis缓存
    @Override
    public void putObject(Object key, Object value) {
        log.info("放入缓存的key：[{}],放入缓存的value:[{}]",key,value);
        getRedisTemplate().opsForHash().put(id,key.toString(),value);
    }

    //从redis获取缓存
    @Override
    public Object getObject(Object key) {
        log.info("获取缓存的key：[{}]",key.toString());
        return getRedisTemplate().opsForHash().get(id,key.toString());
    }

    //删除指定缓存信息
    @Override
    public Object removeObject(Object o) {
        return null;
    }

    //清除缓存
    @Override
    public void clear() {
        log.info("清除所有缓存的信息");
        getRedisTemplate().delete(id);
    }
    
    @Override
    public int getSize() {
        return getRedisTemplate().opsForHash().size(id).intValue();
    }

    //封装获取redisTemplate的方法
    public RedisTemplate getRedisTemplate(){
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}


@Component
public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    //redisTemplate  stringRedisTemplate
    public static Object getBean(String name){
        return applicationContext.getBean(name);
    }
}

4.最后，由于整合了mybatis，需要在使用redis缓存的mapper.xml文件中引入缓存类

    <!--使用缓存-->
    <cache type="com.sise.utils.RedisCache"/>

redis分布式锁

使用场景：多个服务间 + 保证同一时刻内 + 同一用户只能有一个请求（防止关键业务出现数据冲突和并发错误）

建两个Module：redis01，redis02

1.POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>redis01</artifactId>

    <dependencies>
        <!-- web+actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <!-- SpringBoot与Redis整合依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <!-- jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.1.0</version>
        </dependency>

        <!-- Spring Boot AOP技术-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!-- redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
        </dependency>

        <!-- 一般通用基础配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.配置文件

server.port=1111
#2222

#=========================redis相关配香========================
#Redis数据库索引（默认方0）
spring.redis.database=0
#Redis服务器地址
spring.redis.host=localhost
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）默认8
spring.redis.lettuce.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）默认-1
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接默认8
spring.redis.lettuce.pool.max-idle=8
#连接池中的最小空闲连接默犬认0
spring.redis.lettuce.pool.min-idle=0

3.主启动类

@SpringBootApplication
public class RedisApplication01 {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication01.class,args);
    }
}

4.redis配置类

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory){
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
    
    @Bean
    public Redisson redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        return (Redisson)Redisson.create(config);
    }
}

5.接口实现

@RestController
public class GoodController{

    public static final String REDIS_LOCK = "REDIS_LOCK";

    @Autowired
    private Redisson redisson;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/buy_goods")
    public String buy_Goods(){

        RLock redissonLock = redisson.getLock(REDIS_LOCK);
        redissonLock.lock();

        try {
            String result = stringRedisTemplate.opsForValue().get("goods:001");// get key ====看看库存的数量够不够
            int goodsNumber = result == null ? 0 : Integer.parseInt(result);
            if(goodsNumber > 0){
                int realNumber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
                System.out.println("成功买到商品，库存还剩下: "+ realNumber + " 件" + "\t服务提供端口" + serverPort);
                return "成功买到商品，库存还剩下:" + realNumber + " 件" + "\t服务提供端口" + serverPort;
            }else{
                System.out.println("商品已经售完/活动结束/调用超时,欢迎下次光临" + "\t服务提供端口" + serverPort);
            }

            return "商品已经售完/活动结束/调用超时,欢迎下次光临" + "\t服务提供端口" + serverPort;
        }
        finally {
            //确保解的是当前线程的锁
            if(redissonLock.isLocked() && redissonLock.isHeldByCurrentThread()) {
                redissonLock.unlock();
            }
        }
    }

}

6.Nginx配置

upstream myserver{
    server 127.0.0.1:1111;
    server 127.0.0.1:2222;
}

server {
    listen       80;
    server_name  localhost;

    #charset koi8-r;

    #access_log  logs/host.access.log  main;

    location / {
        # 负责用到的配置
        proxy_pass  http://myserver;
        root   html;
        index  index.html index.htm;
    }

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    	root   html;
    }
}

7.验证

redis：set goods:001 100，恢复到100

用到Apache JMeter，100个线程同时访问：http://localhost/buy_goods
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

BlogY
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis 缓存锁的实现方法
阅读之后，对你有帮助，那就点个赞再走吧
03-19 302
1. redis加锁分类 redis能用的的加锁命令分表是INCR、SETNX、SET 2. 第一种锁命令INCR 这种加锁的思路是， key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作进行加一。 然后其它用户在执行 INCR 操作进行加一时，如果返回的数大于 1 ，说明这个锁正在被使用当中。 1、 客户端A请求服务器获取key的值为1表示获取了...
Redis实现 分布式缓存、分布式锁
qq_34139393的博客
07-02 708
Redis实现 分布式缓存、分布式锁
【redis】缓存与分布式锁
ly甲烷的博客
11-25 537
缓存 哪些数据适合放入缓存？ 即时性，数据一致性要求不高的 访问量大，且更新频率不高的数据（读多写少） 整合redis 引入data-redis-starter 简单配置redis的host信息 使用SpringBoot自动配置好的StringRedisTemplate来操作redis 堆外内存溢出异常 原因spring boot 2.0以后 默认使用lettuce作为操作redis的客户端。它使用netty进行网络通信 lettuce的bug导致堆外内存溢出 -Xmx300m 如果netty
缓存redis分布式锁实现
weixin_34417814的博客
02-20 122
2019独角兽企业重金招聘Python工程师标准>>> ...
Redis缓存——（分布式锁）
guochaoHNU的博客
02-22 1298
目录缓存击穿，穿透，雪崩 缓存击穿，穿透，雪崩
Redis（四）缓存、分布式锁
HK的博客
10-06 1787
缓存雪崩、缓存穿透、缓存击穿、分布式锁
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
redis分布式锁与zk分布式锁的对比
qq_27877781的博客
03-12 4064
·
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
Redis 的分布式缓存
古城的博客
07-17 1586
如果master继续写入新数据，其offset就会覆盖旧的数据，直到将slave现在的offset也覆盖，那么此时如果slave想要恢复，就需要同步，却发现自己的offset都没有了，无法完成增量同步了。哨兵模式就是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。主从模式很好的解决了数据备份问题，并且由于主从服务数据几乎是一致的，因而可以将写入数据的命令发送给主机执行，而读取数据的命令发送给不同的从机执行，从而达到读写分离的目的。......
redis缓存的使用
12-14
redis缓存的使用，使用predis驱动程序，包内包含phpRedisAdmin管理工具
java redis依赖包
06-11
jedis.jar redis.jar java缓存 jedis.jar redis.jar java缓存 jedis.jar redis.jar java缓存 jedis.jar redis.jar java缓存
Redis(四)——Redis缓存及分布式锁
yemuxiaweiliang的博客
05-01 1369
Redis(三)——Redis缓存及分布式锁
redis缓存使用及分布式锁实现学习笔记（新手向纯干货）
试问道几许
12-16 209
关于redis缓存和分布式锁的分析。
redis注解缓存----redis锁
qy132的博客
06-30 273
什么样的数据适合放入缓存中。 1. 查询频率高 2. 修改频率低 3. 数据安全行要求低的 package com.ykq.springbootrediscache.service; ​ import com.ykq.springbootrediscache.entity.User; import com.ykq.springbootrediscache.mapper.UserMapper; import org.springframework.beans.factory.annotation.Au
缓存(1)
sjjskshs的博客
11-06 244
放入缓存的数据格式本地缓存：放在本地内存中，先进行查询redis依赖redis本地配置方案lettuce可用数据传输量较大，但是会有后台内存溢出的bug，可进行包排除引入jedis。
分布式锁之Redis缓存锁
光与热的博客
11-26 4550
1.Redis分布式锁用Redis来实现分布式锁最简单的方式是在实例里创建一个键值,创建出来的键值有一个超时时间,所以每个锁最终会被释放,当一个客户端想要释放锁时候,客户端只要删除这个键值就可以。利用redis脚本编写申请和释放锁代码比利用WATCH/MULTI/EXEC编写的代码更加简洁,减少了业务服务器客户服务器之间的交互,在高并发情况下redis脚本编写代码比WATCH/MULTI/EXEC性
Redis分布式缓存锁
肆方海木的博客
08-14 956
1.Redis分布式锁 用的Redis来实现分布式锁最简单的方式是在实例里创建一个键值，创建出来的键值有一个超时时间，所以每个锁最终会被释放，当一个客户端想要释放锁时候，客户端只要删除这个键值就可以。 利用redis的脚本编写申请和释放锁代码比利用WATCH / MULTI / EXEC编写的代码更加简洁，减少了业务服务器客户服务器之间的交互，在高并发情况下redis的脚本编写代码比WATCH...
Redis缓存和redis分布式锁
最新发布
weixin_61518137的博客
01-30 257
热点key永不过期是需要分析出key访问的次数，达到一定次数从而进行设置永不过期，限制访问数据库的访问频率，但是用户访问时间边长，降级。redis最主要的用途，主要是三个方面:存储数据+缓存+消息队列。
Redis缓存雪崩与分布式锁实战剖析
本文将重点讨论Redis的自身实例应用，特别是针对两个关键问题：雪崩现象和分布式锁的设计与实现。 首先，我们来理解Redis的基础结构。Redis采用了内存数据库设计，所有的数据都存储在内存中，以提高读写速度。由于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值