<?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"  
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
           xmlns:p="http://www.springframework.org/schema/p"  
           xmlns:aop="http://www.springframework.org/schema/aop"  
           xmlns:context="http://www.springframework.org/schema/context"  
           xmlns:jee="http://www.springframework.org/schema/jee"  
           xmlns:tx="http://www.springframework.org/schema/tx"  
           xsi:schemaLocation="  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">  
          
        <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <!-- redis最大連線數最好設定為200，不然會出現很多報錯 -->  
            <property name="maxTotal" value="200"></property>  
            <property name="maxIdle" value="200"></property>  
            <property name="minIdle" value="6"></property>  
            <!-- 在丟擲異常之前，呼叫的執行緒將會阻塞maxWaitMillis時長。預設值為true。推薦在生產環境下設定為true；測試環境下設定為false。 -->  
            <property name="blockWhenExhausted" value="false"></property>  
            <property name="maxWaitMillis" value="1000"></property>  
        </bean>  
        <bean id="sentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">  
            <property name="master">  
                <bean class="org.springframework.data.redis.connection.RedisNode">  
                    <property name="name" value="mymaster"></property>  
                </bean>  
            </property>  
            <property name="sentinels">  
                <set>  
                    <bean class="org.springframework.data.redis.connection.RedisNode">  
                        <constructor-arg name="host" value="10.153.29.54"></constructor-arg>  
                        <constructor-arg name="port" value="16379"></constructor-arg>  
                    </bean>  
                    <bean class="org.springframework.data.redis.connection.RedisNode">  
                        <constructor-arg name="host" value="10.153.29.54"></constructor-arg>  
                        <constructor-arg name="port" value="26379"></constructor-arg>  
                    </bean>  
                    <bean class="org.springframework.data.redis.connection.RedisNode">  
                        <constructor-arg name="host" value="10.153.29.55"></constructor-arg>  
                        <constructor-arg name="port" value="16379"></constructor-arg>  
                    </bean>  
                </set>  
            </property>  
        </bean>  
          
        <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
            destroy-method="destroy">  
            <property name="timeout" value="15000" />  
            <property name="database" value="0" />  
            <property name="password" value="" />  
            <property name="usePool" value="true" />  
            <property name="poolConfig" ref="jedisPoolConfig" />  
            <constructor-arg name="sentinelConfig" ref="sentinelConfiguration"></constructor-arg>  
        </bean>  
      
        <!-- redis template definition p表示對該bean裡面的屬性進行注入，格式為p:屬性名=注入的物件 效果與在bean裡面使用<property>標籤一樣 -->  
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" p:connection-factory-ref="jedisConnectionFactory">  
            <property name="defaultSerializer">  
                <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
            </property>  
        </bean>  
        <!-- 對string操作的封裝 -->  
        <bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"  
            p:connection-factory-ref="jedisConnectionFactory" >  
            <property name="defaultSerializer">  
                <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
            </property>  
        </bean>  
          
          
    </beans>  
 

1. import java.util.List;  
2. import java.util.Map;  
3. import java.util.Set;  
4. import java.util.concurrent.TimeUnit;  
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.data.redis.core.StringRedisTemplate;  
7. import org.springframework.data.redis.hash.HashMapper;  
8. import org.springframework.stereotype.Service;  
9. /** 
10.  *  
11.  * @author baoy 
12.  * 
13.  */
14. @Service
15. publicclass RedisRepositoryImpl implements RedisRepository {  
16.     //private static final Logger logger = LoggerFactory.getLogger(RedisRepositoryImpl.class);
17.     @Autowired
18.     private StringRedisTemplate stringRedisTemplate;  
19.     //@Autowired
20.     //private RedisTemplate redisTemplate;
21.     private String keyPrefix = "";  
22.     publicvoid setKeyPrefix(String keyPrefix) {  
23.         if (keyPrefix == null || "".equals(keyPrefix)) {  
24.             this.keyPrefix = "";  
25.         } else {  
26.             this.keyPrefix = keyPrefix;  
27.         }  
28.     }  
29.     /** 
30.      * <pre> 
31.      * 命令：ttl key 
32.      * 說明：以秒為單位，返回給定 key的剩餘生存時間(TTL, time to live)。 
33.      * </pre> 
34.      * @param key 
35.      * @return 
36.      */
37.     publiclong ttl(String key) {  
38.         return stringRedisTemplate.getExpire(keyPrefix+key);  
39.     }  
40.     /** 
41.      * <pre> 
42.      * 命令：keys pattern 
43.      * 說明：查詢所有符合給定模式 pattern的 key 
44.      * </pre> 
45.      */
46.     public Set<String> keys(String pattern) {  
47.         return stringRedisTemplate.keys(pattern);  
48.     }  
49.     /** 
50.      * <pre> 
51.      * 命令：del key 
52.      * 說明：刪除一個key 
53.      * </pre> 
54.      * @param key 
55.      */
56.     publicvoid del(String key) {  
57.         stringRedisTemplate.delete(keyPrefix+key);  
58.     }  
59.     //****************String
60.     /**  
61.      * <pre>  
62.      * 命令：set key value  
63.      * 說明：將key的值設定為value  
64.      * </pre>  
65.      * @param key  
66.      * @param value  
67.      */  
68.     publicvoid set(String key, String value) {  
69.         stringRedisTemplate.opsForValue().set(keyPrefix+key, value);  
70.     }  
71.     /** 
72.      * <pre> 
73.      * 命令：SET key value EX seconds 
74.      * 說明：設定key值的同時，為該key設定超時時間（秒） 
75.      * </pre> 
76.      * @param key 
77.      * @param value 
78.      * @param timeout 
79.      */
80.     publicvoid set(String key, String value, long timeout) {  
81.         stringRedisTemplate.opsForValue().set(keyPrefix+key, value, timeout, TimeUnit.SECONDS);  
82.     }  
83.     /** 
84.      * <pre> 
85.      * 命令：setNx key value 
86.      * 含義：與set的區別是，如果不存在時，寫入；存在時，不覆蓋 
87.      * </pre> 
88.      * @param key 
89.      * @param value 
90.      */
91.     publicboolean setNx(String key, String value) {  
92.         return stringRedisTemplate.opsForValue().setIfAbsent(keyPrefix+key, value);  
93.     }  
94.     /** 
95.      * <pre> 
96.      * 命令：GET key 
97.      * 說明：獲取key值 
98.      * </pre> 
99.      * @param key 
100.      * @return value 
101.      */
102.     public String get(String key) {  
103.         return stringRedisTemplate.opsForValue().get(keyPrefix+key);  
104.     }  
105.     //****************Hash
106.     /**  
107.      * <pre>  
108.      * 命令：hSet key field value  
109.      * 含義：  
110.      * 1、將雜湊表 key中的域 field的值設為 value  
111.      * 2、覆蓋舊有field的value  
112.      * </pre>  
113.      * @param key  
114.      * @param field  
115.      * @param value  
116.      */  
117.     publicvoid hSet(String key, String field, Object value) {  
118.         stringRedisTemplate.opsForHash().put(keyPrefix+key, field, value);  
119.     }  
120.     /** 
121.      * <pre> 
122.      * 命令：hSetNx key field value 
123.      * 含義：與hSet的區別是，如果不存在時，寫入；存在時，不覆蓋 
124.      * </pre> 
125.      * @param key 
126.      * @param field 
127.      * @param value 
128.      */
129.     publicboolean hSetNx(String key, String field, Object value) {  
130.         return stringRedisTemplate.opsForHash().putIfAbsent(keyPrefix+key, field, value);  
131.     }  
132.     /** 
133.      * <pre> 
134.      * 命令：HGET key field 
135.      * 說明：返回雜湊表 key中給定域 field的值 
136.      * </pre> 
137.      * @param key 
138.      * @param field 
139.      * @return 
140.      */
141.     public String hGet(String key, String field) {  
142.         return (String) stringRedisTemplate.opsForHash().get(keyPrefix+key, field);  
143.     }  
144.     /** 
145.      * <pre> 
146.      * 命令：hGetAll key 
147.      * 說明：獲取指定key先所有的key/value的鍵值對 
148.      * </pre> 
149.      * @param key 
150.      * @return 
151.      */
152.     public Map hGetAll(String key) {  
153.         return (Map) stringRedisTemplate.opsForHash().entries(keyPrefix+key);  
154.     }  
155.     /** 
156.      * <pre> 
157.      * 命令：hDel key field [field ...] 
158.      * 說明：刪除雜湊表 key 中的一個或多個指定域，不存在的域將被忽略。 
159.      * </pre> 
160.      * @param key 
161.      * @param fields 
162.      */
163.     publicvoid hDel(String key, Object... fields) {  
164.         stringRedisTemplate.opsForHash().delete(keyPrefix+key, fields);  
165.     }  
166.     //****************List
167.     /**  
168.      * <pre>  
169.      * 命令：lPush key value  
170.      * 說明：  
171.      * 1.將一個值 value插入到列表 key的最左邊  
172.      * 2.當該列表key不存在時，則建立  
173.      * </pre>  
174.      * @param key  
175.      * @param value  
176.      * @return 執行 lPush命令後，列表的長度  
177.      */  
178.     publiclong lPush(String key, String value) {   
179.         return stringRedisTemplate.opsForList().leftPush(keyPrefix+key, value);  
180.     }  
181.     /** 
182.      * <pre> 
183.      * 命令：lPop key 
184.      * 說明：移除該列表key最左邊的元素 
185.      * </pre> 
186.      * @param key 
187.      * @return 列表key的最左邊元素。 
188.      */
189.     public String lPop(String key) {  
190.         return stringRedisTemplate.opsForList().leftPop(keyPrefix+key);  
191.     }  
192.     public List<String> range(String key,int start,int end){  
193.         return stringRedisTemplate.opsForList().range(keyPrefix+key, start, end);  
194.     }  
195.     publiclong llen(String key){  
196.         return stringRedisTemplate.opsForList().size(keyPrefix+key);  
197.     }  
198.     /** 
199.      * <pre> 
200.      * 命令：rPush key value 
201.      * 說明：向list最右邊插入元素value 
202.      * </pre> 
203.      * @param key 
204.      * @param value 
205.      * @return 執行 rPush命令後，列表的長度 
206.      */
207.     publiclong rPush(String key, String value) {   
208.         return stringRedisTemplate.opsForList().rightPush(keyPrefix+key, value);  
209.     }  
210.     /** 
211.      * <pre> 
212.      * 命令：rPop key 
213.      * 說明：移除並返回列表 key的最右邊元素 
214.      * </pre> 
215.      * @param key 
216.      * @return 列表key的最右邊元素。 
217.      */
218.     public String rPop(String key) {  
219.         return stringRedisTemplate.opsForList().rightPop(keyPrefix+key);  
220.     }  
221.     //****************Set
222.     /**  
223.      * <pre>  
224.      * 命令：sAdd key value  
225.      * 說明：  
226.      * 1.將一個 value元素加入到集合 key當中  
227.      * 2.已經存在於集合的 value元素將被忽略。  
228.      * </pre>  
229.      * @param key  
230.      * @param value  
231.      */  
232.     public Long sAdd(String key, String value) {  
233.         return stringRedisTemplate.opsForSet().add(keyPrefix+key, value);  
234.     }  
235.     /** 
236.      * <pre> 
237.      * 命令：sMembers key 
238.      * 說明：返回集合 key 中的所有成員。 
239.      * </pre> 
240.      * @param key 
241.      * @return 
242.      */
243.     public Set<String> sMembers(String key) {  
244.         return stringRedisTemplate.opsForSet().members(keyPrefix+key);  
245.     }  
246.     /** 
247.      * <pre> 
248.      * 命令：sRem key v1[v2 v3…]。 
249.      * 說明：刪除key中指定的values 
250.      * </pre> 
251.      * @param key 
252.      * @param values 
253.      * @return 返回被刪除的元素的數量，如果沒有被刪除的元素，則返回0 
254.      */
255.     public Long sRem(String key, Object... values) {  
256.         return stringRedisTemplate.opsForSet().remove(keyPrefix+key, values);  
257.     }  
258.     //****************SortedSet
259.     /**  
260.      * <pre>  
261.      * 命令：zAdd key score member  
262.      * 說明：將一個 member元素及其 score值加入到有序集 key當中。  
263.      * <pre>  
264.      * @param key  
265.      * @param score  
266.      * @param value  
267.      */  
268.     publicvoid zAdd(String key, double score, String value) {  
269.         stringRedisTemplate.opsForZSet().add(keyPrefix+key, value, score);  
270.     }  
271.     /** 
272.      * <pre> 
273.      * 命令：zRange key start stop 
274.      * 說明：返回有序集 key中，指定區間內的成員。 
275.      * </pre> 
276.      * @param key 
277.      * @param start 
278.      * @param stop 
279.      * @return 
280.      */
281.     public Set<String> zRange(String key, double start, double stop) {  
282.         return stringRedisTemplate.opsForZSet().rangeByScore(keyPrefix+key, start, stop);  
283.     }  
284.     //=====obj2map map2obj
285.     /** 
286.      * 物件轉map。可應用於多個物件（一個類中的屬性是另外一個類） 
287.      * @param t 
288.      * @param mapper 
289.      * @return 
290.      */
291.     public <T> Map obj2map(T t, HashMapper<T, String, String> mapper) {  
292.         return mapper.toHash(t);  
293.     }  
294.     /** 
295.      * map轉物件。只應用於單個物件 
296.      * @param map 
297.      * @param mapper 
298.      * @return 
299.      */
300.     public <T> T map2obj(Map map, HashMapper<T, String, String> mapper) {  
301.         return mapper.fromHash(map);  
302.     }  
303. }  

1. import java.util.List;  
2. import java.util.Map;  
3. import java.util.Set;  
4. import org.springframework.data.redis.hash.HashMapper;  
5. /** 
6.  *  
7.  * @author baoy 
8.  * 
9.  */
10. publicinterface RedisRepository {  
11.     /** 
12.      * <pre> 
13.      * 命令：ttl key 
14.      * 說明：以秒為單位，返回給定 key的剩餘生存時間(TTL, time to live)。 
15.      * </pre> 
16.      * @param key 
17.      * @return 
18.      */
19.     long ttl(String key);  
20.     /** 
21.      * <pre> 
22.      * 命令：keys pattern 
23.      * 說明：查詢所有符合給定模式 pattern的 key 
24.      * </pre> 
25.      */
26.     Set<String> keys(String pattern);  
27.     /** 
28.      * <pre> 
29.      * 命令：del key 
30.      * 說明：刪除一個key 
31.      * </pre> 
32.      * @param key 
33.      */
34.     void del(String key);  
35.     //****************String
36.     /**  
37.      * <pre>  
38.      * 命令：set key value  
39.      * 說明：將key的值設定為value  
40.      * </pre>  
41.      * @param key  
42.      * @param value  
43.      */  
44.     void set(String key, String value);  
45.     /** 
46.      * <pre> 
47.      * 命令：SET key value EX seconds 
48.      * 說明：設定key值的同時，為該key設定超時時間（秒） 
49.      * </pre> 
50.      * @param key 
51.      * @param value 
52.      * @param timeout 
53.      */
54.     void set(String key, String value, long timeout);  
55.     /** 
56.      * <pre> 
57.      * 命令：setNx key value 
58.      * 含義：與set的區別是，如果不存在時，寫入；存在時，不覆蓋 
59.      * </pre> 
60.      * @param key 
61.      * @param value 
62.      */
63.     boolean setNx(String key, String  value);   
64.     /** 
65.      * <pre> 
66.      * 命令：GET key 
67.      * 說明：獲取key值 
68.      * </pre> 
69.      * @param key 
70.      * @return value 
71.      */
72.     String get(String key);  
73.     //****************Hash
74.     /**  
75.      * <pre>  
76.      * 命令：hSet key field value  
77.      * 含義：  
78.      * 1、將雜湊表 key中的域 field的值設為 value  
79.      * 2、覆蓋舊有field的value  
80.      * </pre>  
81.      * @param key  
82.      * @param field  
83.      * @param value  
84.      */  
85.     void hSet(String key, String field, Object value);  
86.     /** 
87.      * <pre> 
88.      * 命令：hSetNx key field value 
89.      * 含義：與hSet的區別是，如果不存在時，寫入；存在時，不覆蓋 
90.      * </pre> 
91.      * @param key 
92.      * @param field 
93.      * @param value 
94.      */
95.     boolean hSetNx(String key, String field, Object value);  
96.     /** 
97.      * <pre> 
98.      * 命令：HGET key field 
99.      * 說明：返回雜湊表 key中給定域 field的值 
100.      * </pre> 
101.      * @param key 
102.      * @param field 
103.      * @return 
104.      */
105.     String hGet(String key, String field);  
106.     /** 
107.      * <pre> 
108.      * 命令：hGetAll key 
109.      * 說明：獲取指定key先所有的key/value的鍵值對 
110.      * </pre> 
111.      * @param key 
112.      * @return 
113.      */
114.     Map hGetAll(String key);  
115.     /** 
116.      * <pre> 
117.      * 命令：hDel key field [field ...] 
118.      * 說明：刪除雜湊表 key 中的一個或多個指定域，不存在的域將被忽略。 
119.      * </pre> 
120.      * @param key 
121.      * @param fields 
122.      */
123.     void hDel(String key, Object... fields);  
124.     //****************List
125.     /**  
126.      * <pre>  
127.      * 命令：lPush key value  
128.      * 說明：  
129.      * 1.將一個值 value插入到列表 key的最左邊  
130.      * 2.當該列表key不存在時，則建立  
131.      * </pre>  
132.      * @param key  
133.      * @param value  
134.      * @return 執行 lPush命令後，列表的長度  
135.      */  
136.     long lPush(String key, String value);  
137.     /** 
138.      * <pre> 
139.      * 命令：lPop key 
140.      * 說明：移除該列表key最左邊的元素 
141.      * </pre> 
142.      * @param key 
143.      * @return 列表key的最左邊元素。 
144.      */
145.     String lPop(String key);  
146.     List<String> range(String key,int start,int end);  
147.     long llen(String key);  
148.     /** 
149.      * <pre> 
150.      * 命令：rPush key value 
151.      * 說明：向list最右邊插入元素value 
152.      * </pre> 
153.      * @param key 
154.      * @param value 
155.      * @return 執行 rPush命令後，列表的長度 
156.      */
157.     long rPush(String key, String value);  
158.     /** 
159.      * <pre> 
160.      * 命令：rPop key 
161.      * 說明：移除並返回列表 key的最右邊元素 
162.      * </pre> 
163.      * @param key 
164.      * @return 列表key的最右邊元素。 
165.      */
166.     String rPop(String key);  
167.     //****************Set
168.     /**  
169.      * <pre>  
170.      * 命令：sAdd key value  
171.      * 說明：  
172.      * 1.將一個 value元素加入到集合 key當中  
173.      * 2.已經存在於集合的 value元素將被忽略。  
174.      * </pre>  
175.      * @param key  
176.      * @param value  
177.      */  
178.     Long sAdd(String key, String value);  
179.     /** 
180.      * <pre> 
181.      * 命令：sMembers key 
182.      * 說明：返回集合 key 中的所有成員。 
183.      * </pre> 
184.      * @param key 
185.      * @return 
186.      */
187.     Set<String> sMembers(String key);  
188.     /** 
189.      * <pre> 
190.      * 命令：sRem key v1[v2 v3…]。 
191.      * 說明：刪除key中指定的values 
192.      * </pre> 
193.      * @param key 
194.      * @param values 
195.      * @return 返回被刪除的元素的數量，如果沒有被刪除的元素，則返回0 
196.      */
197.     Long sRem(String key, Object... values);  
198.     //****************SortedSet
199.     /**  
200.      * <pre>  
201.      * 命令：zAdd key score member  
202.      * 說明：將一個 member元素及其 score值加入到有序集 key當中。  
203.      * <pre>  
204.      * @param key  
205.      * @param score  
206.      * @param value  
207.      */  
208.     void zAdd(String key, double score, String value);  
209.     /** 
210.      * <pre> 
211.      * 命令：zRange key start stop 
212.      * 說明：返回有序集 key中，指定區間內的成員。 
213.      * </pre> 
214.      * @param key 
215.      * @param start 
216.      * @param stop 
217.      * @return 
218.      */
219.     Set<String> zRange(String key, double start, double stop);  
220.     //=====obj2map map2obj
221.     /** 
222.      * 物件轉map。可應用於多個物件（一個類中的屬性是另外一個類） 
223.      * @param t 
224.      * @param mapper 
225.      * @return 
226.      */
227.     <T> Map obj2map(T t, HashMapper<T, String, String> mapper);  
228.     /** 
229.      * map轉物件。只應用於單個物件 
230.      * @param map 
231.      * @param mapper 
232.      * @return 
233.      */
234.     <T> T map2obj(Map map, HashMapper<T, String, String> mapper);  
235. }