1、配置文件pom里面添加redis依赖
<!-- redis客户端:Jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
2、配置文件
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
4 xsi:schemaLocation="http://www.springframework.org/schema/beans
5 http://www.springframework.org/schema/beans/spring-beans.xsd
6 http://www.springframework.org/schema/context
7 http://www.springframework.org/schema/context/spring-context.xsd">
8 <!-- Redis连接池的设置 -->
9 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
10 <!-- 控制一个pool可分配多少个jedis实例 -->
11 <property name="maxTotal" value="${redis.pool.maxActive}" />
12 <!-- 连接池中最多可空闲maxIdle个连接 ，这里取值为20，表示即使没有数据库连接时依然可以保持20空闲的连接，而不被清除，随时处于待命状态。 -->
13 <property name="maxIdle" value="${redis.pool.maxIdle}" />
14 <!-- 最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间(以毫秒计数),超过时间则抛出异常 -->
15 <property name="maxWaitMillis" value="${redis.pool.maxWait}" />
16 <!-- 在获取连接的时候检查有效性 -->
17 <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
18 </bean>
19
20 <!-- 创建Redis连接池，并做相关配置 -->
21 <bean id="jedisWritePool" class="com.imooc.o2o.cache.JedisPoolWriper"
22 depends-on="jedisPoolConfig">
23 <constructor-arg index="0" ref="jedisPoolConfig" />
24 <constructor-arg index="1" value="${redis.hostname}" />
25 <constructor-arg index="2" value="${redis.port}" type="int" />
26
27 </bean>
28
29 <!-- 创建Redis工具类，封装好Redis的连接以进行相关的操作 -->
30 <bean id="jedisUtil" class="com.imooc.o2o.cache.JedisUtil" scope="singleton">
31 <property name="jedisPool">
32 <ref bean="jedisWritePool" />
33 </property>
34 </bean>
35 <!-- Redis的key操作 -->
36 <bean id="jedisKeys" class="com.imooc.o2o.cache.JedisUtil$Keys"
37 scope="singleton">
38 <constructor-arg ref="jedisUtil"></constructor-arg>
39 </bean>
40 <!-- Redis的Strings操作 -->
41 <bean id="jedisStrings" class="com.imooc.o2o.cache.JedisUtil$Strings"
42 scope="singleton">
43 <constructor-arg ref="jedisUtil"></constructor-arg>
44 </bean>
45 <!-- Redis的Lists操作 -->
46 <bean id="jedisLists" class="com.imooc.o2o.cache.JedisUtil$Lists"
47 scope="singleton">
48 <constructor-arg ref="jedisUtil"></constructor-arg>
49 </bean>
50 <!-- Redis的Sets操作 -->
51 <bean id="jedisSets" class="com.imooc.o2o.cache.JedisUtil$Sets"
52 scope="singleton">
53 <constructor-arg ref="jedisUtil"></constructor-arg>
54 </bean>
55 <!-- Redis的HashMap操作 -->
56 <bean id="jedisHash" class="com.imooc.o2o.cache.JedisUtil$Hash"
57 scope="singleton">
58 <constructor-arg ref="jedisUtil"></constructor-arg>
59 </bean>
60 </beans>
1 redis.hostname=127.0.0.1 2 redis.port=6379 3 redis.database=0 4 redis.pool.maxActive=100 5 redis.pool.maxIdle=20 6 redis.pool.maxWait=3000 7 redis.pool.testOnBorrow=true 8 redis.password=sxmsapp
3、修改配置文件spring-dao.xml
4、配置redis连接池
1 import redis.clients.jedis.JedisPool;
2 import redis.clients.jedis.JedisPoolConfig;
3
4 /**
5 * 强指定redis的JedisPool接口构造函数，这样才能在centos成功创建jedispool
6 *
7 */
8 public class JedisPoolWriper {
9 /** Redis连接池对象 */
10 private JedisPool jedisPool;
11
12 public JedisPoolWriper(final JedisPoolConfig poolConfig, final String host,
13 final int port) {
14 try {
15 jedisPool = new JedisPool(poolConfig, host, port);
16 } catch (Exception e) {
17 e.printStackTrace();
18 }
19 }
20
21 /**
22 * 获取Redis连接池对象
23 * @return
24 */
25 public JedisPool getJedisPool() {
26 return jedisPool;
27 }
28
29 /**
30 * 注入Redis连接池对象
31 * @param jedisPool
32 */
33 public void setJedisPool(JedisPool jedisPool) {
34 this.jedisPool = jedisPool;
35 }
36
37 }
5、操作redis
1 package com.imooc.o2o.cache;
2
3 import java.util.List;
4 import java.util.Map;
5 import java.util.Set;
6
7 import redis.clients.jedis.BinaryClient.LIST_POSITION;
8 import redis.clients.jedis.Jedis;
9 import redis.clients.jedis.JedisPool;
10 import redis.clients.jedis.SortingParams;
11 import redis.clients.util.SafeEncoder;
12
13 public class JedisUtil {
14 /**
15 * 缓存生存时间
16 */
17 private final int expire = 60000;
18 /** 操作Key的方法 */
19 public Keys KEYS;
20 /** 对存储结构为String类型的操作 */
21 public Strings STRINGS;
22 /** 对存储结构为List类型的操作 */
23 public Lists LISTS;
24 /** 对存储结构为Set类型的操作 */
25 public Sets SETS;
26 /** 对存储结构为HashMap类型的操作 */
27 public Hash HASH;
28
29 /** Redis连接池对象 */
30 private JedisPool jedisPool;
31
32 /**
33 * 获取redis连接池
34 *
35 * @return
36 */
37 public JedisPool getJedisPool() {
38 return jedisPool;
39 }
40
41 /**
42 * 设置redis连接池
43 *
44 * @return
45 */
46 public void setJedisPool(JedisPoolWriper jedisPoolWriper) {
47 this.jedisPool = jedisPoolWriper.getJedisPool();
48 }
49
50 /**
51 * 从jedis连接池中获取获取jedis对象
52 *
53 * @return
54 */
55 public Jedis getJedis() {
56 return jedisPool.getResource();
57 }
58
59 /**
60 * 设置过期时间
61 *
62 * @author xiangze
63 * @param key
64 * @param seconds
65 */
66 public void expire(String key, int seconds) {
67 if (seconds <= 0) {
68 return;
69 }
70 Jedis jedis = getJedis();
71 jedis.expire(key, seconds);
72 jedis.close();
73 }
74
75 /**
76 * 设置默认过期时间
77 *
78 * @author xiangze
79 * @param key
80 */
81 public void expire(String key) {
82 expire(key, expire);
83 }
84
85 // *******************************************Keys*******************************************//
86 public class Keys {
87
88 /**
89 * 清空所有key
90 */
91 public String flushAll() {
92 Jedis jedis = getJedis();
93 String stata = jedis.flushAll();
94 jedis.close();
95 return stata;
96 }
97
98 /**
99 * 更改key
100 *
101 * @param String
102 * oldkey
103 * @param String
104 * newkey
105 * @return 状态码
106 */
107 public String rename(String oldkey, String newkey) {
108 return rename(SafeEncoder.encode(oldkey), SafeEncoder.encode(newkey));
109 }
110
111 /**
112 * 更改key,仅当新key不存在时才执行
113 *
114 * @param String
115 * oldkey
116 * @param String
117 * newkey
118 * @return 状态码
119 */
120 public long renamenx(String oldkey, String newkey) {
121 Jedis jedis = getJedis();
122 long status = jedis.renamenx(oldkey, newkey);
123 jedis.close();
124 return status;
125 }
126
127 /**
128 * 更改key
129 *
130 * @param String
131 * oldkey
132 * @param String
133 * newkey
134 * @return 状态码
135 */
136 public String rename(byte[] oldkey, byte[] newkey) {
137 Jedis jedis = getJedis();
138 String status = jedis.rename(oldkey, newkey);
139 jedis.close();
140 return status;
141 }
142
143 /**
144 * 设置key的过期时间，以秒为单位
145 *
146 * @param String
147 * key
148 * @param 时间
149 * ,已秒为单位
150 * @return 影响的记录数
151 */
152 public long expired(String key, int seconds) {
153 Jedis jedis = getJedis();
154 long count = jedis.expire(key, seconds);
155 jedis.close();
156 return count;
157 }
158
159 /**
160 * 设置key的过期时间,它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00，格里高利历）的偏移量。
161 *
162 * @param String
163 * key
164 * @param 时间
165 * ,已秒为单位
166 * @return 影响的记录数
167 */
168 public long expireAt(String key, long timestamp) {
169 Jedis jedis = getJedis();
170 long count = jedis.expireAt(key, timestamp);
171 jedis.close();
172 return count;
173 }
174
175 /**
176 * 查询key的过期时间
177 *
178 * @param String
179 * key
180 * @return 以秒为单位的时间表示
181 */
182 public long ttl(String key) {
183 // ShardedJedis sjedis = getShardedJedis();
184 Jedis sjedis = getJedis();
185 long len = sjedis.ttl(key);
186 sjedis.close();
187 return len;
188 }
189
190 /**
191 * 取消对key过期时间的设置
192 *
193 * @param key
194 * @return 影响的记录数
195 */
196 public long persist(String key) {
197 Jedis jedis = getJedis();
198 long count = jedis.persist(key);
199 jedis.close();
200 return count;
201 }
202
203 /**
204 * 删除keys对应的记录,可以是多个key
205 *
206 * @param String
207 * ... keys
208 * @return 删除的记录数
209 */
210 public long del(String... keys) {
211 Jedis jedis = getJedis();
212 long count = jedis.del(keys);
213 jedis.close();
214 return count;
215 }
216
217 /**
218 * 删除keys对应的记录,可以是多个key
219 *
220 * @param String
221 * ... keys
222 * @return 删除的记录数
223 */
224 public long del(byte[]... keys) {
225 Jedis jedis = getJedis();
226 long count = jedis.del(keys);
227 jedis.close();
228 return count;
229 }
230
231 /**
232 * 判断key是否存在
233 *
234 * @param String
235 * key
236 * @return boolean
237 */
238 public boolean exists(String key) {
239 // ShardedJedis sjedis = getShardedJedis();
240 Jedis sjedis = getJedis();
241 boolean exis = sjedis.exists(key);
242 sjedis.close();
243 return exis;
244 }
245
246 /**
247 * 对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法
248 *
249 * @param String
250 * key
251 * @return List<String> 集合的全部记录
252 **/
253 public List<String> sort(String key) {
254 // ShardedJedis sjedis = getShardedJedis();
255 Jedis sjedis = getJedis();
256 List<String> list = sjedis.sort(key);
257 sjedis.close();
258 return list;
259 }
260
261 /**
262 * 对List,Set,SortSet进行排序或limit
263 *
264 * @param String
265 * key
266 * @param SortingParams
267 * parame 定义排序类型或limit的起止位置.
268 * @return List<String> 全部或部分记录
269 **/
270 public List<String> sort(String key, SortingParams parame) {
271 // ShardedJedis sjedis = getShardedJedis();
272 Jedis sjedis = getJedis();
273 List<String> list = sjedis.sort(key, parame);
274 sjedis.close();
275 return list;
276 }
277
278 /**
279 * 返回指定key存储的类型
280 *
281 * @param String
282 * key
283 * @return String string|list|set|zset|hash
284 **/
285 public String type(String key) {
286 // ShardedJedis sjedis = getShardedJedis();
287 Jedis sjedis = getJedis();
288 String type = sjedis.type(key);
289 sjedis.close();
290 return type;
291 }
292
293 /**
294 * 查找所有匹配给定的模式的键
295 *
296 * @param String
297 * key的表达式,*表示多个，？表示一个
298 */
299 public Set<String> keys(String pattern) {
300 Jedis jedis = getJedis();
301 Set<String> set = jedis.keys(pattern);
302 jedis.close();
303 return set;
304 }
305 }
306
307 // *******************************************Strings*******************************************//
308 public class Strings {
309 /**
310 * 根据key获取记录
311 *
312 * @param String
313 * key
314 * @return 值
315 */
316 public String get(String key) {
317 // ShardedJedis sjedis = getShardedJedis();
318 Jedis sjedis = getJedis();
319 String value = sjedis.get(key);
320 sjedis.close();
321 return value;
322 }
323
324 /**
325 * 根据key获取记录
326 *
327 * @param byte[]
328 * key
329 * @return 值
330 */
331 public byte[] get(byte[] key) {
332 // ShardedJedis sjedis = getShardedJedis();
333 Jedis sjedis = getJedis();
334 byte[] value = sjedis.get(key);
335 sjedis.close();
336 return value;
337 }
338
339 /**
340 * 添加记录,如果记录已存在将覆盖原有的value
341 *
342 * @param String
343 * key
344 * @param String
345 * value
346 * @return 状态码
347 */
348 public String set(String key, String value) {
349 return set(SafeEncoder.encode(key), SafeEncoder.encode(value));
350 }
351
352 /**
353 * 添加记录,如果记录已存在将覆盖原有的value
354 *
355 * @param String
356 * key
357 * @param String
358 * value
359 * @return 状态码
360 */
361 public String set(String key, byte[] value) {
362 return set(SafeEncoder.encode(key), value);
363 }
364
365 /**
366 * 添加记录,如果记录已存在将覆盖原有的value
367 *
368 * @param byte[]
369 * key
370 * @param byte[]
371 * value
372 * @return 状态码
373 */
374 public String set(byte[] key, byte[] value) {
375 Jedis jedis = getJedis();
376 String status = jedis.set(key, value);
377 jedis.close();
378 return status;
379 }
380
381 /**
382 * 添加有过期时间的记录
383 *
384 * @param String
385 * key
386 * @param int
387 * seconds 过期时间，以秒为单位
388 * @param String
389 * value
390 * @return String 操作状态
391 */
392 public String setEx(String key, int seconds, String value) {
393 Jedis jedis = getJedis();
394 String str = jedis.setex(key, seconds, value);
395 jedis.close();
396 return str;
397 }
398
399 /**
400 * 添加有过期时间的记录
401 *
402 * @param String
403 * key
404 * @param int
405 * seconds 过期时间，以秒为单位
406 * @param String
407 * value
408 * @return String 操作状态
409 */
410 public String setEx(byte[] key, int seconds, byte[] value) {
411 Jedis jedis = getJedis();
412 String str = jedis.setex(key, seconds, value);
413 jedis.close();
414 return str;
415 }
416
417 /**
418 * 添加一条记录，仅当给定的key不存在时才插入
419 *
420 * @param String
421 * key
422 * @param String
423 * value
424 * @return long 状态码，1插入成功且key不存在，0未插入，key存在
425 */
426 public long setnx(String key, String value) {
427 Jedis jedis = getJedis();
428 long str = jedis.setnx(key, value);
429 jedis.close();
430 return str;
431 }
432
433 /**
434 * 从指定位置开始插入数据，插入的数据会覆盖指定位置以后的数据<br/>
435 * 例:String str1="123456789";<br/>
436 * 对str1操作后setRange(key,4,0000)，str1="123400009";
437 *
438 * @param String
439 * key
440 * @param long
441 * offset
442 * @param String
443 * value
444 * @return long value的长度
445 */
446 public long setRange(String key, long offset, String value) {
447 Jedis jedis = getJedis();
448 long len = jedis.setrange(key, offset, value);
449 jedis.close();
450 return len;
451 }
452
453 /**
454 * 在指定的key中追加value
455 *
456 * @param String
457 * key
458 * @param String
459 * value
460 * @return long 追加后value的长度
461 **/
462 public long append(String key, String value) {
463 Jedis jedis = getJedis();
464 long len = jedis.append(key, value);
465 jedis.close();
466 return len;
467 }
468
469 /**
470 * 将key对应的value减去指定的值，只有value可以转为数字时该方法才可用
471 *
472 * @param String
473 * key
474 * @param long
475 * number 要减去的值
476 * @return long 减指定值后的值
477 */
478 public long decrBy(String key, long number) {
479 Jedis jedis = getJedis();
480 long len = jedis.decrBy(key, number);
481 jedis.close();
482 return len;
483 }
484
485 /**
486 * <b>可以作为获取唯一id的方法</b><br/>
487 * 将key对应的value加上指定的值，只有value可以转为数字时该方法才可用
488 *
489 * @param String
490 * key
491 * @param long
492 * number 要减去的值
493 * @return long 相加后的值
494 */
495 public long incrBy(String key, long number) {
496 Jedis jedis = getJedis();
497 long len = jedis.incrBy(key, number);
498 jedis.close();
499 return len;
500 }
501
502 /**
503 * 对指定key对应的value进行截取
504 *
505 * @param String
506 * key
507 * @param long
508 * startOffset 开始位置(包含)
509 * @param long
510 * endOffset 结束位置(包含)
511 * @return String 截取的值
512 */
513 public String getrange(String key, long startOffset, long endOffset) {
514 // ShardedJedis sjedis = getShardedJedis();
515 Jedis sjedis = getJedis();
516 String value = sjedis.getrange(key, startOffset, endOffset);
517 sjedis.close();
518 return value;
519 }
520
521 /**
522 * 获取并设置指定key对应的value<br/>
523 * 如果key存在返回之前的value,否则返回null
524 *
525 * @param String
526 * key
527 * @param String
528 * value
529 * @return String 原始value或null
530 */
531 public String getSet(String key, String value) {
532 Jedis jedis = getJedis();
533 String str = jedis.getSet(key, value);
534 jedis.close();
535 return str;
536 }
537
538 /**
539 * 批量获取记录,如果指定的key不存在返回List的对应位置将是null
540 *
541 * @param String
542 * keys
543 * @return List<String> 值得集合
544 */
545 public List<String> mget(String... keys) {
546 Jedis jedis = getJedis();
547 List<String> str = jedis.mget(keys);
548 jedis.close();
549 return str;
550 }
551
552 /**
553 * 批量存储记录
554 *
555 * @param String
556 * keysvalues 例:keysvalues="key1","value1","key2","value2";
557 * @return String 状态码
558 */
559 public String mset(String... keysvalues) {
560 Jedis jedis = getJedis();
561 String str = jedis.mset(keysvalues);
562 jedis.close();
563 return str;
564 }
565
566 /**
567 * 获取key对应的值的长度
568 *
569 * @param String
570 * key
571 * @return value值得长度
572 */
573 public long strlen(String key) {
574 Jedis jedis = getJedis();
575 long len = jedis.strlen(key);
576 jedis.close();
577 return len;
578 }
579 }
580
581 // *******************************************Sets*******************************************//
582 public class Sets {
583
584 /**
585 * 向Set添加一条记录，如果member已存在返回0,否则返回1
586 *
587 * @param String
588 * key
589 * @param String
590 * member
591 * @return 操作码,0或1
592 */
593 public long sadd(String key, String member) {
594 Jedis jedis = getJedis();
595 long s = jedis.sadd(key, member);
596 jedis.close();
597 return s;
598 }
599
600 public long sadd(byte[] key, byte[] member) {
601 Jedis jedis = getJedis();
602 long s = jedis.sadd(key, member);
603 jedis.close();
604 return s;
605 }
606
607 /**
608 * 获取给定key中元素个数
609 *
610 * @param String
611 * key
612 * @return 元素个数
613 */
614 public long scard(String key) {
615 // ShardedJedis sjedis = getShardedJedis();
616 Jedis sjedis = getJedis();
617 long len = sjedis.scard(key);
618 sjedis.close();
619 return len;
620 }
621
622 /**
623 * 返回从第一组和所有的给定集合之间的差异的成员
624 *
625 * @param String
626 * ... keys
627 * @return 差异的成员集合
628 */
629 public Set<String> sdiff(String... keys) {
630 Jedis jedis = getJedis();
631 Set<String> set = jedis.sdiff(keys);
632 jedis.close();
633 return set;
634 }
635
636 /**
637 * 这个命令等于sdiff,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。
638 *
639 * @param String
640 * newkey 新结果集的key
641 * @param String
642 * ... keys 比较的集合
643 * @return 新集合中的记录数
644 **/
645 public long sdiffstore(String newkey, String... keys) {
646 Jedis jedis = getJedis();
647 long s = jedis.sdiffstore(newkey, keys);
648 jedis.close();
649 return s;
650 }
651
652 /**
653 * 返回给定集合交集的成员,如果其中一个集合为不存在或为空，则返回空Set
654 *
655 * @param String
656 * ... keys
657 * @return 交集成员的集合
658 **/
659 public Set<String> sinter(String... keys) {
660 Jedis jedis = getJedis();
661 Set<String> set = jedis.sinter(keys);
662 jedis.close();
663 return set;
664 }
665
666 /**
667 * 这个命令等于sinter,但返回的不是结果集,而是将结果集存储在新的集合中，如果目标已存在，则覆盖。
668 *
669 * @param String
670 * newkey 新结果集的key
671 * @param String
672 * ... keys 比较的集合
673 * @return 新集合中的记录数
674 **/
675 public long sinterstore(String newkey, String... keys) {
676 Jedis jedis = getJedis();
677 long s = jedis.sinterstore(newkey, keys);
678 jedis.close();
679 return s;
680 }
681
682 /**
683 * 确定一个给定的值是否存在
684 *
685 * @param String
686 * key
687 * @param String
688 * member 要判断的值
689 * @return 存在返回1，不存在返回0
690 **/
691 public boolean sismember(String key, String member) {
692 // ShardedJedis sjedis = getShardedJedis();
693 Jedis sjedis = getJedis();
694 boolean s = sjedis.sismember(key, member);
695 sjedis.close();
696 return s;
697 }
698
699 /**
700 * 返回集合中的所有成员
701 *
702 * @param String
703 * key
704 * @return 成员集合
705 */
706 public Set<String> smembers(String key) {
707 // ShardedJedis sjedis = getShardedJedis();
708 Jedis sjedis = getJedis();
709 Set<String> set = sjedis.smembers(key);
710 sjedis.close();
711 return set;
712 }
713
714 public Set<byte[]> smembers(byte[] key) {
715 // ShardedJedis sjedis = getShardedJedis();
716 Jedis sjedis = getJedis();
717 Set<byte[]> set = sjedis.smembers(key);
718 sjedis.close();
719 return set;
720 }
721
722 /**
723 * 将成员从源集合移出放入目标集合 <br/>
724 * 如果源集合不存在或不包哈指定成员，不进行任何操作，返回0<br/>
725 * 否则该成员从源集合上删除，并添加到目标集合，如果目标集合中成员已存在，则只在源集合进行删除
726 *
727 * @param String
728 * srckey 源集合
729 * @param String
730 * dstkey 目标集合
731 * @param String
732 * member 源集合中的成员
733 * @return 状态码，1成功，0失败
734 */
735 public long smove(String srckey, String dstkey, String member) {
736 Jedis jedis = getJedis();
737 long s = jedis.smove(srckey, dstkey, member);
738 jedis.close();
739 return s;
740 }
741
742 /**
743 * 从集合中删除成员
744 *
745 * @param String
746 * key
747 * @return 被删除的成员
748 */
749 public String spop(String key) {
750 Jedis jedis = getJedis();
751 String s = jedis.spop(key);
752 jedis.close();
753 return s;
754 }
755
756 /**
757 * 从集合中删除指定成员
758 *
759 * @param String
760 * key
761 * @param String
762 * member 要删除的成员
763 * @return 状态码，成功返回1，成员不存在返回0
764 */
765 public long srem(String key, String member) {
766 Jedis jedis = getJedis();
767 long s = jedis.srem(key, member);
768 jedis.close();
769 return s;
770 }
771
772 /**
773 * 合并多个集合并返回合并后的结果，合并后的结果集合并不保存<br/>
774 *
775 * @param String
776 * ... keys
777 * @return 合并后的结果集合
778 * @see sunionstore
779 */
780 public Set<String> sunion(String... keys) {
781 Jedis jedis = getJedis();
782 Set<String> set = jedis.sunion(keys);
783 jedis.close();
784 return set;
785 }
786
787 /**
788 * 合并多个集合并将合并后的结果集保存在指定的新集合中，如果新集合已经存在则覆盖
789 *
790 * @param String
791 * newkey 新集合的key
792 * @param String
793 * ... keys 要合并的集合
794 **/
795 public long sunionstore(String newkey, String... keys) {
796 Jedis jedis = getJedis();
797 long s = jedis.sunionstore(newkey, keys);
798 jedis.close();
799 return s;
800 }
801 }
802
803 // *******************************************Hash*******************************************//
804 public class Hash {
805
806 /**
807 * 从hash中删除指定的存储
808 *
809 * @param String
810 * key
811 * @param String
812 * fieid 存储的名字
813 * @return 状态码，1成功，0失败
814 */
815 public long hdel(String key, String fieid) {
816 Jedis jedis = getJedis();
817 long s = jedis.hdel(key, fieid);
818 jedis.close();
819 return s;
820 }
821
822 public long hdel(String key) {
823 Jedis jedis = getJedis();
824 long s = jedis.del(key);
825 jedis.close();
826 return s;
827 }
828
829 /**
830 * 测试hash中指定的存储是否存在
831 *
832 * @param String
833 * key
834 * @param String
835 * fieid 存储的名字
836 * @return 1存在，0不存在
837 */
838 public boolean hexists(String key, String fieid) {
839 // ShardedJedis sjedis = getShardedJedis();
840 Jedis sjedis = getJedis();
841 boolean s = sjedis.hexists(key, fieid);
842 sjedis.close();
843 return s;
844 }
845
846 /**
847 * 返回hash中指定存储位置的值
848 *
849 * @param String
850 * key
851 * @param String
852 * fieid 存储的名字
853 * @return 存储对应的值
854 */
855 public String hget(String key, String fieid) {
856 // ShardedJedis sjedis = getShardedJedis();
857 Jedis sjedis = getJedis();
858 String s = sjedis.hget(key, fieid);
859 sjedis.close();
860 return s;
861 }
862
863 public byte[] hget(byte[] key, byte[] fieid) {
864 // ShardedJedis sjedis = getShardedJedis();
865 Jedis sjedis = getJedis();
866 byte[] s = sjedis.hget(key, fieid);
867 sjedis.close();
868 return s;
869 }
870
871 /**
872 * 以Map的形式返回hash中的存储和值
873 *
874 * @param String
875 * key
876 * @return Map<Strinig,String>
877 */
878 public Map<String, String> hgetAll(String key) {
879 // ShardedJedis sjedis = getShardedJedis();
880 Jedis sjedis = getJedis();
881 Map<String, String> map = sjedis.hgetAll(key);
882 sjedis.close();
883 return map;
884 }
885
886 /**
887 * 添加一个对应关系
888 *
889 * @param String
890 * key
891 * @param String
892 * fieid
893 * @param String
894 * value
895 * @return 状态码 1成功，0失败，fieid已存在将更新，也返回0
896 **/
897 public long hset(String key, String fieid, String value) {
898 Jedis jedis = getJedis();
899 long s = jedis.hset(key, fieid, value);
900 jedis.close();
901 return s;
902 }
903
904 public long hset(String key, String fieid, byte[] value) {
905 Jedis jedis = getJedis();
906 long s = jedis.hset(key.getBytes(), fieid.getBytes(), value);
907 jedis.close();
908 return s;
909 }
910
911 /**
912 * 添加对应关系，只有在fieid不存在时才执行
913 *
914 * @param String
915 * key
916 * @param String
917 * fieid
918 * @param String
919 * value
920 * @return 状态码 1成功，0失败fieid已存
921 **/
922 public long hsetnx(String key, String fieid, String value) {
923 Jedis jedis = getJedis();
924 long s = jedis.hsetnx(key, fieid, value);
925 jedis.close();
926 return s;
927 }
928
929 /**
930 * 获取hash中value的集合
931 *
932 * @param String
933 * key
934 * @return List<String>
935 */
936 public List<String> hvals(String key) {
937 // ShardedJedis sjedis = getShardedJedis();
938 Jedis sjedis = getJedis();
939 List<String> list = sjedis.hvals(key);
940 sjedis.close();
941 return list;
942 }
943
944 /**
945 * 在指定的存储位置加上指定的数字，存储位置的值必须可转为数字类型
946 *
947 * @param String
948 * key
949 * @param String
950 * fieid 存储位置
951 * @param String
952 * long value 要增加的值,可以是负数
953 * @return 增加指定数字后，存储位置的值
954 */
955 public long hincrby(String key, String fieid, long value) {
956 Jedis jedis = getJedis();
957 long s = jedis.hincrBy(key, fieid, value);
958 jedis.close();
959 return s;
960 }
961
962 /**
963 * 返回指定hash中的所有存储名字,类似Map中的keySet方法
964 *
965 * @param String
966 * key
967 * @return Set<String> 存储名称的集合
968 */
969 public Set<String> hkeys(String key) {
970 // ShardedJedis sjedis = getShardedJedis();
971 Jedis sjedis = getJedis();
972 Set<String> set = sjedis.hkeys(key);
973 sjedis.close();
974 return set;
975 }
976
977 /**
978 * 获取hash中存储的个数，类似Map中size方法
979 *
980 * @param String
981 * key
982 * @return long 存储的个数
983 */
984 public long hlen(String key) {
985 // ShardedJedis sjedis = getShardedJedis();
986 Jedis sjedis = getJedis();
987 long len = sjedis.hlen(key);
988 sjedis.close();
989 return len;
990 }
991
992 /**
993 * 根据多个key，获取对应的value，返回List,如果指定的key不存在,List对应位置为null
994 *
995 * @param String
996 * key
997 * @param String
998 * ... fieids 存储位置
999 * @return List<String>
1000 */
1001 public List<String> hmget(String key, String... fieids) {
1002 // ShardedJedis sjedis = getShardedJedis();
1003 Jedis sjedis = getJedis();
1004 List<String> list = sjedis.hmget(key, fieids);
1005 sjedis.close();
1006 return list;
1007 }
1008
1009 public List<byte[]> hmget(byte[] key, byte[]... fieids) {
1010 // ShardedJedis sjedis = getShardedJedis();
1011 Jedis sjedis = getJedis();
1012 List<byte[]> list = sjedis.hmget(key, fieids);
1013 sjedis.close();
1014 return list;
1015 }
1016
1017 /**
1018 * 添加对应关系，如果对应关系已存在，则覆盖
1019 *
1020 * @param Strin
1021 * key
1022 * @param Map
1023 * <String,String> 对应关系
1024 * @return 状态，成功返回OK
1025 */
1026 public String hmset(String key, Map<String, String> map) {
1027 Jedis jedis = getJedis();
1028 String s = jedis.hmset(key, map);
1029 jedis.close();
1030 return s;
1031 }
1032
1033 /**
1034 * 添加对应关系，如果对应关系已存在，则覆盖
1035 *
1036 * @param Strin
1037 * key
1038 * @param Map
1039 * <String,String> 对应关系
1040 * @return 状态，成功返回OK
1041 */
1042 public String hmset(byte[] key, Map<byte[], byte[]> map) {
1043 Jedis jedis = getJedis();
1044 String s = jedis.hmset(key, map);
1045 jedis.close();
1046 return s;
1047 }
1048
1049 }
1050
1051 // *******************************************Lists*******************************************//
1052 public class Lists {
1053 /**
1054 * List长度
1055 *
1056 * @param String
1057 * key
1058 * @return 长度
1059 */
1060 public long llen(String key) {
1061 return llen(SafeEncoder.encode(key));
1062 }
1063
1064 /**
1065 * List长度
1066 *
1067 * @param byte[]
1068 * key
1069 * @return 长度
1070 */
1071 public long llen(byte[] key) {
1072 // ShardedJedis sjedis = getShardedJedis();
1073 Jedis sjedis = getJedis();
1074 long count = sjedis.llen(key);
1075 sjedis.close();
1076 return count;
1077 }
1078
1079 /**
1080 * 覆盖操作,将覆盖List中指定位置的值
1081 *
1082 * @param byte[]
1083 * key
1084 * @param int
1085 * index 位置
1086 * @param byte[]
1087 * value 值
1088 * @return 状态码
1089 */
1090 public String lset(byte[] key, int index, byte[] value) {
1091 Jedis jedis = getJedis();
1092 String status = jedis.lset(key, index, value);
1093 jedis.close();
1094 return status;
1095 }
1096
1097 /**
1098 * 覆盖操作,将覆盖List中指定位置的值
1099 *
1100 * @param key
1101 * @param int
1102 * index 位置
1103 * @param String
1104 * value 值
1105 * @return 状态码
1106 */
1107 public String lset(String key, int index, String value) {
1108 return lset(SafeEncoder.encode(key), index, SafeEncoder.encode(value));
1109 }
1110
1111 /**
1112 * 在value的相对位置插入记录
1113 *
1114 * @param key
1115 * @param LIST_POSITION
1116 * 前面插入或后面插入
1117 * @param String
1118 * pivot 相对位置的内容
1119 * @param String
1120 * value 插入的内容
1121 * @return 记录总数
1122 */
1123 public long linsert(String key, LIST_POSITION where, String pivot, String value) {
1124 return linsert(SafeEncoder.encode(key), where, SafeEncoder.encode(pivot), SafeEncoder.encode(value));
1125 }
1126
1127 /**
1128 * 在指定位置插入记录
1129 *
1130 * @param String
1131 * key
1132 * @param LIST_POSITION
1133 * 前面插入或后面插入
1134 * @param byte[]
1135 * pivot 相对位置的内容
1136 * @param byte[]
1137 * value 插入的内容
1138 * @return 记录总数
1139 */
1140 public long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
1141 Jedis jedis = getJedis();
1142 long count = jedis.linsert(key, where, pivot, value);
1143 jedis.close();
1144 return count;
1145 }
1146
1147 /**
1148 * 获取List中指定位置的值
1149 *
1150 * @param String
1151 * key
1152 * @param int
1153 * index 位置
1154 * @return 值
1155 **/
1156 public String lindex(String key, int index) {
1157 return SafeEncoder.encode(lindex(SafeEncoder.encode(key), index));
1158 }
1159
1160 /**
1161 * 获取List中指定位置的值
1162 *
1163 * @param byte[]
1164 * key
1165 * @param int
1166 * index 位置
1167 * @return 值
1168 **/
1169 public byte[] lindex(byte[] key, int index) {
1170 // ShardedJedis sjedis = getShardedJedis();
1171 Jedis sjedis = getJedis();
1172 byte[] value = sjedis.lindex(key, index);
1173 sjedis.close();
1174 return value;
1175 }
1176
1177 /**
1178 * 将List中的第一条记录移出List
1179 *
1180 * @param String
1181 * key
1182 * @return 移出的记录
1183 */
1184 public String lpop(String key) {
1185 return SafeEncoder.encode(lpop(SafeEncoder.encode(key)));
1186 }
1187
1188 /**
1189 * 将List中的第一条记录移出List
1190 *
1191 * @param byte[]
1192 * key
1193 * @return 移出的记录
1194 */
1195 public byte[] lpop(byte[] key) {
1196 Jedis jedis = getJedis();
1197 byte[] value = jedis.lpop(key);
1198 jedis.close();
1199 return value;
1200 }
1201
1202 /**
1203 * 将List中最后第一条记录移出List
1204 *
1205 * @param byte[]
1206 * key
1207 * @return 移出的记录
1208 */
1209 public String rpop(String key) {
1210 Jedis jedis = getJedis();
1211 String value = jedis.rpop(key);
1212 jedis.close();
1213 return value;
1214 }
1215
1216 /**
1217 * 向List尾部追加记录
1218 *
1219 * @param String
1220 * key
1221 * @param String
1222 * value
1223 * @return 记录总数
1224 */
1225 public long lpush(String key, String value) {
1226 return lpush(SafeEncoder.encode(key), SafeEncoder.encode(value));
1227 }
1228
1229 /**
1230 * 向List头部追加记录
1231 *
1232 * @param String
1233 * key
1234 * @param String
1235 * value
1236 * @return 记录总数
1237 */
1238 public long rpush(String key, String value) {
1239 Jedis jedis = getJedis();
1240 long count = jedis.rpush(key, value);
1241 jedis.close();
1242 return count;
1243 }
1244
1245 /**
1246 * 向List头部追加记录
1247 *
1248 * @param String
1249 * key
1250 * @param String
1251 * value
1252 * @return 记录总数
1253 */
1254 public long rpush(byte[] key, byte[] value) {
1255 Jedis jedis = getJedis();
1256 long count = jedis.rpush(key, value);
1257 jedis.close();
1258 return count;
1259 }
1260
1261 /**
1262 * 向List中追加记录
1263 *
1264 * @param byte[]
1265 * key
1266 * @param byte[]
1267 * value
1268 * @return 记录总数
1269 */
1270 public long lpush(byte[] key, byte[] value) {
1271 Jedis jedis = getJedis();
1272 long count = jedis.lpush(key, value);
1273 jedis.close();
1274 return count;
1275 }
1276
1277 /**
1278 * 获取指定范围的记录，可以做为分页使用
1279 *
1280 * @param String
1281 * key
1282 * @param long
1283 * start
1284 * @param long
1285 * end
1286 * @return List
1287 */
1288 public List<String> lrange(String key, long start, long end) {
1289 // ShardedJedis sjedis = getShardedJedis();
1290 Jedis sjedis = getJedis();
1291 List<String> list = sjedis.lrange(key, start, end);
1292 sjedis.close();
1293 return list;
1294 }
1295
1296 /**
1297 * 获取指定范围的记录，可以做为分页使用
1298 *
1299 * @param byte[]
1300 * key
1301 * @param int
1302 * start
1303 * @param int
1304 * end 如果为负数，则尾部开始计算
1305 * @return List
1306 */
1307 public List<byte[]> lrange(byte[] key, int start, int end) {
1308 // ShardedJedis sjedis = getShardedJedis();
1309 Jedis sjedis = getJedis();
1310 List<byte[]> list = sjedis.lrange(key, start, end);
1311 sjedis.close();
1312 return list;
1313 }
1314
1315 /**
1316 * 删除List中c条记录，被删除的记录值为value
1317 *
1318 * @param byte[]
1319 * key
1320 * @param int
1321 * c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
1322 * @param byte[]
1323 * value 要匹配的值
1324 * @return 删除后的List中的记录数
1325 */
1326 public long lrem(byte[] key, int c, byte[] value) {
1327 Jedis jedis = getJedis();
1328 long count = jedis.lrem(key, c, value);
1329 jedis.close();
1330 return count;
1331 }
1332
1333 /**
1334 * 删除List中c条记录，被删除的记录值为value
1335 *
1336 * @param String
1337 * key
1338 * @param int
1339 * c 要删除的数量，如果为负数则从List的尾部检查并删除符合的记录
1340 * @param String
1341 * value 要匹配的值
1342 * @return 删除后的List中的记录数
1343 */
1344 public long lrem(String key, int c, String value) {
1345 return lrem(SafeEncoder.encode(key), c, SafeEncoder.encode(value));
1346 }
1347
1348 /**
1349 * 算是删除吧，只保留start与end之间的记录
1350 *
1351 * @param byte[]
1352 * key
1353 * @param int
1354 * start 记录的开始位置(0表示第一条记录)
1355 * @param int
1356 * end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
1357 * @return 执行状态码
1358 */
1359 public String ltrim(byte[] key, int start, int end) {
1360 Jedis jedis = getJedis();
1361 String str = jedis.ltrim(key, start, end);
1362 jedis.close();
1363 return str;
1364 }
1365
1366 /**
1367 * 算是删除吧，只保留start与end之间的记录
1368 *
1369 * @param String
1370 * key
1371 * @param int
1372 * start 记录的开始位置(0表示第一条记录)
1373 * @param int
1374 * end 记录的结束位置（如果为-1则表示最后一个，-2，-3以此类推）
1375 * @return 执行状态码
1376 */
1377 public String ltrim(String key, int start, int end) {
1378 return ltrim(SafeEncoder.encode(key), start, end);
1379 }
1380 }
1381
1382 }
6、应用举例
先查redis是否有该key，若不存在，则从数据库里面取出相应数据，存到redis中；若存在，则从redis中取出来
1 @Service
2 public class AreaServiceImpl implements AreaService {
3 @Autowired
4 private AreaDao areaDao;
5 @Autowired
6 private JedisUtil.Keys jedisKeys;
7 @Autowired
8 private JedisUtil.Strings jedisStrings;
9
10 private static Logger logger = LoggerFactory.getLogger(AreaServiceImpl.class);
11
12 public static final String AREALISTKEY = "arealist";
13 @Override
14 @Transactional
15 public List<Area> getAreaList() {
16 // 定义redis的key
17 String key = AREALISTKEY;
18 // 定义接收对象
19 List<Area> areaList = null;
20 // 定义jackson数据转换操作类
21 ObjectMapper mapper = new ObjectMapper();
22 // 判断key是否存在
23 if (!jedisKeys.exists(key)) {
24 // 若不存在，则从数据库里面取出相应数据
25 areaList = areaDao.queryArea();
26 // 将相关的实体类集合转换成string,存入redis里面对应的key中
27 String jsonString;
28 try {
29 jsonString = mapper.writeValueAsString(areaList);
30 } catch (JsonProcessingException e) {
31 e.printStackTrace();
32 logger.error(e.getMessage());
33 throw new AreaOperationException(e.getMessage());
34 }
35 jedisStrings.set(key, jsonString);
36 } else {
37 // 若存在，则直接从redis里面取出相应数据
38 String jsonString = jedisStrings.get(key);
39 // 指定要将string转换成的集合类型
40 JavaType javaType = mapper.getTypeFactory().constructParametricType(ArrayList.class, Area.class);
41 try {
42 // 将相关key对应的value里的的string转换成对象的实体类集合
43 areaList = mapper.readValue(jsonString, javaType);
44 } catch (JsonParseException e) {
45 e.printStackTrace();
46 logger.error(e.getMessage());
47 throw new AreaOperationException(e.getMessage());
48 } catch (JsonMappingException e) {
49 e.printStackTrace();
50 logger.error(e.getMessage());
51 throw new AreaOperationException(e.getMessage());
52 } catch (IOException e) {
53 e.printStackTrace();
54 logger.error(e.getMessage());
55 throw new AreaOperationException(e.getMessage());
56 }
57 }
58 return areaList;
59 }
60
61 }