`
JavaCrazyer
  • 浏览: 2989896 次
  • 性别: Icon_minigender_1
  • 来自: 河南
社区版块
存档分类

Jedis使用示例

 
阅读更多

Jedis 是 Redis 官方首选的 Java 客户端开发包。

工作过程总结的一个示例,贴出来,如下:

package com.wujintao.redis;

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.SortingParams;

import com.wujintao.redis.util.RedisUtil;


public class TestCase {

	/**
	 * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接,
	 * 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题,可以使用JedisPool,
	 * JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例,可以从池中拿到Jedis的实例。
	 * 这种方式可以解决那些问题并且会实现高效的性能
	 */

	public static void main(String[] args) {

		// ...when closing your application:
		RedisUtil.getPool().destroy();

	}

	public static void Hello() {
		Jedis jedis = RedisUtil.getJedis();
		try {
			// 向key-->name中放入了value-->minxr
			jedis.set("name", "minxr");
			String ss = jedis.get("name");
			System.out.println(ss);

			// 很直观,类似map 将jintao append到已经有的value之后
			jedis.append("name", "jintao");
			ss = jedis.get("name");
			System.out.println(ss);

			// 2、直接覆盖原来的数据
			jedis.set("name", "jintao");
			System.out.println(jedis.get("jintao"));

			// 删除key对应的记录
			jedis.del("name");
			System.out.println(jedis.get("name"));// 执行结果:null

			/**
			 * mset相当于 jedis.set("name","minxr"); jedis.set("jarorwar","aaa");
			 */
			jedis.mset("name", "minxr", "jarorwar", "aaa");
			System.out.println(jedis.mget("name", "jarorwar"));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

	}

	private void testKey() {
		Jedis jedis = RedisUtil.getJedis();
		System.out.println("=============key==========================");
		// 清空数据
		System.out.println(jedis.flushDB());
		System.out.println(jedis.echo("foo"));
		// 判断key否存在
		System.out.println(jedis.exists("foo"));
		jedis.set("key", "values");
		System.out.println(jedis.exists("key"));
	}

	public static void testString() {
		System.out.println("==String==");
		Jedis jedis = RedisUtil.getJedis();
		try {
			// String
			jedis.set("key", "Hello World!");
			String value = jedis.get("key");
			System.out.println(value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

		System.out.println("=============String==========================");
		// 清空数据
		System.out.println(jedis.flushDB());
		// 存储数据
		jedis.set("foo", "bar");
		System.out.println(jedis.get("foo"));
		// 若key不存在,则存储
		jedis.setnx("foo", "foo not exits");
		System.out.println(jedis.get("foo"));
		// 覆盖数据
		jedis.set("foo", "foo update");
		System.out.println(jedis.get("foo"));
		// 追加数据
		jedis.append("foo", " hello, world");
		System.out.println(jedis.get("foo"));
		// 设置key的有效期,并存储数据
		jedis.setex("foo", 2, "foo not exits");
		System.out.println(jedis.get("foo"));
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
		}
		System.out.println(jedis.get("foo"));
		// 获取并更改数据
		jedis.set("foo", "foo update");
		System.out.println(jedis.getSet("foo", "foo modify"));
		// 截取value的值
		System.out.println(jedis.getrange("foo", 1, 3));
		System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",
				"mset3", "mvalue3", "mset4", "mvalue4"));
		System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));
		System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));
	}

	public static void testList() {
		System.out.println("==List==");
		Jedis jedis = RedisUtil.getJedis();
		try {
			// 开始前,先移除所有的内容
			jedis.del("messages");
			jedis.rpush("messages", "Hello how are you?");
			jedis.rpush("messages", "Fine thanks. I'm having fun with redis.");
			jedis.rpush("messages", "I should look into this NOSQL thing ASAP");

			// 再取出所有数据jedis.lrange是按范围取出,
			// 第一个是key,第二个是起始位置,第三个是结束位置,jedis.llen获取长度 -1表示取得所有
			List<String> values = jedis.lrange("messages", 0, -1);
			System.out.println(values);

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加数据
		jedis.lpush("lists", "vector");
		jedis.lpush("lists", "ArrayList");
		jedis.lpush("lists", "LinkedList");
		// 数组长度
		System.out.println(jedis.llen("lists"));
		// 排序
		System.out.println(jedis.sort("lists"));
		// 字串
		System.out.println(jedis.lrange("lists", 0, 3));
		// 修改列表中单个值
		jedis.lset("lists", 0, "hello list!");
		// 获取列表指定下标的值
		System.out.println(jedis.lindex("lists", 1));
		// 删除列表指定下标的值
		System.out.println(jedis.lrem("lists", 1, "vector"));
		// 删除区间以外的数据
		System.out.println(jedis.ltrim("lists", 0, 1));
		// 列表出栈
		System.out.println(jedis.lpop("lists"));
		// 整个列表值
		System.out.println(jedis.lrange("lists", 0, -1));
	}

	public static void testSet() {
		System.out.println("==Set==");
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.sadd("myset", "1");
			jedis.sadd("myset", "2");
			jedis.sadd("myset", "3");
			jedis.sadd("myset", "4");
			Set<String> setValues = jedis.smembers("myset");
			System.out.println(setValues);

			// 移除noname
			jedis.srem("myset", "4");
			System.out.println(jedis.smembers("myset"));// 获取所有加入的value
			System.out.println(jedis.sismember("myset", "4"));// 判断 minxr
																// 是否是sname集合的元素
			System.out.println(jedis.scard("sname"));// 返回集合的元素个数
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加数据
		jedis.sadd("sets", "HashSet");
		jedis.sadd("sets", "SortedSet");
		jedis.sadd("sets", "TreeSet");
		// 判断value是否在列表中
		System.out.println(jedis.sismember("sets", "TreeSet"));
		;
		// 整个列表值
		System.out.println(jedis.smembers("sets"));
		// 删除指定元素
		System.out.println(jedis.srem("sets", "SortedSet"));
		// 出栈
		System.out.println(jedis.spop("sets"));
		System.out.println(jedis.smembers("sets"));
		//
		jedis.sadd("sets1", "HashSet1");
		jedis.sadd("sets1", "SortedSet1");
		jedis.sadd("sets1", "TreeSet");
		jedis.sadd("sets2", "HashSet2");
		jedis.sadd("sets2", "SortedSet1");
		jedis.sadd("sets2", "TreeSet1");
		// 交集
		System.out.println(jedis.sinter("sets1", "sets2"));
		// 并集
		System.out.println(jedis.sunion("sets1", "sets2"));
		// 差集
		System.out.println(jedis.sdiff("sets1", "sets2"));
	}

	public static void sortedSet() {
		System.out.println("==SoretedSet==");
		Jedis jedis = RedisUtil.getJedis();
		try {
			jedis.zadd("hackers", 1940, "Alan Kay");
			jedis.zadd("hackers", 1953, "Richard Stallman");
			jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");
			jedis.zadd("hackers", 1916, "Claude Shannon");
			jedis.zadd("hackers", 1969, "Linus Torvalds");
			jedis.zadd("hackers", 1912, "Alan Turing");
			Set<String> setValues = jedis.zrange("hackers", 0, -1);
			System.out.println(setValues);
			Set<String> setValues2 = jedis.zrevrange("hackers", 0, -1);
			System.out.println(setValues2);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加数据
		jedis.zadd("zset", 10.1, "hello");
		jedis.zadd("zset", 10.0, ":");
		jedis.zadd("zset", 9.0, "zset");
		jedis.zadd("zset", 11.0, "zset!");
		// 元素个数
		System.out.println(jedis.zcard("zset"));
		// 元素下标
		System.out.println(jedis.zscore("zset", "zset"));
		// 集合子集
		System.out.println(jedis.zrange("zset", 0, -1));
		// 删除元素
		System.out.println(jedis.zrem("zset", "zset!"));
		System.out.println(jedis.zcount("zset", 9.5, 10.5));
		// 整个集合值
		System.out.println(jedis.zrange("zset", 0, -1));
	}

	public static void testHsh() {
		System.out.println("==Hash==");
		Jedis jedis = RedisUtil.getJedis();
		try {
			Map<String, String> pairs = new HashMap<String, String>();
			pairs.put("name", "Akshi");
			pairs.put("age", "2");
			pairs.put("sex", "Female");
			jedis.hmset("kid", pairs);
			List<String> name = jedis.hmget("kid", "name");// 结果是个泛型的LIST
			// jedis.hdel("kid","age"); //删除map中的某个键值
			System.out.println(jedis.hmget("kid", "pwd")); // 因为删除了,所以返回的是null
			System.out.println(jedis.hlen("kid")); // 返回key为user的键中存放的值的个数
			System.out.println(jedis.exists("kid"));// 是否存在key为user的记录
			System.out.println(jedis.hkeys("kid"));// 返回map对象中的所有key
			System.out.println(jedis.hvals("kid"));// 返回map对象中的所有value

			Iterator<String> iter = jedis.hkeys("kid").iterator();
			while (iter.hasNext()) {
				String key = iter.next();
				System.out.println(key + ":" + jedis.hmget("kid", key));
			}

			List<String> values = jedis.lrange("messages", 0, -1);
			values = jedis.hmget("kid", new String[] { "name", "age", "sex" });
			System.out.println(values);
			Set<String> setValues = jedis.zrange("hackers", 0, -1);
			setValues = jedis.hkeys("kid");
			System.out.println(setValues);
			values = jedis.hvals("kid");
			System.out.println(values);
			pairs = jedis.hgetAll("kid");
			System.out.println(pairs);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

		// 清空数据
		System.out.println(jedis.flushDB());
		// 添加数据
		jedis.hset("hashs", "entryKey", "entryValue");
		jedis.hset("hashs", "entryKey1", "entryValue1");
		jedis.hset("hashs", "entryKey2", "entryValue2");
		// 判断某个值是否存在
		System.out.println(jedis.hexists("hashs", "entryKey"));
		// 获取指定的值
		System.out.println(jedis.hget("hashs", "entryKey")); // 批量获取指定的值
		System.out.println(jedis.hmget("hashs", "entryKey", "entryKey1"));
		// 删除指定的值
		System.out.println(jedis.hdel("hashs", "entryKey"));
		// 为key中的域 field 的值加上增量 increment
		System.out.println(jedis.hincrBy("hashs", "entryKey", 123l));
		// 获取所有的keys
		System.out.println(jedis.hkeys("hashs"));
		// 获取所有的values
		System.out.println(jedis.hvals("hashs"));
	}

	public static void testOther() throws InterruptedException {
		Jedis jedis = RedisUtil.getJedis();

		try {
			// keys中传入的可以用通配符
			System.out.println(jedis.keys("*")); // 返回当前库中所有的key [sose, sanme,
													// name, jarorwar, foo,
													// sname, java framework,
													// user, braand]
			System.out.println(jedis.keys("*name"));// 返回的sname [sname, name]
			System.out.println(jedis.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1
														// 删除失败(或者不存在)返回 0
			System.out.println(jedis.ttl("sname"));// 返回给定key的有效时间,如果是-1则表示永远有效
			jedis.setex("timekey", 10, "min");// 通过此方法,可以指定key的存活(有效时间) 时间为秒
			Thread.sleep(5000);// 睡眠5秒后,剩余时间将为<=5
			System.out.println(jedis.ttl("timekey")); // 输出结果为5
			jedis.setex("timekey", 1, "min"); // 设为1后,下面再看剩余时间就是1了
			System.out.println(jedis.ttl("timekey")); // 输出结果为1
			System.out.println(jedis.exists("key"));// 检查key是否存在
			System.out.println(jedis.rename("timekey", "time"));
			System.out.println(jedis.get("timekey"));// 因为移除,返回为null
			System.out.println(jedis.get("time")); // 因为将timekey 重命名为time
													// 所以可以取得值 min
			// jedis 排序
			// 注意,此处的rpush和lpush是List的操作。是一个双向链表(但从表现来看的)
			jedis.del("a");// 先清除数据,再加入数据进行测试
			jedis.rpush("a", "1");
			jedis.lpush("a", "6");
			jedis.lpush("a", "3");
			jedis.lpush("a", "9");
			System.out.println(jedis.lrange("a", 0, -1));// [9, 3, 6, 1]
			System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果
			System.out.println(jedis.lrange("a", 0, -1));
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisUtil.getPool().returnResource(jedis);
		}

	}

	@org.junit.Test
	public void testUnUsePipeline() {
		long start = new Date().getTime();

		Jedis jedis = RedisUtil.getJedis();
		for (int i = 0; i < 10000; i++) {
			jedis.set("age1" + i, i + "");
			jedis.get("age1" + i);// 每个操作都发送请求给redis-server
		}
		long end = new Date().getTime();

		System.out.println("unuse pipeline cost:" + (end - start) + "ms");

		RedisUtil.getPool().returnResource(jedis);
	}

	@org.junit.Test
	/**
	 * 参考:http://blog.csdn.net/freebird_lb/article/details/7778919
	 */
	public void testUsePipeline() {
		long start = new Date().getTime();

		Jedis jedis = RedisUtil.getJedis();
		jedis.flushDB();
		Pipeline p = jedis.pipelined();
		for (int i = 0; i < 10000; i++) {
			p.set("age2" + i, i + "");
			System.out.println(p.get("age2" + i));
		}
		p.sync();// 这段代码获取所有的response

		long end = new Date().getTime();

		System.out.println("use pipeline cost:" + (end - start) + "ms");

		RedisUtil.getPool().returnResource(jedis);
	}


	@org.junit.Test
	/**
	 * 时间复杂度:
		  O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。
		    如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序,时间复杂度 O(N)。
	 */
	public void testSort1() {
		// 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
		Jedis redis = RedisUtil.getJedis();
		// 一般SORT用法 最简单的SORT使用方法是SORT key。
		redis.lpush("mylist", "1");
		redis.lpush("mylist", "4");
		redis.lpush("mylist", "6");
		redis.lpush("mylist", "3");
		redis.lpush("mylist", "0");
		// List<String> list = redis.sort("sort");// 默认是升序
		SortingParams sortingParameters = new SortingParams();
		sortingParameters.desc();
		// sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA
		// 修饰符(modifier)进行排序。
		sortingParameters.limit(0, 2);// 可用于分页查询
		List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		redis.flushDB();
		RedisUtil.closeJedis(redis);
	}

	@org.junit.Test
	/**
	 * sort list
	 * LIST结合hash的排序
	 */
	public void testSort2() {
		Jedis jedis = RedisUtil.getJedis();
		jedis.del("user:66", "user:55", "user:33", "user:22", "user:11",
				"userlist");
		jedis.lpush("userlist", "33");
		jedis.lpush("userlist", "22");
		jedis.lpush("userlist", "55");
		jedis.lpush("userlist", "11");

		jedis.hset("user:66", "name", "66");
		jedis.hset("user:55", "name", "55");
		jedis.hset("user:33", "name", "33");
		jedis.hset("user:22", "name", "79");
		jedis.hset("user:11", "name", "24");
		jedis.hset("user:11", "add", "beijing");
		jedis.hset("user:22", "add", "shanghai");
		jedis.hset("user:33", "add", "guangzhou");
		jedis.hset("user:55", "add", "chongqing");
		jedis.hset("user:66", "add", "xi'an");

		SortingParams sortingParameters = new SortingParams();
		// 符号 "->" 用于分割哈希表的键名(key name)和索引域(hash field),格式为 "key->field" 。
		sortingParameters.get("user:*->name");
		sortingParameters.get("user:*->add");
//		sortingParameters.by("user:*->name");
//		sortingParameters.get("#");
		List<String> result = jedis.sort("userlist", sortingParameters);
		for (String item : result) {
			System.out.println("item...." + item);
		}
		/**
		 * 对应的redis客户端命令是:sort ml get user*->name sort ml get user:*->name get
		 * user:*->add
		 */
	}

	@org.junit.Test
	/**
	 * sort set
	 * SET结合String的排序
	 */
	public void testSort3() {
		Jedis jedis = RedisUtil.getJedis();
		jedis.del("tom:friend:list", "score:uid:123", "score:uid:456",
				"score:uid:789", "score:uid:101", "uid:123", "uid:456",
				"uid:789", "uid:101");

		jedis.sadd("tom:friend:list", "123"); // tom的好友列表
		jedis.sadd("tom:friend:list", "456");
		jedis.sadd("tom:friend:list", "789");
		jedis.sadd("tom:friend:list", "101");

		jedis.set("score:uid:123", "1000"); // 好友对应的成绩
		jedis.set("score:uid:456", "6000");
		jedis.set("score:uid:789", "100");
		jedis.set("score:uid:101", "5999");

		jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
		jedis.set("uid:456", "{'uid':456,'name':'jack'}");
		jedis.set("uid:789", "{'uid':789,'name':'jay'}");
		jedis.set("uid:101", "{'uid':101,'name':'jolin'}");

		SortingParams sortingParameters = new SortingParams();

		sortingParameters.desc();
		// sortingParameters.limit(0, 2);
		// 注意GET操作是有序的,GET user_name_* GET user_password_*
		// 和 GET user_password_* GET user_name_*返回的结果位置不同
		sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"
									// ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。
		sortingParameters.get("uid:*");
		sortingParameters.get("score:uid:*");
		sortingParameters.by("score:uid:*");
		// 对应的redis 命令是./redis-cli sort tom:friend:list by score:uid:* get # get
		// uid:* get score:uid:*
		List<String> result = jedis.sort("tom:friend:list", sortingParameters);
		for (String item : result) {
			System.out.println("item..." + item);
		}

	}

	/**
	 * 
	 * 只获取对象而不排序 BY 修饰符可以将一个不存在的 key 当作权重,让 SORT 跳过排序操作。
	 * 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。 # 确保fake_key不存在 redis> EXISTS fake_key
	 * (integer) 0 # 以fake_key作BY参数,不排序,只GET name 和 GET password redis> SORT
	 * user_id BY fake_key GET # GET user_name_* GET user_password_* 1) "222" #
	 * id 2) "hacker" # user_name 3) "hey,im in" # password 4) "59230" 5) "jack"
	 * 6) "jack201022" 7) "2" 8) "huangz" 9) "nobodyknows" 10) "1" 11) "admin"
	 * 12) "a_long_long_password"
	 */
	public void testSort4() {

	}

	/**
	 * 
	 保存排序结果 默认情况下, SORT 操作只是简单地返回排序结果,如果你希望保存排序结果,可以给 STORE 选项指定一个 key
	 * 作为参数,排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在,则覆盖。) redis> EXISTS
	 * user_info_sorted_by_level # 确保指定key不存在 (integer) 0 redis> SORT user_id BY
	 * user_level_* GET # GET user_name_* GET user_password_* STORE
	 * user_info_sorted_by_level # 排序 (integer) 12 # 显示有12条结果被保存了 redis> LRANGE
	 * user_info_sorted_by_level 0 11 # 查看排序结果 1) "59230" 2) "jack" 3)
	 * "jack201022" 4) "2" 5) "huangz" 6) "nobodyknows" 7) "222" 8) "hacker" 9)
	 * "hey,im in" 10) "1" 11) "admin" 12) "a_long_long_password" 一个有趣的用法是将 SORT
	 * 结果保存,用 EXPIRE 为结果集设置生存时间,这样结果集就成了 SORT 操作的一个缓存。 这样就不必频繁地调用 SORT
	 * 操作了,只有当结果集过期时,才需要再调用一次 SORT 操作。
	 * 有时候为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行 SORT
	 * 操作,并保存为结果集),具体参见 SETNX 命令。
	 */
	@Test
	public void testSort5() {
		// 排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
		Jedis jedis = RedisUtil.getJedis();
		// 一般SORT用法 最简单的SORT使用方法是SORT key。
		jedis.lpush("mylist", "1");
		jedis.lpush("mylist", "4");
		jedis.lpush("mylist", "6");
		jedis.lpush("mylist", "3");
		jedis.lpush("mylist", "0");
		// List<String> list = redis.sort("sort");// 默认是升序
		SortingParams sortingParameters = new SortingParams();
		sortingParameters.desc();
		// sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用 ALPHA
		// 修饰符(modifier)进行排序。
		// sortingParameters.limit(0, 2);//可用于分页查询

		// 没有使用 STORE 参数,返回列表形式的排序结果. 使用 STORE 参数,返回排序结果的元素数量。

		jedis.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中,这里讲结果覆盖原来的KEY

		List<String> list = jedis.lrange("mylist", 0, -1);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		jedis.sadd("tom:friend:list", "123"); // tom的好友列表
		jedis.sadd("tom:friend:list", "456");
		jedis.sadd("tom:friend:list", "789");
		jedis.sadd("tom:friend:list", "101");

		jedis.set("score:uid:123", "1000"); // 好友对应的成绩
		jedis.set("score:uid:456", "6000");
		jedis.set("score:uid:789", "100");
		jedis.set("score:uid:101", "5999");

		jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
		jedis.set("uid:456", "{'uid':456,'name':'jack'}");
		jedis.set("uid:789", "{'uid':789,'name':'jay'}");
		jedis.set("uid:101", "{'uid':101,'name':'jolin'}");

		sortingParameters = new SortingParams();
		// sortingParameters.desc();
		sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"
									// ,用于获取被排序对象(我们这里的例子是 user_id )的当前元素。
		sortingParameters.by("score:uid:*");
		jedis.sort("tom:friend:list", sortingParameters, "tom:friend:list");
		List<String> result = jedis.lrange("tom:friend:list", 0, -1);
		for (String item : result) {
			System.out.println("item..." + item);
		}

		jedis.flushDB();
		RedisUtil.closeJedis(jedis);
	}
	
	
	public void testMore(){
		//ZRANGE取出最新的10个项目。
		//使用LPUSH + LTRIM,确保只取出最新的1000条项目。
		//HINCRBY key field increment,为哈希表 key 中的域 field 的值加上增量 increment
		//INCRBY,HINCRBY等等,redis有了原子递增(atomic increment),你可以放心的加上各种计数,用GETSET重置,或者是让它们过期。
		// LREM greet 2 morning     # 移除从表头到表尾,最先发现的两个 morning,这个可以用来删除特定评论
		// zrevrank test a 查看a在sorted set中倒排序时排在第几名,查询结果按照INDEX,所以INDEX是3表示排在第四名
		// zrank test a 相反,表示正排序时候的名次
		// zscore test one表示one这个元素在sorted set中的score为多少
		// zrevrange test 0 -1 表示sorted set倒排序,zrange test 0 -1表示正排序
		//将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员,那么更新这个 member 的 score 值,并通过重新插入这个 member 元素,来保证该 member 在正确的位置上。
		//zrem test one删除sorted set中某个元素
	}
	
	public List<String> get_latest_comments(int start, int num_items){
		//获取最新评论
		//LPUSH latest.comments <ID> 
		//-我们将列表裁剪为指定长度,因此Redis只需要保存最新的5000条评论:
		//LTRIM latest.comments 0 5000 
		//们做了限制不能超过5000个ID,因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候,才需要去访问数据库。
		Jedis jedis = RedisUtil.getJedis();
		List<String> id_list = jedis.lrange("latest.comments",start,start+num_items-1) ;
		
		if(id_list.size()<num_items){
			//id_list = SQL.EXECUTE("SELECT ... ORDER BY time LIMIT ...");
		}
		return id_list;
	}
		   
	

	@Test
	public void testDB() {
		Jedis jedis = RedisUtil.getJedis();
		System.out.println(jedis.select(0));// select db-index
											// 通过索引选择数据库,默认连接的数据库所有是0,默认数据库数是16个。返回1表示成功,0失败
		System.out.println(jedis.dbSize());// dbsize 返回当前数据库的key数量
		System.out.println(jedis.keys("*")); // 返回匹配指定模式的所有key
		System.out.println(jedis.randomKey());
		jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用
		jedis.flushAll();// 删除所有数据库中的所有key,此方法不会失败。更加慎用

	}

	@Test
	public void testMget() {

		Jedis jedis = RedisUtil.getJedis();
		jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用

		jedis.rpush("ids", "aa");
		jedis.rpush("ids", "bb");
		jedis.rpush("ids", "cc");

		List<String> ids = jedis.lrange("ids", 0, -1);

		jedis.set("aa", "{'name':'zhoujie','age':20}");
		jedis.set("bb", "{'name':'yilin','age':28}");
		jedis.set("cc", "{'name':'lucy','age':21}");
		List<String> list = jedis.mget(ids.toArray(new String[ids.size()]));
		System.out.println(list);
	}

	/**
	 * 可以利用lrange对list进行分页操作
	 */
	@Test
	public void queryPageBy() {
		int pageNo = 6;
		int pageSize = 6;
		Jedis jedis = RedisUtil.getJedis();
		jedis.del("a");
		for (int i = 1; i <= 30; i++) {
			jedis.rpush("a", i + "");
		}

		int start = pageSize * (pageNo - 1);// 因为redis中list元素位置基数是0
		int end = start + pageSize - 1;

		List<String> results = jedis.lrange("a", start, end);// 从start算起,start算一个元素,到结束那个元素
		for (String str : results) {
			System.out.println(str);
		}

	}

	@Test
	/**
	 * [向Redis list压入ID而不是实际的数据]
		在上面的例子里 ,我们将“对象”(此例中是简单消息)直接压入Redis list,但通常不应这么做,
		由于对象可能被多次引用:例如在一个list中维护其时间顺序,在一个集合中保存它的类别,只要有必要,它还会出现在其他list中,等等。
		让我们回到reddit.com的例子,将用户提交的链接(新闻)添加到list中,有更可靠的方法如下所示:
		$ redis-cli incr next.news.id
		(integer) 1
		$ redis-cli set news:1:title "Redis is simple"
		OK
		$ redis-cli set news:1:url "http://code.google.com/p/redis"
		OK
		$ redis-cli lpush submitted.news 1
		OK
		我们自增一个key,很容易得到一个独一无二的自增ID,然后通过此ID创建对象–为对象的每个字段设置一个key。最后将新对象的ID压入submitted.news list。
		这只是牛刀小试。在命令参考文档中可以读到所有和list有关的命令。你可以删除元素,旋转list,根据索引获取和设置元素,当然也可以用LLEN得到list的长度。
	 */
	public void testListStrUsage() {
		String title = "太阳能是绿色能源4";
		String url = "http://javacreazyer.iteye.com";
		Jedis jedis = RedisUtil.getJedis();

		long adInfoId = jedis.incr("ad:adinfo:next.id");
		jedis.set("ad:adinfo:" + adInfoId + ":title", title);
		jedis.set("ad:adinfo:" + adInfoId + ":url", url);
		jedis.lpush("ad:adinfo", String.valueOf(adInfoId));

		String resultTitle = jedis.get("ad:adinfo:" + adInfoId + ":title");
		String resultUrl = jedis.get("ad:adinfo:" + adInfoId + ":url");
		List<String> ids = jedis.lrange("ad:adinfo", 0, -1);
		System.out.println(resultTitle);
		System.out.println(resultUrl);
		System.out.println(ids);

		/**
		 * dbsize返回的是所有key的数目,包括已经过期的, 而redis-cli keys "*"查询得到的是有效的key数目
		 */
		System.out.println(jedis.dbSize());

		jedis.flushAll();
	}

	/**
	 * 下面是一个简单的方案:对每个想加标签的对象,用一个标签ID集合与之关联,并且对每个已有的标签,一组对象ID与之关联。 例如假设我们的新闻ID
	 * 1000被加了三个标签tag 1,2,5和77,就可以设置下面两个集合: $ redis-cli sadd news:1000:tags 1
	 * (integer) 1 $ redis-cli sadd news:1000:tags 2 (integer) 1 $ redis-cli
	 * sadd news:1000:tags 5 (integer) 1 $ redis-cli sadd news:1000:tags 77
	 * (integer) 1 $ redis-cli sadd tag:1:objects 1000 (integer) 1 $ redis-cli
	 * sadd tag:2:objects 1000 (integer) 1 $ redis-cli sadd tag:5:objects 1000
	 * (integer) 1 $ redis-cli sadd tag:77:objects 1000 (integer) 1
	 * 要获取一个对象的所有标签,如此简单: $ redis-cli smembers news:1000:tags 1. 5 2. 1 3. 77 4.
	 * 2 而有些看上去并不简单的操作仍然能使用相应的Redis命令轻松实现。例如我们也许想获得一份同时拥有标签1, 2,
	 * 10和27的对象列表。这可以用SINTER命令来做,他可以在不同集合之间取出交集。因此为达目的我们只需: $ redis-cli sinter
	 * tag:1:objects tag:2:objects tag:10:objects tag:27:objects ... no result
	 * in our dataset composed of just one object ...
	 * 在命令参考文档中可以找到和集合相关的其他命令,令人感兴趣的一抓一大把。一定要留意SORT命令,Redis集合和list都是可排序的。
	 */
	@Test
	public void testSetUsage() {
		Jedis jedis = RedisUtil.getJedis();
		jedis.sadd("zhongsou:news:1000:tags", "1");
		jedis.sadd("zhongsou:news:1000:tags", "2");
		jedis.sadd("zhongsou:news:1000:tags", "5");
		jedis.sadd("zhongsou:news:1000:tags", "77");
		jedis.sadd("zhongsou:news:2000:tags", "1");
		jedis.sadd("zhongsou:news:2000:tags", "2");
		jedis.sadd("zhongsou:news:2000:tags", "5");
		jedis.sadd("zhongsou:news:2000:tags", "77");
		jedis.sadd("zhongsou:news:3000:tags", "2");
		jedis.sadd("zhongsou:news:4000:tags", "77");
		jedis.sadd("zhongsou:news:5000:tags", "1");
		jedis.sadd("zhongsou:news:6000:tags", "5");

		jedis.sadd("zhongsou:tag:1:objects", 1000 + "");
		jedis.sadd("zhongsou:tag:2:objects", 1000 + "");
		jedis.sadd("zhongsou:tag:5:objects", 1000 + "");
		jedis.sadd("zhongsou:tag:77:objects", 1000 + "");

		jedis.sadd("zhongsou:tag:1:objects", 2000 + "");
		jedis.sadd("zhongsou:tag:2:objects", 2000 + "");
		jedis.sadd("zhongsou:tag:5:objects", 2000 + "");
		jedis.sadd("zhongsou:tag:77:objects", 2000 + "");

		Set<String> sets = jedis.sinter("zhongsou:tag:1:objects",
				"zhongsou:tag:2:objects", "zhongsou:tag:5:objects",
				"zhongsou:tag:77:objects");
		System.out.println(sets);
		jedis.flushAll();
	}

	@Test
	public void testSortedSetUsage() {
		Jedis jedis = RedisUtil.getJedis();
		jedis.zadd("zhongsou:hackers", 1940, "Alan Kay");
		jedis.zadd("zhongsou:hackers", 1953, "Richard Stallman");
		jedis.zadd("zhongsou:hackers", 1943, "Jay");
		jedis.zadd("zhongsou:hackers", 1920, "Jellon");
		jedis.zadd("zhongsou:hackers", 1965, "Yukihiro Matsumoto");
		jedis.zadd("zhongsou:hackers", 1916, "Claude Shannon");
		jedis.zadd("zhongsou:hackers", 1969, "Linus Torvalds");
		jedis.zadd("zhongsou:hackers", 1912, "Alan Turing");

		Set<String> hackers = jedis.zrange("zhongsou:hackers", 0, -1);
		System.out.println(hackers);

		Set<String> hackers2 = jedis.zrevrange("zhongsou:hackers", 0, -1);
		System.out.println(hackers2);

		// 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素(两个极值也包含了)。
		Set<String> hackers3 = jedis.zrangeByScore("zhongsou:hackers", "-inf",
				"1920");
		System.out.println(hackers3);

		// ZREMRANGEBYSCORE 这个名字虽然不算好,但他却非常有用,还会返回已删除的元素数量。
		long num = jedis.zremrangeByScore("zhongsou:hackers", "-inf", "1920");
		System.out.println(num);

		jedis.flushAll();
	}

}

 

 

   

    /**
     * 获取连接池.
     * @return 连接池实例
     */
    private static JedisPool getPool(String ip,int port) {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxActive(RedisConfig.getMaxactive());
        config.setMaxIdle(RedisConfig.getMaxidle());
        config.setMaxWait(RedisConfig.getMaxwait());
        config.setTestOnBorrow(true);
        config.setTestOnReturn(true);
        try{  
            /**
             *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
             *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
             */
            pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
        } catch(Exception e) {
            e.printStackTrace();
        }
        return pool;
    }

 

 

附加一个工作中常用到的Jedis工具类,如下:

package com.zhongsou.vertportal.util;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

import com.zhongsou.vertportal.conf.BaseConfig;
import com.zhongsou.vertportal.conf.RedisConfig;

/**
 * Redis工具类,用于获取RedisPool.
 * 参考官网说明如下:
 * You shouldn't use the same instance from different threads because you'll have strange errors.
 * And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections,
 * which leads to strange errors as well. A single Jedis instance is not threadsafe!
 * To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections.
 * This way you can overcome those strange errors and achieve great performance.
 * To use it, init a pool:
 *	JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
 *	You can store the pool somewhere statically, it is thread-safe.
 *	JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults.
 *	For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned.
 * @author wujintao
 */
public class JedisUtil  {
    protected Logger log = LoggerFactory.getLogger(getClass());
    
	/**
	 * 私有构造器.
	 */
	private JedisUtil() {
	    
	}
	private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();
	
    
    /**
     * 获取连接池.
     * @return 连接池实例
     */
    private static JedisPool getPool(String ip,int port) {
    	String key = ip+":" +port;
    	JedisPool pool = null;
        if(!maps.containsKey(key)) {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(RedisConfig.getMaxactive());
            config.setMaxIdle(RedisConfig.getMaxidle());
            config.setMaxWait(RedisConfig.getMaxwait());
            config.setTestOnBorrow(true);
            config.setTestOnReturn(true);
            try{  
                /**
                 *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息
                 *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒)
                 */
                pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());
                maps.put(key, pool);
            } catch(Exception e) {
                e.printStackTrace();
            }
        }else{
        	pool = maps.get(key);
        }
        return pool;
    }

    /**
     *类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
     *没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
     */
    private static class RedisUtilHolder{
        /**
         * 静态初始化器,由JVM来保证线程安全
         */
        private static JedisUtil instance = new JedisUtil();
    }

    /**
     *当getInstance方法第一次被调用的时候,它第一次读取
     *RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静
     *态域,从而创建RedisUtil的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
     *这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。
     */
	public static JedisUtil getInstance() {
		return RedisUtilHolder.instance;
	}
	
	/**
	 * 获取Redis实例.
	 * @return Redis工具类实例
	 */
	public Jedis getJedis(String ip,int port) {
		Jedis jedis  = null;
		int count =0;
		do{
    		try{ 
    			jedis = getPool(ip,port).getResource();
    			//log.info("get redis master1!");
    		} catch (Exception e) {
    			log.error("get redis master1 failed!", e);
    			 // 销毁对象  
    			getPool(ip,port).returnBrokenResource(jedis);  
    		}
    		count++;
		}while(jedis==null&&count<BaseConfig.getRetryNum());
		return jedis;
	}

	/**
	 * 释放redis实例到连接池.
     * @param jedis redis实例
     */
	public void closeJedis(Jedis jedis,String ip,int port) {
		if(jedis != null) {
		    getPool(ip,port).returnResource(jedis);
		}
	}
}

 

 

 

 

开发参考资料:

redis官方文档:http://redis.io/documentation

redis命令参考中文版:http://redis.readthedocs.org/en/2.4/index.html

分享到:
评论
14 楼 jimmyxu1214 2014-12-09  
我会试一下 写道
在JedisUtil.getJedis中似乎有些问题,如果两个线程同时访问此方法,可以在getPool时生成两个面向同一个ip+port的实例,而在保存时只能保存一个,这时会产生有一个实例无法维护。


我这修改了JedisUtil
private static JedisPool getPool(String ip, int port) {
		String key = ip + ":" + port;
		JedisPool pool = null;
		//这里为了提供大多数情况下线程池Map里面已经有对应ip的线程池直接返回,提高效率
		if(maps.containsKey(key)){
			pool = maps.get(key);
			return pool;
		}
		//这里的同步代码块防止多个线程同时产生多个相同的ip线程池
		synchronized (JedisUtil.class) {
			if (!maps.containsKey(key)) {
				JedisPoolConfig config = new JedisPoolConfig();
				config.setMaxTotal(RedisConfig.getMaxTotal());
				config.setMaxIdle(RedisConfig.getMaxIdle());
				config.setMaxWaitMillis(RedisConfig.getMaxWaitMillis());
				config.setTestOnBorrow(true);
				config.setTestOnReturn(true);
				try {
					/**
					 * 如果你遇到 java.net.SocketTimeoutException: Read timed out
					 * exception的异常信息 请尝试在构造JedisPool的时候设置自己的超时值.
					 * JedisPool默认的超时时间是2秒(单位毫秒)
					 */
					pool = new JedisPool(config, ip, port, RedisConfig.getTimeout());
					maps.put(key, pool);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}else {
				pool = maps.get(key);
			}
		}
		return pool;
	}

13 楼 qiuyusir 2014-11-19  
楼主完整代码能共享出来吗,正想学习,谢谢!
12 楼 66tomi 2014-11-17  
请问大家有没有遇到jedis超时设置,超过一定的设置那个超时就没有用了啊,默认是2秒超时,我配个5秒超时,就是5秒超时,但是但我配成8秒(大概)以上程序还没到我设置的时间就超时了,比如你配个15秒或许它还是6秒就超时报错了
11 楼 pepsl2008 2014-11-17  
//删除列表指定下标的值 
System.out.println(jedis.lrem("lists", 1, "vector"));

lrem代表从lists 删除几个 “vector”值  1不是指定的下标而是个数  -1代表从表头删到表尾
10 楼 我会试一下 2014-10-22  
是pool可能会生成多个,不过作为测试来讲没有太大问题。

其实是很好的例子!
9 楼 bluky999 2014-10-22  
我会试一下 写道
在JedisUtil.getJedis中似乎有些问题,如果两个线程同时访问此方法,可以在getPool时生成两个面向同一个ip+port的实例,而在保存时只能保存一个,这时会产生有一个实例无法维护。



LZ 的 maps是私有静态变量,工具类使用基于私有静态内部类的单例方法,所以理论上不会生成多个的吧 。


private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();




private static class RedisUtilHolder{  
        /** 
         * 静态初始化器,由JVM来保证线程安全 
         */  
        private static JedisUtil instance = new JedisUtil();  
} 


8 楼 我会试一下 2014-10-22  
在JedisUtil.getJedis中似乎有些问题,如果两个线程同时访问此方法,可以在getPool时生成两个面向同一个ip+port的实例,而在保存时只能保存一个,这时会产生有一个实例无法维护。
7 楼 xiaguobing 2014-09-02  
bluky999 写道
xiaguobing 写道
大神!   

// 2、直接覆盖原来的数据 
49. jedis.set("name", "jintao"); 
50. System.out.println(jedis.get("jintao"));

这一段代码中,是jedis.get("name")) 而不是jedis.get("jintao"))吧?


你说的很对,哈哈

很谢谢你啊,让我学会了一门新技术。感激不尽! 
6 楼 bluky999 2014-08-29  
xiaguobing 写道
大神!   

// 2、直接覆盖原来的数据 
49. jedis.set("name", "jintao"); 
50. System.out.println(jedis.get("jintao"));

这一段代码中,是jedis.get("name")) 而不是jedis.get("jintao"))吧?


你说的很对,哈哈
5 楼 xiaguobing 2014-08-29  
大神!   

// 2、直接覆盖原来的数据 
49. jedis.set("name", "jintao"); 
50. System.out.println(jedis.get("jintao"));

这一段代码中,是jedis.get("name")) 而不是jedis.get("jintao"))吧?
4 楼 zcool321 2014-08-26  
真的很不错
3 楼 explore 2013-12-08  
RedisConfig跟BaseConfig这两个类怎么没有?
2 楼 loveme1413 2013-10-25  
mark
1 楼 laziobird 2013-09-09  
不错,总结的比较详细。先看看

相关推荐

Global site tag (gtag.js) - Google Analytics