devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

spring boot中集成jedis操作redis_spring.redis.pool.testonborrow

作者：很楠不爱3 | 2024-02-28 16:11:26

赞

踩

spring.redis.pool.testonborrow

1:添加maven依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-redis</artifactId>
  4.     <version>1.4.7.RELEASE</version>
  5. </dependency>

2：在application.yml中配置redis的连接参数

  1. spring:
  2.     redis:
  3.           database: 0
  4.           hostName: 127.0.0.1
  5.           port: 6379
  6.           timeout: 0
  7.           password:
  8.           pool:
  9.             maxTotal: 200
  10.             maxWaitMillis: 10000
  11.             maxIdle: 50
  12.             minIdle: 10
  13.             testOnBorrow: true

3：创建redis的配置类RedisConfig.java 

  1.  
  2. @Configuration
  3. @EnableCaching
  4. public class RedisConfig extends CachingConfigurerSupport {
  5.  
  6. 		@Value("${spring.redis.database}")
  7. 	    private int database;
  8.  
  9. 		@Value("${spring.redis.hostName}")
  10. 	    private String hostName;
  11.  
  12. 	    @Value("${spring.redis.port}")
  13. 	    private int port;
  14.  
  15. 	    @Value("${spring.redis.password}")
  16. 	    private String password;
  17.  
  18. 	    @Value("${spring.redis.timeout}")
  19. 	    private int timeout;
  20.  
  21. 	    @Value("${spring.redis.pool.maxIdle}")
  22. 	    private int maxIdle;
  23.  
  24. 	    @Value("${spring.redis.pool.minIdle}")
  25. 	    private int minIdle;
  26.  
  27.  
  28. 	    @Value("${spring.redis.pool.maxTotal}")
  29. 	    private int maxTotal;
  30.  
  31. 	    @Value("${spring.redis.pool.maxWaitMillis}")
  32. 	    private long maxWaitMillis;
  33.  
  34. 	    @Value("${spring.redis.pool.testOnBorrow}")
  35. 	    private boolean testOnBorrow;
  36.  
  37. 	    public JedisPoolConfig poolCofig(int maxIdle, int maxTotal,
  38.                                          long maxWaitMillis, boolean testOnBorrow) {
  39. 	        JedisPoolConfig poolCofig = new JedisPoolConfig();
  40. 	        poolCofig.setMaxIdle(maxIdle);
  41. 	        poolCofig.setMaxIdle(minIdle);
  42. 	        poolCofig.setMaxTotal(maxTotal);
  43. 	        poolCofig.setMaxWaitMillis(maxWaitMillis);
  44. 	        poolCofig.setTestOnBorrow(testOnBorrow);
  45. 	        return poolCofig;
  46. 	    }
  47.  
  48. 	   @Bean
  49. 	   public JedisConnectionFactory redisConnectionFactory() {
  50. 	       JedisConnectionFactory factory = new JedisConnectionFactory();
  51. 	       factory.setDatabase(database);
  52. 	       factory.setHostName(hostName);
  53. 	       factory.setPort(port);
  54. 	       factory.setPassword(password);
  55. 	       factory.setTimeout(timeout);
  56.  
  57. 	       factory.setPoolConfig(poolCofig(maxIdle, maxTotal, maxWaitMillis,  testOnBorrow));
  58. 	    		           // 初始化连接pool
  59. 	       factory.afterPropertiesSet();
  60.  
  61. 	       return factory;
  62. 	   }
  63.  
  64. 		@Bean
  65. 	    @Override
  66. 	    public KeyGenerator keyGenerator() {
  67. 	        return (target, method, objects) -> {
  68. 	            StringBuilder sb = new StringBuilder();
  69. 	            sb.append(target.getClass().getName());
  70. 	            sb.append("::" + method.getName() + ":");
  71. 	            for (Object obj : objects) {
  72. 	                sb.append(obj.toString());
  73. 	            }
  74. 	            return sb.toString();
  75. 	        };
  76. 	    }
  77.  
  78. //	    @Bean
  79. //	    public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
  80. //	        return new RedisCacheManager(redisTemplate);
  81. //	    }
  82.  
  83. 	    @Bean
  84. 	    public RedisTemplate<String, String> redisTemplate(
  85. 	            RedisConnectionFactory factory) {
  86. 	        StringRedisTemplate template = new StringRedisTemplate(factory);
  87. 	        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  88. 	        ObjectMapper om = new ObjectMapper();
  89. 	        //om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  90. 	        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  91. 	        jackson2JsonRedisSerializer.setObjectMapper(om);
  92. 	        template.setValueSerializer(jackson2JsonRedisSerializer);
  93. 	        template.afterPropertiesSet();
  94. 	        return template;
  95. 	    }
  96.  
  97. 	    @Bean
  98. 	    public JedisPool getJedisPool(){
  99. 	    	JedisPoolConfig config = new JedisPoolConfig();
  100. 	        config.setMaxTotal(maxTotal);
  101. 	        config.setMaxIdle(maxIdle);
  102. 	        config.setMinIdle(minIdle);
  103. 	        config.setTestOnBorrow(testOnBorrow);
  104. 	        config.setTestOnReturn(false);
  105. 	        config.setBlockWhenExhausted(true);
  106. 	        config.setMaxWaitMillis(maxWaitMillis);
  107. 	        JedisPool pool = new JedisPool(config,hostName,port,timeout,password);
  108. 	        return pool;
  109. 	    }
  110. }

4：创建redis操作服务类RedisService.java

  1. @Component
  2. public class RedisService {
  3.  
  4.     @Autowired
  5.     private RedisTemplate redisTemplate;
  6.  
  7.     @Autowired
  8.     private JedisPool jedisPool;
  9.  
  10.  
  11.     public Jedis getResource() {
  12.         return jedisPool.getResource();
  13.     }
  14.  
  15.     public void returnResource(Jedis jedis) {
  16.         if (jedis != null) {
  17.             jedisPool.returnResourceObject(jedis);
  18.         }
  19.     }
  20.  
  21.     //=============================common============================
  22.  
  23.     /**
  24.      * 指定缓存失效时间
  25.      *
  26.      * @param key  键
  27.      * @param time 时间(秒)
  28.      * @return
  29.      */
  30.     public boolean expire(String key, long time) {
  31.         try {
  32.             if (time > 0) {
  33.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  34.             }
  35.             return true;
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.             return false;
  39.         }
  40.     }
  41.  
  42.     /**
  43.      * 根据key 获取过期时间
  44.      *
  45.      * @param key 键 不能为null
  46.      * @return 时间(秒) 返回0代表为永久有效
  47.      */
  48.     public long getExpire(String key) {
  49.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  50.     }
  51.  
  52.     /**
  53.      * 判断key是否存在
  54.      *
  55.      * @param key 键
  56.      * @return true 存在 false不存在
  57.      */
  58.     public boolean hasKey(String key) {
  59.         try {
  60.             return redisTemplate.hasKey(key);
  61.         } catch (Exception e) {
  62.             e.printStackTrace();
  63.             return false;
  64.         }
  65.     }
  66.  
  67.     /**
  68.      * 删除缓存
  69.      *
  70.      * @param key 可以传一个值 或多个
  71.      */
  72.     @SuppressWarnings("unchecked")
  73.     public void del(String... key) {
  74.         if (key != null && key.length > 0) {
  75.             if (key.length == 1) {
  76.                 redisTemplate.delete(key[0]);
  77.             } else {
  78.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  79.             }
  80.         }
  81.     }
  82.  
  83.     //============================String=============================
  84.  
  85.     /**
  86.      * 普通缓存获取
  87.      *
  88.      * @param key 键
  89.      * @return 值
  90.      */
  91.     public Object get(String key) {
  92.         return key == null ? null : redisTemplate.opsForValue().get(key);
  93.     }
  94.  
  95.     /**
  96.      * 普通缓存放入
  97.      *
  98.      * @param key   键
  99.      * @param value 值
  100.      * @return true成功 false失败
  101.      */
  102.     public boolean set(String key, Object value) {
  103.         try {
  104.             redisTemplate.opsForValue().set(key, value);
  105.             return true;
  106.         } catch (Exception e) {
  107.             e.printStackTrace();
  108.             return false;
  109.         }
  110.     }
  111.  
  112.     /**
  113.      * 普通缓存放入并设置时间
  114.      *
  115.      * @param key   键
  116.      * @param value 值
  117.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  118.      * @return true成功 false 失败
  119.      */
  120.     public boolean set(String key, Object value, long time) {
  121.         try {
  122.             if (time > 0) {
  123.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  124.             } else {
  125.                 set(key, value);
  126.             }
  127.             return true;
  128.         } catch (Exception e) {
  129.             e.printStackTrace();
  130.             return false;
  131.         }
  132.     }
  133.  
  134.     /**
  135.      * 递增
  136.      *
  137.      * @param key   键
  138.      * @param delta 要增加几(大于0)
  139.      * @return
  140.      */
  141.     public long incr(String key, long delta) {
  142.         if (delta < 0) {
  143.             throw new RuntimeException("递增因子必须大于0");
  144.         }
  145.         return redisTemplate.opsForValue().increment(key, delta);
  146.     }
  147.  
  148.     /**
  149.      * 递减
  150.      *
  151.      * @param key   键
  152.      * @param delta 要减少几(小于0)
  153.      * @return
  154.      */
  155.     public long decr(String key, long delta) {
  156.         if (delta < 0) {
  157.             throw new RuntimeException("递减因子必须大于0");
  158.         }
  159.         return redisTemplate.opsForValue().increment(key, -delta);
  160.     }
  161.  
  162.     //================================Map=================================
  163.  
  164.     /**
  165.      * HashGet
  166.      *
  167.      * @param key  键 不能为null
  168.      * @param item 项 不能为null
  169.      * @return 值
  170.      */
  171.     public Object hget(String key, String item) {
  172.         return redisTemplate.opsForHash().get(key, item);
  173.     }
  174.  
  175.     /**
  176.      * 获取hashKey对应的所有键值
  177.      *
  178.      * @param key 键
  179.      * @return 对应的多个键值
  180.      */
  181.     public Map<Object, Object> hmget(String key) {
  182.         return redisTemplate.opsForHash().entries(key);
  183.     }
  184.  
  185.     /**
  186.      * HashSet
  187.      *
  188.      * @param key 键
  189.      * @param map 对应多个键值
  190.      * @return true 成功 false 失败
  191.      */
  192.     public boolean hmset(String key, Map<String, Object> map) {
  193.         try {
  194.             redisTemplate.opsForHash().putAll(key, map);
  195.             return true;
  196.         } catch (Exception e) {
  197.             e.printStackTrace();
  198.             return false;
  199.         }
  200.     }
  201.  
  202.     /**
  203.      * HashSet 并设置时间
  204.      *
  205.      * @param key  键
  206.      * @param map  对应多个键值
  207.      * @param time 时间(秒)
  208.      * @return true成功 false失败
  209.      */
  210.     public boolean hmset(String key, Map<String, Object> map, long time) {
  211.         try {
  212.             redisTemplate.opsForHash().putAll(key, map);
  213.             if (time > 0) {
  214.                 expire(key, time);
  215.             }
  216.             return true;
  217.         } catch (Exception e) {
  218.             e.printStackTrace();
  219.             return false;
  220.         }
  221.     }
  222.  
  223.     /**
  224.      * 向一张hash表中放入数据,如果不存在将创建
  225.      *
  226.      * @param key   键
  227.      * @param item  项
  228.      * @param value 值
  229.      * @return true 成功 false失败
  230.      */
  231.     public boolean hset(String key, String item, Object value) {
  232.         try {
  233.             redisTemplate.opsForHash().put(key, item, value);
  234.             return true;
  235.         } catch (Exception e) {
  236.             e.printStackTrace();
  237.             return false;
  238.         }
  239.     }
  240.  
  241.     /**
  242.      * 向一张hash表中放入数据,如果不存在将创建
  243.      *
  244.      * @param key   键
  245.      * @param item  项
  246.      * @param value 值
  247.      * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  248.      * @return true 成功 false失败
  249.      */
  250.     public boolean hset(String key, String item, Object value, long time) {
  251.         try {
  252.             redisTemplate.opsForHash().put(key, item, value);
  253.             if (time > 0) {
  254.                 expire(key, time);
  255.             }
  256.             return true;
  257.         } catch (Exception e) {
  258.             e.printStackTrace();
  259.             return false;
  260.         }
  261.     }
  262.  
  263.     /**
  264.      * 删除hash表中的值
  265.      *
  266.      * @param key  键 不能为null
  267.      * @param item 项 可以使多个 不能为null
  268.      */
  269.     public void hdel(String key, Object... item) {
  270.         redisTemplate.opsForHash().delete(key, item);
  271.     }
  272.  
  273.     /**
  274.      * 判断hash表中是否有该项的值
  275.      *
  276.      * @param key  键 不能为null
  277.      * @param item 项 不能为null
  278.      * @return true 存在 false不存在
  279.      */
  280.     public boolean hHasKey(String key, String item) {
  281.         return redisTemplate.opsForHash().hasKey(key, item);
  282.     }
  283.  
  284.     /**
  285.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  286.      *
  287.      * @param key  键
  288.      * @param item 项
  289.      * @param by   要增加几(大于0)
  290.      * @return
  291.      */
  292.     public double hincr(String key, String item, double by) {
  293.         return redisTemplate.opsForHash().increment(key, item, by);
  294.     }
  295.  
  296.     /**
  297.      * hash递减
  298.      *
  299.      * @param key  键
  300.      * @param item 项
  301.      * @param by   要减少记(小于0)
  302.      * @return
  303.      */
  304.     public double hdecr(String key, String item, double by) {
  305.         return redisTemplate.opsForHash().increment(key, item, -by);
  306.     }
  307.  
  308.     //============================set=============================
  309.  
  310.     /**
  311.      * 根据key获取Set中的所有值
  312.      *
  313.      * @param key 键
  314.      * @return
  315.      */
  316.     public Set<Object> sGet(String key) {
  317.         try {
  318.             return redisTemplate.opsForSet().members(key);
  319.         } catch (Exception e) {
  320.             e.printStackTrace();
  321.             return null;
  322.         }
  323.     }
  324.  
  325.     /**
  326.      * 根据value从一个set中查询,是否存在
  327.      *
  328.      * @param key   键
  329.      * @param value 值
  330.      * @return true 存在 false不存在
  331.      */
  332.     public boolean sHasKey(String key, Object value) {
  333.         try {
  334.             return redisTemplate.opsForSet().isMember(key, value);
  335.         } catch (Exception e) {
  336.             e.printStackTrace();
  337.             return false;
  338.         }
  339.     }
  340.  
  341.     /**
  342.      * 将数据放入set缓存
  343.      *
  344.      * @param key    键
  345.      * @param values 值 可以是多个
  346.      * @return 成功个数
  347.      */
  348.     public long sSet(String key, Object... values) {
  349.         try {
  350.             return redisTemplate.opsForSet().add(key, values);
  351.         } catch (Exception e) {
  352.             e.printStackTrace();
  353.             return 0;
  354.         }
  355.     }
  356.  
  357.     /**
  358.      * 将set数据放入缓存
  359.      *
  360.      * @param key    键
  361.      * @param time   时间(秒)
  362.      * @param values 值 可以是多个
  363.      * @return 成功个数
  364.      */
  365.     public long sSetAndTime(String key, long time, Object... values) {
  366.         try {
  367.             Long count = redisTemplate.opsForSet().add(key, values);
  368.             if (time > 0) expire(key, time);
  369.             return count;
  370.         } catch (Exception e) {
  371.             e.printStackTrace();
  372.             return 0;
  373.         }
  374.     }
  375.  
  376.     /**
  377.      * 获取set缓存的长度
  378.      *
  379.      * @param key 键
  380.      * @return
  381.      */
  382.     public long sGetSetSize(String key) {
  383.         try {
  384.             return redisTemplate.opsForSet().size(key);
  385.         } catch (Exception e) {
  386.             e.printStackTrace();
  387.             return 0;
  388.         }
  389.     }
  390.  
  391.     /**
  392.      * 移除值为value的
  393.      *
  394.      * @param key    键
  395.      * @param values 值 可以是多个
  396.      * @return 移除的个数
  397.      */
  398.     public long setRemove(String key, Object... values) {
  399.         try {
  400.             Long count = redisTemplate.opsForSet().remove(key, values);
  401.             return count;
  402.         } catch (Exception e) {
  403.             e.printStackTrace();
  404.             return 0;
  405.         }
  406.     }
  407.     //===============================list=================================
  408.  
  409.     /**
  410.      * 获取list缓存的内容
  411.      *
  412.      * @param key   键
  413.      * @param start 开始
  414.      * @param end   结束  0 到 -1代表所有值
  415.      * @return
  416.      */
  417.     public List<Object> lGet(String key, long start, long end) {
  418.         try {
  419.             return redisTemplate.opsForList().range(key, start, end);
  420.         } catch (Exception e) {
  421.             e.printStackTrace();
  422.             return null;
  423.         }
  424.     }
  425.  
  426.     /**
  427.      * 获取list缓存的长度
  428.      *
  429.      * @param key 键
  430.      * @return
  431.      */
  432.     public long lGetListSize(String key) {
  433.         try {
  434.             return redisTemplate.opsForList().size(key);
  435.         } catch (Exception e) {
  436.             e.printStackTrace();
  437.             return 0;
  438.         }
  439.     }
  440.  
  441.     /**
  442.      * 通过索引 获取list中的值
  443.      *
  444.      * @param key   键
  445.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  446.      * @return
  447.      */
  448.     public Object lGetIndex(String key, long index) {
  449.         try {
  450.             return redisTemplate.opsForList().index(key, index);
  451.         } catch (Exception e) {
  452.             e.printStackTrace();
  453.             return null;
  454.         }
  455.     }
  456.  
  457.     /**
  458.      * 将list放入缓存
  459.      *
  460.      * @param key   键
  461.      * @param value 值
  462.      * @return
  463.      */
  464.     public boolean lSet(String key, Object value) {
  465.         try {
  466.             redisTemplate.opsForList().rightPush(key, value);
  467.             return true;
  468.         } catch (Exception e) {
  469.             e.printStackTrace();
  470.             return false;
  471.         }
  472.     }
  473.  
  474.     /**
  475.      * 将list放入缓存
  476.      *
  477.      * @param key   键
  478.      * @param value 值
  479.      * @param time  时间(秒)
  480.      * @return
  481.      */
  482.     public boolean lSet(String key, Object value, long time) {
  483.         try {
  484.             redisTemplate.opsForList().rightPush(key, value);
  485.             if (time > 0) expire(key, time);
  486.             return true;
  487.         } catch (Exception e) {
  488.             e.printStackTrace();
  489.             return false;
  490.         }
  491.     }
  492.  
  493.     /**
  494.      * 将list放入缓存
  495.      *
  496.      * @param key   键
  497.      * @param value 值
  498.      * @return
  499.      */
  500.     public boolean lSet(String key, List<Object> value) {
  501.         try {
  502.             redisTemplate.opsForList().rightPushAll(key, value);
  503.             return true;
  504.         } catch (Exception e) {
  505.             e.printStackTrace();
  506.             return false;
  507.         }
  508.     }
  509.  
  510.     /**
  511.      * 将list放入缓存
  512.      *
  513.      * @param key   键
  514.      * @param value 值
  515.      * @param time  时间(秒)
  516.      * @return
  517.      */
  518.     public boolean lSet(String key, List<Object> value, long time) {
  519.         try {
  520.             redisTemplate.opsForList().rightPushAll(key, value);
  521.             if (time > 0) expire(key, time);
  522.             return true;
  523.         } catch (Exception e) {
  524.             e.printStackTrace();
  525.             return false;
  526.         }
  527.     }
  528.  
  529.     /**
  530.      * 根据索引修改list中的某条数据
  531.      *
  532.      * @param key   键
  533.      * @param index 索引
  534.      * @param value 值
  535.      * @return
  536.      */
  537.     public boolean lUpdateIndex(String key, long index, Object value) {
  538.         try {
  539.             redisTemplate.opsForList().set(key, index, value);
  540.             return true;
  541.         } catch (Exception e) {
  542.             e.printStackTrace();
  543.             return false;
  544.         }
  545.     }
  546.  
  547.     /**
  548.      * 移除N个值为value
  549.      *
  550.      * @param key   键
  551.      * @param count 移除多少个
  552.      * @param value 值
  553.      * @return 移除的个数
  554.      */
  555.     public long lRemove(String key, long count, Object value) {
  556.         try {
  557.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  558.             return remove;
  559.         } catch (Exception e) {
  560.             e.printStackTrace();
  561.             return 0;
  562.         }
  563.     }
  564.  
  565.     //======================================
  566.  
  567.     /**
  568.      * 批量删除对应的value
  569.      *
  570.      * @param keys
  571.      */
  572.     public void remove(final String... keys) {
  573.         for (String key : keys) {
  574.             remove(key);
  575.         }
  576.     }
  577.  
  578.     /**
  579.      * 批量删除key
  580.      *
  581.      * @param pattern
  582.      */
  583.     public void removePattern(final String pattern) {
  584.         Set<Serializable> keys = redisTemplate.keys(pattern);
  585.         if (keys.size() > 0)
  586.             redisTemplate.delete(keys);
  587.     }
  588.  
  589.     /**
  590.      * 删除对应的value
  591.      *
  592.      * @param key
  593.      */
  594.     public void remove(final String key) {
  595.         if (exists(key)) {
  596.             redisTemplate.delete(key);
  597.         }
  598.     }
  599.  
  600.     /**
  601.      * 判断缓存中是否有对应的value
  602.      *
  603.      * @param key
  604.      * @return
  605.      */
  606.     public boolean exists(final String key) {
  607.         return redisTemplate.hasKey(key);
  608.     }
  609.  
  610. //	/**
  611. //	 * 读取缓存
  612. //	 *
  613. //	 * @param key
  614. //	 * @return
  615. //	 */
  616. //	public Object get(final String key) {
  617. //		Object result = null;
  618. //		ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  619. //		result = operations.get(key);
  620. //		return result;
  621. //	}
  622.  
  623. //	/**
  624. //	 * 写入缓存
  625. //	 *
  626. //	 * @param key
  627. //	 * @param value
  628. //	 * @return
  629. //	 */
  630. //	public boolean set(final String key, Object value) {
  631. //		boolean result = false;
  632. //		try {
  633. //			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  634. //			operations.set(key, value);
  635. //			result = true;
  636. //		} catch (Exception e) {
  637. //			e.printStackTrace();
  638. //		}
  639. //		return result;
  640. //	}
  641.  
  642. //	/**
  643. //	 * 写入缓存
  644. //	 *
  645. //	 * @param key
  646. //	 * @param value
  647. //	 * @return
  648. //	 */
  649. //	public boolean set(final String key, Object value, Long expireTime) {
  650. //		boolean result = false;
  651. //		try {
  652. //			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  653. //			operations.set(key, value);
  654. //			redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
  655. //			result = true;
  656. //		} catch (Exception e) {
  657. //			e.printStackTrace();
  658. //		}
  659. //		return result;
  660. //	}
  661.  
  662.     /**
  663.      * 删除单个key
  664.      *
  665.      * @param key
  666.      */
  667.     public void removeMemberSet(String key) {
  668.         redisTemplate.opsForSet().getOperations().delete(key);
  669.     }
  670.  
  671.     /**
  672.      * 判断制定集合value是否存在
  673.      *
  674.      * @param key
  675.      * @return
  676.      */
  677.     public boolean isMemberSet(String key, String value) {
  678.         return redisTemplate.opsForSet().isMember(key, value);
  679.     }
  680.  
  681.     /**
  682.      * 向指定无序集合Set里添加value
  683.      *
  684.      * @param key
  685.      */
  686.     public void addMemberSet(String key, String value) {
  687.         redisTemplate.opsForSet().add(key, value);
  688.     }
  689.  
  690.     /**
  691.      * 删除指定key获得集合里的值
  692.      *
  693.      * @param key
  694.      * @param value
  695.      * @return
  696.      */
  697.     public boolean removeMemberSetValue(String key, String value) {
  698.  
  699.         return redisTemplate.opsForSet().remove(key, value) == 1;
  700.  
  701.     }
  702.  
  703.     public Set<? extends Object> getMeberSetMeber(String key) {
  704.         return redisTemplate.opsForSet().members(key);
  705.     }
  706.  
  707.  
  708.     //分布式锁工具类  start
  709.  
  710.  
  711.     /**
  712.      * 获取key的VALUE
  713.      *
  714.      * @param key
  715.      * @return
  716.      */
  717.     @SuppressWarnings("finally")
  718.     public String getByKey(String key) {
  719.         Jedis jedis = null;
  720.         String result = null;
  721.         try {
  722.             jedis = getResource();
  723.             result = jedis.get(key);
  724.         } catch (Exception e) {
  725.             e.printStackTrace();
  726.         } finally {
  727.             if (jedis != null) {
  728.                 returnResource(jedis);
  729.             }
  730.             return result;
  731.         }
  732.     }
  733.  
  734.     /**
  735.      * 不存在新增 成功返回1 ，不成功返回0
  736.      *
  737.      * @param key
  738.      * @param value
  739.      * @return
  740.      */
  741.     @SuppressWarnings("finally")
  742.     public Long setnxByKey(String key, String value) {
  743.         Jedis jedis = null;
  744.         Long result = null;
  745.         try {
  746.             jedis = getResource();
  747.             result = jedis.setnx(key, value);
  748.         } catch (Exception e) {
  749.             e.printStackTrace();
  750.         } finally {
  751.             if (jedis != null) {
  752.                 returnResource(jedis);
  753.             }
  754.             return result;
  755.         }
  756.     }
  757.  
  758.     /**
  759.      * 获取老版本的旧值
  760.      *
  761.      * @param key
  762.      * @param value
  763.      * @return
  764.      */
  765.     @SuppressWarnings("finally")
  766.     public String getSetByKey(String key, String value) {
  767.         Jedis jedis = null;
  768.         String result = null;
  769.         try {
  770.             jedis = getResource();
  771.             result = jedis.getSet(key, value);
  772.         } catch (Exception e) {
  773.             e.printStackTrace();
  774.         } finally {
  775.             if (jedis != null) {
  776.                 returnResource(jedis);
  777.             }
  778.             return result;
  779.         }
  780.     }
  781.  
  782.     /**
  783.      * 制定KEY过期
  784.      *
  785.      * @param key
  786.      * @param seconds
  787.      * @return
  788.      */
  789.     @SuppressWarnings("finally")
  790.     public Long expireByKey(String key, int seconds) {
  791.         Jedis jedis = null;
  792.         Long result = null;
  793.         try {
  794.             jedis = getResource();
  795.             result = jedis.expire(key, seconds);
  796.         } catch (Exception e) {
  797.             e.printStackTrace();
  798.         } finally {
  799.             if (jedis != null) {
  800.                 returnResource(jedis);
  801.             }
  802.             return result;
  803.         }
  804.     }
  805.  
  806.     /**
  807.      * 删除制定KEY的VALUE
  808.      *
  809.      * @param key
  810.      * @return
  811.      */
  812.     @SuppressWarnings("finally")
  813.     public Long delByKey(String key) {
  814.         Jedis jedis = null;
  815.         Long result = null;
  816.         try {
  817.             jedis = getResource();
  818.             result = jedis.del(key);
  819.         } catch (Exception e) {
  820.             e.printStackTrace();
  821.         } finally {
  822.             if (jedis != null) {
  823.                 returnResource(jedis);
  824.             }
  825.             return result;
  826.         }
  827.     }
  828.  
  829.     /**
  830.      * 获取分布式锁
  831.      *
  832.      * @param lockName
  833.      * @return
  834.      */
  835.     public boolean lock(String lockName) {//lockName可以为共享变量名，也可以为方法名，主要是用于模拟锁信息
  836.         System.out.println(Thread.currentThread() + "开始尝试加锁！");
  837.         Long result = setnxByKey(lockName, String.valueOf(System.currentTimeMillis() + 10000));
  838.         if (result != null && result.intValue() == 1) {
  839.             System.out.println(Thread.currentThread() + "加锁成功！");
  840.             expireByKey(lockName, 10);
  841.             System.out.println(Thread.currentThread() + "获得锁可以开始执行业务逻辑！");
  842. //	            delByKey(lockName);  //在业务代码里执行
  843.             return true;
  844.         } else {
  845.             String lockValueA = getByKey(lockName);
  846.             if (lockValueA != null && Long.parseLong(lockValueA) >= System.currentTimeMillis()) {
  847.                 String lockValueB = getSetByKey(lockName, String.valueOf(System.currentTimeMillis() + 10000));
  848.                 if (lockValueB == null || lockValueB.equals(lockValueA)) {
  849.                     System.out.println(Thread.currentThread() + "加锁成功！");
  850.                     expireByKey(lockName, 10);
  851.                     System.out.println(Thread.currentThread() + "获得锁可以开始执行业务逻辑！");
  852. //	                    delByKey(lockName);  //在业务代码里执行
  853.                     return true;
  854.                 } else {
  855.                     return false;
  856.                 }
  857.             } else {
  858.                 return false;
  859.             }
  860.         }
  861.     }
  862. //分布式锁工具类  end
  863. }

5:写测试类来测试

  1. @RunWith(SpringRunner.class)
  2.  
  3. @SpringBootTest
  4.  
  5. public class NanawalletServerApplicationTests {
  6.  
  7.     @Autowired
  8.     private RedisService redisService;
  9.     @Test
  10.     public void contextLoads() {
  11.     }
  12.     @Test
  13.     public void testInsertRedis(){
  14.         this.redisService.set("test_redis","123456");
  15.         System.out.println( this.redisService.get("test_redis"));
  16.     }
  17. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/160053
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号