• Redis使用及工具类


    原地址: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支持五种数据类型:

    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:lihz2@asiainfo-linkage.com">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();
        }
    
    }
  • 相关阅读:
    [SDOI2008]递归数列
    [SCOI2008]奖励关
    [SCOI2010]幸运数字
    [ZJOI2007]矩阵游戏
    [HAOI2006]旅行
    [ZJOI2008]泡泡堂
    [BZOJ1800][Ahoi2009]fly 飞行棋
    [POJ2288]Islands and Bridges
    [LUOGU] 3959 宝藏
    [BZOJ]1029: [JSOI2007]建筑抢修
  • 原文地址:https://www.cnblogs.com/chappell/p/9052178.html
Copyright © 2020-2023  润新知