Redis使用LUA脚本和setNX的方式在分布式缓存中实现系统级缓存锁-----Redis

于 2024-07-30 20:45:18 发布
阅读量1.2k 收藏 12
点赞数 12
分类专栏： 电商项目 # Redis 软件架构设计 文章标签： 微服务 后端 redis 缓存 分布式 spring boot mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75960169/article/details/140806341
版权 
package com.alatus.mall.product.service.impl;

import com.alatus.mall.product.service.CategoryBrandRelationService;
import com.alatus.mall.product.vo.SubCatalogVo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;
import com.alatus.mall.product.dao.CategoryDao;
import com.alatus.mall.product.entity.CategoryEntity;
import com.alatus.mall.product.service.CategoryService;
import org.springframework.transaction.annotation.Transactional;

@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryDao, CategoryEntity> implements CategoryService {
    @Autowired
    private CategoryBrandRelationService categoryBrandRelationService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<CategoryEntity> page = this.page(
                new Query<CategoryEntity>().getPage(params),
                new QueryWrapper<CategoryEntity>()
        );

        return new PageUtils(page);
    }

    @Override
    public List<CategoryEntity> listWithTree() {
//        查出所有分类
        List<CategoryEntity> entities = baseMapper.selectList(null);
//        组装父子的树形结构
//        找到一级分类
        List<CategoryEntity> levelMenuOne = entities.stream().filter(categoryEntity ->
            categoryEntity.getParentCid() == 0
        ).map((menu) -> {
            menu.setChildren(getChildren(menu,entities));
            return menu;
        }).sorted((menu1,menu2) -> {
            return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
        }).collect(Collectors.toList());
        return levelMenuOne;
    }

    @Override
    public void removeMenuByIds(List<Long> list) {
//        检查当前删除的菜单,是否被别的地方引用
        baseMapper.deleteBatchIds(list);
    }

    @Override
    public Long[] findCatelogPath(Long catelogId) {
        List<Long> paths = new ArrayList<>();
        List<Long> parentPath = findParent(catelogId, paths);
        Collections.reverse(parentPath);
        return (Long[])parentPath.toArray(new Long[parentPath.size()]);
    }

//    级联更新所有数据
    @Override
    @Transactional
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
    }

    @Override
    public List<CategoryEntity> getLevelCategories(Integer catLevel) {
        return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("cat_level", catLevel));
    }

    private Map<String, List<SubCatalogVo>> getCatalogJsonFromDb(){
//        加入缓存机制
//        缓存中我们一律保存JSON字符串,因为JSON本身也是跨语言跨平台的
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if(StringUtils.isEmpty(catalogJSON)){
        //            缓存中没有
            List<CategoryEntity> categories = baseMapper.selectList(null);
        //        所有一级分类
            List<CategoryEntity> levelCategories = getParentCid(categories,0L);;
        //        封装数据
            Map<String, List<SubCatalogVo>> subCatalogVosMap = levelCategories.stream().collect(Collectors.toMap(k -> k.getCatId().toString(),v -> {
                List<CategoryEntity> entities = getParentCid(categories,v.getCatId());
                List<SubCatalogVo> subCatalogVos = null;
                if(entities!=null&&!entities.isEmpty()){
                    subCatalogVos = entities.stream().map(item -> {
//                    找三级分类
                        List<CategoryEntity> inCategories = getParentCid(categories,item.getCatId());
                        SubCatalogVo subCatalogVo = new SubCatalogVo(v.getCatId().toString(),null, item.getCatId().toString(), item.getName());
                        if(inCategories!=null&&!inCategories.isEmpty()){
//                        封装成指定格式
                            List<SubCatalogVo.InCatalogVo> inCatalogVos = inCategories.stream().map(inCategory -> {
                                SubCatalogVo.InCatalogVo inCatalogVo = new SubCatalogVo.InCatalogVo(item.getCatId().toString(),inCategory.getCatId().toString(),inCategory.getName());
                                return inCatalogVo;
                            }).collect(Collectors.toList());
                            subCatalogVo.setCatalog3List(inCatalogVos);
                        }
                        return subCatalogVo;
                    }).collect(Collectors.toList());
                }
                return subCatalogVos;
            }));
//        查到的数据保存到缓存中先
            String jsonString = JSON.toJSONString(subCatalogVosMap);
//        查到的数据放入缓存,将这个对象我们转为JSON
            redisTemplate.opsForValue().set("catalogJSON",jsonString,1, TimeUnit.DAYS);
            return subCatalogVosMap;
        }
        return JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<SubCatalogVo>>>(){});
    }

    // TODO 堆外内存溢出,原因是lettuce使用了netty做网络通信,lettuce的bug导致了我们的堆外内存溢出
    @Override
    public Map<String, List<SubCatalogVo>> getCatalogJson() {
        String uuid = UUID.randomUUID().toString();
        //加锁采用setNX加过期时间的方式保证原子性
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3000, TimeUnit.SECONDS);
        if(lock){
            Map<String, List<SubCatalogVo>> catalogJsonFromDb = null;
            try{
                catalogJsonFromDb = getCatalogJsonFromDb();
            }
            finally {
//            LUA脚本解锁
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then\n" +
                        "    return redis.call('del', KEYS[1])\n" +
                        "else\n" +
                        "    return nil\n" +
                        "end\n";
//            删除锁用LUA脚本保持原子性
                redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return catalogJsonFromDb;
        }
        else{
            // TODO 加锁失败,休眠后再次尝试
            try {
                Thread.sleep(333);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return getCatalogJson();
        }
    }

    private List<CategoryEntity> getParentCid(List<CategoryEntity> categories,Long catId) {
        return categories.stream().filter(item -> item.getParentCid() == catId).collect(Collectors.toList());
    }

    private List<Long> findParent(Long catelogId,List<Long> paths){
//        查出当前分类的ID
//        收集当前节点ID
        paths.add(catelogId);
        CategoryEntity id = this.getById(catelogId);
        if(id.getParentCid() != 0){
//            递归查找,每次都从父节点获取
            findParent(id.getParentCid(),paths);
        }
        return paths;
    }

    //    递归查找所有菜单的子菜单
    private List<CategoryEntity> getChildren(CategoryEntity root,List<CategoryEntity> all){
        List<CategoryEntity> children = all.stream().filter(categoryEntity -> {
            return categoryEntity.getParentCid() == root.getCatId();
        }).map(categoryEntity -> {
            categoryEntity.setChildren(getChildren(categoryEntity,all));
            return categoryEntity;
        }).sorted((menu1,menu2) ->{
            return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
        }).collect(Collectors.toList());
        return children;
    }

}
package com.alatus.mall.product.service.impl;

import com.alatus.mall.product.service.CategoryBrandRelationService;
import com.alatus.mall.product.vo.SubCatalogVo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alatus.common.utils.PageUtils;
import com.alatus.common.utils.Query;
import com.alatus.mall.product.dao.CategoryDao;
import com.alatus.mall.product.entity.CategoryEntity;
import com.alatus.mall.product.service.CategoryService;
import org.springframework.transaction.annotation.Transactional;

@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryDao, CategoryEntity> implements CategoryService {
    @Autowired
    private CategoryBrandRelationService categoryBrandRelationService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        IPage<CategoryEntity> page = this.page(
                new Query<CategoryEntity>().getPage(params),
                new QueryWrapper<CategoryEntity>()
        );

        return new PageUtils(page);
    }

    @Override
    public List<CategoryEntity> listWithTree() {
//        查出所有分类
        List<CategoryEntity> entities = baseMapper.selectList(null);
//        组装父子的树形结构
//        找到一级分类
        List<CategoryEntity> levelMenuOne = entities.stream().filter(categoryEntity ->
            categoryEntity.getParentCid() == 0
        ).map((menu) -> {
            menu.setChildren(getChildren(menu,entities));
            return menu;
        }).sorted((menu1,menu2) -> {
            return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
        }).collect(Collectors.toList());
        return levelMenuOne;
    }

    @Override
    public void removeMenuByIds(List<Long> list) {
//        检查当前删除的菜单,是否被别的地方引用
        baseMapper.deleteBatchIds(list);
    }

    @Override
    public Long[] findCatelogPath(Long catelogId) {
        List<Long> paths = new ArrayList<>();
        List<Long> parentPath = findParent(catelogId, paths);
        Collections.reverse(parentPath);
        return (Long[])parentPath.toArray(new Long[parentPath.size()]);
    }

//    级联更新所有数据
    @Override
    @Transactional
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
        categoryBrandRelationService.updateCategory(category.getCatId(),category.getName());
    }

    @Override
    public List<CategoryEntity> getLevelCategories(Integer catLevel) {
        return baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("cat_level", catLevel));
    }

    private Map<String, List<SubCatalogVo>> getCatalogJsonFromDb(){
//        加入缓存机制
//        缓存中我们一律保存JSON字符串,因为JSON本身也是跨语言跨平台的
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if(StringUtils.isEmpty(catalogJSON)){
        //            缓存中没有
            List<CategoryEntity> categories = baseMapper.selectList(null);
        //        所有一级分类
            List<CategoryEntity> levelCategories = getParentCid(categories,0L);;
        //        封装数据
            Map<String, List<SubCatalogVo>> subCatalogVosMap = levelCategories.stream().collect(Collectors.toMap(k -> k.getCatId().toString(),v -> {
                List<CategoryEntity> entities = getParentCid(categories,v.getCatId());
                List<SubCatalogVo> subCatalogVos = null;
                if(entities!=null&&!entities.isEmpty()){
                    subCatalogVos = entities.stream().map(item -> {
//                    找三级分类
                        List<CategoryEntity> inCategories = getParentCid(categories,item.getCatId());
                        SubCatalogVo subCatalogVo = new SubCatalogVo(v.getCatId().toString(),null, item.getCatId().toString(), item.getName());
                        if(inCategories!=null&&!inCategories.isEmpty()){
//                        封装成指定格式
                            List<SubCatalogVo.InCatalogVo> inCatalogVos = inCategories.stream().map(inCategory -> {
                                SubCatalogVo.InCatalogVo inCatalogVo = new SubCatalogVo.InCatalogVo(item.getCatId().toString(),inCategory.getCatId().toString(),inCategory.getName());
                                return inCatalogVo;
                            }).collect(Collectors.toList());
                            subCatalogVo.setCatalog3List(inCatalogVos);
                        }
                        return subCatalogVo;
                    }).collect(Collectors.toList());
                }
                return subCatalogVos;
            }));
//        查到的数据保存到缓存中先
            String jsonString = JSON.toJSONString(subCatalogVosMap);
//        查到的数据放入缓存,将这个对象我们转为JSON
            redisTemplate.opsForValue().set("catalogJSON",jsonString,1, TimeUnit.DAYS);
            return subCatalogVosMap;
        }
        return JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<SubCatalogVo>>>(){});
    }

    // TODO 堆外内存溢出,原因是lettuce使用了netty做网络通信,lettuce的bug导致了我们的堆外内存溢出
    @Override
    public Map<String, List<SubCatalogVo>> getCatalogJson() {
        String uuid = UUID.randomUUID().toString();
        //加锁采用setNX加过期时间的方式保证原子性
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3000, TimeUnit.SECONDS);
        if(lock){
            Map<String, List<SubCatalogVo>> catalogJsonFromDb = null;
            try{
                catalogJsonFromDb = getCatalogJsonFromDb();
            }
            finally {
//            LUA脚本解锁
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then\n" +
                        "    return redis.call('del', KEYS[1])\n" +
                        "else\n" +
                        "    return nil\n" +
                        "end\n";
//            删除锁用LUA脚本保持原子性
                redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);
            }
            return catalogJsonFromDb;
        }
        else{
            // TODO 加锁失败,休眠后再次尝试
            try {
                Thread.sleep(333);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return getCatalogJson();
        }
    }

    private List<CategoryEntity> getParentCid(List<CategoryEntity> categories,Long catId) {
        return categories.stream().filter(item -> item.getParentCid() == catId).collect(Collectors.toList());
    }

    private List<Long> findParent(Long catelogId,List<Long> paths){
//        查出当前分类的ID
//        收集当前节点ID
        paths.add(catelogId);
        CategoryEntity id = this.getById(catelogId);
        if(id.getParentCid() != 0){
//            递归查找,每次都从父节点获取
            findParent(id.getParentCid(),paths);
        }
        return paths;
    }

    //    递归查找所有菜单的子菜单
    private List<CategoryEntity> getChildren(CategoryEntity root,List<CategoryEntity> all){
        List<CategoryEntity> children = all.stream().filter(categoryEntity -> {
            return categoryEntity.getParentCid() == root.getCatId();
        }).map(categoryEntity -> {
            categoryEntity.setChildren(getChildren(categoryEntity,all));
            return categoryEntity;
        }).sorted((menu1,menu2) ->{
            return (menu1.getSort()==null?0:menu1.getSort()) - (menu2.getSort()==null?0:menu2.getSort());
        }).collect(Collectors.toList());
        return children;
    }

}
旧约Alatus
关注
专栏目录
分布式锁2：基于redis实现分布式锁 setnx+lua脚本
健康平安的活着的专栏
10-11 1839
redis中setnx+expire是非原子操作, 除了用LUA脚本保证实现原子操作, 其实可以直接使用redis自带的set方法直接实现.setnx+expire+del 命令实现redis的分布式锁；其中 setnx 不存在则新增；给锁设置一个过期时间，防止锁忘记了释放。来抢锁，如果抢到之后，再用。
基于Redis缓存商城分类以及商品信息Demo
10-15
基于Redis缓存商城分类以及商品信息，实现商城数据高速精确访问，源码，jar包
商城项目优化业务逻辑通过本地缓存优化压力测试表现-----Jmeter
最新发布
春风若有怜花意，可否许我再少年
07-29 1124
商城项目优化业务逻辑通过本地缓存优化压力测试表现-----Jmeter
mall整合Redis实现缓存功能
macrozheng的专栏
05-10 758
本文主要讲解mall整合Redis的过程，以短信验证码的存储验证为例。Redis的安装和启动Redis是用C语言开发的一个高性能键值对数据库，可用于数据缓存，主要用于处理...
Redis分布式锁—SETNX+Lua脚本实现
weixin_44866921的博客
03-25 895
使用redis实现分布式锁，就是利用redis中的setnx，如果key不存在则进行set操作返回1，key已经存在则直接返回0。
redis-lua:我正在使用的redis-lua脚本
05-17
Redis 和 Lua 的结合使用在许多高并发、高性能的场景中非常常见，因为 Redis 支持内嵌的 Lua 脚本执行，这使得我们可以利用 Lua 的简洁语法和执行效率来处理复杂的数据库操作，同时避免了网络通信的开销。...
Golang使用lua脚本实现redis原子操作
12-20
同时，使用`script load`和`script exists`命令，可以预先加载脚本到Redis的脚本缓存中，进一步提高性能，因为之后的调用只需要使用脚本的SHA1校验和即可，而不需要每次都发送完整的脚本。 总之，Golang结合Redis和...
【中间件篇-Redis缓存数据库】Redis高级特性和应用(慢查询、Pipeline、事务、Lua)
11-09
本文将深入探讨Redis的高级特性，包括慢查询、Pipeline、事务和Lua脚本，帮助你更好地理解和利用这些特性提升系统性能。 ### 1. 慢查询 Redis的慢查询日志（Slow Log）是用于追踪执行时间过长的操作，有助于定位和...
lua-nginx-redis：Redis，Lua，Nginx，OpenResty笔记和资料
02-03
在“Lua教程”中，你可以学习到Lua的基础语法、数据类型、控制结构，以及如何在Nginx中使用Lua编写脚本，实现动态处理请求、数据缓存等高级功能。 `Redis`则是一个开源的内存数据存储系统，支持多种数据结构如字符...
django-redis-chs-readthedocs-io-zh_CN-latest.zip
05-04
同时，Redis提供发布/订阅、事务、持久化、Lua脚本等功能，是作为缓存和消息中间件的理想选择。 **3. Django-Redis的特性** - **全功能支持**：`django-redis`完全兼容Django的缓存和session框架，提供与内置缓存...
Redis实战之商城购物车
前者已逝，后者未至。
01-24 1958
目录 目标 商城购物车功能 分析 Redis命令详解 目标 利用Redis实现商城购物车功能。 商城购物车功能 根据用户编号查询购物车列表，且各个商品需要跟在对应的店铺下； 统计购物车中的商品总数； 新增或删减购物车商品； 增加或减少购物车中的商品数量； 设置商品失效并展示； 选中商品后计算支付金额和商品数量。 分析 Hash数据类型：值为多组映射，相当于JAVA中的Map。适合存储对象数据类型。 因为用户ID作为唯一的身份标识，所以可以把模块名称+用户ID作为Redis
Redis 使用 Lua 脚本替代 SETNX / DECR 保证原子性
rgfsgdg的博客
01-05 1872
背景 最近公司出了一起故障，问题代码如下： /** * TRUE: 触发限流，FALSE：未触发限流 */ public function acquire() { try { $redisHandler = $this->redisInstance->getHandler(); $redisH...
商城项目技术总结——redis篇
Weishaolei0818的博客
02-27 513
商城项目中redis的使用场景
Redis解决商城问题的各种策略
sichenss的博客
04-16 1860
这篇文章是我在学习黑马程序员的 虎翼老师讲的Redis入门到实战教程，全面透析redis底层原理+redis分布式锁+企业解决方案+redis实战 课程时记录的笔记, 还没学完 , 做一个笔记 , 方便平时翻看
商城系统使用redis做什么_商城系统开发需要些什么条件
weixin_39575565的博客
11-27 91
互联网的日益发展，也在逐渐改变着人们的生活方式，电子商务在社会中的地位也变得尤为重要，电商平台的网站也随之成为人们关注的热点，从而市面上出现了很多不同类型商城系统平台。那么商城系统开发需要具备什么条件呢？商城系统开发需要具备以下条件：确定商城系统开发的功能需求企业应根据自身的需要，前期一定要做好市场调研，商城系统平台网站与普通的企业网站不一样，功能复杂得多，所以要先确定好商城系统的功能需求，这样...
redis优化商城首页.——淘淘商城（十八）
qq_40369829的博客
04-05 1361
需求 分析 总结 业务中使用缓存 配置 Dao层 Service层 发布缓存同步服务 Service层 Controller层 调用缓存同步服务 Service层 缓存同步的结果 需求 分析 每次调用rest服务，如果都需要和mysql交互，则数据库的压力较大，响应时延也较大。特别是首页这种经常被访问的页面，这种现象尤其明显。所以需要在服务器设置缓存...
基于Redis的分布式锁实现
weixin_33883178的博客
04-25 769
前言 本篇文章主要介绍基于Redis的分布式锁实现到底是怎么一回事，其中参考了许多大佬写的文章，算是对分布式锁做一个总结 分布式锁概览 在多线程的环境下，为了保证一个代码块在同一时间只能由一个线程访问，Java中我们一般可以使用synchronized语法和ReetrantLock去保证，这实际上是本地锁的方式。但是现在公司都是流行分布式架构，在分布式环境下，如何保证不同节点的线程同步执行呢？ 实...
RedisTemplate+lua脚本实现redis分布式锁
qq_36655073的博客
06-13 1467
前言 redis本身属于弱事务，同一个线程向redis提交的指令，并不一定会紧挨着执行，这就会产生数据安全问题。 但由于redis是单线程执行指令的，所以只要能将多个指令打包到一起，就可以保证多个操作的原子性。并且redis是支持lua脚本的，会一次性将lua脚本中的所有指令全部顺序执行完毕，中间不会插入其他线程提交的指令。 鉴于以上特性，使用RedisTemplate+lua脚本实现一把可重入的分布式锁，且支持设定锁时间。 lua脚本准备 上锁的脚本 -- 加锁脚本 -- key1：要加锁的名称 ar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值