企业项目开发--分布式缓存Redis

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了企业项目开发--分布式缓存Redis相关的知识,希望对你有一定的参考价值。

注意:本章代码是在上一章的基础上进行添加修改,上一章链接《第九章 企业项目开发--分布式缓存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         try {
102             jedis = getJedis();//获取jedis实例
103             if(jedis==null){
104                 broken = true;
105                 return false以上是关于企业项目开发--分布式缓存Redis的主要内容,如果未能解决你的问题,请参考以下文章

企业项目开发--分布式缓存Redis

企业项目开发--分布式缓存Redis

(78)java Spring Cloud+Spring boot+mybatis企业快速开发架构之防止缓存穿透方案

(79)java Spring Cloud+Spring boot+mybatis企业快速开发架构之防止缓存雪崩方案

项目课---企业级Memcached服务应用实践

分布式缓存Hazelcast案例一