一、 添加Spring.Redis依赖

注：由于Redis需要应用于所有应用，故安装在最顶层

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

二、配置Redis

Redis是提供给各个微服务的，所以要将配置添加至各微服务的YAML配置文件中。
注： 由于是Spring框架下的，所以必须安装在Spring YAML配置级下，如图：
image.png

  1. #端口号
  2. server:
  3.   port: 8200
  5. #服务注册名称
  6. spring:
  7.   application:
  8.     name: phone-server
  9.   # REDIS (RedisProperties)
  10.   # Redis数据库索引（默认为0）
  11.   redis:
  12.     database: 1
  13.     # Redis服务器地址
  14.     host: 118.25.178.111
  15.     # Redis服务器连接端口
  16.     port: 6380
  17.     # Redis服务器连接密码（默认为空）
  18.     password:
  19.     # 连接池最大连接数（使用负值表示没有限制）
  20.     jedis:
  21.       pool:
  22.         max-active: 8
  23.         # 连接池最大阻塞等待时间（使用负值表示没有限制）
  24.         max-wait: -1
  25.         # 连接池中的最大空闲连接
  26.         max-idle: 8
  27.         # 连接池中的最小空闲连接
  28.         min-idle: 0
  29.     # 连接超时时间（毫秒）
  30.     timeout: 10000
  31. #注册中心地址
  32. eureka:
  33.   client:
  34.     serviceUrl:
  35.       defaultZone: http://localhost:8100/eureka/

三、 添加RedisUtil工具类

注：此工具类要放到各个微服务中，因为微服务是通过YALML配置进行注入的，如果放在Common中，则无法实现注入。而且，各个服务的配置可能不一样，甚至使用不同服务器的Redis所以无法公用。
image.png

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

四、 调用Redis

image.png