Redis使用及工具类

其他 2018-06-28 17:48:40 阅读次数: 2

原地址：https://www.cnblogs.com/wyy123/p/6078593.html

【学会安装redis】

从redis.io下载最新版redis-X.Y.Z.tar.gz后解压，然后进入redis-X.Y.Z文件夹后直接make即可，安装非常简单。

make成功后会在src文件夹下产生一些二进制可执行文件，包括redis-server、redis-cli等等：

代码如下:
$ find . -type f -executable
./redis-benchmark //用于进行redis性能测试的工具
./redis-check-dump //用于修复出问题的dump.rdb文件
./redis-cli //redis的客户端
./redis-server //redis的服务端
./redis-check-aof //用于修复出问题的AOF文件
./redis-sentinel //用于集群管理

【学会启动redis】

启动redis非常简单，直接./redis-server就可以启动服务端了，还可以用下面的方法指定要加载的配置文件：

代码如下:
./redis-server ../redis.conf

默认情况下，redis-server会以非daemon的方式来运行，且默认服务端口为6379。

【使用redis客户端】

代码如下:

//这样来启动redis客户端了
$ ./redis-cli
//用set指令来设置key、value
127.0.0.1:6379> set name "roc"
OK
//来获取name的值
127.0.0.1:6379> get name
"roc"
//通过客户端来关闭redis服务端
127.0.0.1:6379> shutdown
127.0.0.1:6379>

【redis数据结构 – 简介】

redis是一种高级的key:value存储系统，其中value支持五种数据类型：

扫描二维码关注公众号，回复： 1777114 查看本文章

1.字符串（strings）：由于INCR等指令本身就具有原子操作的特性，所以我们完全可以利用redis的INCR、INCRBY、DECR、DECRBY等指令来实现原子计数的效果
2.字符串列表（lists）：lists的常用操作包括LPUSH、RPUSH、LRANGE等。我们可以用LPUSH在lists的左侧插入一个新元素，用RPUSH在lists的右侧插入一个新元素，用LRANGE命令从lists中指定一个范围来提取元素。

　　我们可以利用lists来实现一个消息队列，而且可以确保先后顺序，不必像MySQL那样还需要通过ORDER BY来进行排序。
　　利用LRANGE还可以很方便的实现分页的功能。
　　在博客系统中，每片博文的评论也可以存入一个单独的list中
3.字符串集合（sets）
4.有序字符串集合（sorted sets）：很多时候，我们都将redis中的有序集合叫做zsets，这是因为在redis中，有序集合相关的操作指令都是以z开头的，比如zrange、zadd、zrevrange、zrangebyscore等等
5.哈希（hashes）

而关于key，有几个点要提醒大家：

1.key不要太长，尽量不要超过1024字节，这不仅消耗内存，而且会降低查找的效率；
2.key也不要太短，太短的话，key的可读性会降低；
3.在一个项目中，key最好使用统一的命名模式，例如user:10000:passwd。

【聊聊redis的事务处理】

众所周知，事务是指“一个完整的动作，要么全部执行，要么什么也没有做”。

在聊redis事务处理之前，要先和大家介绍四个redis指令，即MULTI、EXEC、DISCARD、WATCH。这四个指令构成了redis事务处理的基础。

1.MULTI用来组装一个事务；
2.EXEC用来执行一个事务；
3.DISCARD用来取消一个事务；
4.WATCH用来监视一些key，一旦这些key在事务执行之前被改变，则取消事务的执行。

redis存在的好处就在于无需频繁的访问数据库，当一些数据不会发生变化时可以直接添加到redis中，比如聊天一些历史记录等，类似于缓存，这样大大的提高了性能，建议在使用redis最好结合着数据库一起使用。

Redis使用示例：

int user_id = 2;//用户id
String user_name;//用户名
if(jedis.hexists("user"+user_id, "user_name")){//判断jedis中是否存在"user"+user_id哈希表并且value值为user_name
user_name =jedis.hget("user"+user_id, "user_name");//如果存在直接获取然后登陆
System.out.println("欢迎来到Redis登陆: "+user_name);
}else{//如果不存在，则需要查询数据库判断用户名密码是否正确，如果存在则登陆，并且将其信息保存至redis
String sql = "select user_name from user_t where id = "+user_id+"";
try {
ResultSet rs =  conn.createStatement().executeQuery(sql);
if(rs.next()){
jedis.hset("user"+user_id, "user_name", rs.getString("user_name"));//保存至redis中
System.out.println("欢迎来到MySql登陆: "+rs.getString("user_name"));
}else{
System.out.println("欢迎 注册");
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

Redis工具类：

/**
 * 
 */
package com.ai.toptea.basic.util;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import com.ai.toptea.basic.spring.IReloadablePropertyBean;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.util.Pool;

/**
 * 
 * redis链接类
 * 
 * @author <a href="mailto:[email protected]">FluteD</a>
 * @version 2014-4-10
 */
public class RedisUtil implements IReloadablePropertyBean {

    public static final int DB_TEMP = 0;
    public static final int DB_COMMON = 3;
    public static final int DB_SYSMGR = 4;
    public static final int DB_RESM = 5;
    public static final int DB_ITSM = 6;
    public static final int DB_BSM = 7;
    public static final int DB_KBM = 8;
    public static final int DB_CTLM = 9;
    public static final int DB_CCP = 10;

    // 所有的DB索引
    private static Map<String, String> DB = new HashMap<String, String>();

    private static Log log = LogFactory.getLog(RedisUtil.class);

    protected static Set<String> sentinels = new HashSet<String>();
    private static String sentinelsAddrs = "";
    private static String masterName = "topteaRedisMaster";
    private static String masterPass = "";

    /**
     * key="master_dbnum/slave_dbnum",value=JedisSentinelPool/JedisPool
     */
    private static Map<String, Pool<Jedis>> jedisPool = new HashMap<String, Pool<Jedis>>();// 连接池

    public static void init() {
        sentinels.clear();
        sentinels.addAll(Arrays.asList(sentinelsAddrs.split(",")));
        jedisPool.clear();

        DB.put("" + DB_TEMP, "0");
        DB.put("" + DB_COMMON, "3");
        DB.put("" + DB_SYSMGR, "4");
        DB.put("" + DB_RESM, "5");
        DB.put("" + DB_ITSM, "6");
        DB.put("" + DB_BSM, "7");
        DB.put("" + DB_KBM, "8");
        DB.put("" + DB_CTLM, "9");
    }

    /**
     * 建立连接池
     */
    private static synchronized JedisSentinelPool initMasterPool(int dbIndex) {
        if (sentinels.size() == 0) {
            init();
        }

        JedisSentinelPool jedisSentinelPool = getMasterPool(dbIndex);

        if (jedisSentinelPool != null)
            return jedisSentinelPool;

        if (DB.containsKey("" + dbIndex)) {
            jedisSentinelPool = new JedisSentinelPool(masterName, sentinels, new GenericObjectPoolConfig(), Protocol.DEFAULT_TIMEOUT, masterPass,
                    dbIndex);

        } else {
            jedisSentinelPool = new JedisSentinelPool(masterName, sentinels, masterPass);
            dbIndex = 0;

        }

        jedisPool.put("master_" + dbIndex, jedisSentinelPool);

        return jedisSentinelPool;
    }

    /**
     * 建立连接池
     */
    private static JedisPool initSlavePool() {
        JedisPool jedisSlavePool = getSlavePool();

        if (jedisSlavePool != null) {
            try {
                Jedis slave = jedisSlavePool.getResource();
                slave.close();

                return jedisSlavePool;
            } catch (JedisConnectionException e) {
                jedisSlavePool = null;
                log.error(e.getMessage(),e);
            }
            // return jedisSlavePool;
        }

        for (String sentinel : sentinels) {

            List<String> sentinelAddr = Arrays.asList(sentinel.split(":"));
            try {
                Jedis jedis = new Jedis(sentinelAddr.get(0), Integer.parseInt(sentinelAddr.get(1)));
                List<Map<String, String>> salves = jedis.sentinelSlaves(masterName);
                if (salves == null || salves.size() == 0) {
                    continue;
                }
                int randomIndex = 0;
                while (randomIndex < salves.size()) {

                    Map<String, String> salvesAttr = salves.get(randomIndex);

                    // 当slave处于下线状态或者连接不上时，flags字段里会有s_down,disconnected字样
                    String flages = salvesAttr.get("flags");
                    if (flages.indexOf("s_down") != -1 || flages.indexOf("disconnected") != -1) {
                        randomIndex++;
                        continue;
                    }

                    jedisSlavePool = new JedisPool(new GenericObjectPoolConfig(), salvesAttr.get("ip"), Integer.parseInt(salvesAttr.get("port")),
                            Protocol.DEFAULT_TIMEOUT, masterPass);
                    break;

                }
                jedis.close();
                break;
            } catch (JedisConnectionException e) {
                // log.info("Cannot connect to sentinel running @ " + sentinel + ". Trying next one.");
            }
        }

        if (jedisSlavePool == null) {
            try {
                Jedis master = getMasterResource(DB_TEMP);

                jedisSlavePool = new JedisPool(new GenericObjectPoolConfig(), master.getClient().getHost(), master.getClient().getPort(),
                        Protocol.DEFAULT_TIMEOUT, masterPass);

                returnMasterResource(master);
            } catch (Exception e) {
                log.error(e.getMessage(),e);
            }
        }

        jedisPool.put("slave", jedisSlavePool);

        return jedisSlavePool;
    }

    /**
     * 获取jedis资源,调用此方法后，使用完毕，需要调用returnMasterResource方法
     * 
     * @return
     * @throws Exception
     */
    public static Jedis getMasterResource(int dbIndex) throws Exception {
        JedisSentinelPool jedisSentinelPool = initMasterPool(dbIndex);

        Jedis jedis = null;
        int index = 0;
        while (index < 6) {
            try {
                jedis = jedisSentinelPool.getResource();
                int dbi = jedis.getDB().intValue();
                if (dbi != dbIndex)
                    jedis.select(dbIndex);

                break;
            } catch (JedisConnectionException e) {
                log.error(e.getMessage(),e);
                log.info("Cannot connect to redis master. Sleeping 5000ms and retrying..");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e1) {
                    log.error(e.getMessage(),e);
                }

            }
            index++;

            if (index >= 6) {
                log.info("Cannot connect to redis master.");
                throw new Exception("Cannot connect to redis master in 30s");
            }
        }

        return jedis;
    }

    /**
     * 获取jedis slave资源,调用此方法后，使用完毕，需要调用returnSlaveResource方法
     * 
     * @return
     */
    public static Jedis getSlaveResource() {
        JedisPool jedisSlavePool = initSlavePool();
        Jedis slave = null;
        try {
            slave = jedisSlavePool.getResource();
        } catch (JedisConnectionException e) {

        }
        return slave;
    }

    public static Jedis getSlaveResource(int dbIndex) {
        Jedis jedis = getSlaveResource();

        if (jedis != null) {
            jedis.select(dbIndex);
        }

        return jedis;
    }

    public static Jedis getJedisSlave(int dbIndex) {
        Jedis jedis = getSlaveResource();

        if (jedis != null) {
            jedis.select(dbIndex);
        }

        return jedis;
    }

    /**
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @throws Exception
     */
    public static String set(int dbIndex, String key, String value) throws Exception {
        Jedis jedis = null;
        String ret = "";
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.set(key, value);
                break;

            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }

        return ret;
    }

    public static String set(int dbIndex, byte[] key, byte[] value) throws Exception {
        Jedis jedis = null;
        String ret = "";
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.set(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，左拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lpush(int dbIndex, String key, String... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpush(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，左拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lpush(int dbIndex, byte[] key, byte[]... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpush(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，左拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lpushx(int dbIndex, byte[] key, byte[]... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpushx(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，左拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lpushx(int dbIndex, String key, String value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpushx(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，右拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long rpush(int dbIndex, String key, String... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpush(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，右拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long rpushx(int dbIndex, String key, String... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpushx(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，右拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long rpush(int dbIndex, byte[] key, byte[]... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpush(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 链表数组，右拼接
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long rpushx(int dbIndex, byte[] key, byte[]... value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpushx(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 从左侧开始获取链表数据
     * 
     * @param dbIndex
     * @param key
     * @param start
     * @param end
     * @return
     * @throws Exception
     */
    public static List<byte[]> lrange(int dbIndex, byte[] key, long start, long end) {
        Jedis jedis = null;
        List<byte[]> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lrange(key, start, end);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 从左侧开始获取链表数据
     * 
     * @param dbIndex
     * @param key
     * @param start
     * @param end
     * @return
     * @throws Exception
     */
    public static List<String> lrange(int dbIndex, String key, long start, long end) {
        Jedis jedis = null;
        List<String> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lrange(key, start, end);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 从右侧删除数据并返回
     * 
     * @param dbIndex
     * @param key
     * @return
     * @throws Exception
     */
    public static String rpop(int dbIndex, String key) {
        Jedis jedis = null;
        String ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpop(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 从右侧删除数据并返回
     * 
     * @param dbIndex
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] rpop(int dbIndex, byte[] key) {
        Jedis jedis = null;
        byte[] ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.rpop(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 从左侧删除数据并返回
     * 
     * @param dbIndex
     * @param key
     * @return
     * @throws Exception
     */
    public static String lpop(int dbIndex, String key) {
        Jedis jedis = null;
        String ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpop(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 从左侧删除数据并返回
     * 
     * @param dbIndex
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] lpop(int dbIndex, byte[] key) {
        Jedis jedis = null;
        byte[] ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lpop(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }
    
    /**
     * 返回链表长度
     * @param dbIndex
     * @param key
     * @return
     */
    public static long llen(int dbIndex, byte[] key) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.llen(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }
    

    /**
     * 返回链表长度
     * @param dbIndex
     * @param key
     * @return
     */
    public static long llen(int dbIndex, String key) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.llen(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 删除指定数量（count)的指定项(value)
     * 
     * @param dbIndex
     * @param key
     * @param count
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lrem(int dbIndex, String key, long count, String value) {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lrem(key, count, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 删除指定数量（count)的指定项(value)
     * 
     * @param dbIndex
     * @param key
     * @param count
     * @param value
     * @return
     * @throws Exception
     */
    public static Long lrem(int dbIndex, byte[] key, long count, byte[] value) {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lrem(key, count, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        return ret;
    }

    /**
     * 更新制定位置（index）的值
     * 
     * @param dbIndex
     * @param key
     * @param index
     * @param value
     * @return
     * @throws Exception
     */
    public static String lset(int dbIndex, byte[] key, long index, byte[] value) throws Exception {
        Jedis jedis = null;
        String ret = null;
        int retryCount = 0;

        while (retryCount < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lset(key, index, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            retryCount++;
        }
        returnMasterResource(jedis);
        if (retryCount >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 更新制定位置（index）的值
     * 
     * @param dbIndex
     * @param key
     * @param index
     * @param value
     * @return
     * @throws Exception
     */
    public static String lset(int dbIndex, String key, long index, String value) throws Exception {
        Jedis jedis = null;
        String ret = null;
        int retryCount = 0;

        while (retryCount < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.lset(key, index, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            retryCount++;
        }
        returnMasterResource(jedis);
        if (retryCount >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long append(int dbIndex, String key, String value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.append(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long append(int dbIndex, byte[] key, byte[] value) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.append(key, value);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long del(int dbIndex, byte[] key) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.del(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long del(int dbIndex, byte[]... key) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.del(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long del(int dbIndex, String key) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.del(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long del(int dbIndex, String... key) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.del(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long hdel(int dbIndex, String key, String... fields) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hdel(key, fields);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 删除一个键值
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long hdel(int dbIndex, byte[] key, byte[]... fields) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hdel(key, fields);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 设置过期时间
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long expire(int dbIndex, String key, int seconds) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.expire(key, seconds);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 设置过期时间
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long expireAt(int dbIndex, String key, long unixTime) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.expireAt(key, unixTime);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 设置过期时间
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long expire(int dbIndex, byte[] key, int seconds) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.expire(key, seconds);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 设置过期时间
     * 
     * @param dbIndex
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public static Long expireAt(int dbIndex, byte[] key, long unixTime) throws Exception {
        Jedis jedis = null;
        Long ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.expireAt(key, unixTime);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }
        returnMasterResource(jedis);
        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * 获取一个键值
     * 
     * @param dbIndex
     * @param key
     * @return
     */
    public static String get(int dbIndex, String key) {
        Jedis jedis = null;
        String ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.get(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;

    }

    public static String get(int dbIndex, String key, long startOffset, long endOffset) {
        Jedis jedis = null;
        String ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.getrange(key, startOffset, endOffset);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;

    }

    public static String hget(int dbIndex, String key, String field) {
        Jedis jedis = null;
        String ret = "";
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hget(key, field);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);
        return ret;
    }

    public static byte[] hget(int dbIndex, byte[] key, byte[] field) {
        Jedis jedis = null;
        byte[] ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hget(key, field);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);
        return ret;
    }

    public static Map<byte[], byte[]> hgetAll(int dbIndex, byte[] key) {
        Jedis jedis = null;
        Map<byte[], byte[]> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hgetAll(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);
        return ret;
    }

    public static Map<String, String> hgetAll(int dbIndex, String key) {
        Jedis jedis = null;
        Map<String, String> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hgetAll(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }

        returnMasterResource(jedis);
        return ret;
    }

    public static boolean hexists(int dbIndex, String key, String field) {
        Jedis jedis = null;
        boolean ret = false;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hexists(key, field);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }

        returnMasterResource(jedis);
        return ret;
    }

    public static boolean hexists(int dbIndex, byte[] key, byte[] field) {
        Jedis jedis = null;
        boolean ret = false;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hexists(key, field);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }

        returnMasterResource(jedis);
        return ret;
    }

    public static boolean exists(int dbIndex, String key) {
        Jedis jedis = null;
        boolean ret = false;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.exists(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }

        returnMasterResource(jedis);
        return ret;
    }

    public static boolean exists(int dbIndex, byte[] key) {
        Jedis jedis = null;
        boolean ret = false;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.exists(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;
        }

        returnMasterResource(jedis);
        return ret;
    }

    public static Set<String> keys(int dbIndex, String pattern) {
        Jedis jedis = null;
        Set<String> ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.keys(pattern);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;
    }

    public static Set<byte[]> keys(int dbIndex, byte[] pattern) {
        Jedis jedis = null;
        Set<byte[]> ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.keys(pattern);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;
    }

    /**
     * 获取一个键值
     * 
     * @param dbIndex
     * @param key
     * @return
     */
    public static byte[] get(int dbIndex, byte[] key) {
        Jedis jedis = null;
        byte[] ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.get(key);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;

    }

    public static byte[] get(int dbIndex, byte[] key, long startOffset, long endOffset) {
        Jedis jedis = null;
        byte[] ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.getrange(key, startOffset, endOffset);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;

    }

    public static List<String> mget(int dbIndex, String... keys) {
        Jedis jedis = null;
        List<String> ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.mget(keys);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;
    }

    public static List<byte[]> mget(int dbIndex, byte[]... keys) {
        Jedis jedis = null;
        List<byte[]> ret = null;

        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.mget(keys);
                break;
            } catch (Exception e) {
                log.info(e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnSlaveResource(jedis);

        return ret;
    }

    /**
     * map 结构
     * 
     * @param dbIndex
     * @param key
     * @param field
     * @param value
     * @return
     * @throws Exception
     */
    public static long hset(int dbIndex, String key, String field, String value) throws Exception {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hset(key, field, value);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    /**
     * map 结构
     * 
     * @param dbIndex
     * @param key
     * @param field
     * @param value
     * @return
     * @throws Exception
     */
    public static long hset(int dbIndex, byte[] key, byte[] field, byte[] value) throws Exception {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.hset(key, field, value);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        if (index >= 3) {
            throw new Exception("Cannot save data to redis.");
        }
        return ret;
    }

    public static long sort(int dbIndex, String key, String dstkey) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, dstkey);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static long sort(int dbIndex, byte[] key, byte[] dstkey) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, dstkey);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static List<String> sort(int dbIndex, String key) {
        Jedis jedis = null;
        List<String> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static List<String> sort(int dbIndex, String key, SortingParams sp) {
        Jedis jedis = null;
        List<String> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, sp);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static long sort(int dbIndex, String key, SortingParams sp, String dstkey) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, sp, dstkey);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static long sort(int dbIndex, byte[] key, SortingParams sp, byte[] dstkey) {
        Jedis jedis = null;
        long ret = 0;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, sp, dstkey);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static List<byte[]> sort(int dbIndex, byte[] key) {
        Jedis jedis = null;
        List<byte[]> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    public static List<byte[]> sort(int dbIndex, byte[] key, SortingParams sp) {
        Jedis jedis = null;
        List<byte[]> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.sort(key, sp);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 执行脚本
     * 
     * @param dbIndex
     * @param script
     * @return
     */
    public static Object eval(int dbIndex, String script, List<String> keys, List<String> args) {

        Jedis jedis = null;
        Object ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.eval(script, keys, args);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 执行脚本
     * 
     * @param dbIndex
     * @param script
     * @return
     */
    public static Object eval(int dbIndex, String script) {

        Jedis jedis = null;
        Object ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.eval(script);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 执行脚本
     * 
     * @param dbIndex
     * @param scriptShaId
     * @return
     */
    public static Object evalsha(int dbIndex, String scriptShaId, List<String> keys, List<String> args) {

        Jedis jedis = null;
        Object ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                if (jedis.scriptExists(scriptShaId))
                    ret = jedis.evalsha(scriptShaId, keys, args);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 执行脚本
     * 
     * @param dbIndex
     * @param scriptShaId
     * @return
     */
    public static Object evalsha(int dbIndex, String scriptShaId) {

        Jedis jedis = null;
        Object ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                if (jedis.scriptExists(scriptShaId))
                    ret = jedis.evalsha(scriptShaId);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 注册脚本
     * 
     * @param script
     * @return 脚本 sha id
     */
    public static String scriptLoad(int dbIndex, String script) {
        Jedis jedis = null;
        String ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                ret = jedis.scriptLoad(script);
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }

            }

            index++;

        }

        returnMasterResource(jedis);

        return ret;
    }

    /**
     * 管道方式，批量获取键值对象
     * 
     * @param dbIndex
     * @param keys
     * @return
     */
    public static List<Object> pipeGet(int dbIndex, String... keys) {
        Jedis jedis = null;
        List<Object> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                Pipeline pipe = jedis.pipelined();
                for (String key : keys) {
                    pipe.get(key);
                }
                ret = pipe.syncAndReturnAll();
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnMasterResource(jedis);

        return ret;
    }

    public static List<Object> pipeGet(int dbIndex, List<String> keys) {
        if (keys == null)
            return null;
        
        return pipeGet(dbIndex, keys.toArray(new String[0]));
    }

    /**
     * 管道方式，批量获取键值对象
     * 
     * @param dbIndex
     * @param keys
     * @return
     */
    public static List<Object> pipeGet(int dbIndex, byte[]... keys) {
        Jedis jedis = null;
        List<Object> ret = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                Pipeline pipe = jedis.pipelined();
                for (byte[] key : keys) {
                    pipe.get(key);
                }
                ret = pipe.syncAndReturnAll();
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnMasterResource(jedis);

        return ret;
    }
    
    /**
     * 管道方式删除键值对
     * @param dbIndex
     * @param keysPattern 可以用前缀加*匹配多个，如：users*表示删除users开头的
     * @return
     */
    public static void pipeDel(int dbIndex, String keysPattern) {
        Jedis jedis = null;
        int index = 0;

        while (index < 3) {
            try {
                jedis = getJedisMaster(dbIndex);
                Set<String> keys = jedis.keys(keysPattern);
                Pipeline pipe = jedis.pipelined();
                for (String key : keys) {
                    pipe.del(key);
                }
                pipe.sync();
                break;
            } catch (Exception e) {
                log.error(e.getMessage(),e);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e1) {
                    log.error(e1.getMessage(),e1);
                }
            }

            index++;
        }
        returnMasterResource(jedis);

    }



    /**
     * 获取一个指定数据库的Jedis
     * 
     * @param dbIndex
     *            数据库编号
     * @return
     * @throws Exception
     */
    public static Jedis getJedisMaster(int dbIndex) throws Exception {
        Jedis jedis = getMasterResource(dbIndex);
        return jedis;
    }

    public static Jedis getCommonJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_COMMON);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    public static Jedis getSysmgrJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_SYSMGR);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    public static Jedis getItsmJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_ITSM);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    public static Jedis getResmJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_RESM);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    public static Jedis getKbmJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_KBM);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    public static Jedis getBsmJedisMaster() {
        Jedis jedis = null;
        try {
            jedis = getJedisMaster(DB_BSM);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return jedis;
    }

    /**
     * 归还jedis资源
     * 
     * @param jedis
     */
    public static void returnMasterResource(Jedis jedis) {
        if (jedis == null)
            return;
        jedis.close();
        // Long db = jedis.getDB();
        //
        // JedisSentinelPool jedisSentinelPool = getMasterPool(db.intValue());
        //
        // if (jedisSentinelPool == null)
        // return;

        // jedisSentinelPool.returnResource(jedis);
    }

    /**
     * 归还jedis slave资源
     * 
     * @param jedis
     */
    public static void returnSlaveResource(Jedis jedis) {
        if (jedis == null)
            return;
        jedis.close();
        // JedisPool jedisSlavePool = getSlavePool();
        //
        // if (jedisSlavePool == null)
        // return;

        // jedisSlavePool.returnResource(jedis);
    }

    /**
     * @deprecated 对于我们的环境，连接池建立后一般不会销毁
     */
    public static void destroyMasterPool(int dbIndex) {
        JedisSentinelPool jedisSentinelPool = getMasterPool(dbIndex);
        if (jedisSentinelPool == null)
            return;

        jedisSentinelPool.destroy();
    }

    private static JedisSentinelPool getMasterPool(int dbIndex) {
        JedisSentinelPool jedisSentinelPool = null;
        if (!DB.containsKey("" + dbIndex))
            dbIndex = DB_TEMP;
        if (!jedisPool.containsKey("master_" + dbIndex))
            return null;

        jedisSentinelPool = (JedisSentinelPool) jedisPool.get("master_" + dbIndex);
        return jedisSentinelPool;
    }

    private static JedisPool getSlavePool() {
        JedisPool jedisSlavePool = null;
        jedisSlavePool = (JedisPool) jedisPool.get("slave");
        return jedisSlavePool;
    }

    /**
     * @param sentinelsAddrs
     *            the sentinelsAddrs to set
     */
    public static void setSentinelsAddrs(String sentinelsAddrs) {
        RedisUtil.sentinelsAddrs = sentinelsAddrs;
    }

    /**
     * @param masterPass
     *            the masterPass to set
     */
    public static void setMasterPass(String masterPass) {
        RedisUtil.masterPass = masterPass;
    }

    /**
     * @param masterName
     *            the masterName to set
     */
    public static void setMasterName(String masterName) {
        RedisUtil.masterName = masterName;
    }

    /*
     * (non-Javadoc)
     * 
     * @see com.ai.toptea.basic.spring.IReloadablePropertyBean#beforePropertyReload(java.lang.String, java.lang.String)
     */
    @Override
    public void beforePropertyReload(String propertyName, String newValue) {

    }

    /*
     * (non-Javadoc)
     * 
     * @see com.ai.toptea.basic.spring.IReloadablePropertyBean#afterPropertyReload(java.lang.String, java.lang.String)
     */
    @Override
    public void afterPropertyReload(String propertyName, String newValue) {
        // 没有变更直接返回
        if ("sentinelsAddrs".equals(propertyName) && RedisUtil.sentinelsAddrs.equals(newValue))
            return;
        if ("masterPass".equals(propertyName) && RedisUtil.masterPass.equals(newValue))
            return;
        if ("masterName".equals(propertyName) && RedisUtil.masterName.equals(newValue))
            return;
        init();
    }

}

猜你喜欢

转载自www.cnblogs.com/chappell/p/9052178.html
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022