1、参考：IT虾米网
2、首先创建一个maven项目。然后加入依赖的jar包就行了。我加入的jar包很多，反正加入了也没啥坏的影响。
1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 3 <modelVersion>4.0.0</modelVersion> 4 <groupId>com.charts</groupId> 5 <artifactId>com.fline.aic.charts</artifactId> 6 <packaging>war</packaging> 7 <version>0.0.1-SNAPSHOT</version> 8 <name>com.fline.aic.charts Maven Webapp</name> 9 <url>http://maven.apache.org</url> 10 11 <dependencies> 12 <dependency> 13 <groupId>junit</groupId> 14 <artifactId>junit</artifactId> 15 <version>3.8.1</version> 16 <scope>test</scope> 17 </dependency> 18 <!-- https://mvnrepository.com/artifact/log4j/log4j --> 19 <dependency> 20 <groupId>log4j</groupId> 21 <artifactId>log4j</artifactId> 22 <version>1.2.17</version> 23 </dependency> 24 <!-- https://mvnrepository.com/artifact/com.github.kstyrc/embedded-redis --> 25 <dependency> 26 <groupId>com.github.kstyrc</groupId> 27 <artifactId>embedded-redis</artifactId> 28 <version>0.6</version> 29 <scope>test</scope> 30 </dependency> 31 <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> 32 <dependency> 33 <groupId>redis.clients</groupId> 34 <artifactId>jedis</artifactId> 35 <version>2.9.0</version> 36 </dependency> 37 <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis --> 38 <dependency> 39 <groupId>org.springframework.data</groupId> 40 <artifactId>spring-data-redis</artifactId> 41 <version>1.7.2.RELEASE</version> 42 </dependency> 43 <!-- https://mvnrepository.com/artifact/commons-pool/commons-pool --> 44 <dependency> 45 <groupId>commons-pool</groupId> 46 <artifactId>commons-pool</artifactId> 47 <version>1.5.4</version> 48 </dependency> 49 <dependency> 50 <groupId>com.fasterxml.jackson.core</groupId> 51 <artifactId>jackson-core</artifactId> 52 <version>2.1.0</version> 53 </dependency> 54 <dependency> 55 <groupId>com.fasterxml.jackson.core</groupId> 56 <artifactId>jackson-databind</artifactId> 57 <version>2.1.0</version> 58 </dependency> 59 <dependency> 60 <groupId>com.fasterxml.jackson.core</groupId> 61 <artifactId>jackson-annotations</artifactId> 62 <version>2.1.0</version> 63 </dependency> 64 65 <!-- https://mvnrepository.com/artifact/org.springframework/spring-core --> 66 <dependency> 67 <groupId>org.springframework</groupId> 68 <artifactId>spring-core</artifactId> 69 <version>4.3.18.RELEASE</version> 70 </dependency> 71 <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> 72 <dependency> 73 <groupId>org.springframework</groupId> 74 <artifactId>spring-context</artifactId> 75 <version>4.3.18.RELEASE</version> 76 </dependency> 77 <!-- https://mvnrepository.com/artifact/org.springframework/spring-web --> 78 <dependency> 79 <groupId>org.springframework</groupId> 80 <artifactId>spring-web</artifactId> 81 <version>4.3.18.RELEASE</version> 82 </dependency> 83 <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop --> 84 <dependency> 85 <groupId>org.springframework</groupId> 86 <artifactId>spring-aop</artifactId> 87 <version>4.3.18.RELEASE</version> 88 </dependency> 89 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> 90 <dependency> 91 <groupId>org.springframework</groupId> 92 <artifactId>spring-webmvc</artifactId> 93 <version>4.3.18.RELEASE</version> 94 </dependency> 95 <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans --> 96 <dependency> 97 <groupId>org.springframework</groupId> 98 <artifactId>spring-beans</artifactId> 99 <version>4.3.18.RELEASE</version> 100 </dependency> 101 <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> 102 <dependency> 103 <groupId>org.springframework</groupId> 104 <artifactId>spring-jdbc</artifactId> 105 <version>4.3.18.RELEASE</version> 106 </dependency> 107 <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> 108 <dependency> 109 <groupId>org.springframework</groupId> 110 <artifactId>spring-webmvc</artifactId> 111 <version>4.3.18.RELEASE</version> 112 </dependency> 113 <!-- https://mvnrepository.com/artifact/org.springframework/spring-test --> 114 <dependency> 115 <groupId>org.springframework</groupId> 116 <artifactId>spring-test</artifactId> 117 <version>4.3.18.RELEASE</version> 118 <scope>test</scope> 119 </dependency> 120 <dependency> 121 <groupId>org.aspectj</groupId> 122 <artifactId>aspectjweaver</artifactId> 123 <version>1.8.13</version> 124 </dependency> 125 126 </dependencies> 127 <build> 128 <finalName>com.fline.aic.charts</finalName> 129 </build> 130 131 132 133 </project>
3、然后在web.xml里面配置一下Spring框架listener配置。
1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1"> 3 <display-name>Spring_Struts2_20170313</display-name> 4 <welcome-file-list> 5 <welcome-file>index.html</welcome-file> 6 <welcome-file>index.htm</welcome-file> 7 <welcome-file>index.jsp</welcome-file> 8 <welcome-file>default.html</welcome-file> 9 <welcome-file>default.htm</welcome-file> 10 <welcome-file>default.jsp</welcome-file> 11 </welcome-file-list> 12 13 14 <!-- 1：spring配置 ,在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle 15 搜索context-param找到下面这段话即可。记得就该param-value的值，如下所示； 16 2：param-value的值最好使用bean，这样方便引用如/WEB-INF/classes/bean-*.xml 17 --> 18 <context-param> 19 <param-name>contextConfigLocation</param-name> 20 <!-- <param-value>classpath:applicationContext.xml</param-value> --> 21 <param-value>/WEB-INF/applicationContext.xml</param-value> 22 </context-param> 23 <listener> 24 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 25 </listener> 26 27 28 </web-app>
4、然后配置一下Spring的配置文件。
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" 4 xmlns:p="http://www.springframework.org/schema/p" 5 xmlns:context="http://www.springframework.org/schema/context" 6 xsi:schemaLocation=" 7 http://www.springframework.org/schema/beans 8 http://www.springframework.org/schema/beans/spring-beans.xsd 9 http://www.springframework.org/schema/context 10 http://www.springframework.org/schema/context/spring-context.xsd"> 11 12 <!-- 开启注解扫描 --> 13 <context:annotation-config/> 14 <context:component-scan base-package="com.fline.*"></context:component-scan> 15 16 <!-- <import resource="classpath:applicationContext-redis.xml" /> --> 17 18 </beans>
5、然后配置一下Redis的配置文件redis.properties和applicationContext-redis.xml。
1 redis.host=127.0.0.1 2 redis.port=6379 3 redis.password=123456 4 5 redis.maxIdle=300 6 redis.maxActive=600 7 redis.maxWait=1000 8 redis.testOnBorrow=true
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" 4 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 5 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd "> 6 7 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" > 8 <!--最大空闲数--> 9 <property name="maxIdle" value="10" /> 10 <!--连接池的最大数据库连接数 --> 11 <property name="maxTotal" value="50" /> 12 <!--最大建立连接等待时间--> 13 <property name="maxWaitMillis" value="1500" /> 14 <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)--> 15 <property name="minEvictableIdleTimeMillis" value="1800000" /> 16 <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3--> 17 <property name="numTestsPerEvictionRun" value="1024" /> 18 <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1--> 19 <property name="timeBetweenEvictionRunsMillis" value="30000" /> 20 <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个--> 21 <property name="testOnBorrow" value="true" /> 22 <!--在空闲时检查有效性, 默认false --> 23 <property name="testWhileIdle" value="true" /> 24 </bean > 25 26 <!--redis连接工厂 --> 27 <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy"> 28 <property name="poolConfig" ref="jedisPoolConfig"></property> 29 <!--IP地址 --> 30 <property name="hostName" value="127.0.0.1"></property> 31 <!--端口号 --> 32 <property name="port" value="6379"></property> 33 <!--如果Redis设置有密码 --> 34 <property name="password" value="123456" /> 35 <!--客户端超时时间单位是毫秒 --> 36 <property name="timeout" value="1000"></property> 37 </bean> 38 39 <!--redis操作模版,使用该对象可以操作redis --> 40 <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" > 41 <property name="connectionFactory" ref="jedisConnectionFactory" /> 42 <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！ --> 43 <property name="keySerializer" > 44 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" /> 45 </property> 46 <property name="valueSerializer" > 47 <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" /> 48 </property> 49 <property name="hashKeySerializer"> 50 <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> 51 </property> 52 <property name="hashValueSerializer"> 53 <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/> 54 </property> 55 <!--开启事务 --> 56 <property name="enableTransactionSupport" value="true"></property> 57 </bean > 58 59 <bean id="redisUtil" class="com.fline.aic.utils.RedisUtil"> 60 <property name="redisTemplate" ref="redisTemplate" /> 61 </bean> 62 63 </beans>
6、redis的工具类，可以直接拿到项目中使用的。
1 package com.fline.aic.utils;
2
3 import java.util.List;
4 import java.util.Map;
5 import java.util.Set;
6 import java.util.concurrent.TimeUnit;
7
8 import org.springframework.beans.factory.annotation.Autowired;
9 import org.springframework.data.redis.core.RedisTemplate;
10 import org.springframework.stereotype.Component;
11 import org.springframework.util.CollectionUtils;
12
13 /**
14 *
15 * @author QLQ 基于spring和redis的redisTemplate工具类 针对所有的hash 都是以h开头的方法 针对所有的Set
16 * 都是以s开头的方法 不含通用方法 针对所有的List 都是以l开头的方法
17 */
18 @Component // 交给Spring管理(在需要缓存的地方自动注入即可使用)
19 public class RedisUtil {
20
21 @Autowired // (自动注入redisTemplet)
22 private RedisTemplate<String, Object> redisTemplate;
23
24 public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
25 this.redisTemplate = redisTemplate;
26 }
27 // =============================common============================
28
29 /**
30 * 指定缓存失效时间
31 *
32 * @param key
33 * 键
34 * @param time
35 * 时间(秒)
36 * @return
37 */
38 public boolean expire(String key, long time) {
39 try {
40 if (time > 0) {
41 redisTemplate.expire(key, time, TimeUnit.SECONDS);
42 }
43 return true;
44 } catch (Exception e) {
45 e.printStackTrace();
46 return false;
47 }
48 }
49
50 /**
51 * 根据key 获取过期时间
52 *
53 * @param key
54 * 键 不能为null
55 * @return 时间(秒) 返回0代表为永久有效
56 */
57 public long getExpire(String key) {
58 return redisTemplate.getExpire(key, TimeUnit.SECONDS);
59 }
60
61 /**
62 * 判断key是否存在
63 *
64 * @param key
65 * 键
66 * @return true 存在 false不存在
67 */
68 public boolean hasKey(String key) {
69 try {
70 return redisTemplate.hasKey(key);
71 } catch (Exception e) {
72 e.printStackTrace();
73 return false;
74 }
75 }
76
77 /**
78 * 删除缓存
79 *
80 * @param key
81 * 可以传一个值 或多个
82 */
83 @SuppressWarnings("unchecked")
84 public void del(String... key) {
85 if (key != null && key.length > 0) {
86 if (key.length == 1) {
87 redisTemplate.delete(key[0]);
88 } else {
89 redisTemplate.delete(CollectionUtils.arrayToList(key));
90 }
91 }
92 }
93
94 // ============================String=============================
95 /**
96 * 普通缓存获取
97 *
98 * @param key
99 * 键
100 * @return 值
101 */
102 public Object get(String key) {
103 return key == null ? null : redisTemplate.opsForValue().get(key);
104 }
105
106 /**
107 * 普通缓存放入
108 *
109 * @param key
110 * 键
111 * @param value
112 * 值
113 * @return true成功 false失败
114 */
115 public boolean set(String key, Object value) {
116 try {
117 redisTemplate.opsForValue().set(key, value);
118 return true;
119 } catch (Exception e) {
120 e.printStackTrace();
121 return false;
122 }
123
124 }
125
126 /**
127 * 普通缓存放入并设置时间
128 *
129 * @param key
130 * 键
131 * @param value
132 * 值
133 * @param time
134 * 时间(秒) time要大于0 如果time小于等于0 将设置无限期
135 * @return true成功 false 失败
136 */
137 public boolean set(String key, Object value, long time) {
138 try {
139 if (time > 0) {
140 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
141 } else {
142 set(key, value);
143 }
144 return true;
145 } catch (Exception e) {
146 e.printStackTrace();
147 return false;
148 }
149 }
150
151 /**
152 * 递增
153 *
154 * @param key
155 * 键
156 * @param by
157 * 要增加几(大于0)
158 * @return
159 */
160 public long incr(String key, long delta) {
161 if (delta < 0) {
162 throw new RuntimeException("递增因子必须大于0");
163 }
164 return redisTemplate.opsForValue().increment(key, delta);
165 }
166
167 /**
168 * 递减
169 *
170 * @param key
171 * 键
172 * @param by
173 * 要减少几(小于0)
174 * @return
175 */
176 public long decr(String key, long delta) {
177 if (delta < 0) {
178 throw new RuntimeException("递减因子必须大于0");
179 }
180 return redisTemplate.opsForValue().increment(key, -delta);
181 }
182
183 // ================================Map=================================
184 /**
185 * HashGet
186 *
187 * @param key
188 * 键 不能为null
189 * @param item
190 * 项 不能为null
191 * @return 值
192 */
193 public Object hget(String key, String item) {
194 return redisTemplate.opsForHash().get(key, item);
195 }
196
197 /**
198 * 获取hashKey对应的所有键值
199 *
200 * @param key
201 * 键
202 * @return 对应的多个键值
203 */
204 public Map<Object, Object> hmget(String key) {
205 return redisTemplate.opsForHash().entries(key);
206 }
207
208 /**
209 * HashSet
210 *
211 * @param key
212 * 键
213 * @param map
214 * 对应多个键值
215 * @return true 成功 false 失败
216 */
217 public boolean hmset(String key, Map<String, Object> map) {
218 try {
219 redisTemplate.opsForHash().putAll(key, map);
220 return true;
221 } catch (Exception e) {
222 e.printStackTrace();
223 return false;
224 }
225 }
226
227 /**
228 * HashSet 并设置时间
229 *
230 * @param key
231 * 键
232 * @param map
233 * 对应多个键值
234 * @param time
235 * 时间(秒)
236 * @return true成功 false失败
237 */
238 public boolean hmset(String key, Map<String, Object> map, long time) {
239 try {
240 redisTemplate.opsForHash().putAll(key, map);
241 if (time > 0) {
242 expire(key, time);
243 }
244 return true;
245 } catch (Exception e) {
246 e.printStackTrace();
247 return false;
248 }
249 }
250
251 /**
252 * 向一张hash表中放入数据,如果不存在将创建
253 *
254 * @param key
255 * 键
256 * @param item
257 * 项
258 * @param value
259 * 值
260 * @return true 成功 false失败
261 */
262 public boolean hset(String key, String item, Object value) {
263 try {
264 redisTemplate.opsForHash().put(key, item, value);
265 return true;
266 } catch (Exception e) {
267 e.printStackTrace();
268 return false;
269 }
270 }
271
272 /**
273 * 向一张hash表中放入数据,如果不存在将创建
274 *
275 * @param key
276 * 键
277 * @param item
278 * 项
279 * @param value
280 * 值
281 * @param time
282 * 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
283 * @return true 成功 false失败
284 */
285 public boolean hset(String key, String item, Object value, long time) {
286 try {
287 redisTemplate.opsForHash().put(key, item, value);
288 if (time > 0) {
289 expire(key, time);
290 }
291 return true;
292 } catch (Exception e) {
293 e.printStackTrace();
294 return false;
295 }
296 }
297
298 /**
299 * 删除hash表中的值
300 *
301 * @param key
302 * 键 不能为null
303 * @param item
304 * 项 可以使多个 不能为null
305 */
306 public void hdel(String key, Object... item) {
307 redisTemplate.opsForHash().delete(key, item);
308 }
309
310 /**
311 * 判断hash表中是否有该项的值
312 *
313 * @param key
314 * 键 不能为null
315 * @param item
316 * 项 不能为null
317 * @return true 存在 false不存在
318 */
319 public boolean hHasKey(String key, String item) {
320 return redisTemplate.opsForHash().hasKey(key, item);
321 }
322
323 /**
324 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
325 *
326 * @param key
327 * 键
328 * @param item
329 * 项
330 * @param by
331 * 要增加几(大于0)
332 * @return
333 */
334 public double hincr(String key, String item, double by) {
335 return redisTemplate.opsForHash().increment(key, item, by);
336 }
337
338 /**
339 * hash递减
340 *
341 * @param key
342 * 键
343 * @param item
344 * 项
345 * @param by
346 * 要减少记(小于0)
347 * @return
348 */
349 public double hdecr(String key, String item, double by) {
350 return redisTemplate.opsForHash().increment(key, item, -by);
351 }
352
353 // ============================set=============================
354 /**
355 * 根据key获取Set中的所有值
356 *
357 * @param key
358 * 键
359 * @return
360 */
361 public Set<Object> sGet(String key) {
362 try {
363 return redisTemplate.opsForSet().members(key);
364 } catch (Exception e) {
365 e.printStackTrace();
366 return null;
367 }
368 }
369
370 /**
371 * 根据value从一个set中查询,是否存在
372 *
373 * @param key
374 * 键
375 * @param value
376 * 值
377 * @return true 存在 false不存在
378 */
379 public boolean sHasKey(String key, Object value) {
380 try {
381 return redisTemplate.opsForSet().isMember(key, value);
382 } catch (Exception e) {
383 e.printStackTrace();
384 return false;
385 }
386 }
387
388 /**
389 * 将数据放入set缓存
390 *
391 * @param key
392 * 键
393 * @param values
394 * 值 可以是多个
395 * @return 成功个数
396 */
397 public long sSet(String key, Object... values) {
398 try {
399 return redisTemplate.opsForSet().add(key, values);
400 } catch (Exception e) {
401 e.printStackTrace();
402 return 0;
403 }
404 }
405
406 /**
407 * 将set数据放入缓存
408 *
409 * @param key
410 * 键
411 * @param time
412 * 时间(秒)
413 * @param values
414 * 值 可以是多个
415 * @return 成功个数
416 */
417 public long sSetAndTime(String key, long time, Object... values) {
418 try {
419 Long count = redisTemplate.opsForSet().add(key, values);
420 if (time > 0)
421 expire(key, time);
422 return count;
423 } catch (Exception e) {
424 e.printStackTrace();
425 return 0;
426 }
427 }
428
429 /**
430 * 获取set缓存的长度
431 *
432 * @param key
433 * 键
434 * @return
435 */
436 public long sGetSetSize(String key) {
437 try {
438 return redisTemplate.opsForSet().size(key);
439 } catch (Exception e) {
440 e.printStackTrace();
441 return 0;
442 }
443 }
444
445 /**
446 * 移除值为value的
447 *
448 * @param key
449 * 键
450 * @param values
451 * 值 可以是多个
452 * @return 移除的个数
453 */
454 public long setRemove(String key, Object... values) {
455 try {
456 Long count = redisTemplate.opsForSet().remove(key, values);
457 return count;
458 } catch (Exception e) {
459 e.printStackTrace();
460 return 0;
461 }
462 }
463 // ===============================list=================================
464
465 /**
466 * 获取list缓存的内容
467 *
468 * @param key
469 * 键
470 * @param start
471 * 开始
472 * @param end
473 * 结束 0 到 -1代表所有值
474 * @return
475 */
476 public List<Object> lGet(String key, long start, long end) {
477 try {
478 return redisTemplate.opsForList().range(key, start, end);
479 } catch (Exception e) {
480 e.printStackTrace();
481 return null;
482 }
483 }
484
485 /**
486 * 获取list缓存的长度
487 *
488 * @param key
489 * 键
490 * @return
491 */
492 public long lGetListSize(String key) {
493 try {
494 return redisTemplate.opsForList().size(key);
495 } catch (Exception e) {
496 e.printStackTrace();
497 return 0;
498 }
499 }
500
501 /**
502 * 通过索引 获取list中的值
503 *
504 * @param key
505 * 键
506 * @param index
507 * 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
508 * @return
509 */
510 public Object lGetIndex(String key, long index) {
511 try {
512 return redisTemplate.opsForList().index(key, index);
513 } catch (Exception e) {
514 e.printStackTrace();
515 return null;
516 }
517 }
518
519 /**
520 * 将list放入缓存
521 *
522 * @param key
523 * 键
524 * @param value
525 * 值
526 * @param time
527 * 时间(秒)
528 * @return
529 */
530 public boolean lSet(String key, Object value) {
531 try {
532 redisTemplate.opsForList().rightPush(key, value);
533 return true;
534 } catch (Exception e) {
535 e.printStackTrace();
536 return false;
537 }
538 }
539
540 /**
541 * 将list放入缓存
542 *
543 * @param key
544 * 键
545 * @param value
546 * 值
547 * @param time
548 * 时间(秒)
549 * @return
550 */
551 public boolean rSet(String key, Object value) {
552 try {
553 redisTemplate.opsForList().rightPush(key, value);
554 return true;
555 } catch (Exception e) {
556 e.printStackTrace();
557 return false;
558 }
559 }
560
561 /**
562 * 将list放入缓存
563 *
564 * @param key
565 * 键
566 * @param value
567 * 值
568 * @param time
569 * 时间(秒)
570 * @return
571 */
572 public boolean lSet(String key, Object value, long time) {
573 try {
574 redisTemplate.opsForList().rightPush(key, value);
575 if (time > 0)
576 expire(key, time);
577 return true;
578 } catch (Exception e) {
579 e.printStackTrace();
580 return false;
581 }
582 }
583
584 /**
585 * 将list放入缓存
586 *
587 * @param key
588 * 键
589 * @param value
590 * 值
591 * @param time
592 * 时间(秒)
593 * @return
594 */
595 public boolean lSet(String key, List<Object> value) {
596 try {
597 redisTemplate.opsForList().rightPushAll(key, value);
598 return true;
599 } catch (Exception e) {
600 e.printStackTrace();
601 return false;
602 }
603 }
604
605 /**
606 * 将list放入缓存
607 *
608 * @param key
609 * 键
610 * @param value
611 * 值
612 * @param time
613 * 时间(秒)
614 * @return
615 */
616 public boolean lSet(String key, List<Object> value, long time) {
617 try {
618 redisTemplate.opsForList().rightPushAll(key, value);
619 if (time > 0)
620 expire(key, time);
621 return true;
622 } catch (Exception e) {
623 e.printStackTrace();
624 return false;
625 }
626 }
627
628 /**
629 * 根据索引修改list中的某条数据
630 *
631 * @param key
632 * 键
633 * @param index
634 * 索引
635 * @param value
636 * 值
637 * @return
638 */
639 public boolean lUpdateIndex(String key, long index, Object value) {
640 try {
641 redisTemplate.opsForList().set(key, index, value);
642 return true;
643 } catch (Exception e) {
644 e.printStackTrace();
645 return false;
646 }
647 }
648
649 /**
650 * 移除N个值为value
651 *
652 * @param key
653 * 键
654 * @param count
655 * 移除多少个
656 * @param value
657 * 值
658 * @return 移除的个数
659 */
660 public long lRemove(String key, long count, Object value) {
661 try {
662 Long remove = redisTemplate.opsForList().remove(key, count, value);
663 return remove;
664 } catch (Exception e) {
665 e.printStackTrace();
666 return 0;
667 }
668 }
669
670 }
7、最后是Redis的测试类，方便自己进行测试使用。
1 package com.fline.aic.utils;
2
3 import java.util.List;
4 import java.util.Map;
5 import java.util.Map.Entry;
6 import java.util.Set;
7
8 import org.junit.Before;
9 import org.junit.Test;
10 import org.springframework.context.ApplicationContext;
11 import org.springframework.context.support.ClassPathXmlApplicationContext;
12
13 /**
14 *
15 * @Description TODO
16 * @author biehl
17 * @Date 2018年12月7日 下午8:25:34
18 *
19 * 参考：https://www.cnblogs.com/qlqwjy/p/8562703.html
20 */
21 public class RedisTest {
22
23 private RedisUtil redisUtils = null;
24
25 @Before
26 public void before() {
27 ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext-redis.xml");
28 redisUtils = (RedisUtil) context.getBean("redisUtil");
29 }
30
31 // redis存放String类型的
32 @Test
33 public void redisString() throws InterruptedException {
34 // 从redis数据库中获取到dd的字符串
35 String str = (String) redisUtils.get("dd");
36 // 如果获取到的str字符串不为空
37 if (str != null) {
38 // 就删除这个str字符串
39 redisUtils.del(str);
40 }
41 // 将key为dd和value为dd设置到redis里面
42 redisUtils.set("dd", "dd");
43 // 打印该key为dd的字符串
44 System.out.println(redisUtils.get("dd"));
45 }
46
47 // redis存放List类型的
48 @Test
49 public void redisList() throws InterruptedException {
50 // 删除key为list1
51 redisUtils.del("list1");
52 redisUtils.lSet("list1", "list1");
53 redisUtils.lSet("list1", "list2");
54 redisUtils.lSet("list1", "list3");
55 redisUtils.rSet("list1", "list4");
56 List<Object> lGet = redisUtils.lGet("list1", 0, -1);
57 // redisTemplate.opsForList().range("myList", 0, -1);
58 for (Object s : lGet) {
59 System.out.println(s);
60 }
61 }
62
63 // redis存放Set类型的
64 @Test
65 public void redisSet() throws InterruptedException {
66 redisUtils.del("set1");
67 redisUtils.sSet("set1", "set1");
68 redisUtils.sSet("set1", "set2");
69 redisUtils.sSet("set1", "set3");
70 redisUtils.sSet("set1", "set4");
71 Set<Object> sGet = redisUtils.sGet("set1");
72 for (Object s : sGet) {
73 System.out.println(s);
74 }
75 }
76
77 // redis存放Hash类型的
78 @Test
79 public void redisHash() throws InterruptedException {
80 redisUtils.del("hash1");
81 redisUtils.hset("hash1", "beijing", "北京");
82 redisUtils.hset("hash1", "shanghai", "上海");
83 redisUtils.hset("hash1", "chenzhen", "深圳");
84 redisUtils.hset("hash1", "xinxiang", "新乡");
85 Map<Object, Object> hmget = redisUtils.hmget("hash1");
86 Set<Entry<Object, Object>> entrySet = hmget.entrySet();
87 for (Map.Entry<Object, Object> hash : entrySet) {
88 System.out.println(hash.getKey() + " : " + hash.getValue());
89 }
90 }
91
92 }
效果如下所示：
待续.....
