经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » Redis » 查看文章
Redis实战之商城购物车功能的实现代码
来源：jb51　　时间：2021/2/1 11:30:31　　对本文有异议

目标

利用Redis实现商城购物车功能。

功能

根据用户编号查询购物车列表，且各个商品需要跟在对应的店铺下；统计购物车中的商品总数；新增或删减购物车商品；增加或减少购物车中的商品数量。

分析

Hash数据类型：值为多组映射，相当于JAVA中的Map。适合存储对象数据类型。因为用户ID作为唯一的身份标识，所以可以把模块名称+用户ID作为Redis的键；商品ID作为商品的唯一标识，可以把店铺编号+商品ID作为Hash元素的键，商品数量为元素的值。

代码实现

控制层

  1. package com.shoppingcart.controller;
  2.  
  3. import com.shoppingcart.service.ShoppingCartServer;
  4. import org.springframework.web.bind.annotation.*;
  5. import javax.annotation.Resource;
  6. import java.util.List;
  7. import java.util.Map;
  8.  
  9. /**
  10.  * redis实现购物车功能
  11.  */
  12. @RestController
  13. @RequestMapping("/shoppingCart")
  14. public class ShoppingCartController {
  15.  @Resource
  16.  private ShoppingCartServer shoppingCartServer;
  17.  
  18.  /**
  19.   * http://localhost:8099/shoppingCart/addCommodity?userId=001&shopId=1234560&commodityId=001&commodityNum=336
  20.   * 添加商品
  21.   * @return
  22.   * @param: userId 用户ID
  23.   * @param: [{shopId:商铺id,commodityId:商品id,commodityNum:商品数量},{shopId:商铺id,commodityId:商品id,commodityNum:商品数量}]
  24.   * 测试数据：
  25.   [
  26.   {
  27.   "shopId": 123,
  28.   "commodityId": 145350,
  29.   "commodityNum": 155.88
  30.   },
  31.   {
  32.   "shopId": 123,
  33.   "commodityId": 6754434,
  34.   "commodityNum": 945.09
  35.   },
  36.   {
  37.   "shopId": 123,
  38.   "commodityId": 7452,
  39.   "commodityNum": 2445.09
  40.   },
  41.   {
  42.   "shopId": 3210,
  43.   "commodityId": 98766,
  44.   "commodityNum": 2345.09
  45.   },
  46.   {
  47.   "shopId": 456,
  48.   "commodityId": 2435640,
  49.   "commodityNum": 11945.09
  50.   }
  51.   ]
  52.   */
  53.  @GetMapping("/addCommodity")
  54.  public Map<String, Object> addCommodity(
  55.    @RequestParam(value = "userId", required = true) String userId,
  56.    @RequestBody List<Map<String, Object>> list
  57.  ) {
  58.   Map<String, Object> map = shoppingCartServer.addCommodity(userId, list);
  59.   return map;
  60.  }
  61.  
  62.  /**
  63.   * 购物车列表
  64.   * http://localhost:8099/shoppingCart/shoppingCartList?userId=001
  65.   *
  66.   * @param userId
  67.   * @return 返回{店铺ID:商品ID=商品数量}的map。
  68.   */
  69.  @GetMapping("/shoppingCartList")
  70.  public Map<Object, Object> shoppingCartList(
  71.    @RequestParam(value = "userId", required = true) String userId,
  72.    @RequestParam(value = "pageNo", defaultValue = "0") Long pageNo,
  73.    @RequestParam(value = "pageSize", defaultValue = "10") Long pageSize
  74.  ) {
  75.   Map<Object, Object> map = shoppingCartServer.shoppingCartList(userId, pageNo, pageSize);
  76.   return map;
  77.  }
  78.  
  79.  /**
  80.   * http://localhost:8099/shoppingCart/updateNum?userId=001&shopId=01&comId=123456&num=342
  81.   * 修改商品数量。
  82.   *
  83.   * @param userId  用户id
  84.   * @param commodityId 商品id
  85.   * @param commodityNum 商品数量
  86.   * @return
  87.   */
  88.  @GetMapping("/updateNum")
  89.  public Map<String, Object> updateNum(
  90.    @RequestParam(value = "userId", required = true) String userId,
  91.    @RequestParam(value = "shopId", required = true) Long shopId,
  92.    @RequestParam(value = "commodityId", required = true) Long commodityId,
  93.    @RequestParam(value = "commodityNum", required = true) Double commodityNum
  94.  ) {
  95.   return shoppingCartServer.updateNum(userId, shopId, commodityId, commodityNum);
  96.  }
  97.  
  98.  /**
  99.   * http://localhost:8099/shoppingCart/delCom?userId=001&shopId=01&comId=123457
  100.   * 删除购物车中的商品
  101.   * @return
  102.   * @param: userId 用户id
  103.   * @param: [{shopId:商铺id,commodityId:商品id},{shopId:商铺id,commodityId:商品id}]
  104.   */
  105.  @PostMapping("/delCommodity")
  106.  public Map<String, Object> delCommodity(
  107.    @RequestParam(value = "userId", required = true) String userId,
  108.    @RequestBody List<Map<String, Object>> list
  109.  ) {
  110.   return shoppingCartServer.delCommodity(userId, list);
  111.  }
  112. }

业务层

  1. package com.shoppingcart.service;
  2.  
  3. import java.util.List;
  4. import java.util.Map;
  5.  
  6. public interface ShoppingCartServer {
  7.  //购物车列表
  8.  public Map<Object, Object> shoppingCartList(String userId,Long pageNo,Long pageSize);
  9.  Map<String,Object> updateNum(String userId,Long shopId, Long commodityId, Double commodityNum);
  10.  Map<String, Object> delCommodity(String userId, List<Map<String , Object>> list);
  11.  Map<String, Object> addCommodity(String userId, List<Map<String , Object>> list);
  12. }
  1. package com.shoppingcart.service.impl;
  2.  
  3. import com.shoppingcart.service.ShoppingCartServer;
  4. import com.shoppingcart.utils.RedisService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7.  
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12.  
  13. @Service
  14. public class ShoppingCartServerImpl implements ShoppingCartServer {
  15.  @Autowired
  16.  private RedisService redisService;
  17.  //购物车键名前缀
  18.  public static final String SHOPPING_CART = "shoppingCart:";
  19.  //购物车的元素键名前缀
  20.  public static final String SHOP_ID = "shopId";
  21.  
  22.  //添加商品
  23.  @Override
  24.  public Map<String, Object> addCommodity(String userId, List<Map<String, Object>> list) {
  25.   //记录：list中有哪些商品在购物车中已经存在。
  26.   List<String> existCommoditys = new ArrayList<>();
  27.   //todo 购物车key
  28.   String key = SHOPPING_CART + userId;
  29.   for (int i = 0; i < list.size(); i++) {
  30.    String commodityKey = SHOP_ID + list.get(i).get("shopId") + ":" + list.get(i).get("commodityId");
  31.    //todo 添加商品
  32.    boolean boo = redisService.hsetnx(key, commodityKey, Double.parseDouble(list.get(i).get("commodityNum") + ""));
  33.    if (!boo) {
  34.     existCommoditys.add(commodityKey);
  35.    }
  36.   }
  37.   Map<String, Object> m = new HashMap<String, Object>() {
  38.    {
  39.     put("existCommoditys", existCommoditys);
  40.     put("existCommoditysMsg", "这些商品在购物车中已经存在，重复数量："+existCommoditys.size()+"。");
  41.    }
  42.   };
  43.   Map<String, Object> map = new HashMap<String, Object>();
  44.   map.put("data", m);
  45.   map.put("code", 0);
  46.   return map;
  47.  }
  48.  
  49.  //购物车列表
  50.  @Override
  51.  public Map<Object, Object> shoppingCartList(String userId, Long pageNo, Long pageSize) {
  52.   //返回{店铺ID:商品ID=商品数量}的map。
  53.   Map<Object, Object> map = redisService.hmget(SHOPPING_CART + userId);
  54.   return map;
  55.  }
  56.  
  57.  //修改商品数量
  58.  @Override
  59.  public Map<String, Object> updateNum(String userId, Long shopId, Long commodityId, Double commodityNum) {
  60.   Map<String, Object> map = new HashMap<String, Object>();
  61.   //todo 购物车key
  62.   String key = SHOPPING_CART + userId;
  63.   //todo 商品key
  64.   String commodityKey = SHOP_ID + shopId + ":" + commodityId;
  65.   //修改购物车的数量
  66.   boolean boo = redisService.hset(key, commodityKey, commodityNum);
  67.   Map<String, Object> m = new HashMap<String, Object>() {
  68.    {
  69.     put("key", key);
  70.     put("commodityKey", commodityKey);
  71.     put("commodityNum", commodityNum);
  72.    }
  73.   };
  74.   map.put("data", m);
  75.   map.put("msg", boo == true ? "修改购物车商品数量成功。" : "修改购物车商品数量失败。");
  76.   map.put("code", boo == true ? 0 : 1);
  77.   return map;
  78.  }
  79.  
  80.  //删除商品
  81.  @Override
  82.  public Map<String, Object> delCommodity(String userId, List<Map<String, Object>> list) {
  83.   Map<String, Object> map = new HashMap<String, Object>();
  84.   String[] commodityIds = new String[list.size()];
  85.   for (int i = 0; i < list.size(); i++) {
  86.    //todo 商品key
  87.    commodityIds[i] = SHOP_ID + list.get(i).get("shopId") + ":" + list.get(i).get("commodityId");
  88.   }
  89.   //todo 购物车key
  90.   String key = SHOPPING_CART + userId;
  91.   //删除商品的数量
  92.   Long num = redisService.hdel(key, commodityIds);
  93.   map.put("msg", "删除购物车的商品数量：" + num);
  94.   map.put("code", 0);
  95.   return map;
  96.  }
  97. }

 

工具类

  1. package com.shoppingcart.utils;
  2.  
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5.  
  6. public class DateUtils {
  7.  // 日期转字符串，返回指定的格式
  8.  public static String dateToString(Date date, String dateFormat) {
  9.   SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
  10.   return sdf.format(date);
  11.  }
  12. }
  1. package com.shoppingcart.utils;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.data.redis.connection.RedisZSetCommands;
  6. import org.springframework.data.redis.connection.SortParameters;
  7. import org.springframework.data.redis.core.DefaultTypedTuple;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.data.redis.core.ZSetOperations;
  10. import org.springframework.stereotype.Service;
  11. import org.springframework.util.CollectionUtils;
  12. import org.w3c.dom.ranges.Range;
  13.  
  14. import java.util.*;
  15. import java.util.concurrent.TimeUnit;
  16. import java.util.stream.Collectors;
  17.  
  18. @Service
  19. public class RedisService {
  20.  
  21.  @Autowired
  22.  private RedisTemplate<String, Object> redisTemplate;
  23.  
  24.  // =============================common============================
  25.  
  26.  /**
  27.   * 指定缓存失效时间
  28.   *
  29.   * @param key 键
  30.   * @param time 时间(秒)
  31.   * @return
  32.   */
  33.  public boolean expire(String key, long time) {
  34.   try {
  35.    if (time > 0) {
  36.     redisTemplate.expire(key, time, TimeUnit.SECONDS);
  37.    }
  38.    return true;
  39.   } catch (Exception e) {
  40.    e.printStackTrace();
  41.    return false;
  42.   }
  43.  }
  44.  
  45.  /**
  46.   * 根据key 获取过期时间
  47.   *
  48.   * @param key 键 不能为null
  49.   * @return 时间(秒) 返回0代表为永久有效
  50.   */
  51.  public long getExpire(String key) {
  52.   return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  53.  }
  54.  
  55.  /**
  56.   * 判断key是否存在
  57.   *
  58.   * @param key 键
  59.   * @return true 存在 false不存在
  60.   */
  61.  public boolean hasKey(String key) {
  62.   try {
  63.    return redisTemplate.hasKey(key);
  64.   } catch (Exception e) {
  65.    e.printStackTrace();
  66.    return false;
  67.   }
  68.  }
  69.  
  70.  /**
  71.   * 删除缓存
  72.   *
  73.   * @param key 可以传一个值 或多个
  74.   */
  75.  @SuppressWarnings("unchecked")
  76.  public void del(String... key) {
  77.   if (key != null && key.length > 0) {
  78.    if (key.length == 1) {
  79.     redisTemplate.delete(key[0]);
  80.    } else {
  81.     List<String> list = new ArrayList<>(Arrays.asList(key));
  82.     redisTemplate.delete(list);
  83.    }
  84.   }
  85.  }
  86.  
  87.  /**
  88.   * 删除缓存
  89.   *
  90.   * @param keys 可以传一个值 或多个
  91.   */
  92.  @SuppressWarnings("unchecked")
  93.  public void del(Collection keys) {
  94.   if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(keys)) {
  95.    redisTemplate.delete(keys);
  96.   }
  97.  }
  98.  
  99.  // ============================String=============================
  100.  
  101.  /**
  102.   * 普通缓存获取
  103.   *
  104.   * @param key 键
  105.   * @return 值
  106.   */
  107.  public Object get(String key) {
  108.   return key == null ? null : redisTemplate.opsForValue().get(key);
  109.  }
  110.  
  111.  /**
  112.   * 普通缓存放入
  113.   *
  114.   * @param key 键
  115.   * @param value 值
  116.   * @return true成功 false失败
  117.   */
  118.  public boolean set(String key, Object value) {
  119.   try {
  120.    redisTemplate.opsForValue().set(key, value);
  121.    return true;
  122.   } catch (Exception e) {
  123.    e.printStackTrace();
  124.    return false;
  125.   }
  126.  }
  127.  
  128.  /**
  129.   * 普通缓存放入并设置时间
  130.   *
  131.   * @param key 键
  132.   * @param value 值
  133.   * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  134.   * @return true成功 false 失败
  135.   */
  136.  public boolean set(String key, Object value, long time) {
  137.   try {
  138.    if (time > 0) {
  139.     redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  140.    } else {
  141.     set(key, value);
  142.    }
  143.    return true;
  144.   } catch (Exception e) {
  145.    e.printStackTrace();
  146.    return false;
  147.   }
  148.  }
  149.  
  150.  /**
  151.   * 递增
  152.   *
  153.   * @param key 键
  154.   * @param delta 要增加几(大于0)
  155.   * @return
  156.   */
  157.  public long incr(String key, long delta) {
  158.   if (delta < 0) {
  159.    throw new RuntimeException("递增因子必须大于0");
  160.   }
  161.   return redisTemplate.opsForValue().increment(key, delta);
  162.  }
  163.  
  164.  /**
  165.   * 递减
  166.   *
  167.   * @param key 键
  168.   * @param delta 要减少几(小于0)
  169.   * @return
  170.   */
  171.  public long decr(String key, long delta) {
  172.   if (delta < 0) {
  173.    throw new RuntimeException("递减因子必须大于0");
  174.   }
  175.   return redisTemplate.opsForValue().increment(key, -delta);
  176.  }
  177.  
  178.  // ================================Hash=================================
  179.  
  180.  /**
  181.   * HashGet
  182.   *
  183.   * @param key 键 不能为null
  184.   * @param item 项 不能为null
  185.   * @return 值
  186.   */
  187.  public Object hget(String key, String item) {
  188.   return redisTemplate.opsForHash().get(key, item);
  189.  }
  190.  
  191.  /**
  192.   * 获取hashKey对应的所有键值
  193.   *
  194.   * @param key 键
  195.   * @return 对应的多个键值
  196.   */
  197.  public Map<Object, Object> hmget(String key) {
  198.   Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
  199.   return entries;
  200.  }
  201.  
  202.  /**
  203.   * HashSet
  204.   *
  205.   * @param key 键
  206.   * @param map 对应多个键值
  207.   * @return true 成功 false 失败
  208.   */
  209.  public boolean hmset(String key, Map<String, Object> map) {
  210.   try {
  211.    redisTemplate.opsForHash().putAll(key, map);
  212.    return true;
  213.   } catch (Exception e) {
  214.    e.printStackTrace();
  215.    return false;
  216.   }
  217.  }
  218.  
  219.  /**
  220.   * HashSet 并设置时间
  221.   *
  222.   * @param key 键
  223.   * @param map 对应多个键值
  224.   * @param time 时间(秒)
  225.   * @return true成功 false失败
  226.   */
  227.  public boolean hmset(String key, Map<String, Object> map, long time) {
  228.   try {
  229.    redisTemplate.opsForHash().putAll(key, map);
  230.    if (time > 0) {
  231.     expire(key, time);
  232.    }
  233.    return true;
  234.   } catch (Exception e) {
  235.    e.printStackTrace();
  236.    return false;
  237.   }
  238.  }
  239.  
  240.  
  241.  /**
  242.   * 向一张hash表中放入数据,如果存在就覆盖原来的值。
  243.   *
  244.   * @param key 键
  245.   * @param item 项
  246.   * @param value 值
  247.   * @return true 成功 false失败
  248.   */
  249.  public boolean hset(String key, String item, Object value) {
  250.   try {
  251.    redisTemplate.opsForHash().put(key, item, value);
  252.    return true;
  253.   } catch (Exception e) {
  254.    e.printStackTrace();
  255.    return false;
  256.   }
  257.  }
  258.  
  259.  /**
  260.   * 向一张hash表中放入数据,如果存在就覆盖原来的值。
  261.   *
  262.   * @param key 键
  263.   * @param item 项
  264.   * @param value 值
  265.   * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  266.   * @return true 成功 false失败
  267.   */
  268.  public boolean hset(String key, String item, Object value, long time) {
  269.   try {
  270.    redisTemplate.opsForHash().put(key, item, value);
  271.    if (time > 0) {
  272.     expire(key, time);
  273.    }
  274.    return true;
  275.   } catch (Exception e) {
  276.    e.printStackTrace();
  277.    return false;
  278.   }
  279.  }
  280.  
  281.  /**
  282.   * 删除hash表中的值
  283.   *
  284.   * @param key 键 不能为null
  285.   * @param item 项 可以使多个 不能为null
  286.   *    返回被删除的数量
  287.   */
  288.  public Long hdel(String key, Object... item) {
  289.   return redisTemplate.opsForHash().delete(key, item);
  290.  }
  291.  
  292.  /**
  293.   * 删除hash表中的值
  294.   *
  295.   * @param key 键 不能为null
  296.   * @param items 项 可以使多个 不能为null
  297.   */
  298.  public void hdel(String key, Collection items) {
  299.   redisTemplate.opsForHash().delete(key, items.toArray());
  300.  }
  301.  
  302.  /**
  303.   * 判断hash表中是否有该项的值
  304.   *
  305.   * @param key 键 不能为null
  306.   * @param item 项 不能为null
  307.   * @return true 存在 false不存在
  308.   */
  309.  public boolean hHasKey(String key, String item) {
  310.   return redisTemplate.opsForHash().hasKey(key, item);
  311.  }
  312.  
  313.  /**
  314.   * hash数据类型：给元素一个增量 如果不存在,就会创建一个 并把新增后的值返回
  315.   *
  316.   * @param key 键
  317.   * @param item 项
  318.   * @param delta 要增加几(大于0)
  319.   * @return
  320.   */
  321.  public double hincr(String key, String item, double delta) {
  322.   return redisTemplate.opsForHash().increment(key, item, delta);
  323.  }
  324.  // ============================set=============================
  325.  
  326.  /**
  327.   * 根据key获取Set中的所有值
  328.   *
  329.   * @param key 键
  330.   * @return
  331.   */
  332.  public Set<Object> sGet(String key) {
  333.   try {
  334.    return redisTemplate.opsForSet().members(key);
  335.   } catch (Exception e) {
  336.    e.printStackTrace();
  337.    return null;
  338.   }
  339.  }
  340.  
  341.  /**
  342.   * 根据value从一个set中查询,是否存在
  343.   *
  344.   * @param key 键
  345.   * @param value 值
  346.   * @return true 存在 false不存在
  347.   */
  348.  public boolean sHasKey(String key, Object value) {
  349.   try {
  350.    return redisTemplate.opsForSet().isMember(key, value);
  351.   } catch (Exception e) {
  352.    e.printStackTrace();
  353.    return false;
  354.   }
  355.  }
  356.  
  357.  /**
  358.   * 将数据放入set缓存
  359.   *
  360.   * @param key 键
  361.   * @param values 值 可以是多个
  362.   * @return 成功个数
  363.   */
  364.  public long sSet(String key, Object... values) {
  365.   try {
  366.    return redisTemplate.opsForSet().add(key, values);
  367.   } catch (Exception e) {
  368.    e.printStackTrace();
  369.    return 0;
  370.   }
  371.  }
  372.  
  373.  /**
  374.   * 将数据放入set缓存
  375.   *
  376.   * @param key 键
  377.   * @param values 值 可以是多个
  378.   * @return 成功个数
  379.   */
  380.  public long sSet(String key, Collection values) {
  381.   try {
  382.    return redisTemplate.opsForSet().add(key, values.toArray());
  383.   } catch (Exception e) {
  384.    e.printStackTrace();
  385.    return 0;
  386.   }
  387.  }
  388.  
  389.  /**
  390.   * 将set数据放入缓存
  391.   *
  392.   * @param key 键
  393.   * @param time 时间(秒)
  394.   * @param values 值 可以是多个
  395.   * @return 成功个数
  396.   */
  397.  public long sSetAndTime(String key, long time, Object... values) {
  398.   try {
  399.    Long count = redisTemplate.opsForSet().add(key, values);
  400.    if (time > 0)
  401.     expire(key, time);
  402.    return count;
  403.   } catch (Exception e) {
  404.    e.printStackTrace();
  405.    return 0;
  406.   }
  407.  }
  408.  
  409.  /**
  410.   * 获取set缓存的长度
  411.   *
  412.   * @param key 键
  413.   * @return
  414.   */
  415.  public long sGetSetSize(String key) {
  416.   try {
  417.    return redisTemplate.opsForSet().size(key);
  418.   } catch (Exception e) {
  419.    e.printStackTrace();
  420.    return 0;
  421.   }
  422.  }
  423.  
  424.  /**
  425.   * 移除值为value的
  426.   *
  427.   * @param key 键
  428.   * @param values 值 可以是多个
  429.   * @return 移除的个数
  430.   */
  431.  public long setRemove(String key, Object... values) {
  432.   try {
  433.    Long count = redisTemplate.opsForSet().remove(key, values);
  434.    return count;
  435.   } catch (Exception e) {
  436.    e.printStackTrace();
  437.    return 0;
  438.   }
  439.  }
  440.  
  441.  // ===============================list=================================
  442.  
  443.  /**
  444.   * 获取list缓存的内容
  445.   *
  446.   * @param key 键
  447.   * @param start 开始
  448.   * @param end 结束 0 到 -1代表所有值
  449.   * @return
  450.   */
  451.  public List<Object> lGet(String key, long start, long end) {
  452.   try {
  453.    return redisTemplate.opsForList().range(key, start, end);
  454.   } catch (Exception e) {
  455.    e.printStackTrace();
  456.    return null;
  457.   }
  458.  }
  459.  
  460.  /**
  461.   * 获取list缓存的长度
  462.   *
  463.   * @param key 键
  464.   * @return
  465.   */
  466.  public long lGetListSize(String key) {
  467.   try {
  468.    return redisTemplate.opsForList().size(key);
  469.   } catch (Exception e) {
  470.    e.printStackTrace();
  471.    return 0;
  472.   }
  473.  }
  474.  
  475.  /**
  476.   * 通过索引 获取list中的值
  477.   *
  478.   * @param key 键
  479.   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  480.   * @return
  481.   */
  482.  public Object lGetIndex(String key, long index) {
  483.   try {
  484.    return redisTemplate.opsForList().index(key, index);
  485.   } catch (Exception e) {
  486.    e.printStackTrace();
  487.    return null;
  488.   }
  489.  }
  490.  
  491.  /**
  492.   * 将list放入缓存
  493.   *
  494.   * @param key 键
  495.   * @param value 值
  496.   * @return
  497.   */
  498.  public boolean lSet(String key, Object value) {
  499.   try {
  500.    redisTemplate.opsForList().rightPush(key, value);
  501.    return true;
  502.   } catch (Exception e) {
  503.    e.printStackTrace();
  504.    return false;
  505.   }
  506.  }
  507.  
  508.  /**
  509.   * 将list放入缓存
  510.   *
  511.   * @param key 键
  512.   * @param value 值
  513.   * @param time 时间(秒)
  514.   * @return
  515.   */
  516.  public boolean lSet(String key, Object value, long time) {
  517.   try {
  518.    redisTemplate.opsForList().rightPush(key, value);
  519.    if (time > 0)
  520.     expire(key, time);
  521.    return true;
  522.   } catch (Exception e) {
  523.    e.printStackTrace();
  524.    return false;
  525.   }
  526.  }
  527.  
  528.  /**
  529.   * 将list放入缓存
  530.   *
  531.   * @param key 键
  532.   * @param value 值
  533.   * @return
  534.   */
  535.  public boolean lSet(String key, List<Object> value) {
  536.   try {
  537.    redisTemplate.opsForList().rightPushAll(key, value);
  538.    return true;
  539.   } catch (Exception e) {
  540.    e.printStackTrace();
  541.    return false;
  542.   }
  543.  }
  544.  
  545.  /**
  546.   * 将list放入缓存
  547.   *
  548.   * @param key 键
  549.   * @param value 值
  550.   * @param time 时间(秒)
  551.   * @return
  552.   */
  553.  public boolean lSet(String key, List<Object> value, long time) {
  554.   try {
  555.    redisTemplate.opsForList().rightPushAll(key, value);
  556.    if (time > 0)
  557.     expire(key, time);
  558.    return true;
  559.   } catch (Exception e) {
  560.    e.printStackTrace();
  561.    return false;
  562.   }
  563.  }
  564.  
  565.  /**
  566.   * 根据索引修改list中的某条数据
  567.   *
  568.   * @param key 键
  569.   * @param index 索引
  570.   * @param value 值
  571.   * @return
  572.   */
  573.  public boolean lUpdateIndex(String key, long index, Object value) {
  574.   try {
  575.    redisTemplate.opsForList().set(key, index, value);
  576.    return true;
  577.   } catch (Exception e) {
  578.    e.printStackTrace();
  579.    return false;
  580.   }
  581.  }
  582.  
  583.  /**
  584.   * 移除N个值为value
  585.   *
  586.   * @param key 键
  587.   * @param count 移除多少个
  588.   * @param value 值
  589.   * @return 移除的个数
  590.   */
  591.  public long lRemove(String key, long count, Object value) {
  592.   try {
  593.    Long remove = redisTemplate.opsForList().remove(key, count, value);
  594.    return remove;
  595.   } catch (Exception e) {
  596.    e.printStackTrace();
  597.    return 0;
  598.   }
  599.  }
  600.  // ===============================Zset=================================
  601.  
  602.  /**
  603.   * 给key键的value增加value分数，没有则会创建。
  604.   *
  605.   * @param key 键
  606.   * @param value 值
  607.   * @param score 分数
  608.   */
  609.  public Double incrementScore(String key, String value, double score) {
  610.   //Boolean add = redisTemplate.boundZSetOps(key).add(value, score);
  611.   Double add = redisTemplate.boundZSetOps(key).incrementScore(value, score);
  612.   return add;
  613.  }
  614.  
  615.  /**
  616.   * 获得指定Zset元素的分数
  617.   *
  618.   * @param key
  619.   * @param value
  620.   * @return
  621.   */
  622.  public Double score(String key, String value) {
  623.   Double score = redisTemplate.boundZSetOps(key).score(value);
  624.   return score;
  625.  }
  626.  
  627.  /**
  628.   * 升序查询key集合内[endTop,startTop]如果是负数表示倒数
  629.   * endTop=-1，startTop=0表示获取所有数据。
  630.   *
  631.   * @param key
  632.   * @param startPage
  633.   * @param endPage
  634.   */
  635.  public Set<ZSetOperations.TypedTuple<Object>> rangeWithScores(String key, int startPage, int endPage) {
  636.   Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.boundZSetOps(key).rangeWithScores(startPage, endPage);
  637.   return set;
  638.  }
  639.  
  640.  /**
  641.   * 降序查询key集合内[endTop,startTop]，如果是负数表示倒数
  642.   * endTop=-1，startTop=0表示获取所有数据。
  643.   *
  644.   * @param key
  645.   * @param startPage
  646.   * @param endPage
  647.   */
  648.  public Set<ZSetOperations.TypedTuple<Object>> reverseRangeWithScores(String key, int startPage, int endPage) {
  649.   Set<ZSetOperations.TypedTuple<Object>> set = redisTemplate.boundZSetOps(key).reverseRangeWithScores(startPage, endPage);
  650.   return set;
  651.  }
  652.  
  653.  /**
  654.   * 批量新增数据
  655.   *
  656.   * @param key
  657.   * @param set
  658.   * @return
  659.   */
  660.  public Long zsetAdd(String key, Set set) {
  661.   Long add = redisTemplate.boundZSetOps(key).add(set);
  662.   return add;
  663.  }
  664.  
  665.  /**
  666.   * 删除指定键的指定下标范围数据
  667.   *
  668.   * @param key
  669.   * @param startPage
  670.   * @param endPage
  671.   */
  672.  public Long zsetRemoveRange(String key, int startPage, int endPage) {
  673.   Long l = redisTemplate.boundZSetOps(key).removeRange(startPage, endPage);
  674.   return l;
  675.  }
  676.  /**
  677.   * 删除指定键的指定值
  678.   *
  679.   * @param key
  680.   * @param value
  681.   */
  682.  public Long zsetRemove(String key, String value) {
  683.   Long remove = redisTemplate.boundZSetOps(key).remove(value);
  684.   return remove;
  685.  }
  686. }

到此这篇关于Redis实战之商城购物车功能的实现代码的文章就介绍到这了,更多相关Redis商城购物车内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Redis热门文章

  • Redis-复制
  • Redis
  • 关于SpringBoot整合redis使用Lettuce客户端超时问题
  • RedisTemplate常用方法封装
  • RedisTemplate中opsForValue和opsForList方法的使用详解
  • Redis7.0部署集群的实现步骤
  • Java&nbsp;Redis&nbsp;Redisson配置教程详解
  • Go语言开发redis封装及简单使用详解
  • SpringBoot Redis批量存取数据的操作
  • .NetCore下基于FreeRedis实现的Redis6.0客户端缓存之缓存键条件优雅过滤

    • Redis推荐文章

  • Redis系列：使用Stream实现消息队列 （图文总结+Go案例） - Hello-Brand
  • 记一次 redis 事件注册不当导致的内存泄露
  • Java Redis多限流
  • 【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)
  • Redis 高阶应用
  • 【长文】带你搞明白Redis
  • StackExchange.Redis跑起来，为什么这么溜？
  • 【进阶篇】基于 Redis 实现分布式锁的全过程
  • Higress 基于自定义插件访问 Redis
  • 美团二面：如何保证Redis与Mysql双写一致性？连续两个面试问到了！

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号