一、Redis安装

Windows下redis安装

输入如下指令:

  1. redis-server.exe redis.windows.conf

出现如下图就表明redis启动成功啦

二、集成redis

现在正式步骤搞起来。

👉 项目结构图

image.png

👉 引入依赖

  1.        <!--junit-->
  2.         <dependency>
  3.             <groupId>junit</groupId>
  4.             <artifactId>junit</artifactId>
  5.             <version>4.12</version>
  6.             <scope>test</scope>
  7.         </dependency>
  9.         <!--redis-->
  10.         <!-- 整合redis -->
  11.         <dependency>
  12.             <groupId>org.springframework.boot</groupId>
  13.             <artifactId>spring-boot-starter-data-redis</artifactId>
  14.             <exclusions>
  15.                 <exclusion>
  16.                     <groupId>io.lettuce</groupId>
  17.                     <artifactId>lettuce-core</artifactId>
  18.                 </exclusion>
  19.             </exclusions>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>redis.clients</groupId>
  23.             <artifactId>jedis</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>com.alibaba</groupId>
  28.             <artifactId>fastjson</artifactId>
  29.             <version>1.2.68</version>
  30.          </dependency>

👉 编写配置文件

这里我把配置文件放在了resource/config目录下面，主要是觉得方便当然配置在appliation.yml文件也是可以哒

具体放置位置如下图所示:
image.png

  1. #Master的name
  2. redis.name=king
  3. #Matser的ip地址
  4. redis.host=127.0.0.1
  5. #端口号
  6. redis.port=6380
  7. #如果有密码
  8. redis.password=123456
  9. #客户端超时时间单位是毫秒 默认是2000
  10. redis.timeout=10000
  12. #最大空闲数
  13. redis.maxIdle=10
  14. #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
  15. #redis.maxActive=600
  16. #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
  17. redis.maxTotal=300 
  18. #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
  19. redis.maxWaitMillis=3000
  20. #连接的最小空闲时间 默认1800000毫秒(30分钟)
  21. redis.minEvictableIdleTimeMillis=300000  
  22. #每次释放连接的最大数目,默认3
  23. redis.numTestsPerEvictionRun=1024  
  24. #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  25. redis.timeBetweenEvictionRunsMillis=30000  
  26. #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
  27. redis.testOnBorrow=true  
  28. #在空闲时检查有效性, 默认false
  29. redis.testWhileIdle=true  
  31. #redis集群配置
  32. spring.redis.cluster.nodes=127.0.0.1:6380,127.0.0.1:6381,127.0.0.1:6379
  33. #重定向的最大次数  (意义:重定向的最大数量，比如第一台挂了，连第二台，第二台挂了连第三台，这个重新连接的最大数量)
  34. spring.redis.cluster.max-redirects=3
  36. #哨兵模式
  37. redis.sentinel.nodes=10.122.34.111:26379,10.122.36.111:26379

👉配置类RedisConfig

  1. package com.gome.redis.config;
  3. import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
  4. import com.gome.redis.util.RedisUtil;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.beans.factory.annotation.Qualifier;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.boot.context.properties.ConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.PropertySource;
  12. import org.springframework.data.redis.connection.*;
  13. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  14. import org.springframework.data.redis.core.RedisTemplate;
  15. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  16. import org.springframework.data.redis.serializer.GenericToStringSerializer;
  17. import org.springframework.data.redis.serializer.StringRedisSerializer;
  18. import redis.clients.jedis.JedisPoolConfig;
  20. import javax.annotation.PostConstruct;
  21. import java.util.HashSet;
  22. import java.util.Set;
  24. @Configuration
  25. @PropertySource("classpath:config/redis.properties")
  26. //@ConfigurationProperties(prefix =redis )
  27. public class RedisConfig {
  28.     @Value("${redis.name}")
  29.     private String hostName;
  30.     @Value("${redis.host}")
  31.     private String host;
  33.     @Value("${redis.port}")
  34.     private int port;
  35.     @Value("${redis.password}")
  36.     private String password;
  38.     @Value("${redis.timeout}")
  39.     private int timeout;
  41.     @Value("${redis.maxIdle}")
  42.     private Integer maxIdle;
  44.     @Value("${redis.maxTotal}")
  45.     private Integer maxTotal;
  47.     @Value("${redis.maxWaitMillis}")
  48.     private Integer maxWaitMillis;
  50.     @Value("${redis.minEvictableIdleTimeMillis}")
  51.     private Integer minEvictableIdleTimeMillis;
  53.     @Value("${redis.numTestsPerEvictionRun}")
  54.     private Integer numTestsPerEvictionRun;
  56.     @Value("${redis.timeBetweenEvictionRunsMillis}")
  57.     private long timeBetweenEvictionRunsMillis;
  59.     @Value("${redis.testOnBorrow}")
  60.     private boolean testOnBorrow;
  62.     @Value("${redis.testWhileIdle}")
  63.     private boolean testWhileIdle;
  66.     @Value("${spring.redis.cluster.nodes}")
  67.     private String clusterNodes;
  69.     @Value("${spring.redis.cluster.max-redirects}")
  70.     private Integer mmaxRedirectsac;
  72.     @Value("${redis.sentinel.nodes}")
  73.     private String sentinelHosts;
  76.     @PostConstruct
  77.     public void init(){
  78.         System.out.println(host);
  79.         System.out.println(port);
  80.     }
  81.     /**
  82.      * JedisPoolConfig 连接池
  83.      *
  84.      * @return
  85.      */
  86.     @Bean(name="jedis.pool.config")
  87.     public JedisPoolConfig jedisPoolConfig() {
  88.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  89.         // 最大空闲数
  90.         jedisPoolConfig.setMaxIdle(maxIdle);
  91.         // 连接池的最大数据库连接数
  92.         jedisPoolConfig.setMaxTotal(maxTotal);
  93.         // 最大建立连接等待时间
  94.         jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
  95.         // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
  96.         jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  97.         // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
  98.         jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
  99.         // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  100.         jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  101.         // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
  102.         jedisPoolConfig.setTestOnBorrow(testOnBorrow);
  103.         // 在空闲时检查有效性, 默认false
  104.         jedisPoolConfig.setTestWhileIdle(testWhileIdle);
  105.         return jedisPoolConfig;
  106.     }
  108.     /**
  109.      * redis单机配置
  110.      * @return
  111.      */
  112.     @Bean("redis.standalone.config")
  113.     public RedisStandaloneConfiguration redisStandaloneConfiguration(){
  114.         RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
  115.         config.setDatabase(0);
  116.         config.setHostName(host);
  117.         config.setPort(port);
  118.         config.setPassword(password);
  119.         return config;
  120.     }
  122.     /**
  123.      * 集群redis配置
  124.      * @return
  125.      */
  126.     /*@Bean("redis.cluster.config")
  127.     public RedisClusterConfiguration redisClusterConfiguration(){
  128.         RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
  129.         String[] serverHost=clusterNodes.split(",");
  130.         if (serverHost.length<1){
  131.             throw new RuntimeException("请您设置redis服务器配置信息");
  132.         }
  133.         Set<RedisNode> ipNode = new HashSet<>();
  134.         for (String ipAndPorts : serverHost) {
  135.             String[] ipAndPost=ipAndPorts.split(":");
  136.             ipNode.add(new RedisNode(ipAndPost[0].trim(), Integer.valueOf(ipAndPost[1])));
  137.         }
  138.         redisClusterConfiguration.setClusterNodes(ipNode);
  139.         redisClusterConfiguration.setPassword(password);
  140.         redisClusterConfiguration.setMaxRedirects(mmaxRedirectsac);
  141.         return redisClusterConfiguration;
  142.     }
  143. */
  144.     /*@Bean("redis.sentine.congif")
  145.     public RedisSentinelConfiguration sentinelConfiguration(){
  146.         RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
  147.         //配置matser的名称
  148.         RedisNode redisNode = new RedisNode(host, port);
  149.         redisNode.setName(hostName);
  150.         redisSentinelConfiguration.master(redisNode);
  151.         //配置redis的哨兵sentinel
  152.         String[] senHost=sentinelHosts.split(",");
  153.         if (senHost.length <1) {
  154.             throw new RuntimeException("请您设置redis服务器配置信息");
  155.         }
  156.         Set<RedisNode> redisNodeSet = new HashSet<>();
  157.         for (String s : senHost) {
  158.             String[] ipAndPost=s.split(":");
  159.             redisNodeSet.add(new RedisNode(ipAndPost[0].trim(), Integer.valueOf(ipAndPost[1])));
  160.         }
  161.         redisSentinelConfiguration.setSentinels(redisNodeSet);
  162.         return redisSentinelConfiguration;
  163.     }*/
  166.     /**
  167.      * 单机版 factory
  168.      * @return
  169.      */
  170.     @Bean(name = "jedis.standalone.factory")
  171.     public JedisConnectionFactory JedisStandaloneConnectionFactory(RedisStandaloneConfiguration config) {
  172.         return new JedisConnectionFactory(config);
  173.     }
  175.     /**
  176.      * 集群版  factory
  177.      * @param config
  178.      * @param jedisPoolConfig
  179.      * @return
  180.      */
  181.     /*@Bean(name = "jedis.cluster.factory")
  182.     public JedisConnectionFactory JedisClusterConnectionFactory(RedisClusterConfiguration config,JedisPoolConfig jedisPoolConfig) {
  183.         return new JedisConnectionFactory(config,jedisPoolConfig);
  184.     }*/
  186.     /**
  187.      * 哨兵
  188.      * @param config
  189.      * @param jedisPoolConfig
  190.      * @return
  191.      */
  192.     /*@Bean(name = "jedis.sentine.factory")
  193.     public JedisConnectionFactory JedisSentineConnectionFactory(RedisSentinelConfiguration config,JedisPoolConfig jedisPoolConfig) {
  194.         return new JedisConnectionFactory(config,jedisPoolConfig);
  195.     }*/
  197.     /**
  198.      * 实例化 RedisTemplate 对象
  199.      *  使用单机版 @Qualifier("jedis.standalone.factory");使用集群版 @Qualifier("jedis.cluster.factory")
  200.      * @return
  201.      */
  202.     @Bean(name = "redis.template")
  203.     @Autowired
  204.     public RedisTemplate<String, Object> functionDomainRedisTemplate(@Qualifier("jedis.standalone.factory") JedisConnectionFactory jedisConnectionFactory) {
  205.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  206.         initDomainRedisTemplate(redisTemplate, jedisConnectionFactory);
  207.         return redisTemplate;
  208.     }
  210.     /**
  211.      * 设置数据存入 redis 的序列化方式,并开启事务
  212.      *
  213.      * @param redisTemplate
  214.      * @param factory
  215.      */
  216.     private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, JedisConnectionFactory factory) {
  217.         // 使用 GenericFastJsonRedisSerializer 替换默认序列化
  218.         GenericFastJsonRedisSerializer genericFastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
  219.         // 设置key和value的序列化规则
  220.         redisTemplate.setKeySerializer(new GenericToStringSerializer<>(Object.class));
  221.         redisTemplate.setValueSerializer(genericFastJsonRedisSerializer);
  222.         // 设置hashKey和hashValue的序列化规则
  223.         redisTemplate.setHashKeySerializer(new GenericToStringSerializer<>(Object.class));
  224.         redisTemplate.setHashValueSerializer(genericFastJsonRedisSerializer);
  225.         // 开启事务
  226.         redisTemplate.setEnableTransactionSupport(true);
  227.         redisTemplate.setConnectionFactory(factory);
  228.         //调用后初始化方法，没有它将抛出异常
  229.         redisTemplate.afterPropertiesSet();
  230.     }
  232.     /**
  233.      * 注入封装RedisTemplate
  234.      *
  235.      * @return RedisUtil
  236.      * @throws
  237.      * @Title: redisUtil
  238.      * @autor lpl
  239.      * @date 2017年12月21日
  240.      */
  241.     @Bean(name = "redisUtil")
  242.     public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
  243.         RedisUtil redisUtil = new RedisUtil();
  244.         redisUtil.setRedisTemplate(redisTemplate);
  245.         return redisUtil;
  246.     }
  247. }

注意：这里将单机版、集群以及哨兵的配置写在了一起。如果使用单机版则注释掉集群和哨兵的config以及factory。具体操作如上述代码。@Qualifier(“jedis.standalone.factory”)这里更改对应的factory bean对象名称即可。

👉RedisUtil

RedisUtil封装了一些常用的对redis的操作，具体代码如下所示:

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

👀 使用

  1. public class RedisApplicationTests extends BaseJunit {
  2.     @Autowired
  3.     @Qualifier("redisUtil")
  4.     private RedisUtil redisUtil;
  6.     @Test
  7.     public void contextLoads() {
  8.         boolean c = redisUtil.set("c", "1212", 10);
  9.         System.out.println(redisUtil.expire("c", 50));
  11.         System.out.println(redisUtil.getExpire("c"));
  13.     }
  15.     @Test
  16.     public void isOk(){
  17.         /**
  18.          * 业务需求中经常有需要用到计数器的场景：譬如一个手机号一天限制发送5条短信、一个接口一分钟限制多少请求、一个接口一天限制调用多少次等等。使用Redis的Incr自增命令可以轻松实现以上需求。
  19.          */
  20.         String userId = "c";
  22.     }
  24.     /**
  25.      * 是否拒绝服务
  26.      * @return
  27.      */
  28.     private boolean denialOfService(String userId){
  29.         long count = redisUtil.incr(userId);
  30.         if(count<=10){
  31.             return false;
  32.         }
  33.         return true;
  34.     }

注意:BaseJunit是自己封装的一个类。具体代码如下:

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest(classes = RedisApplication.class)
  3. public class BaseJunit {
  4. }

**