导读

由于项目需要，这里需要设置一个关于RedisTemplate使用的工具类。

使用

导入依赖

  1.  <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

工具类

工具类是从网上找的，也可以自己根据需求封装一个。

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.RedisTemplate;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.util.CollectionUtils;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * RedisUtil工具类 用于处理Redis相关的信息
  13.  * 这里使用的是RedisTemplate
  14.  */
  15. @Component
  16. public class RedisUtil {
  18.     @Autowired
  19.     private RedisTemplate<Object, Object> redisTemplate;
  21.     // =============================common============================
  23.     /**
  24.      * 添加字符串KEY
  25.      *
  26.      * @param key      字符串KEY
  27.      * @param value    值 可以为对象
  28.      * @param expire   过期时间
  29.      * @param timeUnit TimeUnit中定义的时间单位
  30.      */
  31.     public void addKey(String key, Object value, long expire, TimeUnit timeUnit) {
  32.         this.redisTemplate.opsForValue().set(key, value, expire, timeUnit);
  33.     }
  35.     /**
  36.      * 指定缓存失效时间
  37.      *
  38.      * @param key  键
  39.      * @param time 时间(秒)
  40.      * @return
  41.      */
  42.     public boolean expire(String key, long time) {
  43.         try {
  44.             if (time > 0) {
  45.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  46.             }
  47.             return true;
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             return false;
  51.         }
  52.     }
  54.     /**
  55.      * 根据KEY获取VALUE
  56.      *
  57.      * @param key
  58.      * @return value
  59.      */
  60.     public Object getValue(String key) {
  61.         return this.redisTemplate.opsForValue().get(key);
  62.     }
  65.     /**
  66.      * 根据key 获取过期时间
  67.      *
  68.      * @param key 键 不能为null
  69.      * @return 时间(秒) 返回0代表为永久有效
  70.      */
  71.     public long getExpire(String key) {
  72.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  73.     }
  75.     /**
  76.      * 判断key是否存在
  77.      *
  78.      * @param key 键
  79.      * @return true 存在 false不存在
  80.      */
  81.     public boolean hasKey(String key) {
  82.         try {
  83.             return redisTemplate.hasKey(key);
  84.         } catch (Exception e) {
  85.             e.printStackTrace();
  86.             return false;
  87.         }
  88.     }
  90.     /**
  91.      * 删除缓存
  92.      *
  93.      * @param key 可以传一个值 或多个
  94.      */
  95.     @SuppressWarnings("unchecked")
  96.     public void del(String... key) {
  97.         if (key != null && key.length > 0) {
  98.             if (key.length == 1) {
  99.                 redisTemplate.delete(key[0]);
  100.             } else {
  101.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  102.             }
  103.         }
  104.     }
  106. // ============================String=============================
  108.     /**
  109.      * 普通缓存获取
  110.      *
  111.      * @param key 键
  112.      * @return 值
  113.      */
  114.     public Object get(String key) {
  115.         return key == null ? null : redisTemplate.opsForValue().get(key);
  116.     }
  118.     /**
  119.      * 普通缓存放入
  120.      *
  121.      * @param key   键
  122.      * @param value 值
  123.      * @return true成功 false失败
  124.      */
  125.     public boolean set(String key, Object value) {
  126.         try {
  127.             redisTemplate.opsForValue().set(key, value);
  128.             return true;
  129.         } catch (Exception e) {
  130.             e.printStackTrace();
  131.             return false;
  132.         }
  134.     }
  136.     /**
  137.      * 普通缓存放入并设置时间
  138.      *
  139.      * @param key   键
  140.      * @param value 值
  141.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  142.      * @return true成功 false 失败
  143.      */
  144.     public boolean set(String key, Object value, long time) {
  145.         try {
  146.             if (time > 0) {
  147.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  148.             } else {
  149.                 set(key, value);
  150.             }
  151.             return true;
  152.         } catch (Exception e) {
  153.             e.printStackTrace();
  154.             return false;
  155.         }
  156.     }
  158.     /**
  159.      * 递增
  160.      *
  161.      * @param key   键
  162.      * @param delta 要增加几(大于0)
  163.      * @return
  164.      */
  165.     public long incr(String key, long delta) {
  166.         if (delta < 0) {
  167.             throw new RuntimeException("递增因子必须大于0");
  168.         }
  169.         return redisTemplate.opsForValue().increment(key, delta);
  170.     }
  172.     /**
  173.      * 递减
  174.      *
  175.      * @param key   键
  176.      * @param delta 要减少几(小于0)
  177.      * @return
  178.      */
  179.     public long decr(String key, long delta) {
  180.         if (delta < 0) {
  181.             throw new RuntimeException("递减因子必须大于0");
  182.         }
  183.         return redisTemplate.opsForValue().increment(key, -delta);
  184.     }
  186.     // ================================Map=================================
  188.     /**
  189.      * HashGet
  190.      *
  191.      * @param key  键 不能为null
  192.      * @param item 项 不能为null
  193.      * @return 值
  194.      */
  195.     public Object hget(String key, String item) {
  196.         return redisTemplate.opsForHash().get(key, item);
  197.     }
  199.     /**
  200.      * 获取hashKey对应的所有键值
  201.      *
  202.      * @param key 键
  203.      * @return 对应的多个键值
  204.      */
  205.     public Map<Object, Object> hmget(String key) {
  206.         return redisTemplate.opsForHash().entries(key);
  207.     }
  209.     /**
  210.      * HashSet
  211.      *
  212.      * @param key 键
  213.      * @param map 对应多个键值
  214.      * @return true 成功 false 失败
  215.      */
  216.     public boolean hmset(String key, Map<String, Object> map) {
  217.         try {
  218.             redisTemplate.opsForHash().putAll(key, map);
  219.             return true;
  220.         } catch (Exception e) {
  221.             e.printStackTrace();
  222.             return false;
  223.         }
  224.     }
  226.     /**
  227.      * HashSet 并设置时间
  228.      *
  229.      * @param key  键
  230.      * @param map  对应多个键值
  231.      * @param time 时间(秒)
  232.      * @return true成功 false失败
  233.      */
  234.     public boolean hmset(String key, Map<String, Object> map, long time) {
  235.         try {
  236.             redisTemplate.opsForHash().putAll(key, map);
  237.             if (time > 0) {
  238.                 expire(key, time);
  239.             }
  240.             return true;
  241.         } catch (Exception e) {
  242.             e.printStackTrace();
  243.             return false;
  244.         }
  245.     }
  247.     /**
  248.      * 向一张hash表中放入数据,如果不存在将创建
  249.      *
  250.      * @param key   键
  251.      * @param item  项
  252.      * @param value 值
  253.      * @return true 成功 false失败
  254.      */
  255.     public boolean hset(String key, String item, Object value) {
  256.         try {
  257.             redisTemplate.opsForHash().put(key, item, value);
  258.             return true;
  259.         } catch (Exception e) {
  260.             e.printStackTrace();
  261.             return false;
  262.         }
  263.     }
  265.     /**
  266.      * 向一张hash表中放入数据,如果不存在将创建
  267.      *
  268.      * @param key   键
  269.      * @param item  项
  270.      * @param value 值
  271.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  272.      * @return true 成功 false失败
  273.      */
  274.     public boolean hset(String key, String item, Object value, long time) {
  275.         try {
  276.             redisTemplate.opsForHash().put(key, item, value);
  277.             if (time > 0) {
  278.                 expire(key, time);
  279.             }
  280.             return true;
  281.         } catch (Exception e) {
  282.             e.printStackTrace();
  283.             return false;
  284.         }
  285.     }
  287.     /**
  288.      * 删除hash表中的值
  289.      *
  290.      * @param key  键 不能为null
  291.      * @param item 项 可以使多个 不能为null
  292.      */
  293.     public void hdel(String key, Object... item) {
  294.         redisTemplate.opsForHash().delete(key, item);
  295.     }
  297.     /**
  298.      * 判断hash表中是否有该项的值
  299.      *
  300.      * @param key  键 不能为null
  301.      * @param item 项 不能为null
  302.      * @return true 存在 false不存在
  303.      */
  304.     public boolean hHasKey(String key, String item) {
  305.         return redisTemplate.opsForHash().hasKey(key, item);
  306.     }
  308.     /**
  309.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  310.      *
  311.      * @param key  键
  312.      * @param item 项
  313.      * @param by   要增加几(大于0)
  314.      * @return
  315.      */
  316.     public double hincr(String key, String item, double by) {
  317.         return redisTemplate.opsForHash().increment(key, item, by);
  318.     }
  320.     /**
  321.      * hash递减
  322.      *
  323.      * @param key  键
  324.      * @param item 项
  325.      * @param by   要减少记(小于0)
  326.      * @return
  327.      */
  328.     public double hdecr(String key, String item, double by) {
  329.         return redisTemplate.opsForHash().increment(key, item, -by);
  330.     }
  332.     // ============================set=============================
  334.     /**
  335.      * 根据key获取Set中的所有值
  336.      *
  337.      * @param key 键
  338.      * @return
  339.      */
  340.     public Set<Object> sGet(String key) {
  341.         try {
  342.             return redisTemplate.opsForSet().members(key);
  343.         } catch (Exception e) {
  344.             e.printStackTrace();
  345.             return null;
  346.         }
  347.     }
  349.     /**
  350.      * 根据value从一个set中查询,是否存在
  351.      *
  352.      * @param key   键
  353.      * @param value 值
  354.      * @return true 存在 false不存在
  355.      */
  356.     public boolean sHasKey(String key, Object value) {
  357.         try {
  358.             return redisTemplate.opsForSet().isMember(key, value);
  359.         } catch (Exception e) {
  360.             e.printStackTrace();
  361.             return false;
  362.         }
  363.     }
  365.     /**
  366.      * 将数据放入set缓存
  367.      *
  368.      * @param key    键
  369.      * @param values 值 可以是多个
  370.      * @return 成功个数
  371.      */
  372.     public long sSet(String key, Object... values) {
  373.         try {
  374.             return redisTemplate.opsForSet().add(key, values);
  375.         } catch (Exception e) {
  376.             e.printStackTrace();
  377.             return 0;
  378.         }
  379.     }
  381.     /**
  382.      * 将set数据放入缓存
  383.      *
  384.      * @param key    键
  385.      * @param time   时间(秒)
  386.      * @param values 值 可以是多个
  387.      * @return 成功个数
  388.      */
  389.     public long sSetAndTime(String key, long time, Object... values) {
  390.         try {
  391.             Long count = redisTemplate.opsForSet().add(key, values);
  392.             if (time > 0) {
  393.                 expire(key, time);
  394.             }
  395.             return count;
  396.         } catch (Exception e) {
  397.             e.printStackTrace();
  398.             return 0;
  399.         }
  400.     }
  402.     /**
  403.      * 获取set缓存的长度
  404.      *
  405.      * @param key 键
  406.      * @return
  407.      */
  408.     public long sGetSetSize(String key) {
  409.         try {
  410.             return redisTemplate.opsForSet().size(key);
  411.         } catch (Exception e) {
  412.             e.printStackTrace();
  413.             return 0;
  414.         }
  415.     }
  417.     /**
  418.      * 移除值为value的
  419.      *
  420.      * @param key    键
  421.      * @param values 值 可以是多个
  422.      * @return 移除的个数
  423.      */
  424.     public long setRemove(String key, Object... values) {
  425.         try {
  426.             Long count = redisTemplate.opsForSet().remove(key, values);
  427.             return count;
  428.         } catch (Exception e) {
  429.             e.printStackTrace();
  430.             return 0;
  431.         }
  432.     }
  433.     // ===============================list=================================
  435.     /**
  436.      * 获取list缓存的内容
  437.      *
  438.      * @param key   键
  439.      * @param start 开始
  440.      * @param end   结束 0 到 -1代表所有值
  441.      * @return
  442.      */
  443.     public List<Object> lGet(String key, long start, long end) {
  444.         try {
  445.             return redisTemplate.opsForList().range(key, start, end);
  446.         } catch (Exception e) {
  447.             e.printStackTrace();
  448.             return null;
  449.         }
  450.     }
  452.     /**
  453.      * 获取list缓存的长度
  454.      *
  455.      * @param key 键
  456.      * @return
  457.      */
  458.     public long lGetListSize(String key) {
  459.         try {
  460.             return redisTemplate.opsForList().size(key);
  461.         } catch (Exception e) {
  462.             e.printStackTrace();
  463.             return 0;
  464.         }
  465.     }
  467.     /**
  468.      * 通过索引 获取list中的值
  469.      *
  470.      * @param key   键
  471.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  472.      * @return
  473.      */
  474.     public Object lGetIndex(String key, long index) {
  475.         try {
  476.             return redisTemplate.opsForList().index(key, index);
  477.         } catch (Exception e) {
  478.             e.printStackTrace();
  479.             return null;
  480.         }
  481.     }
  483.     /**
  484.      * 将list放入缓存
  485.      *
  486.      * @param key   键
  487.      * @param value 值
  488.      * @return
  489.      */
  490.     public boolean lSet(String key, Object value) {
  491.         try {
  492.             redisTemplate.opsForList().rightPush(key, value);
  493.             return true;
  494.         } catch (Exception e) {
  495.             e.printStackTrace();
  496.             return false;
  497.         }
  498.     }
  500.     /**
  501.      * 将list放入缓存
  502.      *
  503.      * @param key   键
  504.      * @param value 值
  505.      * @param time  时间(秒)
  506.      * @return
  507.      */
  508.     public boolean lSet(String key, Object value, long time) {
  509.         try {
  510.             redisTemplate.opsForList().rightPush(key, value);
  511.             if (time > 0) {
  512.                 expire(key, time);
  513.             }
  514.             return true;
  515.         } catch (Exception e) {
  516.             e.printStackTrace();
  517.             return false;
  518.         }
  519.     }
  521.     /**
  522.      * 将list放入缓存
  523.      *
  524.      * @param key   键
  525.      * @param value 值
  526.      * @return
  527.      */
  528.     public boolean lSet(String key, List<Object> value) {
  529.         try {
  530.             redisTemplate.opsForList().rightPushAll(key, value);
  531.             return true;
  532.         } catch (Exception e) {
  533.             e.printStackTrace();
  534.             return false;
  535.         }
  536.     }
  538.     /**
  539.      * 将list放入缓存
  540.      *
  541.      * @param key   键
  542.      * @param value 值
  543.      * @param time  时间(秒)
  544.      * @return
  545.      */
  546.     public boolean lSet(String key, List<Object> value, long time) {
  547.         try {
  548.             redisTemplate.opsForList().rightPushAll(key, value);
  549.             if (time > 0) {
  550.                 expire(key, time);
  551.             }
  552.             return true;
  553.         } catch (Exception e) {
  554.             e.printStackTrace();
  555.             return false;
  556.         }
  557.     }
  559.     /**
  560.      * 根据索引修改list中的某条数据
  561.      *
  562.      * @param key   键
  563.      * @param index 索引
  564.      * @param value 值
  565.      * @return
  566.      */
  567.     public boolean lUpdateIndex(String key, long index, Object value) {
  568.         try {
  569.             redisTemplate.opsForList().set(key, index, value);
  570.             return true;
  571.         } catch (Exception e) {
  572.             e.printStackTrace();
  573.             return false;
  574.         }
  575.     }
  577.     /**
  578.      * 移除N个值为value
  579.      *
  580.      * @param key   键
  581.      * @param count 移除多少个
  582.      * @param value 值
  583.      * @return 移除的个数
  584.      */
  585.     public long lRemove(String key, long count, Object value) {
  586.         try {
  587.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  588.             return remove;
  589.         } catch (Exception e) {
  590.             e.printStackTrace();
  591.             return 0;
  592.         }
  593.     }
  594. }

具体使用

  1.     @RequestMapping("/info")
  2.     public void getRedis() {
  3.         RedisUtil redisUtil = new RedisUtil();
  4.         //字符串处理
  5.         redisUtil.set("sss", "hhhhhhh");
  6.         String str = (String) redisUtil.get("sss");
  7.         System.out.println(str);
  8.         //对象处理
  9.         User mUser = new User();
  10.         mUser.setAge(10);
  11.         mUser.setName("小明");
  12.         redisUtil.set("props", mUser, 2000);
  13.         redisUtil.set("user", mUser);
  14.         User user = (User) redisUtil.get("user");
  15.         System.out.println(user);
  16.         //集合处理
  17.         List list = new ArrayList();
  18.         list.add(mUser);
  19.         redisUtil.lSet("sj", list);
  20.     }


END

搞定~