redis簡單示例

package com.chauvet.utils.redis;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringUtils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class RedisClient {
    
    private static String ADDR = "127.0.0.1";   //Redis服務器IP 
    private static int PORT = 6379;   //Redis的端口號 
    private static String AUTH = null;//"admin";//訪問密碼
    private static int MAX_ACTIVE = 1024;//可用連接實例的最大數目，默認值為8；如果賦值為-1，則表示不限制；如果pool已經分配了maxActive個jedis實例，則此時pool的狀態為exhausted(耗盡)。
    private static int MAX_IDLE = 200; //控制一個pool最多有多少個狀態為idle(空閑的)的jedis實例，默認值也是8。
    private static int MAX_WAIT = 10000;//等待可用連接的最大時間，單位毫秒，默認值為-1，表示永不超時。如果超過等待時間，則直接拋出JedisConnectionException；
    private static int TIMEOUT = 10000;
    private static boolean TEST_ON_BORROW = true;//在borrow一個jedis實例時，是否提前進行validate操作；如果為true，則得到的jedis實例均是可用的；
    private static JedisPool jedisPool = null;
    
    /**
     * 初始化Redis連接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWait(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 獲取Jedis實例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    
    private static Jedis jedis = getJedis();
    
    /**
     * 釋放jedis資源
     * @param jedis
     */
    public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
    
    /***
     * 清空所有db
     */
    public static void flushAll(){
        jedis.flushAll();
        RedisClient.returnResource(jedis);
    }
    
    /***
     * 清空當前db
     */
    public static void flushDb(){
        jedis.flushDB();
        RedisClient.returnResource(jedis);
    }
    
    /***
     * 模糊查詢所有的key
     *         例如 所有 包含‘name’的key
     * @param key
     *        用法說明：  *key* 包含key,  key* 以key開頭， *key 以key結尾
     * @return
     *        返回的是key集合  不是 value
     */
    public static Set<String> getAllKeySetByParrten(String key){
        Set<String> keySet = new HashSet<String>();
        if(StringUtils.isNotBlank(key)){
            keySet = jedis.keys(key);
        }
        RedisClient.returnResource(jedis);
        return keySet;
    }
    
    /***
     * 判斷當前key是否已經存在於redis中
     * @param key
     * @return
     */
    public static boolean isExistsKey(String key){
        boolean isExists = false;
        if(StringUtils.isNotBlank(key)){
            isExists = jedis.exists(key);
        }
        RedisClient.returnResource(jedis);
        return isExists;
    }
    
    /***
     * 存key並且有超時時間
     * @param key
     * @param seconds
     * @param value
     */
    public static void setKeyByTimeout(String key,int seconds,String value){
        if(StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value)){
            jedis.setex(key, seconds, value);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 獲取key的剩余超時時間
     * @param key
     * @return
     */
    public static long gettime(String key){
        long time = 0;
        if(StringUtils.isNotBlank(key)){
            time = jedis.ttl(key);
        }
        RedisClient.returnResource(jedis);
        return time;
    }
    
    /***
     * 取消超時時間的設置
     * @param key
     */
    public static void cancleTime(String key){
        if(StringUtils.isNotBlank(key)){
            jedis.persist(key);
        }
        RedisClient.returnResource(jedis); 
    }
    
    /***
     * int類型 遞增/遞減：incr()/decr()
     * @param key
     *                 key
     * @param type
     *                 0遞增/1遞減
     */
    public static void valueIncrOrDecr(String key,int type){
        if(StringUtils.isNotBlank(key)){
            switch (type) {
            case 0:
                jedis.incr(key); // 遞增
                break;
            case 1:
                jedis.decr(key); ///遞減
                break;
            }
        }
        RedisClient.returnResource(jedis); 
    }
    
    /***
     * 存單個string類型
     * @param key
     * @param value
     */
    public static void setStringVal(String key,String value){
        if(StringUtils.isNotBlank(key)&&StringUtils.isNotBlank(value)){
//            Jedis jedis = RedisClient.getJedis();
            jedis.set(key, value);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 根據key獲取單個value
     * @param key
     * @return
     */
    public static String getStringVal(String key){
        String value = null;
        if(StringUtils.isNotBlank(key)){
//            Jedis jedis = RedisClient.getJedis();
            value = jedis.get(key);
            RedisClient.returnResource(jedis);
        }
        return value;
    }
    
    /***
     * 根據key 給value后面拼加
     * @param key
     * @param appendVal
     */
    public static void appendStringVal(String key,String appendVal){
        if(StringUtils.isNotBlank(key)&&StringUtils.isNotBlank(appendVal)){
            jedis.append(key, appendVal);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 根據key刪除單個
     * @param key
     */
    public static void delStringVal(String key){
        if(StringUtils.isNotBlank(key)){
            jedis.del(key);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 存多個String
     * @param keys
     * @param values
     */
//    public static void mSetStringVal(String[] keys,String[] values){
//        if((null != keys && keys.length > 0) && (null != values && values.length > 0)){
//            for (String str : keys) {
//                
//            }
//        }
//        
//    }
    
    /***
     * 存Map
     * @param key
     * @param map
     */
    public static void setMapValue(String key,Map<String, String> map){
        if(StringUtils.isNotBlank(key) && null != map){
            jedis.hmset(key, map);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 根據key獲取map中的值
     * @param key
     *             redis里面的key
     * @param mapKeys
     *             map里面的key  可以傳多個
     * @return
     */
    public static List<String> getMapValue(String key,String ... mapKeys){
        List<String> strList = new ArrayList<String>();
        if(StringUtils.isNotBlank(key) && (null != mapKeys && mapKeys.length > 0)){
            strList = jedis.hmget(key, mapKeys);
            RedisClient.returnResource(jedis);
        }
        return strList;
    }
    
    /***
     * 刪除map中的某個鍵值  
     * @param key
     *             redis里面的key
     * @param mapKey
     *             map里面的key
     */
    public static void delMapKey(String key,String... mapKey){
        if(StringUtils.isNotBlank(key) && (null != mapKey && mapKey.length > 0)){
            jedis.hdel(key, mapKey);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 獲取map里面的所有的key
     * @param key
     */
    public static void getMapKey(String key){
         Iterator<String> iter=jedis.hkeys(key).iterator();  
         while (iter.hasNext()){  
             String mapKey = iter.next();  
              System.out.println(mapKey+":"+jedis.hmget(key,mapKey));  
         }
         RedisClient.returnResource(jedis);
    }
    
    /***
     * 存List
     * lpush方式存入，先進后出
     * @param key
     * @param value
     */
    public static void setListValueByLpush(String key,String... values){
        if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
            jedis.lpush(key, values);
        }
        RedisClient.returnResource(jedis);
    }
    
    /***
     * 存List
     * rpush方式存入，先進先出
     * @param key
     * @param value
     */
    public static void setListValueByRpush(String key,String... values){
        if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
            jedis.rpush(key, values);
        }
        RedisClient.returnResource(jedis);
    }
    
    /***
     * 對List排序
     * @param key
     */
    public static void sortList(String key){
        if(StringUtils.isNotBlank(key)){
            jedis.sort(key);
        }
    }
    
    /***
     * 獲取redis中的list
     *             lrange是按范圍取出
     * @param key
     *             key
     * @param beginIndex
     *             起點位置
     * @param endIndex
     *             是結束位置， -1表示取得所有  ，jedis.llen獲取長度
     * 
     * @return
     */
    public static List<String> getListValue(String key,long beginIndex,long endIndex){
        List<String> listStr = new ArrayList<String>();
        if(StringUtils.isNotBlank(key)){
            listStr = jedis.lrange(key, beginIndex, endIndex);
        }
        RedisClient.returnResource(jedis);
        return listStr;
    }
    
    /***
     * 清空指定key存放的list
     * @param key
     */
    public static void flushListValue(String... keys){
        if(null != keys && keys.length > 0){
            jedis.del(keys);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 將Set存入redis
     * @param key
     * @param value
     */
    public static void setSetValue(String key,String... values){
        if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
            jedis.sadd(key, values);
        }
        RedisClient.returnResource(jedis);
    }
    
    /***
     * 獲取redis存放的set
     * 無序
     * @param key
     * @return
     */
    public static Set<String> getSetListByKey(String key){
        Set<String> valSet = new HashSet<String>();
        if(StringUtils.isNotBlank(key)){
            valSet = jedis.smembers(key);
            RedisClient.returnResource(jedis);
        }
        return valSet;
    }
    
    /***
     * 移除set中的key
     * @param key
     * @param setKeys
     */
    public static void removeSetValue(String key,String... setKeys){
        if(StringUtils.isNotBlank(key) && (null != setKeys && setKeys.length > 0)){
            jedis.srem(key,setKeys);
            RedisClient.returnResource(jedis);
        }
    }
    
    /***
     * 判斷setKey是否是key的元素
     * @param key
     * @param setKey
     * @return
     */
    public static boolean isKeyInSet(String key,String setKey){
        boolean isExists = false;
        if(StringUtils.isNotEmpty(key) && StringUtils.isNotBlank(setKey)){
            isExists = jedis.sismember(key,setKey);
        }
        RedisClient.returnResource(jedis);
        return isExists;
    }

    /***
     * 獲取set中元素的個數
     * @param key
     * @return
     */
    public static long getSetValueCount(String key){
        long count = 0;
        if(StringUtils.isNotBlank(key)){
            count = jedis.scard(key);
        }
        RedisClient.returnResource(jedis);
        return count;
    }

    /***
     * 隨機獲取一個set元素
     * @param key
     * @return
     */
    public static String getSetValueByRandem(String key){
        String value = null;
        if(StringUtils.isNotBlank(key)){
            value = jedis.srandmember(key);
        }
        RedisClient.returnResource(jedis);
        return value;
    }
    
    
    
    public static void main(String[] args) {
        
        /*Jedis jedis = RedisClient.getJedis();
        jedis.set("name", "wxw");
        System.out.println(jedis.get("name"));
        RedisClient.returnResource(jedis);*/
        
        /*RedisClient.flushAll();
        RedisClient.setStringVal("name","wxw");
        System.out.println(RedisClient.getStringVal("name"));
        RedisClient.appendStringVal("name", " is me!");
        System.out.println(RedisClient.getStringVal("name"));*/
        
        /*Map<String,String> mapStr = new HashMap<String, String>();
        mapStr.put("1", "11");
        mapStr.put("2", "22");
        mapStr.put("3", "33");
        mapStr.put("4", "44");
        RedisClient.setMapValue("wxwMap", mapStr);
        RedisClient.getMapValue("wxwMap", "1","3");*/
        
        /*RedisClient.setStringVal("age", "22");
        RedisClient.jedis.incr("age"); // 值   遞增/遞減：incr()/decr()
        System.out.println(RedisClient.getStringVal("age"));*/
        
        
        /*jedis.lpush("wxw", "my");
        jedis.lpush("wxw", "name");
        jedis.lpush("wxw", "is");
        jedis.lpush("wxw", "chauvet");
        System.out.println(jedis.lrange("wxw",0,-1));  */
        
        /*jedis.del("wxw");
        jedis.rpush("wxw", "my");
        jedis.rpush("wxw", "name");
        jedis.rpush("wxw", "is");
        jedis.rpush("wxw", "chauvet");
        System.out.println(jedis.lrange("wxw",0,-1));*/
        
//        jedis.srem("user","w","x","w","a","s","1","2","3","4","5");
//        jedis.sadd("user", "w","x","w","a","s","1","2","3","4","5");
//        System.out.println(jedis.smembers("user"));
//        System.out.println(jedis.srandmember("user")); // 隨機獲取一個元素
//        System.out.println(jedis.sismember("user", "a"));//判斷 who 是否是user集合的元素  
        
        
    /*    Jedis jedis = RedisClient.getJedis();
        jedis.set("name", "wxw");
        System.out.println(jedis.keys("*am*"));
        RedisClient.returnResource(jedis);*/
        
        
           /*5. 事務支持：
           @ 獲取事務：
         Transaction tx = jedis.multi();
         @ 批量操作：tx采用和jedis一致的API接口
         for(int i = 0;i < 10;i ++) {
              tx.set("key" + i, "value" + i); 
              System.out.println("--------key" + i);
              Thread.sleep(1000);  
         }
       @ 執行事務：針對每一個操作，返回其執行的結果，成功即為Ok
         List<Object> results = tx.exec();*/
        
        
        
        
        
        
    }
}