转载：https://www.cnblogs.com/JJJ1990/p/10438292.html

一，redis安装

首先我们需要下载Windows版本的redis压缩包地址如下：

https://github.com/MicrosoftArchive/redis/releases

连接打开后如下图所示

我们选择64位的压缩包，下载后需要解压，我们解压至D盘，如下图所示：

接下来我们需要执行一些安装命令

1，在如上图的目录中，直接键入“cmd“

2，在打开的cmd命令窗口中输入 “redis-server.exe redis.windows.conf” 用于启动redis服务

（注意采用这个命令相当于启动一个临时服务，如果当前窗口被关闭，则服务也会被关闭）

3，我们再打开一个同样的cmd命令窗口，在其中键入 “redis-cli” ，这个命令的作用是启动一个redis客户端。客户端默认的端口号是6379 如果我们要修改端口号，需要打开我们前面执行的命令中的conf文件redis.windows.conf 找到port 修改其后的端口号

4，在启动的客户端中检查redis服务是否正常，我们可以进行数据的设置和读取等操作，比如我们可以执行一个命令 “set redis jj”，然后我们再执行一个命令“get redis” 就可以将前面设置的123 查询出来 ，如下图所示

5，将redis服务注册到我们的Windows，我们继续新打开一个cmd窗口，执行命令 “redis-server --service-install redis.windows.conf” 这个时候呢，提示：Redis successfully installed as a service. 表示加入服务成功！

6，启动注册到Windows的redis服务。键入命令“redis-server.exe --service-start” 可能会报错，如下图。原因是我们已经在这个端口绑定了一个服务，就是我们前面启动的那个所谓的临时服务，这个时候我们需要关闭刚才启动的临时服务的窗口。

7，再启动如果还是报上面的错误，那可能需要我们调整注册到Windows的服务为本地系统服务，而不是网络服务，如下图所示。除此之外可能还会有防火墙等问题导致redis服务启动失败。

8，如下图所示，服务启动ok，这个时候我们在继续操作redis客户端是没有问题的。

二，springboot 集成redis

1，新建springboot工程，如果有不清楚如何新建的，请移步 https://www.cnblogs.com/JJJ1990/p/8384386.html

2，在pom文件中加入redis jar包的引用

我的整个工程的pom文件如下，注意第34-38行，即为引入的redis 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/xsd/maven-4.0.0.xsd">
 3 <modelVersion>4.0.0</modelVersion>
 4 
 5 <groupId>com</groupId>
 6 <artifactId>redis</artifactId>
 7 <version>0.0.1-SNAPSHOT</version>
 8 <packaging>jar</packaging>
 9 
10 <name>redis</name>
11 <url>http://maven.apache.org</url>
12 
13 <properties>
14 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15 </properties>
16 
17 <parent>
18 <groupId>org.springframework.boot</groupId>
19 <artifactId>spring-boot-starter-parent</artifactId>
20 <version>1.5.8.RELEASE</version>
21 </parent>
22 
23 <dependencies>
24 <dependency>
25 <groupId>junit</groupId>
26 <artifactId>junit</artifactId>
27 <version>3.8.1</version>
28 <scope>test</scope>
29 </dependency>
30 <dependency>
31 <groupId>org.springframework.boot</groupId>
32 <artifactId>spring-boot-starter-web</artifactId>
33 </dependency>
34 <dependency>
35 <groupId>org.springframework.boot</groupId>
36 <artifactId>spring-boot-starter-data-redis</artifactId>
37 </dependency> 
38 </dependencies>
39 </project>

3，编写RedisConfig 类代码

 1 package com.redis;
 2 
 3 import org.springframework.beans.factory.annotation.Value;
 4 import org.springframework.context.annotation.Bean;
 5 import org.springframework.context.annotation.Configuration;
 6 import org.springframework.context.annotation.PropertySource;
 7 import org.springframework.data.redis.connection.RedisConnectionFactory;
 8 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
 9 import org.springframework.data.redis.core.RedisTemplate;
 10 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 11 import org.springframework.data.redis.serializer.StringRedisSerializer;
 12 
 13 import redis.clients.jedis.JedisPoolConfig;
 14 
 15 @Configuration
 16 @PropertySource("classpath:config/redis.properties")
 17 public class RedisConfig {
 18 
 19 @Value("${redis.maxIdle}")
 20 private Integer maxIdle;
 21 
 22 @Value("${redis.maxTotal}")
 23 private Integer maxTotal;
 24 
 25 @Value("${redis.maxWaitMillis}")
 26 private Integer maxWaitMillis;
 27 
 28 @Value("${redis.minEvictableIdleTimeMillis}")
 29 private Integer minEvictableIdleTimeMillis;
 30 
 31 @Value("${redis.numTestsPerEvictionRun}")
 32 private Integer numTestsPerEvictionRun;
 33 
 34 @Value("${redis.timeBetweenEvictionRunsMillis}")
 35 private long timeBetweenEvictionRunsMillis;
 36 
 37 @Value("${redis.testOnBorrow}")
 38 private boolean testOnBorrow;
 39 
 40 @Value("${redis.testWhileIdle}")
 41 private boolean testWhileIdle;
 42 
 43 
 44 @Value("${spring.redis.cluster.nodes}")
 45 private String clusterNodes; 
 46 
 47 @Value("${spring.redis.cluster.max-redirects}")
 48 private Integer mmaxRedirectsac;
 49 
 50 /**
 51 * JedisPoolConfig 连接池
 52 * @return
 53 */
 54 @Bean
 55 public JedisPoolConfig jedisPoolConfig() {
 56 JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
 57 // 最大空闲数
 58 jedisPoolConfig.setMaxIdle(maxIdle);
 59 // 连接池的最大数据库连接数
 60 jedisPoolConfig.setMaxTotal(maxTotal);
 61 // 最大建立连接等待时间
 62 jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
 63 // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
 64 jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
 65 // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
 66 jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
 67 // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
 68 jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
 69 // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
 70 jedisPoolConfig.setTestOnBorrow(testOnBorrow);
 71 // 在空闲时检查有效性, 默认false
 72 jedisPoolConfig.setTestWhileIdle(testWhileIdle);
 73 System.out.println("redis 连接池配置完成！");
 74 return jedisPoolConfig;
 75 }
 76 /**
 77 * 单机版配置
 78 * @throws
 79 */
 80 @Bean
 81 public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
 82 JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
 83 //连接池 
 84 JedisConnectionFactory.setPoolConfig(jedisPoolConfig); 
 85 //IP地址 
 86 JedisConnectionFactory.setHostName("127.0.0.1"); 
 87 //端口号 
 88 JedisConnectionFactory.setPort(6379); 
 89 //如果Redis设置有密码 
 90 //JedisConnectionFactory.setPassword(password); 
 91 //客户端超时时间单位是毫秒 
 92 JedisConnectionFactory.setTimeout(5000); 
 93 System.out.println("jedis 连接工厂配置完成！");
 94 return JedisConnectionFactory; 
 95 }
 96 
 97 /**
 98 * 实例化 RedisTemplate 对象
 99 * @return
100 */
101 @Bean
102 public RedisTemplate<String, Object> functionDomainRedisTemplate(JedisConnectionFactory redisConnectionFactory) {
103 RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
104 initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
105 System.out.println("functionDomainRedisTemplates 配置完成！");
106 return redisTemplate;
107 }
108 /**
109 * 设置数据存入 redis 的序列化方式,并开启事务
110 * @param redisTemplate
111 * @param factory
112 */
113 private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
114 //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！ 
115 redisTemplate.setKeySerializer(new StringRedisSerializer());
116 redisTemplate.setHashKeySerializer(new StringRedisSerializer());
117 redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
118 redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
119 // 开启事务
120 redisTemplate.setEnableTransactionSupport(true);
121 redisTemplate.setConnectionFactory(factory);
122 }
123 /**
124 * 注入封装RedisTemplate
125 * @Title: redisUtil 
126 * @return RedisUtil
127 * @throws
128 */
129 @Bean(name = "redisUtil")
130 public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
131 RedisUtil redisUtil = new RedisUtil();
132 redisUtil.setRedisTemplate(redisTemplate);
133 System.out.println("redisUtil 配置完成！");
134 return redisUtil;
135 }
136 }

4，编写RedisUtil类，用于操作redis数据库

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

5，新建 redis.properties 文件

注意文件位置，在我们新建RedisConfig 的时候有指定 为config/redis.properties ，所以我们的redis.properties 文件位置如下图所示

6，编写redis.properties 文件内容

 1 #Matser的ip地址 
 2 redis.hostName=172.0.0.1
 3 #端口号 
 4 redis.port=6379
 5 #如果有密码 
 6 redis.password=
 7 #客户端超时时间单位是毫秒 默认是2000 
 8 redis.timeout=10000 
 9 
10 #最大空闲数 
11 redis.maxIdle=300 
12 #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal 
13 #redis.maxActive=600 
14 #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性 
15 redis.maxTotal=1000 
16 #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。 
17 redis.maxWaitMillis=1000 
18 #连接的最小空闲时间 默认1800000毫秒(30分钟) 
19 redis.minEvictableIdleTimeMillis=300000 
20 #每次释放连接的最大数目,默认3 
21 redis.numTestsPerEvictionRun=1024 
22 #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1 
23 redis.timeBetweenEvictionRunsMillis=30000 
24 #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个 
25 redis.testOnBorrow=true 
26 #在空闲时检查有效性, 默认false 
27 redis.testWhileIdle=true 
28 
29 #redis集群配置 
30 spring.redis.cluster.nodes=192.168.177.128:7001,192.168.177.128:7002,192.168.177.128:7003,192.168.177.128:7004,192.168.177.128:7005,192.168.177.128:7006
31 spring.redis.cluster.max-redirects=3

7,编写测试controller

 1 package com.redis;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Controller;
 5 import org.springframework.web.bind.annotation.PathVariable;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RequestMethod;
 8 import org.springframework.web.bind.annotation.ResponseBody;
 9 
10 @Controller
11 public class Firstblood {
12 
13 @Autowired
14 RedisUtil redisUtil;
15 
16 @RequestMapping(value="/FristBlood/{name}",method= RequestMethod.GET)
17 @ResponseBody
18 public String hello(@PathVariable("name") String name) {
19 return "查询结果：" + redisUtil.get(name) ;
20 }
21 }

8，测试验证

打开浏览器，输入 “http://localhost:8080/FristBlood/redis” 这个url中的redis就等于是我们本次请求要查询的key ，

但是这块有一个问题是，我们使用了@ResponseBody 注解，但是我们在redis数据库中，之前存入的时候，我们执行了一个命令"set redis jj" ,

虽然我们认为存入的是一个字符串但是在我们代码中执行获取这个key的value的时候不会这么认为，会导致解析出错。

这个时候我们从新set一下，如下图

然后在浏览器中我们继续输入上面的url，返回的结果页面如下，则说明整个工程ok

如果输入的key不存在 则返回null，如下图所示：