Redis分布式缓存使用本地锁和分布式锁的区别和用本地锁改造查询接口-----Redis

最新推荐文章于 2024-08-13 14:41:03 发布

旧约Alatus

最新推荐文章于 2024-08-13 14:41:03 发布

阅读量1.1k

点赞数 14

分类专栏：软件架构设计 # Redis 数据库文章标签：缓存 redis spring cloud 分布式后端数据库架构

本文链接：https://blog.csdn.net/2201_75960169/article/details/140781871

版权

数据库同时被 3 个专栏收录

106 篇文章 0 订阅

订阅专栏

Redis

79 篇文章 0 订阅

订阅专栏

软件架构设计

15 篇文章 0 订阅

订阅专栏

分布式下如何加锁
因为在本地代码中添加的锁,虽然锁住了当前容器的请求,而且确实实现了单个请求访问
但是在分布式系统下,一个容器,一次部署,一个应用就会有一个请求
本地锁就无法实现了,必须采用分布式锁
分布式下如何加锁
因为在本地代码中添加的锁,虽然锁住了当前容器的请求,而且确实实现了单个请求访问
但是在分布式系统下,一个容器,一次部署,一个应用就会有一个请求
本地锁就无法实现了,必须采用分布式锁

本地锁的设置逻辑必须遵循
上锁的部分必须同时将查询数据库和写入缓存两个操作包含在内
否则在超大并发下,仍然会出现第一个线程释放了锁后,在没有写入缓存的情况下
第二个甚至更多的线程获取了锁,并没有查询到缓存中的数据
仍然执行了查询数据库的操作,直接集中了数据库,导致了类似缓存穿透的问题
击穿数据库
本地锁的设置逻辑必须遵循
上锁的部分必须同时将查询数据库和写入缓存两个操作包含在内
否则在超大并发下,仍然会出现第一个线程释放了锁后,在没有写入缓存的情况下
第二个甚至更多的线程获取了锁,并没有查询到缓存中的数据
仍然执行了查询数据库的操作,直接集中了数据库,导致了类似缓存穿透的问题
击穿数据库

分布式锁会让所有服务都获取这个锁,当然会降低查询效率
需要一整个服务去占有锁,并执行业务,完成后释放锁
我们也可以将逻辑设计为占坑,占到就执行,否则就一直等待
直到释放锁
分布式锁会让所有服务都获取这个锁,当然会降低查询效率
需要一整个服务去占有锁,并执行业务,完成后释放锁
我们也可以将逻辑设计为占坑,占到就执行,否则就一直等待
直到释放锁

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.stereotype.Service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
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(){
        synchronized (this){
            if(!StringUtils.isEmpty(redisTemplate.opsForValue().get("catalogJSON"))){
                return JSON.parseObject(redisTemplate.opsForValue().get("catalogJSON"),new TypeReference<Map<String, List<SubCatalogVo>>>(){});
            }
            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;
            }));
            redisTemplate.opsForValue().set("catalogJSON",JSON.toJSONString(subCatalogVosMap),1, TimeUnit.DAYS);
            return subCatalogVosMap;
        }
    }

    // TODO 堆外内存溢出,原因是lettuce使用了netty做网络通信,lettuce的bug导致了我们的堆外内存溢出
    @Override
    public Map<String, List<SubCatalogVo>> getCatalogJson() {
//        加入缓存机制
//        缓存中我们一律保存JSON字符串,因为JSON本身也是跨语言跨平台的
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if(StringUtils.isEmpty(catalogJSON)){
//            缓存中没有
            Map<String, List<SubCatalogVo>> catalogJsonFromDb = this.getCatalogJsonFromDb();
//            查到的数据放入缓存,将这个对象我们转为JSON
            String jsonString = JSON.toJSONString(catalogJsonFromDb);
            redisTemplate.opsForValue().set("catalogJSON",jsonString,1, TimeUnit.DAYS);
            return catalogJsonFromDb;
        }
        return JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<SubCatalogVo>>>(){});
    }

    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.stereotype.Service;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
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(){
        synchronized (this){
            if(!StringUtils.isEmpty(redisTemplate.opsForValue().get("catalogJSON"))){
                return JSON.parseObject(redisTemplate.opsForValue().get("catalogJSON"),new TypeReference<Map<String, List<SubCatalogVo>>>(){});
            }
            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;
            }));
            redisTemplate.opsForValue().set("catalogJSON",JSON.toJSONString(subCatalogVosMap),1, TimeUnit.DAYS);
            return subCatalogVosMap;
        }
    }

    // TODO 堆外内存溢出,原因是lettuce使用了netty做网络通信,lettuce的bug导致了我们的堆外内存溢出
    @Override
    public Map<String, List<SubCatalogVo>> getCatalogJson() {
//        加入缓存机制
//        缓存中我们一律保存JSON字符串,因为JSON本身也是跨语言跨平台的
        String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
        if(StringUtils.isEmpty(catalogJSON)){
//            缓存中没有
            Map<String, List<SubCatalogVo>> catalogJsonFromDb = this.getCatalogJsonFromDb();
//            查到的数据放入缓存,将这个对象我们转为JSON
            String jsonString = JSON.toJSONString(catalogJsonFromDb);
            redisTemplate.opsForValue().set("catalogJSON",jsonString,1, TimeUnit.DAYS);
            return catalogJsonFromDb;
        }
        return JSON.parseObject(catalogJSON,new TypeReference<Map<String, List<SubCatalogVo>>>(){});
    }

    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;
    }

}