Redis分布式缓存解决分布式缓存中存在的缓存击穿缓存雪崩缓存穿透等问题-----Redis

高并发下缓存失效问题:缓存穿透
缓存穿透:查询一个不存在的数据,缓存绝对不会命中,请求就会来到数据库
但是数据库也无此数据,因此遭到这样的读取实际上变成了对我们数据库的攻击
大大增加了数据库的负担,也失去了缓存保护数据库的意义
最好的解决方法就说通过null结果缓存
并加入短暂的过期时间

高并发下缓存失效问题:缓存穿透
缓存穿透:查询一个不存在的数据,缓存绝对不会命中,请求就会来到数据库
但是数据库也无此数据,因此遭到这样的读取实际上变成了对我们数据库的攻击
大大增加了数据库的负担,也失去了缓存保护数据库的意义
最好的解决方法就说通过null结果缓存
并加入短暂的过期时间

缓存雪崩:缓存雪崩是指我们设置缓存的key采用了相同的过期时间
导致大量缓存在某一时刻同时过期,请求全部转发到数据库
数据库遭遇瞬时压力过大导致雪崩
对此我们需要在失效时间后添加一个随机值,保证缓存过期时间重复率低
避免出现集体失效导致的缓存雪崩

 缓存雪崩:缓存雪崩是指我们设置缓存的key采用了相同的过期时间
导致大量缓存在某一时刻同时过期,请求全部转发到数据库
数据库遭遇瞬时压力过大导致雪崩
对此我们需要在失效时间后添加一个随机值,保证缓存过期时间重复率低
避免出现集体失效导致的缓存雪崩

缓存击穿:个别热点Key有高并发访问的需求
在过期时间内,被超高并发访问,导致这个热点key的请求全部击中数据库
导致数据库被瞬间击垮,这种情况我们称之为缓存击穿
解决方案就是为这些高并发数据加上锁
让所有的请求都排队查询,查到数据再释放锁,这样就能保证查询的请求
始终都是前往缓存,并保证缓存内时刻都有数据,不用去数据库了

 缓存击穿:个别热点Key有高并发访问的需求
在过期时间内,被超高并发访问,导致这个热点key的请求全部击中数据库
导致数据库被瞬间击垮,这种情况我们称之为缓存击穿
解决方案就是为这些高并发数据加上锁
让所有的请求都排队查询,查到数据再释放锁,这样就能保证查询的请求
始终都是前往缓存,并保证缓存内时刻都有数据,不用去数据库了

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(){
        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;
        }));
        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(){
        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;
        }));
        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;
    }

}
  • 34
    点赞
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值