本文共 20825 字，大约阅读时间需要 69 分钟。

第2章 缓存解决方案

学习目标

掌握SpringDataRedis 的常用操作

能够理解并说出什么是缓存穿透、缓存击穿、缓存雪崩，以及对应的解决方案 使用缓存预热的方式实现商品分类导航缓存 使用缓存预热的方式实现广告轮播图缓存 使用缓存预热的方式实现商品价格缓存 项目序列-10:https://github.com/Jonekaka/javaweb-qingcheng-10-85

1. SpringDataRedis

1.1 SpringDataRedis简介

SpringDataRedis 属于Spring Data 家族一员，用于对redis的操作进行封装的框架

Spring Data ----- Spring 的一个子项目。Spring 官方提供一套数据层综合解决方案，用

于简化数据库访问，支持NoSQL和关系数据库存储。包括Spring Data JPA 、Spring Data Redis 、SpringDataSolr 、SpringDataElasticsearch 、Spring DataMongodb 等 框架。

1.2 SpringDataRedis快速入门

1.2.1 准备工作

（1）构建Maven工程 SpringDataRedisDemo 引入Spring相关依赖、JUnit依赖、Jedis

和SpringDataRedis依赖

   
           
            
                
     
      redis.clients
                 
     
      jedis
                 
     
      2.9.0
             
            
                
     
      org.springframework.data
                 
     
      spring-data-redis
                 
     
      2.0.5.RELEASE
             
            
            
                
     
      junit
                 
     
      junit
                 
     
      4.12
             
            
            
                
     
      org.springframework
                 
     
      spring-test
                 
     
      5.0.5.RELEASE
             
        
   

（2）在src/main/resources下创建properties文件夹，建立redis-config.properties

redis主机配置,端口,密码,数据库,连接数,最大等待时长

redis.host=127.0.0.1        redis.port=6379        redis.pass=        redis.database=0        redis.maxIdle=300        redis.maxWait=3000

maxIdle ：最大空闲数

maxWaitMillis: 连接时的最大等待毫秒数 （3）在src/main/resources下创建spring文件夹，创建applicationContext-redis.xml 对redis进行配置

接下来演示redis如何增删改查数据

1.2.2 值类型操作

运行redis服务器,windows上也能运行

一个服务器,一个客户端,客户端可以连接其他机器进行操作

/** * @ClassName redis值测试 * Description TODO **//*标识这是一个单元测试类*/@RunWith(SpringJUnit4ClassRunner.class)/*指定redis配置文件*/@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")public class TestValue {
       /*将redis操作对象注入进来*/    @Autowired    private RedisTemplate redisTemplate;    /*存值,取值,删值*/    /**     * @Description 存值,key,value     * @Param []     * @return void     **/    @Test    public void setValue() {
           redisTemplate.boundValueOps("name").set("lili");    }    /**     * @Description 取值     * @Param []     * @return void     **/    @Test    public void getValue() {
           String name = (String) redisTemplate.boundValueOps("name").get();        System.out.println(name);    }    @Test    public void del() {
           redisTemplate.delete("name");    }}

测试存值

取值

1.2.3 Set类型操作

当存入的是集合,且没有顺序要求,可以使用set

添加顺序到输出顺序不一致

/** * @ClassName redis值测试 * Description TODO **//*标识这是一个单元测试类*/@RunWith(SpringJUnit4ClassRunner.class)/*指定redis配置文件*/@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")public class TestSet {
       /*将redis操作对象注入进来*/    @Autowired    private RedisTemplate redisTemplate;    /*存值,取值,删值*/    /**     * @Description set,key,value     * @Param []     * @return void     **/    @Test    public void setSet() {
           redisTemplate.boundSetOps("nameSet").add("心剑");        redisTemplate.boundSetOps("nameSet").add("魔剑");        redisTemplate.boundSetOps("nameSet").add("生死棋");    }    /**     * @Description 取值     * @Param []     * @return void     **/    @Test    public void getSet() {
           Set names = redisTemplate.boundSetOps("nameSet").members();        System.out.println(names);    }    @Test    public void del() {
           redisTemplate.delete("nameSet");    }    /**     * @Description 删除其中一个     * @Param []     * @return void     **/    @Test    public void delValue() {
           redisTemplate.boundSetOps("nameSet").remove("魔剑");    }}

1.2.4 List类型操作

可以保留原来的顺序

（1）右压栈 后添加的对象排在后边

（2）左压栈 后添加的对象排在前边

（3）根据索引查询元素

（4）移除指定个数的值

/** * @ClassName redis值测试 * Description TODO **//*标识这是一个单元测试类*/@RunWith(SpringJUnit4ClassRunner.class)/*指定redis配置文件*/@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")public class TestList {
       /*将redis操作对象注入进来*/    @Autowired    private RedisTemplate
   
     redisTemplate;    /**     * @return void     * @Description 右压栈     * @Param []     **/    @Test    public void rightStack() {
           redisTemplate.boundListOps("nameList").rightPush(1);        redisTemplate.boundListOps("nameList").rightPush(2);        redisTemplate.boundListOps("nameList").rightPush(3);    }    @Test    public void getRightStack() {
           /*range(0, 10)代表查询范围,0,-1代表查询所有,开始索引,查询条数*/        List
    
      nameList = redisTemplate.boundListOps("nameList").range(0, 10);        System.out.println(nameList);    }    /**     * @return void     * @Description 左压栈     * @Param []     **/    @Test    public void leftStack() {
           redisTemplate.boundListOps("nameList").leftPush(1);        redisTemplate.boundListOps("nameList").leftPush(2);        redisTemplate.boundListOps("nameList").leftPush(3);    }    @Test    public void getLeftStack() {
           /*range(0, 10)代表查询范围,0,-1代表查询所有,开始索引,查询条数*/        List
     
       nameList = redisTemplate.boundListOps("nameList").range(0, 10);        System.out.println(nameList);    }    /*查询具体的某个索引的值*/    @Test    public void getIndexValue() {
           Integer nameList = redisTemplate.boundListOps("nameList").index(0);        System.out.println(nameList);    }    /*移除某个索引的值,(移除的个数,值),个数<=>值,如果有三个值,移除4个,则三个都移除不报错,移除两个还有一个*/    public void delValue() {
           /*代表移除2个1*/        redisTemplate.boundListOps("nameList").remove(2, 1);    }    }
     
    
   

1.2.5 Hash类型操作

（1）存入值

（2）提取所有的KEY （3）提取所有的值 （4）根据KEY提取值 （5）根据KEY移除值

/** * @ClassName redis值测试 * Description TODO **//*标识这是一个单元测试类*/@RunWith(SpringJUnit4ClassRunner.class)/*指定redis配置文件*/@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")public class TestHash {
       /*将redis操作对象注入进来*/    @Autowired    private RedisTemplate redisTemplate;    @Test   public void testHash() {
          redisTemplate.boundHashOps("nameHash").put("a",1);       redisTemplate.boundHashOps("nameHash").put("b",2);       redisTemplate.boundHashOps("nameHash").put("c",3);       redisTemplate.boundHashOps("nameHash").put("d",4);   }   @Test   public void getKey() {
          Set nameHash = redisTemplate.boundHashOps("nameHash").keys();       System.out.println(nameHash);   }   /*根据key查询出value*/    @Test   public void getValues() {
   //       List nameHash = redisTemplate.boundHashOps("nameHash").values();        Integer o = (Integer) redisTemplate.boundHashOps("nameHash").get("a");        System.out.println(o);   }   @Test    public void delKey() {
           redisTemplate.boundHashOps("nameHash").delete("a");   }}

1.2.6 ZSet类型操作

因为有了分值,而有了排序,并非是输入顺序,而是绑定的值顺序

绑定的值是可以动态变化的,可以理解为主播榜,谁被刷的礼物多谁就靠前 如果值是用数据库保存,将会带来很大压力,常用缓存解决

zset是set的升级版本，它在set的基础上增加了一格顺序属性，这一属性在添加元素

的同时可以指定，每次指定后，zset会自动重新按照新的值调整顺序。 可以理解为有两列的mysql表，一列存储value，一列存储分值。 假设有abc三个人直播,受到礼物 （1）存值 ，指定分值 （2）查询，由低到高 （3）查询，由高到低， （4）增加分数 （5）查询值和分数 TypedTuple是值与分数的封装。

/** * @ClassName redis值测试 * Description TODO **//*标识这是一个单元测试类*/@RunWith(SpringJUnit4ClassRunner.class)/*指定redis配置文件*/@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")public class TestZset {
       /*将redis操作对象注入进来*/    @Autowired    private RedisTemplate redisTemplate;    @Test    public void setZset() {
           redisTemplate.boundZSetOps("nameZset").add("a", 100);        redisTemplate.boundZSetOps("nameZset").add("b", 200);        redisTemplate.boundZSetOps("nameZset").add("c", 10);    }    /*默认从低到高排序*/    @Test    public void getValue() {
           Set nameZset = redisTemplate.boundZSetOps("nameZset").range(0, -1);        System.out.println(nameZset);    }    /*设定从高到低排序*/    @Test    public void getHighValue() {
           Set nameZset = redisTemplate.boundZSetOps("nameZset").reverseRange(0, -1);        System.out.println(nameZset);    }    /*对数值变更,,增加礼物*/    @Test    public void updateScore() {
            redisTemplate.boundZSetOps("nameZset").incrementScore("a", 1000);    }    /*查询出键值全部信息,为一个对象组合,因此要循环才能得到*/    @Test    public void getALlinfo() {
           Set
   
     nameZset = redisTemplate.boundZSetOps("nameZset").reverseRangeWithScores(0, -1);        /*此处是对象地址*/        System.out.println(nameZset);//rg.springframework.data.redis.core.DefaultTypedTuple@ccb70423, org.springframework.        for (ZSetOperations.TypedTuple typedTuple : nameZset) {
               System.out.println(typedTuple.getValue());            System.out.println(typedTuple.getScore());        }    }
   

1.2.7 过期时间设置

以值类型为例：存值时指定过期时间和时间单位

都有过期方法 常用语短信验证码

/** * 存值 */@Testpublic void setValue(){
           redisTemplate.boundValueOps("name").set("aaa");        redisTemplate.boundValueOps("name").expire(10,TimeUnit.SECONDS);        }

2. 缓存穿透、缓存击穿、缓存雪崩

2.1 缓存穿透

持续的穿透了缓存去找数据库,带给缓存和数据库巨大的访问压力

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。如下面这段代码就存在缓存穿透的问题。

根据id查询价格

public Integer findPrice(Long id) {
   //从缓存中查询        Integer sku_price =  (Integer)redisTemplate.boundHashOps("sku_price").get(id);        if(sku_price==null){
   //缓存中没有，从数据库查询        Sku sku = skuMapper.selectByPrimaryKey(id);        if(sku!=null){
    //如果数据库有此对象        sku_price = sku.getPrice();        redisTemplate.boundHashOps("sku_price").put(id,sku_price);        }        }        return sku_price;        }

解决方案：

1.接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截； 2.从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为 key-0。这样可以防止攻击用户反复用同一个id暴力攻击。代码举例： redisTemplate.boundHashOps(“sku_price”).put(id,0); 如果数据库也没有,就把这个id绑定到缓存里,为0 下次再访问缓存就能返回数据了

public int findPrice(Long id) {
   //从缓存中查询        Integer sku_price =        (Integer)redisTemplate.boundHashOps("sku_price").get(id);        if(sku_price==null){
   //缓存中没有，从数据库查询        Sku sku = skuMapper.selectByPrimaryKey(id);        if(sku!=null){
    //如果数据库有此对象        sku_price = sku.getPrice();        redisTemplate.boundHashOps("sku_price").put(id,sku_price);        }else{
           redisTemplate.boundHashOps("sku_price").put(id,0);        }        }        return sku_price;        }

3. 使用缓存预热
   缓存预热就是将数据提前加入到缓存中，当数据发生变更，再将最新的数据更新到缓存。
   将数据访问压力转移到缓存,保护数据库
   后边我们就用缓存预热的方式实现对分类导航、广告轮播图等数据的缓存。

2.2 缓存击穿

特点:和穿透比起来一般没有id;穿透是有人攻击,但是击穿是常见现象

缓存击穿是指缓存中没有但数据库中有的数据。这时由于并发用户特别多，同时读

缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压 力。 以下代码可能会产生缓存击穿： 加过期时间是为了保证数据的更新,假如设定5分钟更新一次,那么每5分钟就存在一个击穿的风险

@Autowiredprivate RedisTemplate redisTemplate;public List

解决方案：

1.设置热点数据永远不过期。 2.缓存预热

2.3 缓存雪崩

存在大量缓存,不止同一条数据,结果数据同时到期了,压力被转移到数据库

缓存雪崩是指缓存数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案： 1.缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。 2.设置热点数据永远不过期。 3.使用缓存预热 缓存预热还是非常好的解决方案

3. 商品分类导航缓存

3.1 需求分析

为了提升首页的加载速度，减轻数据库访问压力，我们将首页的商品分类导航数据加载

在缓存中。

3.2 实现思路

为了避免缓存穿透、击穿等问题，我们采用缓存预热的方式实现对分类导航数据的缓

存。 考虑到商品分类导航数据不经常变动，所以我们不设置过期时间。

3.3 代码实现

缓存几乎在所有模块中都有遇到,因此放到公共服务模块

3.3.1 通用模块整合spring data redis

（1）qingcheng_common_service引入依赖

   
   
    
     redis.clients
    
    
     jedis
    
    
     2.9.0
    
   
   
    
     org.springframework.data
    
    
     spring‐data‐redis
    
    
     2.0.5.RELEASE
    
   

（2）qingcheng_common_service新增配置文件 redis-config.properties

redis.host=127.0.0.1        redis.port=6379        redis.pass=        redis.database=0        redis.maxIdle=300        redis.maxWait=3000

maxWait：连接池中连接用完时,新的请求等待时间,毫秒

maxIdle： 最大闲置个数 （3）qingcheng_common_service新增spring配置文件applicationContext-redis.xml

（4）qingcheng_common_service工程新增枚举

创建枚举的目的是统一各个功能所用缓存的名称,防止因为名字不同犯低级调用错误

public enum CacheKey {
       AD,//广告    SKU_PRICE,//价格    CATEGORY_TREE;//商品分类导航树}

至此spring data redis 已经整合完成,开始实现业务需求

3.3.2 商品分类加载到缓存

为缓存预热

（1）服务接口CategoryService新增方法定义

/** * 将商品分类树放入缓存 */public void saveCategoryTreeToRedis();

（2）CategoryServiceImpl实现此方法

@Autowired    private RedisTemplate redisTemplate;    public void saveCategoryTreeToRedis() {
           System.out.println("将商品分类数据加载到缓存");        Example example = new Example(Category.class);        Example.Criteria criteria = example.createCriteria();        criteria.andEqualTo("isShow", "1");        List
   
     categories = categoryMapper.selectByExample(example);        /*将查询到的数据变换成树形结构*/        List
    
   

（3）qingcheng_service_goods工程新增类

希望当此模块启动的时候自动对缓存预热 implements InitializingBean后继承此方法启动后要进行的逻辑 @Component加注解后表示这是bean

@Componentpublic class Init implements InitializingBean {
       @Autowired    private CategoryService categoryService;    public void afterPropertiesSet() throws Exception {
           System.out.println("缓存预热");        categoryService.saveCategoryTreeToRedis();//模块启动后自动加载商品分类导航缓存    }}

实现InitializingBean接口的类会在启动时自动调用。

3.3.3 查询商品分类缓存

修改CategoryServiceImpl的findCategoryTree方法 ，直接从缓存中提取数据。

上次从数据库中查找数据,然而已经不需要了

/*直接从缓存中读取数据*/    public List

查看是否可用

启动zk,redis服务 运行business,goods,portal 控制台中可以看到提示数据从缓存中取出

3.3.4 更新商品分类缓存

缓存中的数据当然也需要更新

修改CategoryServiceImpl的增删改方法，在增删改后重新加载缓存

/** * 新增 * @param category */public void add(Category category) {
           categoryMapper.insert(category);        saveCategoryTreeToRedis();        }/** * 修改 * @param category */public void update(Category category) {
           categoryMapper.updateByPrimaryKeySelective(category);        saveCategoryTreeToRedis();        }/** * 删除 * @param id */public void delete(Integer id) {
   //判断是否存在下级分类//......        saveCategoryTreeToRedis();        }

4. 广告轮播图缓存

4.1 需求分析

为了提升首页的加载速度，减轻数据库访问压力，我们将首页的广告轮播图数据加载在

缓存中。 然而,这里需要考虑的是所有广告

4.2 实现思路

使用“缓存预热”的方式实现

广告数据不只是轮播图，我们可以使用hash来存储广告数据。 hash本身有key ,value,位置-广告 大key用来存储广告,小key用来区分广告

4.3 代码实现

4.3.1 广告数据加载到缓存

这种更新只是局部的更新

（1）AdService新增方法定义 saveAdToRedisByPosition 更新广告的时候会调用

/** * 将某个位置的广告存入缓存 * @param position */public void saveAdToRedisByPosition(String position);/** * 将全部广告数据存入缓存 */public void saveAllAdToRedis();

（2）AdServiceImpl方法实现

从数据库中查询某位置的广告,并装入缓存 查询所有的广告位置遍历位置装入缓存

@Autowiredprivate RedisTemplate redisTemplate;public void saveAdToRedisByPosition(String position) {
   //查询某位置的广告列表        Example example=new Example(Ad.class);        Example.Criteria criteria = example.createCriteria();        criteria.andEqualTo("position",position);        criteria.andLessThanOrEqualTo("startTime",new Date());//开始时间小于等于当前时间        criteria.andGreaterThanOrEqualTo("endTime",new Date());//截至时间大于等于当前时间        criteria.andEqualTo("status","1");        List
   
     adList = adMapper.selectByExample(example);//装入缓存        redisTemplate.boundHashOps(CacheKey.AD).put(position,adList);        }/** * 返回所有的广告位置 * @return */private List
    
      getPositionList(){
           List
     
       positionList=new ArrayList
      
       ();        positionList.add("index_lb");//首页广告轮播图//。。。        return positionList;        }public void saveAllAdToRedis() {
   //循环所有的广告位置,将每个位置的广告封装入缓存        for(String position:getPositionList()){
           saveAdToRedisByPosition(position);        }        }
      
     
    
   

（3）qingcheng_service_business工程新增类

启动该模块时自动装入该时段广告数据进入缓存

@Componentpublic class Init implements InitializingBean {
       @Autowired    private AdService adService;    public void afterPropertiesSet() throws Exception {
           System.out.println("‐‐‐缓存预热‐‐‐");        adService.saveAllAdToRedis();    }}

4.3.2 查询广告缓存

修改AdServiceImpl的findByPosition方法

public List
   
     findByPosition(String position) {
   //从缓存中查询广告列表        return(List
    
     )redisTemplate.boundHashOps(CacheKey.AD).get(position);        }
    
   

goods和business都参与了首页页面

4.3.3 更新广告缓存

缓存当然要面临更新问题

修改AdServiceImpl的增删改方法

/** * 新增 * @param ad */public void add(Ad ad) {
           adMapper.insert(ad);        saveAdByPosition(ad.getPosition());//重新加载缓存        }/** * 修改,可能对广告位置也进行了更新 * @param ad */public void update(Ad ad) {
   //获取之前的广告位置        String position =        adMapper.selectByPrimaryKey(ad.getId()).getPosition();        //对广告更新        adMapper.updateByPrimaryKeySelective(ad);   //位置变化才进行更新缓存        if(!position.equals(ad.getPosition())){
    //如果广告位置发生变化        saveAdToRedisByPosition(ad.getPosition());//更新        }        }/** * 删除,在删除之前更新缓存,不然没得查 * @param id */public void delete(Integer id) {
           String position = adMapper.selectByPrimaryKey(id).getPosition();        saveAdByPosition(position);//重新加载缓存        adMapper.deleteByPrimaryKey(id);        }

5. 商品详细页价格缓存

5.1 需求分析

我们已经将商品的信息生成为静态页面，但是商品价格经常变动，如果每次价格变动后都对静态页重新生成会影响服务器性能。

所以，对于商品价格，我们采用异步调用的方式来进行客户端渲染。

5.2 实现思路

（1）商品服务启动后加载全部价格数据到缓存。使用hash存储，skuID作为小KEY

（2）从缓存查询商品价格，封装为controller，并设置可跨域调用 什么叫跨域？ 当协议、子域名、主域名、端口号中任意一个不相同时，都算作不同域。不同域之间相 互请求资源，就算作“跨域”。 比如这个contoller请求那个controller JavaScript出于安全方面的考虑，不允许跨域调用其他页面的对象。 那什么是跨域呢，简单地理解就是因为JavaScript同源策略的限制，a.com域名下的js无法操作b.com 或是c.a.com域名下的对象。 当协议、子域名、主域名、端口号中任意一个不相同时，都算作不同域。不同域之间相 互请求资源，就算作“跨域”。 现在我们要实现的查询商品价格缓存功能就存在跨域问题。后端controller在http://www.qingcheng.com ，商品详细页在http://item.qingcheng.com, 如何解决跨域问题？我们使用CORS实现跨域。 CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resourcesharing）。它允许浏览器向跨源服务器，发出 XMLHttpRequest 请求，从而克服了AJAX只能同源使用的限制。使用非常简单，只需要在controller类上添加一个 @CrossOrigin 注解即可 （3）修改商品详细页模板，使用ajax读取价格，并进行客户端渲染。

5.3 代码实现

5.3.1 价格数据加载到缓存

（1）SkuService接口新增方法定义

/** * 保存全部价格到缓存 */public void saveAllPriceToRedis();

（2）SkuServiceImpl类新增方法

如果缓存已经存在就没有必要重复查询 那么之前广告和商品分类数据为什么不做判断呢? 也可以,但是数据量比较小,即使重复载入影响不大,但是价格数据量大,对于性能有较大影响

@Autowired    private RedisTemplate redisTemplate;    public void saveAllPriceToRedis() {
           /*如果缓存并没有建立*/        if (!redisTemplate.hasKey(CacheKey.SKU_PRICE)) {
               System.out.println("加载全部价格");            List
   
     skuList = skuMapper.selectAll();            for (Sku sku : skuList) {
                   if ("1".equals(sku.getStatus())) {
                       redisTemplate.boundHashOps(CacheKey.SKU_PRICE).put(sku.getId(), sku.getPrice());                }            }        }        else{
               System.out.println("缓存已经存在,价格数据未更新,不必预热");        }    }
   

（3）修改Init类

@Componentpublic class Init implements InitializingBean {
       @Autowired    private CategoryService categoryService;    @Autowired    private SkuService skuService;    public void afterPropertiesSet() throws Exception {
           System.out.println("缓存预热");        categoryService.saveCategoryTreeToRedis();//模块启动后自动加载商品分类导航缓存        skuService.saveAllPriceToRedis();//加载价格数据也进入缓存    }}

5.3.2 查询价格缓存

后端代码：

（1）SkuService新增方法定义

public Integer findPrice(String id)

（2）SkuServiceImpl实现findPrice方法

public Integer findPrice(String id) {
   //从缓存中查询        return    (Integer)redisTemplate.boundHashOps(CacheKey.SKU_PRICE).get(id);        }

（3）qingcheng_web_portal工程新增类

@RestController@RequestMapping("/sku")@CrossOriginpublic class SkuController {
       @Reference    private SkuService skuService;    @GetMapping("/price")    public Integer price(String id){
           return skuService.findPrice(id);    }}

前端代码（修改模板）：

（1）将vue.js axios.js 放到html输出文件夹下的js文件夹中。 （2）修改qingcheng_web_portal工程的模板 item.html

th:inline 定义js脚本可以使用变量 js脚本的变量用 /[[${ }]]/ 渲染

（3）修改qingcheng_web_portal工程的模板 item.html ，body,添加

，并将价格修改为vue表达式

{
   {
   price}}

5.3.3 更新价格缓存

（1）SkuService接口新增方法定义

/** * 保存价格到缓存 * @param skuId */public void savePriceToRedisById(String id,Integer price);

（2）SkuServiceImpl类新增方法

public void savePriceToRedisById(String id,Integer price) {
           redisTemplate.boundHashOps(CacheKey.SKU_PRICE).put(id,price);        }

（3）SpuServiceImpl类引入SkuService

@Autowiredprivate SkuService skuService;

（4）修改SpuServiceImpl类saveGoods方法，在SKU列表循环体中添加代码

skuService.savePriceToRedisById(sku.getId(),sku.getPrice());

5.3.4 删除价格缓存

删除商品时删除缓存中的价格，释放内存空间

（1）SkuService新增方法定义

/** * 根据sku id 删除商品价格缓存 * @param id */public void deletePriceFromRedis(String id);

（2）SkuServiceImpl新增方法实现

public void deletePriceFromRedis(String id) {
           redisTemplate.boundHashOps(CacheKey.SKU_PRICE).delete(id);        }

（3）修改SpuServiceImpl的delete方法，新增代码逻辑

//删除缓存中的价格Map map=new HashMap();        map.put("spuId",id);        List
   
     skuList = skuService.findList(map);        for(Sku sku:skuList){
           skuService.deletePriceFromRedis(sku.getId());        }