Redis客户端之Spring整合Jedis

Posted 2020-06-28

1.下载相关jar包，并引入工程：

jedis-2.4.2.jar

commons-pool2-2.0.jar

2.将以下XML配置引入spring

1. <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">  
2.        <constructor-arg index="0" ref="jedisPoolConfig"/>  
3.        <constructor-arg index="1">  
4.            <list>  
5.                 <bean name="slaver" class="redis.clients.jedis.JedisShardInfo">  
6.                    <constructor-arg index="0" value="${redis.slaver.host}"/>  
7.                    <constructor-arg index="1" value="${redis.slaver.port}" type="int"/>  
8.                </bean>  
9.                 <bean name="master" class="redis.clients.jedis.JedisShardInfo">  
10.                    <constructor-arg index="0" value="${redis.master.host}"/>  
11.                    <constructor-arg index="1" value="${redis.master.port}" type="int"/>  
12.                </bean>  
13.            </list>  
14.        </constructor-arg>  
15.    </bean>  
16.   
17.    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
18.        <property name="maxTotal" value="2048" />  
19.        <property name="maxIdle" value="200" />  
20.        <property name="numTestsPerEvictionRun" value="1024"/>  
21.        <property name="timeBetweenEvictionRunsMillis" value="30000" />  
22.        <property name="minEvictableIdleTimeMillis" value="-1" />  
23.        <property name="softMinEvictableIdleTimeMillis" value="10000" />  
24.        <property name="maxWaitMillis" value="1500"/>  
25.        <property name="testOnBorrow" value="true" />  
26.        <property name="testWhileIdle" value="true"/>  
27.        <property name="testOnReturn" value="false"/>  
28.        <property name="jmxEnabled" value="true"/>  
29.        <property name="jmxNamePrefix" value="youyuan"/>  
30.        <property name="blockWhenExhausted" value="false"/>  
31.    </bean>  

3.将shardedJedisPool注入相关的类中即可使用

 

 

 

 

1. @Resource  
2.     private ShardedJedisPool shardedJedisPool;  
3.   
4.   
5.     /** 
6.      * 设置一个key的过期时间（单位：秒） 
7.      * @param key key值 
8.      * @param seconds 多少秒后过期 
9.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
10.      */  
11.     public long expire(String key, int seconds) {  
12.         if (key==null || key.equals("")) {  
13.             return 0;  
14.         }  
15.   
16.         ShardedJedis shardedJedis = null;  
17.         try {  
18.             shardedJedis = shardedJedisPool.getResource();  
19.             return shardedJedis.expire(key, seconds);  
20.         } catch (Exception ex) {  
21.             logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);  
22.             returnBrokenResource(shardedJedis);  
23.         } finally {  
24.             returnResource(shardedJedis);  
25.         }  
26.         return 0;  
27.     }  
28.   
29.     /** 
30.      * 设置一个key在某个时间点过期 
31.      * @param key key值 
32.      * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数 
33.      * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
34.      */  
35.     public long expireAt(String key, int unixTimestamp) {  
36.         if (key==null || key.equals("")) {  
37.             return 0;  
38.         }  
39.   
40.         ShardedJedis shardedJedis = null;  
41.         try {  
42.             shardedJedis = shardedJedisPool.getResource();  
43.             return shardedJedis.expireAt(key, unixTimestamp);  
44.         } catch (Exception ex) {  
45.             logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);  
46.             returnBrokenResource(shardedJedis);  
47.         } finally {  
48.             returnResource(shardedJedis);  
49.         }  
50.         return 0;  
51.     }  
52.   
53.     /** 
54.      * 截断一个List 
55.      * @param key 列表key 
56.      * @param start 开始位置 从0开始 
57.      * @param end 结束位置 
58.      * @return 状态码 
59.      */  
60.     public String trimList(String key, long start, long end) {  
61.         if (key == null || key.equals("")) {  
62.             return "-";  
63.         }  
64.         ShardedJedis shardedJedis = null;  
65.         try {  
66.             shardedJedis = shardedJedisPool.getResource();  
67.             return shardedJedis.ltrim(key, start, end);  
68.         } catch (Exception ex) {  
69.             logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
70.             returnBrokenResource(shardedJedis);  
71.         } finally {  
72.             returnResource(shardedJedis);  
73.         }  
74.         return "-";  
75.     }  
76.     /** 
77.      * 检查Set长度 
78.      * @param key 
79.      * @return 
80.      */  
81.     public long countSet(String key){  
82.         if(key == null ){  
83.             return 0;  
84.         }  
85.         ShardedJedis shardedJedis = null;  
86.         try {  
87.             shardedJedis = shardedJedisPool.getResource();  
88.             return shardedJedis.scard(key);  
89.         } catch (Exception ex) {  
90.             logger.error("countSet error.", ex);  
91.             returnBrokenResource(shardedJedis);  
92.         } finally {  
93.             returnResource(shardedJedis);  
94.         }  
95.         return 0;  
96.     }  
97.     /** 
98.      * 添加到Set中（同时设置过期时间） 
99.      * @param key key值 
100.      * @param seconds 过期时间 单位s 
101.      * @param value 
102.      * @return 
103.      */  
104.     public boolean addSet(String key,int seconds, String... value) {  
105.         boolean result = addSet(key, value);  
106.         if(result){  
107.             long i = expire(key, seconds);  
108.             return i==1;  
109.         }  
110.         return false;  
111.     }  
112.     /** 
113.      * 添加到Set中 
114.      * @param key 
115.      * @param value 
116.      * @return 
117.      */  
118.     public boolean addSet(String key, String... value) {  
119.         if(key == null || value == null){  
120.             return false;  
121.         }  
122.         ShardedJedis shardedJedis = null;  
123.         try {  
124.             shardedJedis = shardedJedisPool.getResource();  
125.             shardedJedis.sadd(key, value);  
126.             return true;  
127.         } catch (Exception ex) {  
128.             logger.error("setList error.", ex);  
129.             returnBrokenResource(shardedJedis);  
130.         } finally {  
131.             returnResource(shardedJedis);  
132.         }  
133.         return false;  
134.     }  
135.   
136.       
137.     /** 
138.      * @param key 
139.      * @param value 
140.      * @return 判断值是否包含在set中 
141.      */  
142.     public boolean containsInSet(String key, String value) {  
143.         if(key == null || value == null){  
144.             return false;  
145.         }  
146.         ShardedJedis shardedJedis = null;  
147.         try {  
148.             shardedJedis = shardedJedisPool.getResource();  
149.             return shardedJedis.sismember(key, value);  
150.         } catch (Exception ex) {  
151.             logger.error("setList error.", ex);  
152.             returnBrokenResource(shardedJedis);  
153.         } finally {  
154.             returnResource(shardedJedis);  
155.         }  
156.         return false;  
157.     }  
158.     /** 
159.      * 获取Set 
160.      * @param key 
161.      * @return 
162.      */  
163.     public  Set<String> getSet(String key){  
164.         ShardedJedis shardedJedis = null;  
165.         try {  
166.             shardedJedis = shardedJedisPool.getResource();  
167.             return shardedJedis.smembers(key);  
168.         } catch (Exception ex) {  
169.             logger.error("getList error.", ex);  
170.             returnBrokenResource(shardedJedis);  
171.         } finally {  
172.             returnResource(shardedJedis);  
173.         }  
174.         return null;  
175.     }  
176.   
177.     /** 
178.      * 从set中删除value 
179.      * @param key 
180.      * @return 
181.      */  
182.     public  boolean removeSetValue(String key,String... value){  
183.         ShardedJedis shardedJedis = null;  
184.         try {  
185.             shardedJedis = shardedJedisPool.getResource();  
186.             shardedJedis.srem(key, value);  
187.             return true;  
188.         } catch (Exception ex) {  
189.             logger.error("getList error.", ex);  
190.             returnBrokenResource(shardedJedis);  
191.         } finally {  
192.             returnResource(shardedJedis);  
193.         }  
194.         return false;  
195.     }  
196.       
197.       
198.       
199.     /** 
200.      * 从list中删除value 默认count 1 
201.      * @param key 
202.      * @param values 值list 
203.      * @return 
204.      */  
205.     public  int removeListValue(String key,List<String> values){  
206.         return removeListValue(key, 1, values);  
207.     }  
208.     /** 
209.      * 从list中删除value 
210.      * @param key 
211.      * @param count  
212.      * @param values 值list 
213.      * @return 
214.      */  
215.     public  int removeListValue(String key,long count,List<String> values){  
216.         int result = 0;  
217.         if(values != null && values.size()>0){  
218.             for(String value : values){  
219.                 if(removeListValue(key, count, value)){  
220.                     result++;  
221.                 }  
222.             }  
223.         }  
224.         return result;  
225.     }  
226.     /** 
227.      *  从list中删除value 
228.      * @param key 
229.      * @param count 要删除个数 
230.      * @param value 
231.      * @return 
232.      */  
233.     public  boolean removeListValue(String key,long count,String value){  
234.         ShardedJedis shardedJedis = null;  
235.         try {  
236.             shardedJedis = shardedJedisPool.getResource();  
237.             shardedJedis.lrem(key, count, value);  
238.             return true;  
239.         } catch (Exception ex) {  
240.             logger.error("getList error.", ex);  
241.             returnBrokenResource(shardedJedis);  
242.         } finally {  
243.             returnResource(shardedJedis);  
244.         }  
245.         return false;  
246.     }  
247.       
248.     /** 
249.      * 截取List 
250.      * @param key  
251.      * @param start 起始位置 
252.      * @param end 结束位置 
253.      * @return 
254.      */  
255.     public List<String> rangeList(String key, long start, long end) {  
256.         if (key == null || key.equals("")) {  
257.             return null;  
258.         }  
259.         ShardedJedis shardedJedis = null;  
260.         try {  
261.             shardedJedis = shardedJedisPool.getResource();  
262.             return shardedJedis.lrange(key, start, end);  
263.         } catch (Exception ex) {  
264.             logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
265.             returnBrokenResource(shardedJedis);  
266.         } finally {  
267.             returnResource(shardedJedis);  
268.         }  
269.         return null;  
270.     }  
271.       
272.     /** 
273.      * 检查List长度 
274.      * @param key 
275.      * @return 
276.      */  
277.     public long countList(String key){  
278.         if(key == null ){  
279.             return 0;  
280.         }  
281.         ShardedJedis shardedJedis = null;  
282.         try {  
283.             shardedJedis = shardedJedisPool.getResource();  
284.             return shardedJedis.llen(key);  
285.         } catch (Exception ex) {  
286.             logger.error("countList error.", ex);  
287.             returnBrokenResource(shardedJedis);  
288.         } finally {  
289.             returnResource(shardedJedis);  
290.         }  
291.         return 0;  
292.     }  
293.       
294.     /** 
295.      * 添加到List中（同时设置过期时间） 
296.      * @param key key值 
297.      * @param seconds 过期时间 单位s 
298.      * @param value  
299.      * @return  
300.      */  
301.     public boolean addList(String key,int seconds, String... value){  
302.         boolean result = addList(key, value);  
303.         if(result){  
304.             long i = expire(key, seconds);  
305.             return i==1;  
306.         }  
307.         return false;  
308.     }  
309.     /** 
310.      * 添加到List 
311.      * @param key 
312.      * @param value 
313.      * @return 
314.      */  
315.     public boolean addList(String key, String... value) {  
316.         if(key == null || value == null){  
317.             return false;  
318.         }  
319.         ShardedJedis shardedJedis = null;  
320.         try {  
321.             shardedJedis = shardedJedisPool.getResource();  
322.             shardedJedis.lpush(key, value);  
323.             return true;  
324.         } catch (Exception ex) {  
325.             logger.error("setList error.", ex);  
326.             returnBrokenResource(shardedJedis);  
327.         } finally {  
328.             returnResource(shardedJedis);  
329.         }  
330.         return false;  
331.     }  
332.     /** 
333.      * 添加到List(只新增) 
334.      * @param key 
335.      * @param value 
336.      * @return 
337.      */  
338.     public boolean addList(String key, List<String> list) {  
339.         if(key == null || list == null || list.size() == 0){  
340.             return false;  
341.         }  
342.         for(String value : list){  
343.             addList(key, value);  
344.         }  
345.         return true;  
346.     }  
347.       
348.     /** 
349.      * 获取List 
350.      * @param key 
351.      * @return 
352.      */  
353.     public  List<String> getList(String key){  
354.         ShardedJedis shardedJedis = null;  
355.         try {  
356.             shardedJedis = shardedJedisPool.getResource();  
357.             return shardedJedis.lrange(key, 0, -1);  
358.         } catch (Exception ex) {  
359.             logger.error("getList error.", ex);  
360.             returnBrokenResource(shardedJedis);  
361.         } finally {  
362.             returnResource(shardedJedis);  
363.         }  
364.         return null;  
365.     }  
366.     /** 
367.      * 设置HashSet对象 
368.      * 
369.      * @param domain 域名 
370.      * @param key    键值 
371.      * @param value  Json String or String value 
372.      * @return 
373.      */  
374.     public boolean setHSet(String domain, String key, String value) {  
375.         if (value == null) return false;  
376.         ShardedJedis shardedJedis = null;  
377.         try {  
378.             shardedJedis = shardedJedisPool.getResource();  
379.             shardedJedis.hset(domain, key, value);  
380.             return true;  
381.         } catch (Exception ex) {  
382.             logger.error("setHSet error.", ex);  
383.             returnBrokenResource(shardedJedis);  
384.         } finally {  
385.             returnResource(shardedJedis);  
386.         }  
387.         return false;  
388.     }  
389.   
390.     /** 
391.      * 获得HashSet对象 
392.      * 
393.      * @param domain 域名 
394.      * @param key    键值 
395.      * @return Json String or String value 
396.      */  
397.     public String getHSet(String domain, String key) {  
398.         ShardedJedis shardedJedis = null;  
399.         try {  
400.             shardedJedis = shardedJedisPool.getResource();  
401.             return shardedJedis.hget(domain, key);  
402.         } catch (Exception ex) {  
403.             logger.error("getHSet error.", ex);  
404.             returnBrokenResource(shardedJedis);  
405.         } finally {  
406.             returnResource(shardedJedis);  
407.         }  
408.         return null;  
409.     }  
410.   
411.     /** 
412.      * 删除HashSet对象 
413.      * 
414.      * @param domain 域名 
415.      * @param key    键值 
416.      * @return 删除的记录数 
417.      */  
418.     public long delHSet(String domain, String key) {  
419.         ShardedJedis shardedJedis = null;  
420.         long count = 0;  
421.         try {  
422.             shardedJedis = shardedJedisPool.getResource();  
423.             count = shardedJedis.hdel(domain, key);  
424.         } catch (Exception ex) {  
425.             logger.error("delHSet error.", ex);  
426.             returnBrokenResource(shardedJedis);  
427.         } finally {  
428.             returnResource(shardedJedis);  
429.         }  
430.         return count;  
431.     }  
432.   
433.     /** 
434.      * 删除HashSet对象 
435.      * 
436.      * @param domain 域名 
437.      * @param key    键值 
438.      * @return 删除的记录数 
439.      */  
440.     public long delHSet(String domain, String... key) {  
441.         ShardedJedis shardedJedis = null;  
442.         long count = 0;  
443.         try {  
444.             shardedJedis = shardedJedisPool.getResource();  
445.             count = shardedJedis.hdel(domain, key);  
446.         } catch (Exception ex) {  
447.             logger.error("delHSet error.", ex);  
448.             returnBrokenResource(shardedJedis);  
449.         } finally {  
450.             returnResource(shardedJedis);  
451.         }  
452.         return count;  
453.     }  
454.   
455.     /** 
456.      * 判断key是否存在 
457.      * 
458.      * @param domain 域名 
459.      * @param key    键值 
460.      * @return 
461.      */  
462.     public 以上是关于Redis客户端之Spring整合Jedis的主要内容，如果未能解决你的问题，请参考以下文章

     Redis + Jedis + Spring整合遇到的异常（转）

     Spring整合Redis

     Redis入门很简单之五Jedis和Spring的整合

     Spring data redis-StringRedisTemplate 用法

     Spring Boot整合Redis

     Spring集成Redis方案（spring-data-redis）（基于Jedis的单机模式）（待实践）