jedis缓存

最新推荐文章于 2024-06-18 11:06:44 发布
原创 最新推荐文章于 2024-06-18 11:06:44 发布 · 850 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

package util;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import com.alibaba.fastjson.JSON;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtils {

private volatile static RedisUtils REDISUTILS = null;
    private static JedisPoolConfig jedisPoolconfig = null;
    private static JedisPool redisPool = null;

    public  JedisPool getRedisPool() {
        return redisPool;
    }

    private RedisUtils() {
        inItRedisPool();
    }

    public void returnResource(Jedis jedis){
        if(jedis!=null){
            redisPool.returnResource(jedis);
        }
    }

    // 单例模式
    /**
     * 得到redis连接实例
     */
    public static RedisUtils getInstance() {
        if (REDISUTILS == null) {
            synchronized(RedisUtils.class){
                if (REDISUTILS == null) {
                    REDISUTILS = new RedisUtils();
                }
            }   
        }
        return REDISUTILS;
    }

    /**
     * 获取连接池redis_pool
     */
    private void inItRedisPool() {
        if (jedisPoolconfig == null){
            jedisPoolconfig = new JedisPoolConfig();
        }
        jedisPoolconfig.setMaxActive(500);
        jedisPoolconfig.setMaxIdle(10);
        jedisPoolconfig.setMaxWait(3000L);
        jedisPoolconfig.setTestOnBorrow(true);
        if(redisPool==null){
            redisPool=new JedisPool(jedisPoolconfig, ConfigUtil.LOCALHOST_REDIS_SERVER, ConfigUtil.LOCALHOST_REDIS_PORT,ConfigUtil.REDIS_TIMEOUT);
        }
    }
    /**
     * 
     * 项目名称：redisutil    
     * 描述： 将字符串值 value 关联到 key
     * @param @param key
     * @param @param value
     * @param @return 
     * @return boolean 
     *
     */
    public boolean setString(String key,String value){
        Jedis jedis =redisPool.getResource();
        try{        
            String isok=jedis.set(key,value);
            if("OK".equals(isok.toUpperCase())){
                return true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }

    /*
     * 加1
     */
    public boolean incrString(String key){
        Jedis jedis =redisPool.getResource();
        try{        
            Long isok=jedis.incr(key);
            if(isok==1){
                return true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：  将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)
     * @param @param key
     * @param @param seconds
     * @param @param value
     * @param @return 
     * @return boolean 
     *
     */
    public boolean setexString(String key,int seconds,String value){
        Jedis jedis =redisPool.getResource();
        try{        
            String isok=jedis.setex(key, seconds, value);
            if("OK".equals(isok.toUpperCase())){
                return true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   将字符串值 value 关联到 key
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return boolean 
     *
     */
    public boolean setString(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
            String isok=jedis.set(key,JSON.toJSONString(obj));
            if("OK".equals(isok.toUpperCase())){
                return true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }
    /**
     * 
     * 项目名称：redisutil    
     * 描述：   将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
     * @param @param key
     * @param @param seconds
     * @param @param obj
     * @return boolean 
     *
     */
    public boolean setexString(String key,int seconds,Object obj){
        Jedis jedis =redisPool.getResource();
        try{        
            String isok=jedis.setex(key,seconds,JSON.toJSONString(obj));
            if("OK".equals(isok.toUpperCase())){
                return true;
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   返回 key 所关联的字符串值。
     * @param @param key
     * @param @return 
     * @return String 
     *
     */
    public String getString(String key){
        Jedis jedis =redisPool.getResource();
        try{
            return jedis.get(key);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }
    /**
     * 
     * 项目名称：redisutil    
     * 描述：   返回 key 所关联的字符串值。
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return Object 
     *
     */
    public Object getStringToObj(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
            String value=jedis.get(key);
            if(StringUtils.isNotEmpty(value)){
                return JSON.parseObject(value,obj.getClass());
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   删除给定的一个或多个 key 
     * @param @param key
     * @param @return 
     * @return long 
     *
     */
    public long delKey(String key){
        Jedis jedis =redisPool.getResource();
        try{
            return jedis.del(key); 
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }

    /**
     *    
     * 项目名称：sr_sms    
     * 描述：    key是否存在
     * @param @param key
     * @param @return 
     * @return boolean 
     *
     */
    public boolean isKey(String key){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.exists(key); 
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return false;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
     * @param @param key
     * @param @param seconds
     * @param @return 
     * @return long 
     *
     */
    public long expire(String key,int seconds){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.expire(key,seconds); 
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述： 将一个值 value 插入到列表 key 的表头
     * @param @param key
     * @param @param value
     * @param @return 
     * @return long 
     *
     */
    public long addListLpush(String key,String value){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.lpush(key,value);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   将一个值 value 插入到列表 key 的表头
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return long 
     *
     */
    public long addListLpush(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.lpush(key,JSON.toJSONString(obj));
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   将一个值 value 插入到列表 key 的表尾
     * @param @param key
     * @param @param value
     * @param @return 
     * @return long 
     *
     */
    public long addListRpush(String key,String value){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.rpush(key,value);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }
    /**
     *    
     * 项目名称：redisutil    
     * 描述：     将一个值 value 插入到列表 key 的表尾
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return long 
     *
     */
    public long addListRpush(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.rpush(key,JSON.toJSONString(obj));
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return 0;
    }

    /**
     *    
     * 项目名称：redisutil    
     * 描述：   移除并返回列表 key 的尾元素。
     * @param @param key
     * @param @return 
     * @return String 
     *
     */
    public String getListRpop(String key){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.rpop(key);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   移除并返回列表 key 的尾元素。
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return Object 
     *
     */
    public Object getListRpopToObj(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
            String s=jedis.rpop(key);
            if(StringUtils.isNotEmpty(key)){
                return JSON.parseObject(s,obj.getClass());
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }


    /**
     * 
     * 项目名称：redisutil    
     * 描述：   移除并返回列表 key 的头元素。
     * @param @param key
     * @param @return 
     * @return String 
     *
     */
    public String getListLpop(String key){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.lpop(key);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }

    /**
     *    
     * 项目名称：redisutil    
     * 描述：   移除并返回列表 key 的头元素。
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return Object 
     *
     */
    public Object getListLpopToObj(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        try{
            String s=jedis.lpop(key);
            if(StringUtils.isNotEmpty(key)){
                return JSON.parseObject(s,obj.getClass());
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return null;
    }

    /**
     *    
     * 项目名称：redisutil    
     * 描述：   返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
     * @param @param key
     * @param @param start
     * @param @param end
     * @param @return 
     * @return List 
     *
     */
    public List findListLrange(String key,int start,int end){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.lrange(key, start, end);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return new ArrayList();
    }
    /**
     *    
     * 项目名称：redisutil    
     * 描述：   返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
     * @param @param key
     * @param @param start
     * @param @param end
     * @param @param obj
     * @param @return 
     * @return List 
     *
     */
    public List findListLrange(String key,int start,int end,Object obj){
        Jedis jedis =redisPool.getResource();
        List arrayList=new ArrayList();
        try{ 
             List list=jedis.lrange(key, start, end);
             for(Iterator<String> it=list.iterator();it.hasNext();){
                 arrayList.add(JSON.parseObject(it.next(),obj.getClass()));
             }
             return arrayList;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return new ArrayList();
    }


    /**
     * 
     * 项目名称：redisutil    
     * 描述：   返回列表 key 中的数据
     * @param @param key
     * @param @return 
     * @return List 
     *
     */
    public List findListLrange(String key){
        Jedis jedis =redisPool.getResource();
        try{
             return jedis.lrange(key, 0, jedis.llen(key));
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return new ArrayList();
    }

    /**
     * 
     * 项目名称：redisutil    
     * 描述：   返回列表 key 中的数据
     * @param @param key
     * @param @param obj
     * @param @return 
     * @return List 
     *
     */
    public List findListLrange(String key,Object obj){
        Jedis jedis =redisPool.getResource();
        List arrayList=new ArrayList();
        try{ 
             List list=jedis.lrange(key, 0,jedis.llen(key));
             for(Iterator<String> it=list.iterator();it.hasNext();){
                 arrayList.add(JSON.parseObject(it.next(),obj.getClass()));
             }
             return arrayList;
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally{
            redisPool.returnResource(jedis);
        }
        return new ArrayList();
    }

    /**
     * key返回列表key的长度
     * @param key
     * @return
     */
    public Long getLength(String key) {
        Jedis jedis = redisPool.getResource();
        try {
            return jedis.llen(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            redisPool.returnResource(jedis);
        }
        return 0L;
    }

    public static void main(String[] args) {
        RedisUtils redisUtil = RedisUtils.getInstance();
//      Jedis jedis =redisPool.getResource();
//      jedis.sadd("lwp","1");
//      jedis.sadd("lwp","2");
//      jedis.sadd("lwp","3");
//      Set<String> set=jedis.smembers("lwp");
//      Object[] o=set.toArray();
//      List list=Arrays.asList(o);
//      redisUtil.setString("lwp", "123");
//      System.out.println(redisUtil.getString("lwp"));
//      Test t=new Test();
//      t.setId("1");
//      t.setName("lwp");
//      redisUtil.addListRpush("lwp",t);
//      redisUtil.addListRpush("lwp",t);
//      System.out.println(redisUtil.findListLrange("lwp",new Test()).size());
//      System.out.println(redisUtil.delKey("lwp"));
//      redisUtil.setString("a", "1");
//      System.out.println(redisUtil.getString("b"));
//      System.out.println(redisUtil.isKey("a"));
//      redisUtil.delKey("b");
//      redisUtil.addListLpush("b", "11");
//      redisUtil.addListLpush("b", "22");
//      int i = 0;
////        System.out.println(redisUtil.getLength("b")>=i);
//      System.out.println(!redisUtil.isKey("b"));
//      System.out.println(redisUtil.findListLrange("b"));
////        System.out.println(redisUtil.findListLrange("b",1,1));
//      Long len = redisUtil.getLength("b");
//      List list = redisUtil.findListLrange("b",len.intValue()-1,len.intValue()-1);
//      System.out.println(list.get(0));
//      System.out.println(redisUtil.getListRpop("b"));//从尾取
//      redisUtil.delKey("b");
//      long l = 1363176871825l;
//      System.out.println(System.currentTimeMillis()-l);
//      String s = "18658850522";
//      System.out.println(s.substring(0, 7));
//      long date = System.currentTimeMillis();
    }
}
缓存第四篇：在maven项目中使用redis实例
万米高空的博客
07-11 1万+
本节利用之前ssm+ehcache搭建好的ssm框架进行改造，其中的ehcache部分已经弃掉，防止ehcache缓存的存在对这里的redis缓存的判断。又整合了redis内容和日志内容，利用控制台日志输出看缓存有没有起作用。注意点比较多，我准备了差不多几天时间把这个环境和项目简单搭建起来，多次的修改和报错后终于搞定了。其实缓存的整合不在spring部分，而在mybatis部分。整合也是整合redi
java jedis 缓存list_Java客户端利用Jedis操作redis缓存示例代码
weixin_42300927的博客
02-13 528
前言Redis是一个开源的Key-Value数据缓存，和Memcached类似。Redis多种类型的value，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。Jedis 是 Redis 官方首选的 Java 客户端开发包。下面就来给大家详细关于Java客户端利用Jedis操作redis缓存的相关内容，话不多说，直...
JedisCommand接口说明
weixin_34221773的博客
06-02 575
本专栏与Redis相关的文章 Redis Sentinel机制与用法（一）Redis Sentinel机制与用法（二）Jedis的JedisSentinelPool源代码分析Jedis的Sharded源代码分析Redis 主从 Replication 的配置详解Redis SORT命令 JedisCommand接口说明 Sharded 和...
Redis 客户端Jedis使用（一）
weixin_34306593的博客
10-17 298
为什么80%的码农都做不了架构师？>>> ...
使用Jedis操作Redis(笔记)
beyond_zl的博客
06-17 540
Redis部署在Linux下，远程使用Jedis包操作Redis的尝试Jedis连接测试：public static void main(String[] args) { Jedis jedis = new Jedis("192.168.0.3",6379); System.out.println(jedis); System.out.println(
Jedis缓存实现类
qq_38921377的博客
07-13 465
Jedis缓存实现类
java项目直接使用Jedis操作Redis缓存示例-java项目使用Jedis
最新发布
北海山人
06-18 278
java项目直接使用Jedis操作Redis缓存示例-java项目使用Jedis
原生servlet项目使用jedis缓存同步更新数据
weixin_43410352的博客
08-12 935
目前维护的项目中需要添加一个类似说说的功能，之前也正好学过redis，正好拿来练练手。 1.需要两个包 commons-pool2-2.0.jar jedis-2.8.2.jar 没有的话自行去maven仓库下载 jedis连接池 public class JedisUtil extends HttpServlet { private static Jedis jedis; priva...
SpringBoot 集成Jedis操作Redis缓存
hjseo_seg的博客
08-24 414
在使用SpringBoot构建SpringCloud微服务时，需要用到Redis做数据缓存，提高业务逻辑的处理。所以就不得不让SpringBoot集成Redis，但如果使用官方的Redis去操作的话，你叫麻烦，所以就使用Jedis去操作Reids，这样操作简便，编码效率打打提高。最后配置JedisConfiguration类，生成2个工具Bean，redisTemplate和forecastRedisTemplate，在需要使用jedis的地方注入bean，可以对redis进行操作。
Redis入门十五：Java中使用Redis五：利用Jedis缓存数据一；（其实，就是利用redis存储【对象JSON序列化后的字符串】）
小枯林的博客
07-20 522
说明： （1）演示【如何在redis数据库中，存储对象】 ● MySQL数据库，默认会把数据存在硬盘上；由于硬盘的读写速度较慢，随着数据量的增大，并发数的增加，导致MySQL处理速度较慢，出现延迟。 ● Redis利用内存来存储数据，内存读写速度很快；所以，在项目中，比如【商品数据】、【人员信息】、【设备信息】、【资产状况】等不太经常变动的数据，通常使用Redis来存储； ● 本篇博客就是演示【如何在redis数据库中，存储对象】，模拟在...
基于Jedis的Redis缓存操作SDK设计源码
05-30
本项目是基于Jedis的Redis缓存操作SDK设计源码，包含59个文件，主要文件类型为java、prefs、properties、classpath、gitignore、project、LICENSE和md。该项目适用于Redis缓存操作的开发和设计，为用户提供了一个...
Java客户端利用Jedis操作redis缓存示例代码
08-30
本文将深入探讨如何使用Jedis进行Redis缓存操作。 首先，连接Redis服务器是进行所有操作的基础。在Java中，可以通过创建Jedis对象并指定服务器地址和端口号来建立连接，例如： ```java Jedis jedis = new Jedis(...
【Redis缓存】- Java客户端Jedis
m0_75232472的博客
04-03 474
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
DESede(3DES) 加密
我要修改昵称
02-27 9465
package util;import java.security.Security;import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec;public class DES3 { private static final String Algorithm
redis每天生成自增流水号(20180901003)
我要修改昵称
04-22 7278
原理: 利用redis的RedisAtomicLong类实现该功能: 让其每天第一次放置一个新的自增的值(一天过期) 然后和每天的日期相加就可以了 例子: 20180901 + 001 ;当天就是 20180901 + 002 如果要多少个0,可以自己配置(工具类中) 1.pom配置 其实用springbootstarter是比较好的; 说一下自己版本 <!-- redis --> ...
java获取客户端登陆地址信息(国家、省份、城市等)
我要修改昵称
02-28 5446
原文：java获取客户端登陆地址信息(国家、省份、城市等) 源代码下载地址：http://www.zuidaima.com/share/1550463687658496.htm java获取客户端登陆地址信息(国家、省份、城市等) [java] view plaincopyprint?/**  * @param urlStr  *            请求的地址  * @param content
运算 double类型的数字相加不丢失精度
我要修改昵称
02-27 3116
package util;import java.math.BigDecimal; import java.text.DecimalFormat;/** * * 工具类 - 运算 double类型的数字相加不丢失精度 * */public class ArithUtil { // 默认除法运算精度 private static final int DEF_DIV_SCAL
MyEclipse使用经验总结
我要修改昵称
03-26 2207
快捷键 ================================================================================编辑:Ctrl+Shift+L显示所有快捷键Ctrl+K 参照选中的词(Word)快速定位到下一个Ctrl+Shift+K参照选中的词(Word)快速定位到上一个Ctrl+O 快速显示OutLineCtrl+T 快速显示当
根据时间生成订单
我要修改昵称
02-27 1256
package util;import java.util.Date; import java.util.Random; import java.util.UUID;/** * 生成订单Id * */ public class OrderInfoIdUtil { public static String getOrderInfoId(){ Random rd=new R
Redis学习笔记：Jedis快速缓存配置详解
本资源主要涵盖了Redis的环境搭建、数据类型、排序、事务、Pipeline批量处理、发布订阅、持久化、主从复制以及虚拟内存等核心知识点，适合学习和配置Jedis缓存的初学者。" Redis是一种开源的NoSQL数据库，以键值对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我要修改昵称

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值