RedisUtil工具类代码,Java代码库,德仔网

代码语言
代码分类
【Java】 RedisUtil工具类
作者: / 发布于2016/12/6/ 558
package com.test.util;  
  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
  
import javax.annotation.Resource;  
  
import com.ucf.platform.framework.core.log.UcfLogger;  
import com.ucf.platform.framework.core.log.UcfLoggerFactory;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.ScanParams;  
import redis.clients.jedis.ScanResult;  
import redis.clients.jedis.ShardedJedis;  
import redis.clients.jedis.ShardedJedisPool;  
  
/**  
 *   
 * @ClassName RedisUtil  
 * @Description: redisUtil 工具类    
 * @author: GuXiYang    
 * @date: 2016-11-28 下午4:48:37  
 * @see http://haiziwoainixx.iteye.com/blog/2087115  
 */  
public class RedisUtil {  
    private  static final UcfLogger logger = UcfLoggerFactory.getLogger(RedisUtil.class);  
    @Resource    
    private ShardedJedisPool shardedJedisPool;    
  
  
    /**   
     * 设置一个key的过期时间（单位：秒）   
     * @param key key值   
     * @param seconds 多少秒后过期   
     * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间   
     */    
    public long expire(String key, int seconds) {    
        if (key==null || key.equals("")) {    
            return 0;    
        }    
  
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.expire(key, seconds);    
        } catch (Exception ex) {    
            logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
  
    /**   
     * 设置一个key在某个时间点过期   
     * @param key key值   
     * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数   
     * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间   
     */    
    public long expireAt(String key, int unixTimestamp) {    
        if (key==null || key.equals("")) {    
            return 0;    
        }    
  
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.expireAt(key, unixTimestamp);    
        } catch (Exception ex) {    
            logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
  
    /**   
     * 截断一个List   
     * @param key 列表key   
     * @param start 开始位置 从0开始   
     * @param end 结束位置   
     * @return 状态码   
     */    
    public String trimList(String key, long start, long end) {    
        if (key == null || key.equals("")) {    
            return "-";    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.ltrim(key, start, end);    
        } catch (Exception ex) {    
            logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return "-";    
    }    
    /**   
     * 检查Set长度   
     * @param key   
     * @return   
     */    
    public long countSet(String key){    
        if(key == null ){    
            return 0;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.scard(key);    
        } catch (Exception ex) {    
            logger.error("countSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
    /**   
     * 添加到Set中（同时设置过期时间）   
     * @param key key值   
     * @param seconds 过期时间 单位s   
     * @param value   
     * @return   
     */    
    public boolean addSet(String key,int seconds, String... value) {    
        boolean result = addSet(key, value);    
        if(result){    
            long i = expire(key, seconds);    
            return i==1;    
        }    
        return false;    
    }    
    /**   
     * 添加到Set中   
     * @param key   
     * @param value   
     * @return   
     */    
    public boolean addSet(String key, String... value) {    
        if(key == null || value == null){    
            return false;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.sadd(key, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("setList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
  
    /**   
     * @param key   
     * @param value   
     * @return 判断值是否包含在set中   
     */    
    public boolean containsInSet(String key, String value) {    
        if(key == null || value == null){    
            return false;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.sismember(key, value);    
        } catch (Exception ex) {    
            logger.error("setList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
    /**   
     * 获取Set   
     * @param key   
     * @return   
     */    
    public  Set<String> getSet(String key){    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.smembers(key);    
        } catch (Exception ex) {    
            logger.error("getList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    /**   
     * 从set中删除value   
     * @param key   
     * @return   
     */    
    public  boolean removeSetValue(String key,String... value){    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.srem(key, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("getList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
  
  
    /**   
     * 从list中删除value 默认count 1   
     * @param key   
     * @param values 值list   
     * @return   
     */    
    public  int removeListValue(String key,List<String> values){    
        return removeListValue(key, 1, values);    
    }    
    /**   
     * 从list中删除value   
     * @param key   
     * @param count    
     * @param values 值list   
     * @return   
     */    
    public  int removeListValue(String key,long count,List<String> values){    
        int result = 0;    
        if(values != null && values.size()>0){    
            for(String value : values){    
                if(removeListValue(key, count, value)){    
                    result++;    
                }    
            }    
        }    
        return result;    
    }    
    /**   
     *  从list中删除value   
     * @param key   
     * @param count 要删除个数   
     * @param value   
     * @return   
     */    
    public  boolean removeListValue(String key,long count,String value){    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.lrem(key, count, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("getList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    /**   
     * 截取List   
     * @param key    
     * @param start 起始位置   
     * @param end 结束位置   
     * @return   
     */    
    public List<String> rangeList(String key, long start, long end) {    
        if (key == null || key.equals("")) {    
            return null;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.lrange(key, start, end);    
        } catch (Exception ex) {    
            logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    /**   
     * 检查List长度   
     * @param key   
     * @return   
     */    
    public long countList(String key){    
        if(key == null ){    
            return 0;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.llen(key);    
        } catch (Exception ex) {    
            logger.error("countList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
  
    /**   
     * 添加到List中（同时设置过期时间）   
     * @param key key值   
     * @param seconds 过期时间 单位s   
     * @param value    
     * @return    
     */    
    public boolean addList(String key,int seconds, String... value){    
        boolean result = addList(key, value);    
        if(result){    
            long i = expire(key, seconds);    
            return i==1;    
        }    
        return false;    
    }    
    /**   
     * 添加到List   
     * @param key   
     * @param value   
     * @return   
     */    
    public boolean addList(String key, String... value) {    
        if(key == null || value == null){    
            return false;    
        }    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.lpush(key, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("setList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
    /**   
     * 添加到List(只新增)   
     * @param key   
     * @param value   
     * @return   
     */    
    public boolean addList(String key, List<String> list) {    
        if(key == null || list == null || list.size() == 0){    
            return false;    
        }    
        for(String value : list){    
            addList(key, value);    
        }    
        return true;    
    }    
  
    /**   
     * 获取List   
     * @param key   
     * @return   
     */    
    public  List<String> getList(String key){    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.lrange(key, 0, -1);    
        } catch (Exception ex) {    
            logger.error("getList error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
    /**   
     * 设置HashSet对象   
     *   
     * @param domain 域名   
     * @param key    键值   
     * @param value  Json String or String value   
     * @return   
     */    
    public boolean setHSet(String domain, String key, String value) {    
        if (value == null) return false;    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.hset(domain, key, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("setHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    /**   
     * 获得HashSet对象   
     *   
     * @param domain 域名   
     * @param key    键值   
     * @return Json String or String value   
     */    
    public String getHSet(String domain, String key) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.hget(domain, key);    
        } catch (Exception ex) {    
            logger.error("getHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    /**   
     * 删除HashSet对象   
     *   
     * @param domain 域名   
     * @param key    键值   
     * @return 删除的记录数   
     */    
    public long delHSet(String domain, String key) {    
        ShardedJedis shardedJedis = null;    
        long count = 0;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            count = shardedJedis.hdel(domain, key);    
        } catch (Exception ex) {    
            logger.error("delHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return count;    
    }    
  
    /**   
     * 删除HashSet对象   
     *   
     * @param domain 域名   
     * @param key    键值   
     * @return 删除的记录数   
     */    
    public long delHSet(String domain, String... key) {    
        ShardedJedis shardedJedis = null;    
        long count = 0;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            count = shardedJedis.hdel(domain, key);    
        } catch (Exception ex) {    
            logger.error("delHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return count;    
    }    
  
    /**   
     * 判断key是否存在   
     *   
     * @param domain 域名   
     * @param key    键值   
     * @return   
     */    
    public boolean existsHSet(String domain, String key) {    
        ShardedJedis shardedJedis = null;    
        boolean isExist = false;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            isExist = shardedJedis.hexists(domain, key);    
        } catch (Exception ex) {    
            logger.error("existsHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return isExist;    
    }    
  
    /**   
     * 全局扫描hset   
     *   
     * @param match field匹配模式   
     * @return   
     */    
    public List<Map.Entry<String, String>> scanHSet(String domain, String match) {    
        ShardedJedis shardedJedis = null;    
        try {    
            int cursor = 0;    
            shardedJedis = shardedJedisPool.getResource();    
            ScanParams scanParams = new ScanParams();    
            scanParams.match(match);    
            Jedis jedis = shardedJedis.getShard(domain);    
            ScanResult<Map.Entry<String, String>> scanResult;    
            List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();    
            do {    
                scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);    
                list.addAll(scanResult.getResult());    
                cursor = Integer.parseInt(scanResult.getStringCursor());    
            } while (cursor > 0);    
            return list;    
        } catch (Exception ex) {    
            logger.error("scanHSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
  
    /**   
     * 返回 domain 指定的哈希集中所有字段的value值   
     *   
     * @param domain   
     * @return   
     */    
  
    public List<String> hvals(String domain) {    
        ShardedJedis shardedJedis = null;    
        List<String> retList = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            retList = shardedJedis.hvals(domain);    
        } catch (Exception ex) {    
            logger.error("hvals error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return retList;    
    }    
  
    /**   
     * 返回 domain 指定的哈希集中所有字段的key值   
     *   
     * @param domain   
     * @return   
     */    
  
    public Set<String> hkeys(String domain) {    
        ShardedJedis shardedJedis = null;    
        Set<String> retList = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            retList = shardedJedis.hkeys(domain);    
        } catch (Exception ex) {    
            logger.error("hkeys error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return retList;    
    }    
  
    /**   
     * 返回 domain 指定的哈希key值总数   
     *   
     * @param domain   
     * @return   
     */    
    public long lenHset(String domain) {    
        ShardedJedis shardedJedis = null;    
        long retList = 0;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            retList = shardedJedis.hlen(domain);    
        } catch (Exception ex) {    
            logger.error("hkeys error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return retList;    
    }    
  
    /**   
     * 设置排序集合   
     *   
     * @param key   
     * @param score   
     * @param value   
     * @return   
     */    
    public boolean setSortedSet(String key, long score, String value) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.zadd(key, score, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("setSortedSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    /**   
     * 获得排序集合   
     *   
     * @param key   
     * @param startScore   
     * @param endScore   
     * @param orderByDesc   
     * @return   
     */    
    public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            if (orderByDesc) {    
                return shardedJedis.zrevrangeByScore(key, endScore, startScore);    
            } else {    
                return shardedJedis.zrangeByScore(key, startScore, endScore);    
            }    
        } catch (Exception ex) {    
            logger.error("getSoredSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    /**   
     * 计算排序长度   
     *   
     * @param key   
     * @param startScore   
     * @param endScore   
     * @return   
     */    
    public long countSoredSet(String key, long startScore, long endScore) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            Long count = shardedJedis.zcount(key, startScore, endScore);    
            return count == null ? 0L : count;    
        } catch (Exception ex) {    
            logger.error("countSoredSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0L;    
    }    
  
    /**   
     * 删除排序集合   
     *   
     * @param key   
     * @param value   
     * @return   
     */    
    public boolean delSortedSet(String key, String value) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            long count = shardedJedis.zrem(key, value);    
            return count > 0;    
        } catch (Exception ex) {    
            logger.error("delSortedSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    /**   
     * 获得排序集合   
     *   
     * @param key   
     * @param startRange   
     * @param endRange   
     * @param orderByDesc   
     * @return   
     */    
    public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            if (orderByDesc) {    
                return shardedJedis.zrevrange(key, startRange, endRange);    
            } else {    
                return shardedJedis.zrange(key, startRange, endRange);    
            }    
        } catch (Exception ex) {    
            logger.error("getSoredSetByRange error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    /**   
     * 获得排序打分   
     *   
     * @param key   
     * @return   
     */    
    public Double getScore(String key, String member) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.zscore(key, member);    
        } catch (Exception ex) {    
            logger.error("getSoredSet error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return null;    
    }    
  
    public boolean set(String key, String value, int second) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.setex(key, second, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("set error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    public boolean set(String key, String value) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.set(key, value);    
            return true;    
        } catch (Exception ex) {    
            logger.error("set error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    public String get(String key, String defaultValue) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);    
        } catch (Exception ex) {    
            logger.error("get error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return defaultValue;    
    }    
  
    public boolean del(String key) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            shardedJedis.del(key);    
            return true;    
        } catch (Exception ex) {    
            logger.error("del error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return false;    
    }    
  
    public long incr(String key) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.incr(key);    
        } catch (Exception ex) {    
            logger.error("incr error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
  
    public long decr(String key) {    
        ShardedJedis shardedJedis = null;    
        try {    
            shardedJedis = shardedJedisPool.getResource();    
            return shardedJedis.decr(key);    
        } catch (Exception ex) {    
            logger.error("incr error.", ex);    
            returnBrokenResource(shardedJedis);    
        } finally {    
            returnResource(shardedJedis);    
        }    
        return 0;    
    }    
  
  
  
    private void returnBrokenResource(ShardedJedis shardedJedis) {    
        try {    
            shardedJedisPool.returnBrokenResource(shardedJedis);    
        } catch (Exception e) {    
            logger.error("returnBrokenResource error.", e);    
        }    
    }    
  
    private void returnResource(ShardedJedis shardedJedis) {    
        try {    
            shardedJedisPool.returnResource(shardedJedis);    
        } catch (Exception e) {    
            logger.error("returnResource error.", e);    
        }    
    }    
}
试试其它关键字
　RedisUtil工具类　
同语言下
可能有用的
贡献的其它代码Label