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个例子，更多例子请查看下方的“参考资料”

[java] view plain copy

1. package cn.fansunion.redis;  
2.   
3. import hprose.io.HproseFormatter;  
4.   
5. import java.io.IOException;  
6. import java.util.Locale;  
7. import java.util.ResourceBundle;  
8.   
9. import redis.clients.jedis.Jedis;  
10. import redis.clients.jedis.JedisPool;  
11. import redis.clients.jedis.JedisPoolConfig;  
12. //简单的Redis例子，用到了Hprose序列化  
13. public class MyDemo {  
14.   
15.     private static String HOST = "127.0.0.1";  
16.     private static int PORT = 6379;  
17.     private static int MAX_ACTIVE = 20;  
18.     private static int MAX_IDLE = 5;  
19.     private static int MAX_WAIT = 1000;  
20.     private static int TIME_OUT = 2000;// 毫秒  
21.   
22.     private static boolean TEST_ON_BORROW = true;// 当调用borrow  
23.                                                     // object方法时，是否进行有效性检查  
24.     private static boolean TEST_ON_RETURN = true;// 当调用return object时，是否进行有效性检查  
25.   
26.     private static JedisPool pool;  
27.     static {  
28.         initPool();  
29.     }  
30.   
31.     private static void setValueFromBundle() {  
32.         ResourceBundle bundle = ResourceBundle.getBundle("redis",  
33.                 Locale.getDefault(), MyDemo.class.getClassLoader());  
34.         if (bundle == null) {  
35.             throw new IllegalArgumentException(  
36.                     "[redis.properties] is not found!");  
37.         }  
38.         HOST = bundle.getString("redis.host");  
39.         PORT = Integer.parseInt(bundle.getString("redis.port"));  
40.         MAX_ACTIVE = Integer.valueOf(bundle.getString("redis.maxActive"));  
41.         MAX_IDLE = Integer.valueOf(bundle.getString("redis.maxIdle"));  
42.         MAX_WAIT = Integer.valueOf(bundle.getString("redis.maxWait"));  
43.         TIME_OUT = Integer.valueOf(bundle.getString("redis.timeOut"));  
44.         TEST_ON_BORROW = Boolean.valueOf(bundle  
45.                 .getString("redis.testOnBorrow"));  
46.         TEST_ON_RETURN = Boolean.valueOf(bundle  
47.                 .getString("redis.testOnReturn"));  
48.     }  
49.   
50.     private static void initPool() {  
51.         JedisPoolConfig config = new JedisPoolConfig();  
52.         try {  
53.             setValueFromBundle();  
54.         } catch (Exception e) {  
55.             System.out.println("redis bundle resource get error");  
56.         }  
57.         config.setMaxActive(MAX_ACTIVE);  
58.         config.setMaxIdle(MAX_IDLE);  
59.         config.setMaxIdle(MAX_WAIT);  
60.         config.setTestOnBorrow(TEST_ON_BORROW);  
61.         config.setTestOnReturn(TEST_ON_RETURN);  
62.         pool = new JedisPool(config, HOST, PORT, TIME_OUT);  
63.     }  
64.   
65.     public static void put(String key, Object value) {  
66.         Jedis jedis = null;  
67.         try {  
68.             jedis = pool.getResource();  
69.             jedis.set(key.getBytes(), HproseFormatter.serialize(value)  
70.                     .toByteArray());  
71.         } catch (IOException e) {  
72.             e.printStackTrace();  
73.             pool.returnBrokenResource(jedis);  
74.         } finally {  
75.             pool.returnResource(jedis);  
76.         }  
77.     }  
78.   
79.     public static void delete(String key) {  
80.         Jedis jedis = null;  
81.         try {  
82.             jedis = pool.getResource();  
83.             jedis.del(key.getBytes());  
84.         } catch (Exception e) {  
85.             e.printStackTrace();  
86.             pool.returnBrokenResource(jedis);  
87.         } finally {  
88.             pool.returnResource(jedis);  
89.         }  
90.     }  
91.   
92.     public static Object get(String key) {  
93.         Object result = null;  
94.         Jedis jedis = null;  
95.         try {  
96.             jedis = pool.getResource();  
97.             if (key != null) {  
98.                 byte[] bt = jedis.get(key.getBytes());  
99.                 if (bt != null) {  
100.                     result = HproseFormatter.unserialize(jedis.get(key  
101.                             .getBytes()));  
102.                 }  
103.             }  
104.         } catch (IOException e) {  
105.             e.printStackTrace();  
106.             pool.returnBrokenResource(jedis);  
107.         } finally {  
108.             pool.returnResource(jedis);  
109.         }  
110.         return result;  
111.     }  
112.   
113.     public static void main(String[] args) {  
114.         String name = "小雷FansUnion";  
115.         String key = "name";  
116.         MyDemo.put(key, name);  
117.         Object nameObject = MyDemo.get(key);  
118.         if (nameObject != null) {  
119.             String n = (String) nameObject;  
120.             System.out.println(n);  
121.         }  
122.   
123.         MyDemo.delete(key);  
124.         Object nullObject = MyDemo.get(name);  
125.         if (nullObject == null) {  
126.             System.out.println("The name object has been deleted.");  
127.         }  
128.     }  
129. }  

[java] view plain copy

1. package cn.fansunion.redis;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6. import java.util.Set;  
7.   
8. import redis.clients.jedis.Jedis;  
9. import redis.clients.jedis.JedisPool;  
10. import redis.clients.jedis.JedisPoolConfig;  
11. import redis.clients.jedis.JedisShardInfo;  
12. import redis.clients.jedis.ShardedJedis;  
13. import redis.clients.jedis.ShardedJedisPool;  
14. import redis.clients.jedis.SortingParams;  
15.   
16. //根据网上代码，略微改造的例子  
17. public class RedisClient {  
18.   
19.     private static final int PORT = 6379;  
20.     private static final String HOST = "127.0.0.1";  
21.     private Jedis jedis;// 非切片客户端连接  
22.     private JedisPool jedisPool;// 非切片连接池  
23.     private ShardedJedis shardedJedis;// 切片额客户端连接  
24.     private ShardedJedisPool shardedJedisPool;// 切片连接池  
25.   
26.     public RedisClient() {  
27.         initialPool();  
28.         initialShardedPool();  
29.         shardedJedis = shardedJedisPool.getResource();  
30.         jedis = jedisPool.getResource();  
31.     }  
32.   
33.     /** 
34.      * 初始化非切片池 
35.      */  
36.     private void initialPool() {  
37.         // 池基本配置  
38.         JedisPoolConfig config = new JedisPoolConfig();  
39.         config.setMaxActive(20);  
40.         config.setMaxIdle(5);  
41.         config.setMaxWait(1000l);  
42.         config.setTestOnBorrow(false);  
43.   
44.         jedisPool = new JedisPool(config, HOST, PORT);  
45.     }  
46.   
47.     /** 
48.      * 初始化切片池 
49.      */  
50.     private void initialShardedPool() {  
51.         // 池基本配置  
52.         JedisPoolConfig config = new JedisPoolConfig();  
53.         config.setMaxActive(20);  
54.         config.setMaxIdle(5);  
55.         config.setMaxWait(1000l);  
56.         config.setTestOnBorrow(false);  
57.         // slave链接  
58.         List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();  
59.         shards.add(new JedisShardInfo(HOST, 6379, "master"));  
60.   
61.         // 构造池  
62.         shardedJedisPool = new ShardedJedisPool(config, shards);  
63.     }  
64.   
65.     public static void main(String[] args) {  
66.         RedisClient redisClient = new RedisClient();  
67.         redisClient.show();  
68.     }  
69.       
70.     public void show() {  
71.         keyOperate();  
72.         stringOperate();  
73.         listOperate();  
74.         setOperate();  
75.         sortedSetOperate();  
76.         hashOperate();  
77.         jedisPool.returnResource(jedis);  
78.         shardedJedisPool.returnResource(shardedJedis);  
79.     }  
80.   
81.     private static void pn(Object o){  
82.         System.out.println(o);  
83.     }  
84.     private static void pn(){  
85.         System.out.println();  
86.     }  
87.       
88.     private void keyOperate() {  
89.         pn("======================key==========================");  
90.         // 清空数据  
91.         pn("清空库中所有数据：" + jedis.flushDB());  
92.         // 判断key否存在  
93.         pn("判断key999键是否存在：" + shardedJedis.exists("key999"));  
94.         pn("新增key001,value001键值对："  
95.                 + shardedJedis.set("key001", "value001"));  
96.         pn("判断key001是否存在：" + shardedJedis.exists("key001"));  
97.         // 输出系统中所有的key  
98.         pn("新增key002,value002键值对："  
99.                 + shardedJedis.set("key002", "value002"));  
100.         pn("系统中所有键如下：");  
101.         Set<String> keys = jedis.keys("*");  
102.         Iterator<String> it = keys.iterator();  
103.         while (it.hasNext()) {  
104.             String key = it.next();  
105.             pn(key);  
106.         }  
107.         // 删除某个key,若key不存在，则忽略该命令。  
108.         pn("系统中删除key002: " + jedis.del("key002"));  
109.         pn("判断key002是否存在：" + shardedJedis.exists("key002"));  
110.         // 设置 key001的过期时间  
111.         pn("设置 key001的过期时间为5秒:" + jedis.expire("key001", 5));  
112.         try {  
113.             Thread.sleep(2000);  
114.         } catch (InterruptedException e) {  
115.         }  
116.         // 查看某个key的剩余生存时间,单位【秒】.永久生存或者不存在的都返回-1  
117.         pn("查看key001的剩余生存时间：" + jedis.ttl("key001"));  
118.         // 移除某个key的生存时间  
119.         pn("移除key001的生存时间：" + jedis.persist("key001"));  
120.         pn("查看key001的剩余生存时间：" + jedis.ttl("key001"));  
121.         // 查看key所储存的值的类型  
122.         pn("查看key所储存的值的类型：" + jedis.type("key001"));  
123.         /* 
124.          * 一些其他方法：1、修改键名：jedis.rename("key6", "key0"); 
125.          * 2、将当前db的key移动到给定的db当中：jedis.move("foo", 1) 
126.          */  
127.     }  
128.   
129.     private void stringOperate() {  
130.         System.out  
131.                 .println("======================String_1==========================");  
132.         // 清空数据  
133.         pn("清空库中所有数据：" + jedis.flushDB());  
134.   
135.         pn("=============增=============");  
136.         jedis.set("key001", "value001");  
137.         jedis.set("key002", "value002");  
138.         jedis.set("key003", "value003");  
139.         pn("已新增的3个键值对如下：");  
140.         pn(jedis.get("key001"));  
141.         pn(jedis.get("key002"));  
142.         pn(jedis.get("key003"));  
143.   
144.         pn("=============删=============");  
145.         pn("删除key003键值对：" + jedis.del("key003"));  
146.         pn("获取key003键对应的值：" + jedis.get("key003"));  
147.   
148.         pn("=============改=============");  
149.         // 1、直接覆盖原来的数据  
150.         pn("直接覆盖key001原来的数据："  
151.                 + jedis.set("key001", "value001-update"));  
152.         pn("获取key001对应的新值：" + jedis.get("key001"));  
153.         // 2、直接覆盖原来的数据  
154.         pn("在key002原来值后面追加："  
155.                 + jedis.append("key002", "+appendString"));  
156.         pn("获取key002对应的新值" + jedis.get("key002"));  
157.   
158.         pn("=============增，删，查（多个）=============");  
159.         /** 
160.          * mset,mget同时新增，修改，查询多个键值对 等价于： jedis.set("name","ssss"); 
161.          * jedis.set("jarorwar","xxxx"); 
162.          */  
163.         pn("一次性新增key201,key202,key203,key204及其对应值："  
164.                 + jedis.mset("key201", "value201", "key202", "value202",  
165.                         "key203", "value203", "key204", "value204"));  
166.         pn("一次性获取key201,key202,key203,key204各自对应的值："  
167.                 + jedis.mget("key201", "key202", "key203", "key204"));  
168.         pn("一次性删除key201,key202："  
169.                 + jedis.del(new String[] { "key201", "key202" }));  
170.         pn("一次性获取key201,key202,key203,key204各自对应的值："  
171.                 + jedis.mget("key201", "key202", "key203", "key204"));  
172.         pn();  
173.   
174.         // jedis具备的功能shardedJedis中也可直接使用，下面测试一些前面没用过的方法  
175.         System.out  
176.                 .println("======================String_2==========================");  
177.         // 清空数据  
178.         pn("清空库中所有数据：" + jedis.flushDB());  
179.   
180.         pn("=============新增键值对时防止覆盖原先值=============");  
181.         pn("原先key301不存在时，新增key301："  
182.                 + shardedJedis.setnx("key301", "value301"));  
183.         pn("原先key302不存在时，新增key302："  
184.                 + shardedJedis.setnx("key302", "value302"));  
185.         pn("当key302存在时，尝试新增key302："  
186.                 + shardedJedis.setnx("key302", "value302_new"));  
187.         pn("获取key301对应的值：" + shardedJedis.get("key301"));  
188.         pn("获取key302对应的值：" + shardedJedis.get("key302"));  
189.   
190.         pn("=============超过有效期键值对被删除=============");  
191.         // 设置key的有效期，并存储数据  
192.         pn("新增key303，并指定过期时间为2秒"  
193.                 + shardedJedis.setex("key303", 2, "key303-2second"));  
194.         pn("获取key303对应的值：" + shardedJedis.get("key303"));  
195.         try {  
196.             Thread.sleep(3000);  
197.         } catch (InterruptedException e) {  
198.         }  
199.         pn("3秒之后，获取key303对应的值：" + shardedJedis.get("key303"));  
200.   
201.         pn("=============获取原值，更新为新值一步完成=============");  
202.         pn("key302原值："  
203.                 + shardedJedis.getSet("key302", "value302-after-getset"));  
204.         pn("key302新值：" + shardedJedis.get("key302"));  
205.   
206.         pn("=============获取子串=============");  
207.         pn("获取key302对应值中的子串："  
208.                 + shardedJedis.getrange("key302", 5, 7));  
209.     }  
210.   
211.     private void listOperate() {  
212.         pn("======================list==========================");  
213.         // 清空数据  
214.         pn("清空库中所有数据：" + jedis.flushDB());  
215.   
216.         pn("=============增=============");  
217.         shardedJedis.lpush("stringlists", "vector");  
218.         shardedJedis.lpush("stringlists", "ArrayList");  
219.         shardedJedis.lpush("stringlists", "vector");  
220.         shardedJedis.lpush("stringlists", "vector");  
221.         shardedJedis.lpush("stringlists", "LinkedList");  
222.         shardedJedis.lpush("stringlists", "MapList");  
223.         shardedJedis.lpush("stringlists", "SerialList");  
224.         shardedJedis.lpush("stringlists", "HashList");  
225.         shardedJedis.lpush("numberlists", "3");  
226.         shardedJedis.lpush("numberlists", "1");  
227.         shardedJedis.lpush("numberlists", "5");  
228.         shardedJedis.lpush("numberlists", "2");  
229.         pn("所有元素-stringlists："  
230.                 + shardedJedis.lrange("stringlists", 0, -1));  
231.         pn("所有元素-numberlists："  
232.                 + shardedJedis.lrange("numberlists", 0, -1));  
233.   
234.         pn("=============删=============");  
235.         // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈  
236.         pn("成功删除指定元素个数-stringlists："  
237.                 + shardedJedis.lrem("stringlists", 2, "vector"));  
238.         pn("删除指定元素之后-stringlists："  
239.                 + shardedJedis.lrange("stringlists", 0, -1));  
240.         // 删除区间以外的数据  
241.         pn("删除下标0-3区间之外的元素："  
242.                 + shardedJedis.ltrim("stringlists", 0, 3));  
243.         pn("删除指定区间之外元素后-stringlists："  
244.                 + shardedJedis.lrange("stringlists", 0, -1));  
245.         // 列表元素出栈  
246.         pn("出栈元素：" + shardedJedis.lpop("stringlists"));  
247.         pn("元素出栈后-stringlists："  
248.                 + shardedJedis.lrange("stringlists", 0, -1));  
249.   
250.         pn("=============改=============");  
251.         // 修改列表中指定下标的值  
252.         shardedJedis.lset("stringlists", 0, "hello list!");  
253.         pn("下标为0的值修改后-stringlists："  
254.                 + shardedJedis.lrange("stringlists", 0, -1));  
255.         pn("=============查=============");  
256.         // 数组长度  
257.         pn("长度-stringlists：" + shardedJedis.llen("stringlists"));  
258.         pn("长度-numberlists：" + shardedJedis.llen("numberlists"));  
259.         // 排序  
260.         /* 
261.          * list中存字符串时必须指定参数为alpha，如果不使用SortingParams，而是直接使用sort("list")， 
262.          * 会出现"ERR One or more scores can't be converted into double" 
263.          */  
264.         SortingParams sortingParameters = new SortingParams();  
265.         sortingParameters.alpha();  
266.         sortingParameters.limit(0, 3);  
267.         pn("返回排序后的结果-stringlists："  
268.                 + shardedJedis.sort("stringlists", sortingParameters));  
269.         pn("返回排序后的结果-numberlists："  
270.                 + shardedJedis.sort("numberlists"));  
271.         // 子串： start为元素下标，end也为元素下标；-1代表倒数一个元素，-2代表倒数第二个元素  
272.         pn("子串-第二个开始到结束："  
273.                 + shardedJedis.lrange("stringlists", 1, -1));  
274.         // 获取列表指定下标的值  
275.         pn("获取下标为2的元素：" + shardedJedis.lindex("stringlists", 2)  
276.                 + "\n");  
277.     }  
278.   
279.     private void setOperate() {  
280.         pn("======================set==========================");  
281.         // 清空数据  
282.         pn("清空库中所有数据：" + jedis.flushDB());  
283.   
284.         pn("=============增=============");  
285.         pn("向sets集合中加入元素element001："  
286.                 + jedis.sadd("sets", "element001"));  
287.         pn("向sets集合中加入元素element002："  
288.                 + jedis.sadd("sets", "element002"));  
289.         pn("向sets集合中加入元素element003："  
290.                 + jedis.sadd("sets", "element003"));  
291.         pn("向sets集合中加入元素element004："  
292.                 + jedis.sadd("sets", "element004"));  
293.         pn("查看sets集合中的所有元素:" + jedis.smembers("sets"));  
294.         pn();  
295.   
296.         pn("=============删=============");  
297.         pn("集合sets中删除元素element003："  
298.                 + jedis.srem("sets", "element003"));  
299.         pn("查看sets集合中的所有元素:" + jedis.smembers("sets"));  
300.         /* 
301.          * pn("sets集合中任意位置的元素出栈："+jedis.spop("sets"));//注： 
302.          * 出栈元素位置居然不定？--无实际意义 
303.          * pn("查看sets集合中的所有元素:"+jedis.smembers("sets")); 
304.          */  
305.         pn();  
306.   
307.         pn("=============改=============");  
308.         pn();  
309.   
310.         pn("=============查=============");  
311.         pn("判断element001是否在集合sets中："  
312.                 + jedis.sismember("sets", "element001"));  
313.         pn("循环查询获取sets中的每个元素：");  
314.         Set<String> set = jedis.smembers("sets");  
315.         Iterator<String> it = set.iterator();  
316.         while (it.hasNext()) {  
317.             Object obj = it.next();  
318.             pn(obj);  
319.         }  
320.         pn();  
321.   
322.         pn("=============集合运算=============");  
323.         pn("sets1中添加元素element001："  
324.                 + jedis.sadd("sets1", "element001"));  
325.         pn("sets1中添加元素element002："  
326.                 + jedis.sadd("sets1", "element002"));  
327.         pn("sets1中添加元素element003："  
328.                 + jedis.sadd("sets1", "element003"));  
329.         pn("sets1中添加元素element002："  
330.                 + jedis.sadd("sets2", "element002"));  
331.         pn("sets1中添加元素element003："  
332.                 + jedis.sadd("sets2", "element003"));  
333.         pn("sets1中添加元素element004："  
334.                 + jedis.sadd("sets2", "element004"));  
335.         pn("查看sets1集合中的所有元素:" + jedis.smembers("sets1"));  
336.         pn("查看sets2集合中的所有元素:" + jedis.smembers("sets2"));  
337.         pn("sets1和sets2交集：" + jedis.sinter("sets1", "sets2"));  
338.         pn("sets1和sets2并集：" + jedis.sunion("sets1", "sets2"));  
339.         pn("sets1和sets2差集：" + jedis.sdiff("sets1", "sets2"));// 差集：set1中有，set2中没有的元素  
340.   
341.     }  
342.   
343.     private void sortedSetOperate() {  
344.         pn("======================zset==========================");  
345.         // 清空数据  
346.         pn(jedis.flushDB());  
347.   
348.         pn("=============增=============");  
349.         pn("zset中添加元素element001："  
350.                 + shardedJedis.zadd("zset", 7.0, "element001"));  
351.         pn("zset中添加元素element002："  
352.                 + shardedJedis.zadd("zset", 8.0, "element002"));  
353.         pn("zset中添加元素element003："  
354.                 + shardedJedis.zadd("zset", 2.0, "element003"));  
355.         pn("zset中添加元素element004："  
356.                 + shardedJedis.zadd("zset", 3.0, "element004"));  
357.         pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));// 按照权重值排序  
358.         pn();  
359.   
360.         pn("=============删=============");  
361.         pn("zset中删除元素element002："  
362.                 + shardedJedis.zrem("zset", "element002"));  
363.         pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));  
364.         pn();  
365.   
366.         pn("=============改=============");  
367.         pn();  
368.   
369.         pn("=============查=============");  
370.         pn("统计zset集合中的元素中个数：" + shardedJedis.zcard("zset"));  
371.         pn("统计zset集合中权重某个范围内（1.0——5.0），元素的个数："  
372.                 + shardedJedis.zcount("zset", 1.0, 5.0));  
373.         pn("查看zset集合中element004的权重："  
374.                 + shardedJedis.zscore("zset", "element004"));  
375.         pn("查看下标1到2范围内的元素值："  
376.                 + shardedJedis.zrange("zset", 1, 2));  
377.   
378.     }  
379.   
380.     private void hashOperate() {  
381.         pn("======================hash==========================");  
382.         // 清空数据  
383.         pn(jedis.flushDB());  
384.   
385.         pn("=============增=============");  
386.         pn("hashs中添加key001和value001键值对："  
387.                 + shardedJedis.hset("hashs", "key001", "value001"));  
388.         pn("hashs中添加key002和value002键值对："  
389.                 + shardedJedis.hset("hashs", "key002", "value002"));  
390.         pn("hashs中添加key003和value003键值对："  
391.                 + shardedJedis.hset("hashs", "key003", "value003"));  
392.         pn("新增key004和4的整型键值对："  
393.                 + shardedJedis.hincrBy("hashs", "key004", 4l));  
394.         pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));  
395.         pn();  
396.   
397.         pn("=============删=============");  
398.         pn("hashs中删除key002键值对："  
399.                 + shardedJedis.hdel("hashs", "key002"));  
400.         pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));  
401.         pn();  
402.   
403.         pn("=============改=============");  
404.         pn("key004整型键值的值增加100："  
405.                 + shardedJedis.hincrBy("hashs", "key004", 100l));  
406.         pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));  
407.         pn();  
408.   
409.         pn("=============查=============");  
410.         pn("判断key003是否存在："  
411.                 + shardedJedis.hexists("hashs", "key003"));  
412.         pn("获取key004对应的值："  
413.                 + shardedJedis.hget("hashs", "key004"));  
414.         pn("批量获取key001和key003对应的值："  
415.                 + shardedJedis.hmget("hashs", "key001", "key003"));  
416.         pn("获取hashs中所有的key：" + shardedJedis.hkeys("hashs"));  
417.         pn("获取hashs中所有的value：" + shardedJedis.hvals("hashs"));  
418.         pn();  
419.     }  
420. }  

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

补充说明：我在秒针工作的时候，有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