Windows環境下springboot集成redis的安裝與使用

時間 2019-12-13

標籤 windows 環境 springboot 集成 redis 安裝使用欄目 Windows 简体版

原文原文鏈接

一，redis安裝html

首先咱們須要下載Windows版本的redis壓縮包地址以下：java

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

鏈接打開後以下圖所示git

咱們選擇64位的壓縮包，下載後須要解壓，咱們解壓至D盤，以下圖所示：github

接下來咱們須要執行一些安裝命令web

1，在如上圖的目錄中，直接鍵入「cmd「redis

2，在打開的cmd命令窗口中輸入「redis-server.exe redis.windows.conf」用於啓動redis服務spring

（注意採用這個命令至關於啓動一個臨時服務，若是當前窗口被關閉，則服務也會被關閉）數據庫

3，咱們再打開一個一樣的cmd命令窗口，在其中鍵入「redis-cli」，這個命令的做用是啓動一個redis客戶端。客戶端默認的端口號是6379 若是咱們要修改端口號，須要打開咱們前面執行的命令中的conf文件redis.windows.conf 找到port 修改其後的端口號apache

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工程，若是有不清楚如何新建的，請移步 http://www.javashuo.com/article/p-ypsgaemc-cw.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 }