java redis 配置使用

1.RedisKit

package com.seryo.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.SortedSet;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

import org.redisson.Redisson;
import org.redisson.api.RBucket;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RKeys;
import org.redisson.api.RList;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

/**
 * redis 操作輔助工具 <br />
 * 
 * @category redis 操作輔助工具
 * @className RedisKit
 * @package com.xy.redis
 * @description
 */
public class RedisKit {

	private static interface Helper {
		RedisKit INSTANCE = new RedisKit();
	}

	private RedissonClient client;

	private RedisKit() {
	}

	private static ReentrantLock lock = new ReentrantLock();

	/**
	 * 連接redis 服務
	 * 
	 * @category 連接redis 服務
	 */
	private void connect() {
		if (client == null || client.isShutdown() || client.isShuttingDown()) {
			lock.lock();
			try {
				if (client == null || client.isShutdown() || client.isShuttingDown()) {
					Config cfg = Config.fromJSON(RedisKit.class.getClassLoader().getResourceAsStream("redis.json"));
					client = Redisson.create(cfg);
				}
			} catch (Exception e) {
				throw new RuntimeException(e);
			} finally {
				lock.unlock();
			}
		}
	}

	/**
	 * 斷開連接<br />
	 * 斷開連接後，如果需要重新使用，只能重新獲取實例了
	 * 
	 * @category 斷開連接
	 */
	public void disconnect() {
		if (client != null) {
			client.shutdown();
			client = null;
		}
	}

	/**
	 * set 不設置過期時間
	 * 
	 * @category set
	 * @param key
	 * @param value
	 * @return
	 */
	private <T> RBucket<T> _set(String key, T value) {
		RBucket<T> bucket = client.getBucket(key);
		bucket.set(value);
		return bucket;
	}

	/**
	 * 獲取緩存bucket
	 * 
	 * @category 獲取緩存bucket
	 * @author prz
	 * @date 2017年7月28日
	 * @param key
	 * @return
	 * @return RBucket<T>
	 */
	private <T> RBucket<T> _getBucket(String key) {
		return client.<T>getBucket(key);
	}

	/**
	 * 使緩存timeout毫秒後過期
	 * 
	 * @category 使緩存timeout毫秒後過期
	 * @author prz
	 * @date 2017年7月28日
	 * @param bucket
	 * @param timeout
	 */
	private boolean _expire(RBucket bucket, long timeout) {
		return bucket.expire(timeout, TimeUnit.MILLISECONDS);
	}

	/**
	 * 使緩存timeout毫秒後過期
	 * 
	 * @category 使緩存timeout毫秒後過期
	 * @author prz
	 * @date 2017年7月28日
	 * @param key
	 * @param timeout
	 */
	private boolean _expire(String key, long timeout) {
		return _expire(_getBucket(key), timeout);
	}

	/**
	 * 使緩存在expireAt時間點過期
	 * 
	 * @category 使緩存在expireAt時間點過期
	 * @param bucket
	 * @param expireAt
	 */
	private boolean _expireAt(RBucket bucket, long expireAt) {
		return bucket.expireAt(expireAt);
	}

	/**
	 * 使緩存在expireAt時間點過期
	 * 
	 * @category 使緩存在expireAt時間點過期
	 * @param key
	 * @param expireAt
	 */
	private boolean _expireAt(String key, long expireAt) {
		return _expireAt(_getBucket(key), expireAt);
	}

	/**
	 * set <br />
	 * 不設置過期時間
	 * 
	 * @category set
	 * @param key
	 * @param value
	 */
	public <T> void set(String key, T value) {
		_set(key, value);
	}

	/**
	 * cache set<br />
	 * x毫秒後過期
	 * 
	 * @category cache set
	 * @param key
	 *            鍵
	 * @param value
	 *            值
	 * @param timeout
	 *            x毫秒後過期
	 */
	public <T> void set(String key, T value, long timeout) {
		RBucket bucket = _set(key, value);
		_expire(bucket, timeout);
	}

	/**
	 * cache set 在某個時間點後過期
	 * 
	 * @category cache set
	 * @param key
	 *            鍵
	 * @param value
	 *            值
	 * @param expireAt
	 *            時間節點（long表示）
	 */
	public <T> void setExpAt(String key, T value, long expireAt) {
		RBucket bucket = _set(key, value);
		_expireAt(bucket, expireAt);
	}

	/**
	 * 判斷是否存在某個key
	 * 
	 * @category 判斷是否存在某個key
	 * @param key
	 * @return boolean
	 */
	public boolean exists(String key) {
		return client.getBucket(key).isExists();
	}

	/**
	 * get <br />
	 * 支持所有數據處理
	 * 
	 * @category get
	 * @param key
	 * @return T
	 */
	public <T> T get(String key) {
		return this.<T>_getBucket(key).get();
	}

	/**
	 * delete <br />
	 * 支持所有數據類似處理
	 * 
	 * @category delete
	 * @param key
	 * @return boolean
	 */
	public boolean del(String key) {
		return _getBucket(key).delete();
	}

	/**
	 * 使緩存timeout後超期
	 * 
	 * @category 使緩存timeout後超期
	 * @param key
	 * @param timeout
	 * @return
	 */
	public boolean expire(String key, long timeout) {
		return _expire(key, timeout);
	}

	/**
	 * 使緩存expireAt時刻超期
	 * 
	 * @category 使緩存expireAt時刻超期
	 * @param key
	 * @param expireAt
	 * @return boolean
	 */
	public boolean expireAt(String key, long expireAt) {
		return _expireAt(key, expireAt);
	}

	/**
	 * 清空過期時間，即持久化
	 * 
	 * @category 清空過期時間，即持久化
	 * @param key
	 * @return boolean
	 */
	public boolean persist(String key) {
		return _getBucket(key).clearExpire();
	}

	/**
	 * 存儲字符串
	 * 
	 * @category 存儲字符串
	 * @param key
	 * @param value
	 */
	public void str(String key, String value) {
		set(key, value);
	}

	/**
	 * 獲取字符串
	 * 
	 * @category 獲取字符串
	 * @param key
	 * @return
	 */
	public String str(String key) {
		return (String) get(key);
	}

	/**
	 * 獲取list
	 * 
	 * @category 獲取list
	 * @param key
	 * @return
	 */
	public List list(String key) {
		return client.getList(key);
	}

	/**
	 * 保存list
	 * 
	 * @category 保存list
	 * @param key
	 * @param list
	 * @return
	 */
	public boolean list(String key, List<Object> list) {
		client.getList(key).delete();
		return client.getList(key).addAll(list);
	}

	/**
	 * 獲取list元素
	 * 
	 * @category 獲取list元素
	 * @param key
	 * @param index
	 * @return
	 */
	public Object lget(String key, int index) {
		return list(key).get(index);
	}

	/**
	 * 向指定list裏面添加數據
	 * 
	 * @category 向指定list裏面添加數據
	 * @param key
	 * @param obj
	 */
	public void ladd(String key, Object obj) {
		client.getList(key).add(obj);
	}

	/**
	 * 向指定list裏面添加數據
	 * 
	 * @category 向指定list裏面添加數據
	 * @param key
	 * @param list
	 */
	public void ladd(String key, List list) {
		client.getList(key).addAll(list);
	}

	/**
	 * 向指定list裏面的指定位置添加數據
	 * 
	 * @category 向指定list裏面的指定位置添加數據
	 * @param index
	 * @param key
	 * @param obj
	 */
	public void ladd(int index, String key, Object obj) {
		client.getList(key).add(index, obj);
	}

	/**
	 * 獲取set
	 * 
	 * @category 獲取set
	 * @param key
	 * @return
	 */
	public Set sset(String key) {
		return client.getSet(key);
	}

	/**
	 * 往set中添加元素
	 * 
	 * @category 往set中添加元素
	 * @param key
	 * @param value
	 */
	public void sadd(String key, Object value) {
		client.getSet(key).add(value);
	}

	/**
	 * 往set中添加元素
	 * 
	 * @category 往set中添加元素
	 * @param key
	 * @param set
	 */
	public void sadd(String key, Set set) {
		client.getSet(key).addAll(set);
	}

	/**
	 * 獲取sorted set
	 * 
	 * @category 獲取sorted set
	 * @param key
	 */
	public <T> SortedSet<T> zset(String key) {
		return client.getSortedSet(key);
	}

	/**
	 * 取排序集合第一個
	 * 
	 * @category 取排序集合第一個
	 * @param key
	 * @return
	 */
	public <T> T zsetFirst(String key) {
		return this.<T>zset(key).first();
	}

	/**
	 * 取排序集合最後一個
	 * 
	 * @category 取排序集合最後一個
	 * @param key
	 * @return
	 */
	public <T> T zsetLast(String key) {
		return this.<T>zset(key).last();
	}

	/**
	 * 排序集合添加一個
	 * 
	 * @category 排序集合添加一個
	 * @param key
	 * @param value
	 */
	public <T> void zsetAdd(String key, T value) {
		zset(key).add(value);
	}

	/**
	 * 獲取所有的key
	 * 
	 * @category 獲取所有的key
	 * @return
	 */
	public List<String> keys() {
		RKeys rKeys = client.getKeys();
		Iterator<String> iterator = rKeys.getKeys().iterator();
		List<String> keys = new ArrayList<String>();
		while (iterator.hasNext()) {
			keys.add(iterator.next());
		}
		return keys;
	}
	
	/** 
     * 獲取消息的Topic 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public <M> RTopic<M> getRTopic(String objectName){  
         RTopic<M> rTopic=client.getTopic(objectName);  
         return rTopic;  
    } 
    
    /** 
     * 獲取記數鎖 
     * @param redisson 
     * @param objectName 
     * @return 
     */  
    public RCountDownLatch getRCountDownLatch(String objectName){  
        RCountDownLatch rCountDownLatch=client.getCountDownLatch(objectName);  
        return rCountDownLatch;  
    } 
    
    /** 
     * 使用ip地址和端口創建Redisson 
     * @param ip 
     * @param port 
     * @return 
     */  
    public Redisson getRedisson(String ip,String port){  
        Config config=new Config();  
        config.useSingleServer().setAddress(ip+":"+port);  
        Redisson redisson=(Redisson) Redisson.create(config);  
        System.out.println("成功連接Redis Server"+"\t"+"連接"+ip+":"+port+"服務器");  
        return redisson;  
    }  

	// ------------ 靜態方法 ------------

	/**
	 * 獲取實例
	 * 
	 * @category 獲取實例
	 * @return
	 */
	public static RedisKit getInstance() {
		Helper.INSTANCE.connect();
		return Helper.INSTANCE;
	}

	public static void main(String[] args) {
		RedisKit kit = getInstance();
		Random rd = new Random(System.currentTimeMillis());
		new Thread(()->{
			for(int i = 1;i<100;i++) {
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				kit.ladd("list","201807261005-" + i);
			}
		}).start();
		new Thread(()->{
			for(int i = 1;i<100;i++) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				RList<String> list = (RList<String>)kit.list("list");
				System.out.println("初始化的list: " + list);
				if(list.size() > 0) {
					String key = list.remove(rd.nextInt(list.size()));
					boolean exists = kit.exists(key);
					System.out.println( "key: " + key + "已過期，移除");
				}
				//list.clear();
				//kit.list("list",new ArrayList<>());
				System.out.println("處理後的list : " + list);
				System.out.println("\n");
			}
		}).start();
		
		new Timer().schedule(new TimerTask() {
			
			@Override
			public void run() {
				
			}
		}, 500);
	}
}

2.Cache

package com.seryo.cache;

import java.util.List;

import com.seryo.vo.LogObject;

/**
 * 緩存接口
 * 
 * @category 緩存接口
 * @version 1.0
 */
public interface Cache {

	public static final String CACHE_FLAG = "Cache";

	/**
	 * 設置緩存
	 * 
	 * @category 設置緩存
	 * @param key
	 * @param value
	 * @param timeout
	 *            ms
	 */
	public <T> void set(String key, T value, long timeout);

	/**
	 * 設置緩存
	 * 
	 * @category 設置緩存
	 * @param key
	 * @param value
	 * @param expireAt
	 *            ms
	 */
	public <T> void setExpireAt(String key, T value, long expireAt);

	/**
	 * 獲取緩存
	 * 
	 * @category 獲取緩存
	 * @param key
	 * @return Object 緩存對象
	 */
	public <T> T get(String key);

	/**
	 * 使某個緩存過期
	 * 
	 * @category 使某個緩存過期
	 * @param key
	 * @param timeout
	 * @return T 緩存對象
	 */
	public boolean expire(String key, long timeout);

	/**
	 * 使得某個緩存在某個時刻過期
	 * 
	 * @category 使得某個緩存在某個時刻過期
	 * @param key
	 * @param expireAt
	 */
	public boolean expireAt(String key, long expireAt);

	/**
	 * 判斷某個緩存是否存在
	 * 
	 * @category 判斷某個緩存是否存在
	 * @param key
	 * @return boolean
	 */
	public boolean exist(String key);

	/**
	 * 刪除緩存
	 * 
	 * @category 刪除緩存
	 * @author prz
	 * @date 2017年7月28日
	 * @param key
	 * @return boolean
	 */
	public boolean del(String key);
	
	/**
	 * 添加key 的list數據緩存  
	 * @param: @param key
	 * @param: @param value      
	 * @return: void      
	 * @throws
	 */
	public <T> void ladd(String key, T value);
	
	/**
	 * 獲得 key 的list數據緩存  
	 * @param: @param key
	 * @param: @return      
	 * @return: RList<String>      
	 * @throws
	 */
	public List<LogObject> list(String key);
}

3.RedisCache

package com.seryo.cache;

import java.util.List;

import org.redisson.api.RList;

import com.seryo.util.RedisKit;
import com.seryo.vo.LogObject;

/**
 * redis cache
 * 
 * @category redis cache
 * @version 1.0
 */
public class RedisCache implements Cache {

	/**
	 * 獲取redis 工具
	 * 
	 * @category 獲取redis 工具
	 * @return RedisKit
	 */
	private RedisKit kit() {
		return RedisKit.getInstance();
	}

	@Override
	public <T> T get(String key) {
		return kit().get(key);
	}

	@Override
	public <T> void set(String key, T value, long timeout) {
		kit().set(key, value, timeout);
	}

	@Override
	public boolean expire(String key, long timeout) {
		return kit().expire(key, timeout);
	}

	@Override
	public boolean exist(String key) {
		return kit().exists(key);
	}

	@Override
	public <T> void setExpireAt(String key, T value, long expireAt) {
		kit().<T>setExpAt(key, value, expireAt);
	}

	@Override
	public boolean expireAt(String key, long expireAt) {
		return kit().expireAt(key, expireAt);
	}

	@Override
	public boolean del(String key) {
		return kit().del(key);
	}
	
	/**
	 * 添加key 的list數據緩存   
	 * @param: @param key
	 * @param: @param value      
	 * @return: void      
	 * @throws
	 */
	public <T> void ladd(String key, T value){
		kit().ladd(key, value);
	}
	
	/**
	 * 獲得 key 的list數據緩存     
	 * @param: @param key
	 * @param: @return      
	 * @return: RList<String>      
	 * @throws
	 */
	public List<LogObject> list(String key){ 
		return  kit().list(key);
	}
}

4.CacheFactory

package com.seryo.cache;

import com.seryo.util.StringUtils;

public class CacheFactory {

	public static final String REDIS = "redis";
	public static final String EHCACHE_DEFAULT_CACHE = "ehcache_default_cache";

	public static Cache build(String key) {
		if (StringUtils.isBlank(key)) {
			throw new RuntimeException("不存在的緩存工具");
		}
		if (key.equalsIgnoreCase(REDIS)) {
			return new RedisCache();
		} else if(key.equalsIgnoreCase(EHCACHE_DEFAULT_CACHE)){
			return new EhcacheDefaultCache();
		}else{
			throw new RuntimeException("不存在的緩存工具");
		}
	}
}

5.調用

Cache cache = CacheFactory.build(CacheFactory.REDIS);
cache.get(key);// 獲取緩存信息
 cache.set(key, 數據, 30 * 60 * 1000L);// 存放緩存30分鐘

6.redis.json

{
	"singleServerConfig" : {
		"address" : "redis://(ip):6379"
	},
	"threads" : 1000,
	"useLinuxNativeEpoll" : false
}

redisson-all-2.8.0.jar 包