基于Redis的投票应用

Redis 专栏收录该内容
20 篇文章 0 订阅

在日常生活中,大家肯定都被拉去投过票,这里我们就来基于Redis实现一个简单的投票运行,其投票需求如下:

  • 用户可以发表信息,发表时默认给自己投了一票
  • 为防止同一用户多次投票,用户只能给一条信息投一次票
  • 投票活动限时,如发布信息五分钟后进行截止统计票数
  • 用户可以按照文章发布时间进行排序
  • 用户在查看所有信息时可以按评分进行排列查看

那么在实现之前,这里我们就来先逐步分析上述的需求,针对每个需求应该采用什么样的解决方式,如下:


用户可以发表信息,发表时默认给自己投了一票

这里我们首先来规划下用户发布信息的内容,以及我们需要存储的信息(用户id、发布时间、得票数是我们给用户添加的,用户发布信息时,无需关注)


用户发布的信息内容——proposal

标题内容连接用户id发布时间得票数
titlecontentlinkuserIdpublishTimevotes

这里看过Redis的数据结构及常用命令,那么肯定知道这里我们一般都是采用Hash的数据结构进行存储。(如下是存储用户发布信息的代码片段,后续会详细介绍)
在这里插入图片描述



为防止同一用户多次投票,用户只能给一条信息投一次票

为了满足该需求,我们只需记录已投票用户,以用来防止重投,从Redis的数据结构及常用命令中,我们介绍的5中数据类型来说,肯定想到是使用Set集合,因为Set集合的特点就是不允许有重复元素。
在这里插入图片描述

所以使用set集合就很好处理了,我们只需将投过票的用户ID放入一个set集合即可,每次用户投票之前就先将其放入该集合,成功则记录投票数,放入失败则表示集合中已存在,则反馈错误信息,提示用户请勿重复投票。
在这里插入图片描述



投票活动限时,如发布信息五分钟后进行截止统计票数

满足该需要,我们只需将用法发布信息的时间记录下来,然后我们在投票的时候会先判断其时间是否截止即可,这里我们使用了有序集合(zset)来存储,其中存储了用户发布信息的时间,以及信息存在的Redis的Key。
在这里插入图片描述


至于为什么使用有序集合(zset),因为我们还有一个需求呀,就是用户可以按照文章发布时间进行排序。


然后我们就来看看,在投票之前的判断动作,如下:
在这里插入图片描述



用户可以按照文章发布时间进行排序

该需求上述已经介绍,即使用有序集合(zset)即可。



用户在查看所有信息时可以按评分进行排列查看

这个需求其实和上述类似,这里我们同样也是可以使用有序集合(zset)完成,我们只需要将用户得分和信息的Key值放入Redis中即口,如下:
在这里插入图片描述




上述大致介绍了如何实现,及其解决方式,同时我们上述看来部分的代码,下面就来看看其整体的代码,首先需要引入Redis的依赖,如下:

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.7.2</version>
</dependency>

然后我们来看一看投票服务的完整代码,如下:

@Service
public class VoteServiceImpl implements VoteService {

    private static final long VALID_TIME = TimeUnit.SECONDS.convert(5, TimeUnit.MINUTES); //投票开始后5分钟之内有效,超过时间不能投票
    private static final int PROPOSALS_PER_PAGE = 25; //分页查询每页显示25条

    private static JedisUtil jedisUtil = new JedisUtil();

    /**
     * 发起提议活动
     *
     * @param title   活动标题
     * @param content 活动内容
     * @param link    活动链接
     * @param userId  用户ID
     */
    @Override
    public String postProposal(String title, String content, String link, String userId) {
        //获取当前时间
        long currentTimeMillis = System.currentTimeMillis();

        String votedKey = "voted:" + userId;
        Long sadd = jedisUtil.sadd(votedKey, userId); //将投票的用户记录到 voted:? 键集合来存储
        jedisUtil.expire(votedKey, Math.toIntExact(VALID_TIME)); //设置失效时间

        String proposalKey = "proposal:" + userId;
        HashMap<String, String> proposalData = new HashMap<>();
        proposalData.put("title", title);
        proposalData.put("content", content);
        proposalData.put("link", link);
        proposalData.put("userId", userId);
        proposalData.put("publishTime", String.valueOf(currentTimeMillis));
        proposalData.put("votes", "1");
        jedisUtil.hmset(proposalKey, proposalData);
        jedisUtil.expire(proposalKey, Math.toIntExact(VALID_TIME));

        jedisUtil.zadd("score", 1, proposalKey);//根据分值排序文章的有序集合

        jedisUtil.zadd("time", currentTimeMillis, proposalKey); //根据活动发布时间排序文章的有序集合

        return proposalKey;
    }


    /**
     * 活动投票
     */
    @Override
    public void proposalVote(String id, String userId) {
        //计算投票截止时间
        long cutoff = System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(VALID_TIME);

        //检查是否还可以对文章进行投票,如果该文章的发布时间比截止时间小,则已过期,不能进行投票
        if (jedisUtil.zscore("time", "proposal:"+id) < cutoff) {
            System.out.println("活动投票已结束...");
            return;
        }

        //将投票的用户加入到键为 voted:? 的集合中,表示该用户已投过票了
        if (jedisUtil.sadd("voted:"+id, userId) == 1) {
            jedisUtil.zincrby("score", 1, "proposal:"+id);
            jedisUtil.hincrBy("proposal:"+id, "votes", 1L);
        } else {
            System.out.println("请勿重复投票");
        }
    }


    /**
     * 文章列表查询(分页)
     *
     * @param page key
     * @return Redis查询结果
     */
    @Override
    public List<Map<String, String>> getProposals(String key, int page) {
        if (page < 0) {
            System.out.println("请输入正确的页码");
            return new ArrayList<>();
        }

        int start = (page - 1) * PROPOSALS_PER_PAGE;
        int end = start + PROPOSALS_PER_PAGE - 1;

        //倒序查询出投票数最高的文章,zset有序集合,分值递减
        Set<String> ids = jedisUtil.zrevrange(key, start, end);

        List<Map<String, String>> proposals = new ArrayList<>();
        for (String id : ids) {
            Map<String, String> proposalData = jedisUtil.hgetAll(id);
            proposalData.put("id", id);
            proposals.add(proposalData);
        }
        return proposals;
    }
} 

其实上述我们还包括了没有介绍到的功能,如最后的分页查询功能,最后其中的JedisUtil工具类,其实就是我们用来连接Redis并操作的工具类,使用Jedis来操作,其实和Redis的数据结构及常用命令介绍的相关命令是一模一样的,我们之前介绍的命令时如何进行使用的,在Jedis中也是一样的(因为该工具类较大,会在文末贴出JedisUtil工具类的代码)


然后我们就来看看几个简单的测试用例,如下:

public class VoteServiceTest {

    private VoteService voteService = new VoteServiceImpl();

    /**
     * 测试用例:用户发布文章
     */
    @Test
    public void testPostProposal() {
        String userId = "001";
        String title = "大家好,我是001";
        String content = "请大家投票给我,支持我,谢谢";
        String link = "www.user001.com";

        //发布文章,返回文章ID
        String proposalId = voteService.postProposal(title, content, link, userId);
        System.out.println("刚发布了一个信息,文章ID为: " + proposalId);

        System.out.println("该信息所有属性值内容如下:");
        Map<String, String> articleData = voteService.hgetAll(proposalId);
        for (Map.Entry<String, String> entry : articleData.entrySet()) {
            System.out.println("  " + entry.getKey() + ": " + entry.getValue());
        }
        System.out.println();
    }

    /**
     * 测试用例:用户对提议进行投票
     */
    @Test
    public void testProposalVote() {
        String userId = "002";
        String id = "001";
        String proposalKey = "proposal:001";

        voteService.proposalVote(id, userId);

        //投票完后,查询当前活动的投票数
        String votes = voteService.hget(proposalKey, "votes");

        System.out.println(proposalKey + "从Redis查出来结果为: " + votes);
        System.out.println();
    }

    /**
     * 测试用例:获取活动列表并打印出来
     */
    @Test
    public void testGetProposals() {
        int page = 1;
        String key = "score";
        System.out.println("查询当前的信息列表集合为:");
        List<Map<String, String>> articles = voteService.getProposals(key, page);
        for (Map<String, String> article : articles) {
            System.out.println("  id: " + article.get("id"));
            for (Map.Entry<String, String> entry : article.entrySet()) {
                if (entry.getKey().equals("id")) {
                    continue;
                }
                System.out.println("    " + entry.getKey() + ": " + entry.getValue());
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


Jedis工具类

@Component
public class JedisUtil {

    private static JedisPool pool = null;
    private static final String ip = "127.0.0.1";
    private static final int port = 6379;

    /**
     * 构建Redis连接
     */
    public JedisUtil() {
        this(ip, port);
    }

    /**
     * 传入ip和port构建Redis连接
     *
     * @param ip
     * @param port
     */
    public JedisUtil(String ip, int port) {
        if (pool == null) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(500);    //连接池的最大数
            config.setMaxIdle(5);       //连接池的最大空闲数
            config.setMaxWaitMillis(100);   //连接的最大等待时间
            config.setTestOnBorrow(true);   //检测连接的可用性
            pool = new JedisPool(config, ip, port, 100000);
        }
    }

    /**
     * 通过key获取储存在Redis中的value并释放连
     *
     * @param key
     * @return 成功返回value, 失败返回null
     */
    public String get(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = pool.getResource();
            value = jedis.get(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return value;
    }

    /**
     * 向Redis存入key和value,并释放连接资源
     * 如果key已经存在,则覆盖
     *
     * @param key
     * @param value
     * @return 返回OK,失败返回0
     */
    public String set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();     //每次操作时向pool借用个jedis对象,用完即还
            return jedis.set(key, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 向Redis存入序列化的key和value,并释放连接资源。
     * 如果key已经存在,则覆盖
     *
     * @param keyBytes
     * @param valueBytes
     * @return 成功 返回OK 失败返回 0
     */
    public String setSerializer(byte[] keyBytes, byte[] valueBytes) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.set(keyBytes, valueBytes);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 通过序列化key获取储存在Redis中的序列化value,并释放连
     *
     * @param key
     * @return 成功返回value, 失败返回null
     */
    public byte[] getSerializer(byte[] key) {
        Jedis jedis = null;
        byte[] value = null;
        try {
            jedis = pool.getResource();
            value = jedis.get(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return value;
    }

    /**
     * 删除指定的key
     *
     * @param keys 可传入多个个key
     * @return 返回删除成功的个
     */
    public Long del(String... keys) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.del(keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return 0L;
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 通过key向指定的value值追加
     *
     * @param key
     * @param str
     * @return 成功返回添加后value的长;失败返回添加value的长;异常返回0L
     */
    public Long append(String key, String str) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.append(key, str);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return 0L;
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 判断key是否存在
     *
     * @param key
     * @return true OR false
     */
    public Boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.exists(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return false;
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 设置key value,如果key已经存在则返0,nx->not exist
     *
     * @param key
     * @param value
     * @return 成功返回1, 如果存在发生异常返回0
     */
    public Long setnx(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.setnx(key, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return 0L;
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 设置key value并制定这个键值的有效
     *
     * @param key
     * @param value
     * @param seconds 单位:秒
     * @return 成功返回OK, 失败和异常返回null
     */
    public String setex(String key, String value, int seconds) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.setex(key, seconds, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 设置key value,如果key已经存在则返0,成功还制定这个键值的有效时间(单位:秒)
     *
     * @param key
     * @param value
     * @param seconds 单位:秒
     * @return 成功返回OK, 失败和异常返回null
     */
    public String setnxex(String key, String value, int seconds) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.set(key, value, "NX", "EX", seconds);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 设置key value,如果key已经存在则返0,成功还制定这个键值的有效时间(单位:毫秒)
     *
     * @param key
     * @param value
     * @param mills 单位:毫秒
     * @return 成功返回OK, 失败和异常返回null
     */
    public String setnxpx(String key, String value, int mills) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.set(key, value, "NX", "PX", mills);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key和offset,从指定的位置始将原先value替换,offset表示从offset下标始替
     *
     * @param key
     * @param str
     * @param offset 下标位置
     * @return 返回替换value的长
     */
    public Long setrange(String key, String str, int offset) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            return jedis.setrange(key, offset, str);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return 0L;
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 通过批量的key获取批量的value
     *
     * @param keys string数组,也可以是个key
     * @return 成功返回value的集合, 失败返回null的集合,异常返回
     */
    public List<String> mget(String... keys) {
        Jedis jedis = null;
        List<String> values = null;
        try {
            jedis = pool.getResource();
            values = jedis.mget(keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return values;
    }

    /**
     * 批量的设置key:value
     * String[]{"key2","value1","key2","value2"})
     *
     * @param keysvalues
     * @return 成功返回OK 失败 异常 返回 null
     */
    public String mset(String... keysvalues) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.mset(keysvalues);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 删除多个字符串key 并释放连接
     *
     * @param keys
     * @return 成功返回value 失败返回null
     */
    public boolean mdel(List<String> keys) {
        Jedis jedis = null;
        boolean flag = false;
        try {
            jedis = pool.getResource();     //从连接池获取Jedis对象
            Pipeline pipeline = jedis.pipelined();      //获取Jedis对象的pipeline对象
            for (String key : keys) {
                pipeline.del(key);      //将多个key放入pipeline删除指令
            }
            pipeline.sync();    //执行命令,完全此时pipeline对象的远程调用
            flag = true;
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return flag;
    }

    /**
     * 批量的设置key:value,如果key已经存在则会失败
     * String[]{"key2","value1","key2","value2"})
     *
     * @param keysvalues
     * @return 成功返回1 失败返回0
     */
    public Long msetnx(String... keysvalues) {
        Jedis jedis = null;
        Long ret = 0L;
        try {
            jedis = pool.getResource();
            ret = jedis.msetnx(keysvalues);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 设置key的值,并返回一个旧值
     *
     * @param key
     * @param value
     * @return 旧值,如果key不存在,则返回null
     */
    public String getset(String key, String value) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.getSet(key, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过下标 和key 获取指定下标位置 value
     *
     * @param key
     * @param startOffset 始位0,负数表示从右边开始截
     * @param endOffset
     * @return 如果没有返回null
     */
    public String getrange(String key, int startOffset, int endOffset) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.getrange(key, startOffset, endOffset);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key 对value进行加+1操作,当value不是int类型时会返回错误,当key不存在是则value
     *
     * @param key
     * @return 加后的结果
     */
    public Long incr(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.incr(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key给指定的value加,如果key不存,则这是value为该值
     *
     * @param key
     * @param integer
     * @return
     */
    public Long incrBy(String key, Long integer) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.incrBy(key, integer);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 对key的值做减减操作,如果key不存,则设置key-1
     *
     * @param key
     * @return
     */
    public Long decr(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.decr(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 减去指定的值
     *
     * @param key
     * @param integer
     * @return
     */
    public Long decrBy(String key, Long integer) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.decrBy(key, integer);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取value值的长度
     *
     * @param key
     * @return 失败返回null
     */
    public Long serlen(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.strlen(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key给field设置指定的?,如果key不存,则先创建
     *
     * @param key
     * @param field 字段
     * @param value
     * @return 如果存在返回0 异常返回null
     */
    public Long hset(String key, String field, String value) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hset(key, field, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key给field设置指定的值,如果key不存在则先创,如果field已经存在,返回0
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hsetnx(String key, String field, String value) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hsetnx(key, field, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key同时设置 hash的多个field
     *
     * @param key
     * @param hash
     * @return 返回OK 异常返回null
     */
    public String hmset(String key, Map<String, String> hash) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hmset(key, hash);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key field 获取指定 value
     *
     * @param key
     * @param field
     * @return 没有返回null
     */
    public String hget(String key, String field) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hget(key, field);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key fields 获取指定的value 如果没有对应的value则返回null
     *
     * @param key
     * @param fields
     * @return
     */
    public List<String> hmget(String key, String... fields) {
        Jedis jedis = null;
        List<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hmget(key, fields);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key给指定的field的value加上给定的值
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hincrby(String key, String field, Long value) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hincrBy(key, field, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key和field判断是否有指定的value存在
     *
     * @param key
     * @param field
     * @return
     */
    public Boolean hexists(String key, String field) {
        Jedis jedis = null;
        Boolean ret = false;
        try {
            jedis = pool.getResource();
            ret = jedis.hexists(key, field);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回field的属性个数
     *
     * @param key
     * @return
     */
    public Long hlen(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hlen(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取所有属性及值
     *
     * @param key
     * @return
     */
    public Map<String, String> hgetAll(String key) {
        Jedis jedis = null;
        Map<String, String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hgetAll(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key 删除指定 field
     *
     * @param key
     * @param fields
     * @return
     */
    public Long hdel(String key, String... fields) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hdel(key, fields);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 查看start至end分数内的所有成员
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> zrange(String key, Long start, Long end) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrange(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回有的field
     *
     * @param key
     * @return
     */
    public Set<String> hkeys(String key) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hkeys(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回有和key有关的value
     *
     * @param key
     * @return
     */
    public List<String> hvals(String key) {
        Jedis jedis = null;
        List<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hvals(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取有的field和value
     *
     * @param key
     * @return
     */
    public Map<String, String> hgetall(String key) {
        Jedis jedis = null;
        Map<String, String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.hgetAll(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key向list头部添加字符
     *
     * @param key
     * @param strs
     * @return 返回list的value个数
     */
    public Long lpush(String key, String... strs) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lpush(key, strs);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key向list尾部添加字符
     *
     * @param key
     * @param strs
     * @return 返回list的value个数
     */
    public Long rpush(String key, String... strs) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.rpush(key, strs);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key在list指定的位置之前或者之,添加字符串元
     *
     * @param key
     * @param where LIST_POSITION枚举类型
     * @param pivot list里面的value
     * @param value 添加的value
     * @return
     */
    public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.linsert(key, where, pivot, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key设置list指定下标位置的value
     * 如果下标超过list里面value的个数则报错
     *
     * @param key
     * @param index
     * @param value
     * @return 成功返回OK
     */
    public String lset(String key, Long index, String value) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lset(key, index, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key从对应的list中删除指定的count value相同的元
     *
     * @param key
     * @param count 当count0时删除全部
     * @param value
     * @return 返回被删除的个数
     */
    public Long lrem(String key, long count, String value) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lrem(key, count, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key保留list中从strat下标始到end下标结束的value
     *
     * @param key
     * @param start
     * @param end
     * @return 成功返回OK
     */
    public String ltrim(String key, long start, long end) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.ltrim(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key从list的头部删除一个value,并返回该value
     *
     * @param key
     * @return
     */
    public String lpop(String key) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lpop(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key从list尾部删除个value,并返回该元素
     *
     * @param key
     * @return
     */
    public String rpop(String key) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.rpop(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key从一个list的尾部删除一个value并添加到另一个list的头,并返回该value
     * 如果第一个list为空或值不存在则返回null
     *
     * @param srckey
     * @param dstkey
     * @return
     */
    public String rpoplpush(String srckey, String dstkey) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.rpoplpush(srckey, dstkey);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取list中指定下标位置的value
     *
     * @param key
     * @param index
     * @return 如果没有返回null
     */
    public String lindex(String key, long index) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lindex(key, index);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回list的长
     *
     * @param key
     * @return
     */
    public Long llen(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.llen(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取list指定下标位置的value
     * 如果start  0 end  -1 则返回全部的list中的value
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<String> lrange(String key, long start, long end) {
        Jedis jedis = null;
        List<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.lrange(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key向指定的set中添加value
     *
     * @param key
     * @param members 可以是一个String 也可以是个String数组
     * @return 添加成功的个
     */
    public Long sadd(String key, String... members) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sadd(key, members);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 设置key的过期时间
     *
     * @param key
     * @param times
     */
    public void expire(String key, int times) {
        Jedis jedis = null;

        try {
            jedis = pool.getResource();
            jedis.expire(key, times);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 通过key删除set中对应的value
     *
     * @param key
     * @param members 可以是一个String 也可以是个String数组
     * @return 删除的个数
     */
    public Long srem(String key, String... members) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.srem(key, members);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key随机删除个set中的value并返回该
     *
     * @param key
     * @return
     */
    public String spop(String key) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.spop(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取set中的差集
     * 以第个set为标
     *
     * @param keys 可以使一个string 则返回set中所有的value 也可以是string数组
     * @return
     */
    public Set<String> sdiff(String... keys) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sdiff(keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取set中的差集并存入到另一个key
     * 以第个set为标
     *
     * @param dstkey 差集存入的key
     * @param keys   可以使一个string 则返回set中所有的value 也可以是string数组
     * @return
     */
    public Long sdiffstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sdiffstore(dstkey, keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取指定set中的交集
     *
     * @param keys 可以使一个string 也可以是个string数组
     * @return
     */
    public Set<String> sinter(String... keys) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sinter(keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取指定set中的交集 并将结果存入新的set
     *
     * @param dstkey
     * @param keys   可以使一个string 也可以是个string数组
     * @return
     */
    public Long sinterstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sinterstore(dstkey, keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回有set的并集
     *
     * @param keys 可以使一个string 也可以是个string数组
     * @return
     */
    public Set<String> sunion(String... keys) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sunion(keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回有set的并,并存入到新的set
     *
     * @param dstkey
     * @param keys   可以使一个string 也可以是个string数组
     * @return
     */
    public Long sunionstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sunionstore(dstkey, keys);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key将set中的value移除并添加到第二个set
     *
     * @param srckey 要移除的
     * @param dstkey 添加
     * @param member set中的value
     * @return
     */
    public Long smove(String srckey, String dstkey, String member) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.smove(srckey, dstkey, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取set中value的个数
     *
     * @param key
     * @return
     */
    public Long scard(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.scard(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key判断value是否是set中的元素
     *
     * @param key
     * @param member
     * @return
     */
    public Boolean sismember(String key, String member) {
        Jedis jedis = null;
        Boolean ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.sismember(key, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取set中随机的value,不删除元素
     *
     * @param key
     * @return
     */
    public String srandmember(String key) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.srandmember(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取set中所有的value
     *
     * @param key
     * @return
     */
    public Set<String> smembers(String key) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.smembers(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key向zset中添加value,score,其中score就是用来排序 如果该value已经存在则根据score更新元素
     *
     * @param key
     * @param scoreMembers
     * @return
     */
    public Long zadd(String key, Map<String, Double> scoreMembers) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zadd(key, scoreMembers);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key向zset中添加value,score,其中score就是用来排序 如果该value已经存在则根据score更新元素
     *
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Long zadd(String key, double score, String member) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zadd(key, score, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key删除在zset中指定的value
     *
     * @param key
     * @param members 可以使一个string 也可以是个string数组
     * @return
     */
    public Long zrem(String key, String... members) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrem(key, members);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key增加该zset中value的score的值
     *
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Double zincrby(String key, double score, String member) {
        Jedis jedis = null;
        Double ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zincrby(key, score, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key增加该hash中value的score的值
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public long hincrBy(String key, String field, long value) {
        Jedis jedis = null;
        long ret = 0l;
        try {
            jedis = pool.getResource();
            ret = jedis.hincrBy(key, field, value);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回zset中value的排 下标从小到大排序
     *
     * @param key
     * @param member
     * @return
     */
    public Long zrank(String key, String member) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrank(key, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回zset中value的排 下标从大到小排序
     *
     * @param key
     * @param member
     * @return
     */
    public Long zrevrank(String key, String member) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrevrank(key, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key将获取score从start到end中zset的value socre从大到小排序 当start0 end-1时返回全
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> zrevrange(String key, long start, long end) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrevrange(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回指定score内zset中的value
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    public Set<String> zrangebyscore(String key, String max, String min) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrevrangeByScore(key, max, min);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回指定score内zset中的value
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    public Set<String> zrangeByScore(String key, double max, double min) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zrevrangeByScore(key, max, min);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 返回指定区间内zset中value的数
     *
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Long zcount(String key, String min, String max) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zcount(key, min, max);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key返回zset中的value个数
     *
     * @param key
     * @return
     */
    public Long zcard(String key) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zcard(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key获取zset中value的score
     *
     * @param key
     * @param member
     * @return
     */
    public Double zscore(String key, String member) {
        Jedis jedis = null;
        Double ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zscore(key, member);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key删除给定区间内的元素
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long zremrangeByRank(String key, long start, long end) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zremrangeByRank(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key删除指定score内的元素
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long zremrangeByScore(String key, double start, double end) {
        Jedis jedis = null;
        Long ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.zremrangeByScore(key, start, end);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 返回满足pattern表达式的有key keys(*) 返回有的key
     *
     * @param pattern
     * @return
     */
    public Set<String> keys(String pattern) {
        Jedis jedis = null;
        Set<String> ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.keys(pattern);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 通过key判断值得类型
     *
     * @param key
     * @return
     */
    public String type(String key) {
        Jedis jedis = null;
        String ret = null;
        try {
            jedis = pool.getResource();
            ret = jedis.type(key);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
        } finally {
            returnResource(pool, jedis);
        }
        return ret;
    }

    /**
     * 清空Redis所有数据库
     *
     * @return
     */
    public String flushall() {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();//每次操作时向pool借用一个jedis对象,用完即还。
            return jedis.flushAll();
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 用于将脚本 script 添加到脚本缓存中,但并不立即执行这个脚本。
     *
     * @param script
     * @return
     */
    public String scriptLoad(String script) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();//每次操作时向pool借用一个jedis对象,用完即还。
            return jedis.scriptLoad(script);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 结合LUA使用Redis
     */
    public Object eval(String script, int keyCount, String... params) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();//每次操作时向pool借用一个jedis对象,用完即还。
            return jedis.eval(script, keyCount, params);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 结合LUA使用Redis
     */
    public Object eval(String script, List<String> keys, List<String> args) {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();//每次操作时向pool借用一个jedis对象,用完即还。
            return jedis.eval(script, keys, args);
        } catch (Exception e) {
            pool.returnBrokenResource(jedis);
            e.printStackTrace();
            return "0";
        } finally {
            returnResource(pool, jedis);
        }
    }

    /**
     * 返还到连接池
     *
     * @param pool
     * @param jedis
     */
    private static void returnResource(JedisPool pool, Jedis jedis) {
        if (jedis != null) {
            pool.returnResource(jedis);
        }
    }
}
  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

打赏
文章很值,打赏犒劳作者一下
相关推荐
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页

打赏

newbie0107

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

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

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

打赏作者

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

抵扣说明:

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

余额充值