玖叶教程网

一、相关配置

1.spring-redis.xml：

[java] view plain copy

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:p="http://www.springframework.org/schema/p"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:cache="http://www.springframework.org/schema/cache"
6. xsi:schemaLocation="http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
8. http://www.springframework.org/schema/context
9. http://www.springframework.org/schema/context/spring-context-4.2.xsd
10. http://www.springframework.org/schema/mvc
11. http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
12. http://www.springframework.org/schema/cache
13. http://www.springframework.org/schema/cache/spring-cache-4.2.xsd">
15. <context:property-placeholder location="classpath:redis.porperties" />
17. <!-- 这里注入RedisUtil工具类，service层注解调用-->
19. <context:component-scan base-package="com.xian.manager.util" />
21. <!-- redis 相关配置 -->
22. <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
23. <property name="maxIdle" value="${redis.maxIdle}" />
24. <property name="maxWaitMillis" value="${redis.maxWait}" />
25. <property name="testOnBorrow" value="${redis.testOnBorrow}" />
26. </bean>
28. <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
29. <property name="poolConfig" ref="poolConfig" />
30. <property name="port" value="${redis.port}" />
31. <property name="hostName" value="${redis.host}" />
32. <property name="password" value="${redis.pass}" />
33. <property name="timeout" value="${redis.timeout}" />
34. </bean>
36. <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
37. <property name="connectionFactory" ref="connectionFactory" />
38. </bean>
40. </beans>

使用的是RedisTemplate默认的JDK序列化策略。

2.相关工具类：

1).Redis工具类

[java] view plain copy

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

2).序列化反序列化工具类

[java] view plain copy

1. package com.xian.manager.util;
3. import java.io.ByteArrayInputStream;
4. import java.io.ByteArrayOutputStream;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
8. import org.apache.log4j.Logger;
10. public class SerializeUtil {
12. private static Logger logger = Logger.getLogger(SerializeUtil.class);
14. /*
15. * 序列化
16. */
17. public static byte[] serialize(Object object) {
18. ObjectOutputStream oos = null;
19. ByteArrayOutputStream baos = null;
20. try {
21. baos = new ByteArrayOutputStream();
22. oos = new ObjectOutputStream(baos);
23. oos.writeObject(object);
24. byte[] bytes = baos.toByteArray();
25. return bytes;
26. } catch (Exception e) {
27. logger.warn("序列化对象出现异常： ", e);
28. }
29. return null;
30. }
32. /*
33. * 反序列化
34. */
35. public static Object deserialize(byte[] bytes) {
36. ByteArrayInputStream bais = null;
37. try {
38. bais = new ByteArrayInputStream(bytes);
39. ObjectInputStream ois = new ObjectInputStream(bais);
40. return ois.readObject();
41. } catch (Exception e) {
42. logger.warn("反序列化对象出现异常： ", e);
43. }
44. return null;
45. }
46. }

3). 实体类与字节数组互转工具类

[java] view plain copy

1. package com.xian.manager.util;
3. import java.io.ByteArrayInputStream;
4. import java.io.ByteArrayOutputStream;
5. import java.io.IOException;
6. import java.io.ObjectInputStream;
7. import java.io.ObjectOutputStream;
9. public class ObjectAndByteUtil {
11. /**
12. * 对象转数组
13. * @param obj
14. * @return
15. */
16. public static byte[] toByteArray (Object obj) {
17. byte[] bytes = null;
18. ByteArrayOutputStream bos = new ByteArrayOutputStream();
19. try {
20. ObjectOutputStream oos = new ObjectOutputStream(bos);
21. oos.writeObject(obj);
22. oos.flush();
23. bytes = bos.toByteArray ();
24. oos.close();
25. bos.close();
26. } catch (IOException ex) {
27. ex.printStackTrace();
28. }
29. return bytes;
30. }
32. /**
33. * 数组转对象
34. * @param bytes
35. * @return
36. */
37. public static Object toObject (byte[] bytes) {
38. Object obj = null;
39. try {
40. ByteArrayInputStream bis = new ByteArrayInputStream (bytes);
41. ObjectInputStream ois = new ObjectInputStream (bis);
42. obj = ois.readObject();
43. ois.close();
44. bis.close();
45. } catch (IOException ex) {
46. ex.printStackTrace();
47. } catch (ClassNotFoundException ex) {
48. ex.printStackTrace();
49. }
50. return obj;
51. }
52. }

三、具体使用

1.设值：

User user = new User();

user.setUsername("夜gg");

user.setPassword("123456");

redisUtil.set("user", user);

注意点：实体类User需要实现Serializable接口，而且重写toString()方法。

[java] view plain copy

1. package com.xian.manager.entity;
3. import java.io.Serializable;
5. public class User implements Serializable{
7. private int id;
8. private String username;
9. private String password;
10. private int sex;
11. private int age;
12. private int state;
14. public User() {
15. }
17. public String getUsername() {
18. return username;
19. }
21. public void setUsername(String username) {
22. this.username = username;
23. }
25. public String getPassword() {
26. return password;
27. }
29. public void setPassword(String password) {
30. this.password = password;
31. }
33. public int getSex() {
34. return sex;
35. }
37. public void setSex(int sex) {
38. this.sex = sex;
39. }
41. public int getAge() {
42. return age;
43. }
45. public void setAge(int age) {
46. this.age = age;
47. }
49. public int getId() {
50. return id;
51. }
53. public void setId(int id) {
54. this.id = id;
55. }
57. public int getState() {
58. return state;
59. }
61. public void setState(int state) {
62. this.state = state;
63. }
65. @Override
66. public String toString() {
67. return "User [id=" + id + ", username=" + username + ", password=" + password + ", sex=" + sex + ", age=" + age
68. + ", state=" + state + "]";
69. }
71. }

2.取值：

User user = (User) SerializeUtil.deserialize(ObjectAndByteUtil.toByteArray(redisUtil.get("user")));

System.out.println(user.getUsername());

使用可视化工具RedisDesktopManager查看（以字节数组的形式）：