第十章企業項目開發--分散式緩存Redis(2)

註意：本章代碼是在上一章的基礎上進行添加修改，上一章鏈接《第九章企業項目開發--分散式緩存Redis(1)》上一章說了ShardedJedisPool的創建過程，以及redis五種數據結構的第一種String類型的常用緩存操作方法。下麵說餘下的四種： list（有序列表） set（無序集合） s

註意：本章代碼是在上一章的基礎上進行添加修改，上一章鏈接《第九章企業項目開發--分散式緩存Redis(1)》

上一章說了ShardedJedisPool的創建過程，以及redis五種數據結構的第一種String類型的常用緩存操作方法。下麵說餘下的四種：

list（有序列表）
set（無序集合）
sorted set（有序集合）
hash

1、ssmm0-cache

1.1、RedisListUtil（有序列表工具類）

  1 package com.xxx.cache.redis;
  2 
  3 import java.util.List;
  4 
  5 import redis.clients.jedis.ShardedJedis;
  6 
  7 /**
  8  * list緩存操作類
  9  * 1、順序為插入list的順序
 10  * 2、允許存放重覆元素
 11  * 3、可用作模擬隊列（queue）、堆棧（stack），支持雙向操作（L--首部或者R--尾部）
 12  * 4、index從0開始 -1表示結尾  -2表示倒數第二個
 13  * 5、API中的 start end參數 都是包前也包後的
 14  */
 15 public class RedisListUtil extends RedisBaseUtil{
 16     
 17     /***************************添加緩存*****************************/
 18     /**
 19      * 從左邊（首部）加入列表
 20      * 註意：
 21      * 1、可以一次性入隊n個元素（這裡使用了不定參數,當然可以換做數組）
 22      * 2、不定參數必須放在所有參數的最後邊
 23      * 3、左邊入隊，相當於在隊頭插入元素，則之後的元素都要後移一位；而右邊入隊的話元素直接插在隊尾，之前的元素的索引不變
 24      * 4、沒有從list中獲取指定value的運算
 25      */
 26     public static void lpush(String list, String... values){
 27         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 28         ShardedJedis jedis = null;
 29         try {
 30             jedis = getJedis();//獲取jedis實例
 31             if(jedis==null){
 32                 broken = true;
 33                 return;
 34             }
 35             /*
 36              * lpush(String key, String... strings);
 37              * 返回push之後的list中包含的元素個數
 38              */
 39             jedis.lpush(list, values);
 40         } catch (Exception e) {
 41             broken = true;
 42         }finally{
 43             returnJedis(jedis, broken);
 44         }
 45     }
 46     
 47     /**
 48      * 從左邊（首部）加入列表
 49      * 並指定列表緩存過期時間
 50      */
 51     public static void lpush(String list, int expire, String... values){
 52         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 53         ShardedJedis jedis = null;
 54         try {
 55             jedis = getJedis();//獲取jedis實例
 56             if(jedis==null){
 57                 broken = true;
 58                 return;
 59             }
 60             /*
 61              * lpush(String key, String... strings);
 62              * 返回push之後的list中包含的元素個數
 63              */
 64             jedis.lpush(list, values);
 65             jedis.expire(list, expire);//為該list設置緩存過期時間
 66         } catch (Exception e) {
 67             broken = true;
 68         }finally{
 69             returnJedis(jedis, broken);
 70         }
 71     }
 72     
 73     /**
 74      * 從右邊（尾部）加入列表
 75      */
 76     public static void rpush(String list, String... values){
 77         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 78         ShardedJedis jedis = null;
 79         try {
 80             jedis = getJedis();//獲取jedis實例
 81             if(jedis==null){
 82                 broken = true;
 83                 return;
 84             }
 85             jedis.rpush(list, values);
 86         } catch (Exception e) {
 87             broken = true;
 88         }finally{
 89             returnJedis(jedis, broken);
 90         }
 91     }
 92     
 93     /**
 94      * 從右邊（尾部）加入列表
 95      * 並設置緩存過期時間
 96      */
 97     public static void rpush(String list, int expire, String... values){
 98         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 99         ShardedJedis jedis = null;
100         try {
101             jedis = getJedis();//獲取jedis實例
102             if(jedis==null){
103                 broken = true;
104                 return;
105             }
106             jedis.rpush(list, values);
107             jedis.expire(list, expire);//設置緩存過期時間
108         } catch (Exception e) {
109             broken = true;
110         }finally{
111             returnJedis(jedis, broken);
112         }
113     }
114     
115     /**
116      * 設置list中index位置的元素
117      * index==-1表示最後一個元素
118      */
119     public static void lSetIndex(String list, long index, String value){
120         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
121         ShardedJedis jedis = null;
122         try {
123             jedis = getJedis();//獲取jedis實例
124             if(jedis==null){
125                 broken = true;
126                 return;
127             }
128             jedis.lset(list, index, value);
129         } catch (Exception e) {
130             broken = true;
131         }finally{
132             returnJedis(jedis, broken);
133         }
134     }
135     
136     /***************************獲取緩存*****************************/
137     /**
138      * 從左邊（首部）出列表
139      */
140     public static String lpop(String list){
141         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
142         ShardedJedis jedis = null;
143         try {
144             jedis = getJedis();//獲取jedis實例
145             if(jedis==null){
146                 broken = true;
147                 return null;
148             }
149             return jedis.lpop(list);
150         } catch (Exception e) {
151             broken = true;
152         }finally{
153             returnJedis(jedis, broken);
154         }
155         return null;
156     }
157     
158     /**
159      * 從右邊出列表
160      */
161     public static String rpop(String list){
162         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
163         ShardedJedis jedis = null;
164         try {
165             jedis = getJedis();//獲取jedis實例
166             if(jedis==null){
167                 broken = true;
168                 return null;
169             }
170             return jedis.rpop(list);
171         } catch (Exception e) {
172             broken = true;
173         }finally{
174             returnJedis(jedis, broken);
175         }
176         return null;
177     }
178     
179     /**
180      * 返回list中index位置的元素
181      */
182     public static String lGetIndex(String list, long index){
183         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
184         ShardedJedis jedis = null;
185         try {
186             jedis = getJedis();//獲取jedis實例
187             if(jedis==null){
188                 broken = true;
189                 return null;
190             }
191             return jedis.lindex(list, index);
192         } catch (Exception e) {
193             broken = true;
194         }finally{
195             returnJedis(jedis, broken);
196         }
197         return null;
198     }
199     
200     /**
201      * 返回list指定區間[start,end]內的元素 
202      */
203     public static List<String> lrange(String list, long start, long end){
204         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
205         ShardedJedis jedis = null;
206         try {
207             jedis = getJedis();//獲取jedis實例
208             if(jedis==null){
209                 broken = true;
210                 return null;
211             }
212             return jedis.lrange(list, start, end);//
213         } catch (Exception e) {
214             broken = true;
215         }finally{
216             returnJedis(jedis, broken);
217         }
218         return null;
219     }
220     
221     /**
222      * 返回list內的全部元素 
223      */
224     public static List<String> lrange(String list){
225         return lrange(list, 0, -1);
226     }
227     
228     /*** 刪除緩存（刪除整個list，直接用RedisStringUtil的delete就好）******/
229     /**
230      * 讓list只保留指定區間[start,end]內的元素，不在指定區間內的元素都將被刪除 
231      */
232     public static void ltrim(String list, long start, long end){
233         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
234         ShardedJedis jedis = null;
235         try {
236             jedis = getJedis();//獲取jedis實例
237             if(jedis==null){
238                 broken = true;
239                 return;
240             }
241             jedis.ltrim(list, start, end);
242         } catch (Exception e) {
243             broken = true;
244         }finally{
245             returnJedis(jedis, broken);
246         }
247     }
248     
249     /**
250      * 刪除list中所有與value相等的元素
251      * 註意：
252      * count
253      * ==0 ：刪除表中所有與value相等的元素
254      * >0：從表頭開始向表尾搜索，移除count個與value相等的元素
255      * <0：從表尾開始向表頭搜索，移除count個與value相等的元素
256      */
257     public static void lremove(String list, long count, String value){
258         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
259         ShardedJedis jedis = null;
260         try {
261             jedis = getJedis();//獲取jedis實例
262             if(jedis==null){
263                 broken = true;
264                 return;
265             }
266             jedis.lrem(list, count, value);//返回刪除了多少個元素
267         } catch (Exception e) {
268             broken = true;
269         }finally{
270             returnJedis(jedis, broken);
271         }
272     }
273     
274     /**
275      * 刪除list中所有與value相等的元素
276      */
277     public static void lremove(String list, String value){
278         lremove(list, 0, value);
279     }
280     
281     /***************************其他*****************************/
282     /**
283      * 返回list中共有多少個元素
284      */
285     public static long llength(String list){
286         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
287         ShardedJedis jedis = null;
288         try {
289             jedis = getJedis();//獲取jedis實例
290             if(jedis==null){
291                 broken = true;
292                 return 0;
293             }
294             return jedis.llen(list);
295         } catch (Exception e) {
296             broken = true;
297         }finally{
298             returnJedis(jedis, broken);
299         }
300         return 0;
301     }
302     
303     public static void main(String[] args) {
304         lpush("adminList", "jigang");
305         lpush("adminList", "nana");//頭部
306         System.out.println(llength("adminList"));
307         System.out.println(lrange("adminList"));
308         //lpop("adminList");
309         //System.out.println(llength("adminList"));
310         //ltrim("adminList", 0, 1);
311         //System.out.println(lrange("adminList"));
312         //System.out.println(lpop("adminList"));//左邊進左邊出，棧（後進先出）
313         //System.out.println(rpop("adminList"));//左邊進右邊出，隊列（先進先出）
314         System.out.println(lGetIndex("adminList",1));
315         
316     }
317 }

View Code

註意：

元素在list中的存放順序為：插入list的順序（從左邊插入在頭部，從右邊插入在尾部）
允許存放重覆元素
可用作模擬隊列（queue）、堆棧（stack），支持雙向操作（L--首部或者R--尾部）
index從0開始 -1表示結尾 -2表示倒數第二個
API中的 start end參數都是包前也包後的
左邊入隊，相當於在隊頭插入元素，則之後的元素都要後移一位；而右邊入隊的話元素直接插在隊尾，之前的元素的索引不變（推薦使用右邊入隊，即隊尾入隊）
沒有從list中獲取指定value的運算（這也是set/sorted set所沒有的）

沒有直接的指定緩存過期的API（這也是set/sorted set/hash所沒有的），但是可以按例如如下的方式指定緩存過期時間

 1     /**
 2      * 從左邊（首部）加入列表
 3      * 並指定列表緩存過期時間
 4      */
 5     public static void lpush(String list, int expire, String... values){
 6         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 7         ShardedJedis jedis = null;
 8         try {
 9             jedis = getJedis();//獲取jedis實例
10             if(jedis==null){
11                 broken = true;
12                 return;
13             }
14             /*
15              * lpush(String key, String... strings);
16              * 返回push之後的list中包含的元素個數
17              */
18             jedis.lpush(list, values);
19             jedis.expire(list, expire);//為該list設置緩存過期時間
20         } catch (Exception e) {
21             broken = true;
22         }finally{
23             returnJedis(jedis, broken);
24         }
25     }

View Code

刪除整個list可以直接使用jedis.del(list)（set/sorted set/hash同理）

1.2、RedisSetUtil（無序集合工具類）

  1 package com.xxx.cache.redis;
  2 
  3 import java.util.Set;
  4 
  5 import redis.clients.jedis.ShardedJedis;
  6 
  7 /**
  8  * set緩存操作類
  9  * 1、無序集合，最後的順序不一定是插入順序
 10  * 2、元素不能重覆
 11  * 3、對於set而言，Jedis有交集、差集、並集運算，可是ShardJedis沒有
 12  * 4、沒有從set中獲取指定value的運算
 13  */
 14 public class RedisSetUtil extends RedisBaseUtil {
 15     /***************************添加緩存*****************************/
 16     /**
 17      * 添加緩存
 18      * @param set    緩存將要添加到的set集合
 19      * @param values 添加的緩存元素
 20      */
 21     public static void sadd(String set, String... values){
 22         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 23         ShardedJedis jedis = null;
 24         try {
 25             jedis = getJedis();//獲取jedis實例
 26             if(jedis==null){
 27                 broken = true;
 28                 return;
 29             }
 30             /*
 31              * 對比：
 32              * lpush(String key, String... strings);
 33              * 返回push之後的list中包含的元素個數
 34              * 
 35              * sadd(String key, String... members)
 36              * 1：添加元素成功
 37              * 0：set中已經有要添加的元素了
 38              */
 39             jedis.sadd(set, values);
 40         } catch (Exception e) {
 41             broken = true;
 42         }finally{
 43             returnJedis(jedis, broken);
 44         }
 45     }
 46     
 47     /***************************獲取緩存*****************************/
 48     /**
 49      * 獲取set集合中的所有緩存
 50      * @param set
 51      */
 52     public static Set<String> smembers(String set){
 53         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 54         ShardedJedis jedis = null;
 55         try {
 56             jedis = getJedis();//獲取jedis實例
 57             if(jedis==null){
 58                 broken = true;
 59                 return null;
 60             }
 61             return jedis.smembers(set);
 62         } catch (Exception e) {
 63             broken = true;
 64         }finally{
 65             returnJedis(jedis, broken);
 66         }
 67         return null;
 68     }
 69     
 70     /***************************刪除緩存*****************************/
 71     /**
 72      * 刪除緩存
 73      * @param set
 74      * @param values
 75      */
 76     public static void sremove(String set, String... values){
 77         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
 78         ShardedJedis jedis = null;
 79         try {
 80             jedis = getJedis();//獲取jedis實例
 81             if(jedis==null){
 82                 broken = true;
 83                 return;
 84             }
 85             jedis.srem(set, values);
 86         } catch (Exception e) {
 87             broken = true;
 88         }finally{
 89             returnJedis(jedis, broken);
 90         }
 91     }
 92     
 93     /***************************其他*****************************/
 94     /**
 95      * set集合是否包含value
 96      * @param set
 97      */
 98     public static boolean sismembers(String set, String value){
 99         boolean broken = false;//標記：該操作是否被異常打斷而沒有正常結束
100         ShardedJedis jedis = null;
101

第十章 企業項目開發--分散式緩存Redis(2)

第十章企業項目開發--分散式緩存Redis(2)