Redis學習總結和相關資料

因為別人都在用Redis，所以我不得不用Redis。
  聽起來感覺我很菜的樣子，事實上和菜沒有關係。
  一是由於別人都用，作為後來者，沒有“先發”優勢，只能順著別人的思路來做。當前的整體技術環境和人文環境，對一個人有很大的影響力。
  二是別人都用，自然有選擇Redis的道理，比如高效能、穩定之類的各種溢美之辭。
  
  在Java中，熟悉使用Redis主要分為3步：
  
  一.瞭解Redis
     redis
 redis是在memcache之後編寫的，大家經常把這兩者做比較，如果說它是個key-value store 的話但是它具有豐富的資料型別，我想暫時把它叫做快取資料流中心，就像現在物流中心那樣，order、package、store、classification、distribute、end。現在還很流行的LAMP PHP架構 不知道和 redis+mysql 或者 redis + mongodb的效能比較（聽群裡的人說mongodb分片不穩定）。
先說說reidis的特性


1. 支援持久化
     redis的本地持久化支援兩種方式：RDB和AOF。RDB 在redis.conf配置檔案裡配置持久化觸發器，AOF指的是redis沒增加一條記錄都會儲存到持久化檔案中（儲存的是這條記錄的生成命令），如果不是用redis做DB用的話還會不要開AOF ，資料太龐大了，重啟恢復的時候是一個巨大的工程！
2.豐富的資料型別
    redis 支援 String 、Lists、sets、sorted sets、hashes 多種資料型別,新浪微博會使用redis做nosql主要也是它具有這些型別，時間排序、職能排序、我的微博、發給我的這些功能List 和 sorted set   的強大操作功能息息相關
3.高效能
   這點跟memcache很想象，記憶體操作的級別是毫秒級的比硬碟操作秒級操作自然高效不少，較少了磁頭尋道、資料讀取、頁面交換這些高開銷的操作！這也是NOSQL冒出來的原因吧，應該是高效能
  是基於RDBMS的衍生產品，雖然RDBMS也具有快取結構，但是始終在app層面不是我們想要的那麼操控的。
4.replication
    redis提供主從複製方案，跟mysql一樣增量複製而且複製的實現都很相似，這個複製跟AOF有點類似複製的是新增記錄命令，主庫新增記錄將新增指令碼傳送給從庫，從庫根據指令碼生成記錄，這個過程非常快，就看網路了，一般主從都是在同一個區域網，所以可以說redis的主從近似及時同步，同事它還支援一主多從，動態新增從庫，從庫數量沒有限制。 主從庫搭建，我覺得還是採用網狀模式，如果使用鏈式（master-slave-slave-slave-slave·····）如果第一個slave出現當機重啟，首先從master  接收 資料恢復指令碼，這個是阻塞的，如果主庫資料幾TB的情況恢復過程得花上一段時間，在這個過程中其他的slave就無法和主庫同步了。
 
5.更新快
   這點好像從我接觸到redis到目前為止 已經發了大版本就4個，小版本沒算過。redis作者是個非常積極的人，無論是郵件提問還是論壇發帖，他都能及時耐心的為你解答，維護度很高。有人維護的話，讓我們用的也省心和放心。目前作者對redis 的主導開發方向是redis的叢集方向。


所以如果希望簡單就用ehcache，如果開發任務比較複雜，希望得到比較多的支援什麼的就redis


    
  
  二.安裝Redis
    Windows下，我喜歡用解壓版的，有4個exe檔案，直接雙擊redis-server.exe就起來了。
Linux下，我也喜歡用解壓版的，直接shell啟動。
  
    幾個exe程式的功能：　　　　
    redis-benchmark.exe：效能測試，用以模擬同時由N個客戶端傳送M個 SETs/GETs 查詢 (類似於 Apache 的ab 工具).
  　redis-check-aof.exe：更新日誌檢查
　　redis-check-dump.exe：本地資料庫檢查
　　redis-cli.exe：客戶端

　　redis-server.exe：服務端　　

  原來是5個exe檔案，差點不會數數了。

  
  三.使用Jedis或SpringDataRedis操作Redis
     我自己寫的3個例子，更多例子請檢視下方的“參考資料”
 

package cn.fansunion.redis;

import hprose.io.HproseFormatter;

import java.io.IOException;
import java.util.Locale;
import java.util.ResourceBundle;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
//簡單的Redis例子，用到了Hprose序列化
public class MyDemo {

	private static String HOST = "127.0.0.1";
	private static int PORT = 6379;
	private static int MAX_ACTIVE = 20;
	private static int MAX_IDLE = 5;
	private static int MAX_WAIT = 1000;
	private static int TIME_OUT = 2000;// 毫秒

	private static boolean TEST_ON_BORROW = true;// 當呼叫borrow
													// object方法時，是否進行有效性檢查
	private static boolean TEST_ON_RETURN = true;// 當呼叫return object時，是否進行有效性檢查

	private static JedisPool pool;
	static {
		initPool();
	}

	private static void setValueFromBundle() {
		ResourceBundle bundle = ResourceBundle.getBundle("redis",
				Locale.getDefault(), MyDemo.class.getClassLoader());
		if (bundle == null) {
			throw new IllegalArgumentException(
					"[redis.properties] is not found!");
		}
		HOST = bundle.getString("redis.host");
		PORT = Integer.parseInt(bundle.getString("redis.port"));
		MAX_ACTIVE = Integer.valueOf(bundle.getString("redis.maxActive"));
		MAX_IDLE = Integer.valueOf(bundle.getString("redis.maxIdle"));
		MAX_WAIT = Integer.valueOf(bundle.getString("redis.maxWait"));
		TIME_OUT = Integer.valueOf(bundle.getString("redis.timeOut"));
		TEST_ON_BORROW = Boolean.valueOf(bundle
				.getString("redis.testOnBorrow"));
		TEST_ON_RETURN = Boolean.valueOf(bundle
				.getString("redis.testOnReturn"));
	}

	private static void initPool() {
		JedisPoolConfig config = new JedisPoolConfig();
		try {
			setValueFromBundle();
		} catch (Exception e) {
			System.out.println("redis bundle resource get error");
		}
		config.setMaxActive(MAX_ACTIVE);
		config.setMaxIdle(MAX_IDLE);
		config.setMaxIdle(MAX_WAIT);
		config.setTestOnBorrow(TEST_ON_BORROW);
		config.setTestOnReturn(TEST_ON_RETURN);
		pool = new JedisPool(config, HOST, PORT, TIME_OUT);
	}

	public static void put(String key, Object value) {
		Jedis jedis = null;
		try {
			jedis = pool.getResource();
			jedis.set(key.getBytes(), HproseFormatter.serialize(value)
					.toByteArray());
		} catch (IOException e) {
			e.printStackTrace();
			pool.returnBrokenResource(jedis);
		} finally {
			pool.returnResource(jedis);
		}
	}

	public static void delete(String key) {
		Jedis jedis = null;
		try {
			jedis = pool.getResource();
			jedis.del(key.getBytes());
		} catch (Exception e) {
			e.printStackTrace();
			pool.returnBrokenResource(jedis);
		} finally {
			pool.returnResource(jedis);
		}
	}

	public static Object get(String key) {
		Object result = null;
		Jedis jedis = null;
		try {
			jedis = pool.getResource();
			if (key != null) {
				byte[] bt = jedis.get(key.getBytes());
				if (bt != null) {
					result = HproseFormatter.unserialize(jedis.get(key
							.getBytes()));
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
			pool.returnBrokenResource(jedis);
		} finally {
			pool.returnResource(jedis);
		}
		return result;
	}

	public static void main(String[] args) {
		String name = "小雷FansUnion";
		String key = "name";
		MyDemo.put(key, name);
		Object nameObject = MyDemo.get(key);
		if (nameObject != null) {
			String n = (String) nameObject;
			System.out.println(n);
		}

		MyDemo.delete(key);
		Object nullObject = MyDemo.get(name);
		if (nullObject == null) {
			System.out.println("The name object has been deleted.");
		}
	}
}

package cn.fansunion.redis;

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.SortingParams;

//根據網上程式碼，略微改造的例子
public class RedisClient {

	private static final int PORT = 6379;
	private static final String HOST = "127.0.0.1";
	private Jedis jedis;// 非切片客戶端連線
	private JedisPool jedisPool;// 非切片連線池
	private ShardedJedis shardedJedis;// 切片額客戶端連線
	private ShardedJedisPool shardedJedisPool;// 切片連線池

	public RedisClient() {
		initialPool();
		initialShardedPool();
		shardedJedis = shardedJedisPool.getResource();
		jedis = jedisPool.getResource();
	}

	/**
	 * 初始化非切片池
	 */
	private void initialPool() {
		// 池基本配置
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxActive(20);
		config.setMaxIdle(5);
		config.setMaxWait(1000l);
		config.setTestOnBorrow(false);

		jedisPool = new JedisPool(config, HOST, PORT);
	}

	/**
	 * 初始化切片池
	 */
	private void initialShardedPool() {
		// 池基本配置
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxActive(20);
		config.setMaxIdle(5);
		config.setMaxWait(1000l);
		config.setTestOnBorrow(false);
		// slave連結
		List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
		shards.add(new JedisShardInfo(HOST, 6379, "master"));

		// 構造池
		shardedJedisPool = new ShardedJedisPool(config, shards);
	}

	public static void main(String[] args) {
		RedisClient redisClient = new RedisClient();
		redisClient.show();
	}
	
	public void show() {
		keyOperate();
		stringOperate();
		listOperate();
		setOperate();
		sortedSetOperate();
		hashOperate();
		jedisPool.returnResource(jedis);
		shardedJedisPool.returnResource(shardedJedis);
	}

	private static void pn(Object o){
		System.out.println(o);
	}
	private static void pn(){
		System.out.println();
	}
	
	private void keyOperate() {
		pn("======================key==========================");
		// 清空資料
		pn("清空庫中所有資料：" + jedis.flushDB());
		// 判斷key否存在
		pn("判斷key999鍵是否存在：" + shardedJedis.exists("key999"));
		pn("新增key001,value001鍵值對："
				+ shardedJedis.set("key001", "value001"));
		pn("判斷key001是否存在：" + shardedJedis.exists("key001"));
		// 輸出系統中所有的key
		pn("新增key002,value002鍵值對："
				+ shardedJedis.set("key002", "value002"));
		pn("系統中所有鍵如下：");
		Set<String> keys = jedis.keys("*");
		Iterator<String> it = keys.iterator();
		while (it.hasNext()) {
			String key = it.next();
			pn(key);
		}
		// 刪除某個key,若key不存在，則忽略該命令。
		pn("系統中刪除key002: " + jedis.del("key002"));
		pn("判斷key002是否存在：" + shardedJedis.exists("key002"));
		// 設定 key001的過期時間
		pn("設定 key001的過期時間為5秒:" + jedis.expire("key001", 5));
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
		}
		// 檢視某個key的剩餘生存時間,單位【秒】.永久生存或者不存在的都返回-1
		pn("檢視key001的剩餘生存時間：" + jedis.ttl("key001"));
		// 移除某個key的生存時間
		pn("移除key001的生存時間：" + jedis.persist("key001"));
		pn("檢視key001的剩餘生存時間：" + jedis.ttl("key001"));
		// 檢視key所儲存的值的型別
		pn("檢視key所儲存的值的型別：" + jedis.type("key001"));
		/*
		 * 一些其他方法：1、修改鍵名：jedis.rename("key6", "key0");
		 * 2、將當前db的key移動到給定的db當中：jedis.move("foo", 1)
		 */
	}

	private void stringOperate() {
		System.out
				.println("======================String_1==========================");
		// 清空資料
		pn("清空庫中所有資料：" + jedis.flushDB());

		pn("=============增=============");
		jedis.set("key001", "value001");
		jedis.set("key002", "value002");
		jedis.set("key003", "value003");
		pn("已新增的3個鍵值對如下：");
		pn(jedis.get("key001"));
		pn(jedis.get("key002"));
		pn(jedis.get("key003"));

		pn("=============刪=============");
		pn("刪除key003鍵值對：" + jedis.del("key003"));
		pn("獲取key003鍵對應的值：" + jedis.get("key003"));

		pn("=============改=============");
		// 1、直接覆蓋原來的資料
		pn("直接覆蓋key001原來的資料："
				+ jedis.set("key001", "value001-update"));
		pn("獲取key001對應的新值：" + jedis.get("key001"));
		// 2、直接覆蓋原來的資料
		pn("在key002原來值後面追加："
				+ jedis.append("key002", "+appendString"));
		pn("獲取key002對應的新值" + jedis.get("key002"));

		pn("=============增，刪，查（多個）=============");
		/**
		 * mset,mget同時新增，修改，查詢多個鍵值對 等價於： jedis.set("name","ssss");
		 * jedis.set("jarorwar","xxxx");
		 */
		pn("一次性新增key201,key202,key203,key204及其對應值："
				+ jedis.mset("key201", "value201", "key202", "value202",
						"key203", "value203", "key204", "value204"));
		pn("一次性獲取key201,key202,key203,key204各自對應的值："
				+ jedis.mget("key201", "key202", "key203", "key204"));
		pn("一次性刪除key201,key202："
				+ jedis.del(new String[] { "key201", "key202" }));
		pn("一次性獲取key201,key202,key203,key204各自對應的值："
				+ jedis.mget("key201", "key202", "key203", "key204"));
		pn();

		// jedis具備的功能shardedJedis中也可直接使用，下面測試一些前面沒用過的方法
		System.out
				.println("======================String_2==========================");
		// 清空資料
		pn("清空庫中所有資料：" + jedis.flushDB());

		pn("=============新增鍵值對時防止覆蓋原先值=============");
		pn("原先key301不存在時，新增key301："
				+ shardedJedis.setnx("key301", "value301"));
		pn("原先key302不存在時，新增key302："
				+ shardedJedis.setnx("key302", "value302"));
		pn("當key302存在時，嘗試新增key302："
				+ shardedJedis.setnx("key302", "value302_new"));
		pn("獲取key301對應的值：" + shardedJedis.get("key301"));
		pn("獲取key302對應的值：" + shardedJedis.get("key302"));

		pn("=============超過有效期鍵值對被刪除=============");
		// 設定key的有效期，並儲存資料
		pn("新增key303，並指定過期時間為2秒"
				+ shardedJedis.setex("key303", 2, "key303-2second"));
		pn("獲取key303對應的值：" + shardedJedis.get("key303"));
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
		}
		pn("3秒之後，獲取key303對應的值：" + shardedJedis.get("key303"));

		pn("=============獲取原值，更新為新值一步完成=============");
		pn("key302原值："
				+ shardedJedis.getSet("key302", "value302-after-getset"));
		pn("key302新值：" + shardedJedis.get("key302"));

		pn("=============獲取子串=============");
		pn("獲取key302對應值中的子串："
				+ shardedJedis.getrange("key302", 5, 7));
	}

	private void listOperate() {
		pn("======================list==========================");
		// 清空資料
		pn("清空庫中所有資料：" + jedis.flushDB());

		pn("=============增=============");
		shardedJedis.lpush("stringlists", "vector");
		shardedJedis.lpush("stringlists", "ArrayList");
		shardedJedis.lpush("stringlists", "vector");
		shardedJedis.lpush("stringlists", "vector");
		shardedJedis.lpush("stringlists", "LinkedList");
		shardedJedis.lpush("stringlists", "MapList");
		shardedJedis.lpush("stringlists", "SerialList");
		shardedJedis.lpush("stringlists", "HashList");
		shardedJedis.lpush("numberlists", "3");
		shardedJedis.lpush("numberlists", "1");
		shardedJedis.lpush("numberlists", "5");
		shardedJedis.lpush("numberlists", "2");
		pn("所有元素-stringlists："
				+ shardedJedis.lrange("stringlists", 0, -1));
		pn("所有元素-numberlists："
				+ shardedJedis.lrange("numberlists", 0, -1));

		pn("=============刪=============");
		// 刪除列表指定的值 ，第二個引數為刪除的個數（有重複時），後add進去的值先被刪，類似於出棧
		pn("成功刪除指定元素個數-stringlists："
				+ shardedJedis.lrem("stringlists", 2, "vector"));
		pn("刪除指定元素之後-stringlists："
				+ shardedJedis.lrange("stringlists", 0, -1));
		// 刪除區間以外的資料
		pn("刪除下標0-3區間之外的元素："
				+ shardedJedis.ltrim("stringlists", 0, 3));
		pn("刪除指定區間之外元素後-stringlists："
				+ shardedJedis.lrange("stringlists", 0, -1));
		// 列表元素出棧
		pn("出棧元素：" + shardedJedis.lpop("stringlists"));
		pn("元素出棧後-stringlists："
				+ shardedJedis.lrange("stringlists", 0, -1));

		pn("=============改=============");
		// 修改列表中指定下標的值
		shardedJedis.lset("stringlists", 0, "hello list!");
		pn("下標為0的值修改後-stringlists："
				+ shardedJedis.lrange("stringlists", 0, -1));
		pn("=============查=============");
		// 陣列長度
		pn("長度-stringlists：" + shardedJedis.llen("stringlists"));
		pn("長度-numberlists：" + shardedJedis.llen("numberlists"));
		// 排序
		/*
		 * list中存字串時必須指定引數為alpha，如果不使用SortingParams，而是直接使用sort("list")，
		 * 會出現"ERR One or more scores can't be converted into double"
		 */
		SortingParams sortingParameters = new SortingParams();
		sortingParameters.alpha();
		sortingParameters.limit(0, 3);
		pn("返回排序後的結果-stringlists："
				+ shardedJedis.sort("stringlists", sortingParameters));
		pn("返回排序後的結果-numberlists："
				+ shardedJedis.sort("numberlists"));
		// 子串： start為元素下標，end也為元素下標；-1代表倒數一個元素，-2代表倒數第二個元素
		pn("子串-第二個開始到結束："
				+ shardedJedis.lrange("stringlists", 1, -1));
		// 獲取列表指定下標的值
		pn("獲取下標為2的元素：" + shardedJedis.lindex("stringlists", 2)
				+ "\n");
	}

	private void setOperate() {
		pn("======================set==========================");
		// 清空資料
		pn("清空庫中所有資料：" + jedis.flushDB());

		pn("=============增=============");
		pn("向sets集合中加入元素element001："
				+ jedis.sadd("sets", "element001"));
		pn("向sets集合中加入元素element002："
				+ jedis.sadd("sets", "element002"));
		pn("向sets集合中加入元素element003："
				+ jedis.sadd("sets", "element003"));
		pn("向sets集合中加入元素element004："
				+ jedis.sadd("sets", "element004"));
		pn("檢視sets集合中的所有元素:" + jedis.smembers("sets"));
		pn();

		pn("=============刪=============");
		pn("集合sets中刪除元素element003："
				+ jedis.srem("sets", "element003"));
		pn("檢視sets集合中的所有元素:" + jedis.smembers("sets"));
		/*
		 * pn("sets集合中任意位置的元素出棧："+jedis.spop("sets"));//注：
		 * 出棧元素位置居然不定？--無實際意義
		 * pn("檢視sets集合中的所有元素:"+jedis.smembers("sets"));
		 */
		pn();

		pn("=============改=============");
		pn();

		pn("=============查=============");
		pn("判斷element001是否在集合sets中："
				+ jedis.sismember("sets", "element001"));
		pn("迴圈查詢獲取sets中的每個元素：");
		Set<String> set = jedis.smembers("sets");
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			Object obj = it.next();
			pn(obj);
		}
		pn();

		pn("=============集合運算=============");
		pn("sets1中新增元素element001："
				+ jedis.sadd("sets1", "element001"));
		pn("sets1中新增元素element002："
				+ jedis.sadd("sets1", "element002"));
		pn("sets1中新增元素element003："
				+ jedis.sadd("sets1", "element003"));
		pn("sets1中新增元素element002："
				+ jedis.sadd("sets2", "element002"));
		pn("sets1中新增元素element003："
				+ jedis.sadd("sets2", "element003"));
		pn("sets1中新增元素element004："
				+ jedis.sadd("sets2", "element004"));
		pn("檢視sets1集合中的所有元素:" + jedis.smembers("sets1"));
		pn("檢視sets2集合中的所有元素:" + jedis.smembers("sets2"));
		pn("sets1和sets2交集：" + jedis.sinter("sets1", "sets2"));
		pn("sets1和sets2並集：" + jedis.sunion("sets1", "sets2"));
		pn("sets1和sets2差集：" + jedis.sdiff("sets1", "sets2"));// 差集：set1中有，set2中沒有的元素

	}

	private void sortedSetOperate() {
		pn("======================zset==========================");
		// 清空資料
		pn(jedis.flushDB());

		pn("=============增=============");
		pn("zset中新增元素element001："
				+ shardedJedis.zadd("zset", 7.0, "element001"));
		pn("zset中新增元素element002："
				+ shardedJedis.zadd("zset", 8.0, "element002"));
		pn("zset中新增元素element003："
				+ shardedJedis.zadd("zset", 2.0, "element003"));
		pn("zset中新增元素element004："
				+ shardedJedis.zadd("zset", 3.0, "element004"));
		pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));// 按照權重值排序
		pn();

		pn("=============刪=============");
		pn("zset中刪除元素element002："
				+ shardedJedis.zrem("zset", "element002"));
		pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));
		pn();

		pn("=============改=============");
		pn();

		pn("=============查=============");
		pn("統計zset集合中的元素中個數：" + shardedJedis.zcard("zset"));
		pn("統計zset集合中權重某個範圍內（1.0——5.0），元素的個數："
				+ shardedJedis.zcount("zset", 1.0, 5.0));
		pn("檢視zset集合中element004的權重："
				+ shardedJedis.zscore("zset", "element004"));
		pn("檢視下標1到2範圍內的元素值："
				+ shardedJedis.zrange("zset", 1, 2));

	}

	private void hashOperate() {
		pn("======================hash==========================");
		// 清空資料
		pn(jedis.flushDB());

		pn("=============增=============");
		pn("hashs中新增key001和value001鍵值對："
				+ shardedJedis.hset("hashs", "key001", "value001"));
		pn("hashs中新增key002和value002鍵值對："
				+ shardedJedis.hset("hashs", "key002", "value002"));
		pn("hashs中新增key003和value003鍵值對："
				+ shardedJedis.hset("hashs", "key003", "value003"));
		pn("新增key004和4的整型鍵值對："
				+ shardedJedis.hincrBy("hashs", "key004", 4l));
		pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));
		pn();

		pn("=============刪=============");
		pn("hashs中刪除key002鍵值對："
				+ shardedJedis.hdel("hashs", "key002"));
		pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));
		pn();

		pn("=============改=============");
		pn("key004整型鍵值的值增加100："
				+ shardedJedis.hincrBy("hashs", "key004", 100l));
		pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));
		pn();

		pn("=============查=============");
		pn("判斷key003是否存在："
				+ shardedJedis.hexists("hashs", "key003"));
		pn("獲取key004對應的值："
				+ shardedJedis.hget("hashs", "key004"));
		pn("批量獲取key001和key003對應的值："
				+ shardedJedis.hmget("hashs", "key001", "key003"));
		pn("獲取hashs中所有的key：" + shardedJedis.hkeys("hashs"));
		pn("獲取hashs中所有的value：" + shardedJedis.hvals("hashs"));
		pn();
	}
}

 第3個例子，Spring-Data和Redis結合的

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.0.xsd
               ">

	<!-- scanner redis properties -->
	<context:property-placeholder
		location="classpath:redis.properties"
		ignore-unresolvable="true" />

	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="${redis.maxIdle}" />
		<property name="maxActive" value="${redis.maxActive}" />
		<property name="maxWait" value="${redis.maxWait}" />
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
	</bean>

	<bean id="connectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
		p:pool-config-ref="poolConfig" />

	<bean id="businessConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
		p:pool-config-ref="poolConfig" />

	<bean id="loginRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
		<property name="connectionFactory" ref="connectionFactory" />
		<!--如果不配置Serializer，那麼儲存的時候智慧使用String，如果用User型別儲存，那麼會提示錯誤User can't cast 
			to String！！！ -->
		<property name="keySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
		</property>
	</bean>

	<bean id="businessRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
		<property name="connectionFactory" ref="businessConnectionFactory" />
		<!--如果不配置Serializer，那麼儲存的時候智慧使用String，如果用User型別儲存，那麼會提示錯誤User can't cast 
			to String！！！ -->
		<property name="keySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
		</property>
	</bean>

	

	<bean id="defaultCache" class="cn.fansunion.redis.springdata.RedisClientImpl">
	</bean>

	<bean id="loginCache" class="cn.fansunion.redis.springdata.LoginRedisImpl">
		<property name="loginRedisTemplate" ref="loginRedisTemplate" />
	</bean>
	<context:component-scan base-package="cn.fansunion.redis.springdata" />
</beans>

public interface Cache {

	Map<String, Object> getMulti(List<String> keys);

	Object[] getMulti(String[] keys);

	void add(String key, Object value, long timeout);

	Object getValue(String key);

	void delete(String key);

	void delete(Collection<String> keys);

	Boolean exists(String key);

	boolean setIfAbsent(String key, Object value, long timeout);

	void add(String key, Object value);
}

package cn.fansunion.redis.springdata;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

/**
 * Redis介面封裝
 */
public class LoginRedisImpl implements Cache {

	private RedisTemplate<String, Object> loginRedisTemplate;

	public RedisTemplate<String, Object> getLoginRedisTemplate() {
		return loginRedisTemplate;
	}

	public void setLoginRedisTemplate(
			RedisTemplate<String, Object> loginRedisTemplate) {
		this.loginRedisTemplate = loginRedisTemplate;
	}

	public void add(String key, Object value, long timeout) {
		ValueOperations<String, Object> valueops = loginRedisTemplate
				.opsForValue();
		valueops.set(key, value, timeout, TimeUnit.SECONDS);
	}

	public Object getValue(String key) {
		if(StringUtils.isBlank(key)){
			return null;
		}
		ValueOperations<String, Object> valueops = loginRedisTemplate
				.opsForValue();
		Object value = valueops.get(key);
		return value;
	}

	public void delete(String key) {
		if(StringUtils.isBlank(key)){
			return;
		}
		loginRedisTemplate.delete(key);
	}

	/**
	 * 批量刪除
	 */
	public void delete(Collection<String> keys) {
		if(keys==null || keys.size()==0){
			return;
		}
		loginRedisTemplate.delete(keys);
	}

	public Boolean exists(String key) {
		if(StringUtils.isBlank(key)){
			return false;
		}
		return loginRedisTemplate.hasKey(key);
	}

	@Override
	public boolean setIfAbsent(String key, Object value, long timeout) {
		return false;
	}

	@Override
	public Map<String, Object> getMulti(List<String> keys) {
		return null;
	}

	@Override
	public Object[] getMulti(String[] keys) {
		ValueOperations<String, Object> valueops = loginRedisTemplate
				.opsForValue();
		List<String> keys_list = Arrays.asList(keys);
		List<Object> value = valueops.multiGet(keys_list);
		return value.toArray();
	}

	@Override
	public void add(String key, Object value) {
		ValueOperations<String, Object> valueops = loginRedisTemplate
				.opsForValue();
		valueops.set(key, value);
	}

}

 

package cn.fansunion.redis.springdata;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
//根據自己參與的專案，簡化的例子
public class SpringDataRedisDemo {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"classpath:/spring-data-redis.xml");
		Cache loginCache = (Cache) ac.getBean("loginCache");
		loginCache.add("name", "FansUnion");
		Object v = loginCache.getValue("name");
		System.out.println(v);
	}

}

  redis.properties

redis.pool.maxActive=1024
redis.pool.maxIdle=200
redis.pool.maxWait=1000
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
#IP 
redis.ip=127.0.0.1
#Port   
redis.port=6379

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>cn.fansunion</groupId>
	<artifactId>redis</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>Redis</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>	
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>3.1.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>3.1.2.RELEASE</version>
		</dependency>
			<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.0.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.3.2</version>
		</dependency>

		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.1.0</version>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.2</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.6.1</version>
		</dependency>
		<!-- 將現有的jakarta commons logging的呼叫轉換成lsf4j的呼叫。 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>1.6.1</version>
		</dependency>
		<!-- Hack：確保commons-logging的jar包不被引入，否則將和jcl-over-slf4j衝突 -->
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.1.1</version>
			<scope>provided</scope>
		</dependency>
		<!-- slf4j的實現：logback，用來取代log4j。更快、更強！ -->
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>0.9.24</version>
			<scope>runtime</scope>
		</dependency>
	</dependencies>
</project>

    補充說明：我在秒針工作的時候，有2個專案都用了Hprose，來做序列化。
因此，我自己的程式碼中，也用了Hprose，需要的網上下載哦。

  各種參考資料：
  百度知道：java web開發快取方案，ehcache和redis哪個更好 http://zhidao.baidu.com/link?url=v9i98VamdEEv-qvhXZ875qpAeLlk6Y1jLeeUjUa8RqH2OK8LLxKCfsdPMuVzLZHaJSacvOGnxJF6P3Ve9e0uYCCfniI7XzSdHyfuK7uEUKq
  百度百科Redis：http://baike.baidu.com/link?url=t3DT1YANTECL0iYZ0y40otALPMqaPjgTkZV7CXyKhm9eMNZS5p3E2u4N7sbnbuHKixrmxFY9ZXS2QAlALsYcCq
  java對redis的基本操作 http://www.cnblogs.com/edisonfeng/p/3571870.html#undefined
  java之redis篇(spring-data-redis整合) http://www.cnblogs.com/tankaixiong/p/3660075.html
  官方網站:http://redis.io/