jedis——java 操作redis

2016-12-24 10:25:56来源:oschina作者:远方__人点击


publicclassTestCase{/**
*在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接,
*也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题,可以使用JedisPool,
*JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例,可以从池中拿到Jedis的实例。
*这种方式可以解决那些问题并且会实现高效的性能
*/publicstaticvoidmain(String[]args){//...whenclosingyourapplication:
RedisUtil.getPool().destroy();}publicstaticvoidHello(){
Jedisjedis=RedisUtil.getJedis();
try{
//向key-->name中放入了value-->minxr
jedis.set("name","minxr");
Stringss=jedis.get("name");
System.out.println(ss);//很直观,类似map将jintaoappend到已经有的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(Exceptione){
e.printStackTrace();
}finally{
RedisUtil.getPool().returnResource(jedis);
}}privatevoidtestKey(){
Jedisjedis=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"));
}publicstaticvoidtestString(){
System.out.println("==String==");
Jedisjedis=RedisUtil.getJedis();
try{
//String
jedis.set("key","HelloWorld!");
Stringvalue=jedis.get("key");
System.out.println(value);
}catch(Exceptione){
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","foonotexits");
System.out.println(jedis.get("foo"));
//覆盖数据
jedis.set("foo","fooupdate");
System.out.println(jedis.get("foo"));
//追加数据
jedis.append("foo","hello,world");
System.out.println(jedis.get("foo"));
//设置key的有效期,并存储数据
jedis.setex("foo",2,"foonotexits");
System.out.println(jedis.get("foo"));
try{
Thread.sleep(3000);
}catch(InterruptedExceptione){
}
System.out.println(jedis.get("foo"));
//获取并更改数据
jedis.set("foo","fooupdate");
System.out.println(jedis.getSet("foo","foomodify"));
//截取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(newString[]{"foo","foo1","foo3"}));
}publicstaticvoidtestList(){
System.out.println("==List==");
Jedisjedis=RedisUtil.getJedis();
try{
//开始前,先移除所有的内容
jedis.del("messages");
jedis.rpush("messages","Hellohowareyou?");
jedis.rpush("messages","Finethanks.I'mhavingfunwithredis.");
jedis.rpush("messages","IshouldlookintothisNOSQLthingASAP");//再取出所有数据jedis.lrange是按范围取出,
//第一个是key,第二个是起始位置,第三个是结束位置,jedis.llen获取长度-1表示取得所有
Listvalues=jedis.lrange("messages",0,-1);
System.out.println(values);}catch(Exceptione){
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,"hellolist!");
//获取列表指定下标的值
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));
}publicstaticvoidtestSet(){
System.out.println("==Set==");
Jedisjedis=RedisUtil.getJedis();
try{
jedis.sadd("myset","1");
jedis.sadd("myset","2");
jedis.sadd("myset","3");
jedis.sadd("myset","4");
SetsetValues=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(Exceptione){
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"));
}publicstaticvoidsortedSet(){
System.out.println("==SoretedSet==");
Jedisjedis=RedisUtil.getJedis();
try{
jedis.zadd("hackers",1940,"AlanKay");
jedis.zadd("hackers",1953,"RichardStallman");
jedis.zadd("hackers",1965,"YukihiroMatsumoto");
jedis.zadd("hackers",1916,"ClaudeShannon");
jedis.zadd("hackers",1969,"LinusTorvalds");
jedis.zadd("hackers",1912,"AlanTuring");
SetsetValues=jedis.zrange("hackers",0,-1);
System.out.println(setValues);
SetsetValues2=jedis.zrevrange("hackers",0,-1);
System.out.println(setValues2);
}catch(Exceptione){
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));
}publicstaticvoidtestHsh(){
System.out.println("==Hash==");
Jedisjedis=RedisUtil.getJedis();
try{
Mappairs=newHashMap();
pairs.put("name","Akshi");
pairs.put("age","2");
pairs.put("sex","Female");
jedis.hmset("kid",pairs);
Listname=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对象中的所有valueIteratoriter=jedis.hkeys("kid").iterator();
while(iter.hasNext()){
Stringkey=iter.next();
System.out.println(key+":"+jedis.hmget("kid",key));
}Listvalues=jedis.lrange("messages",0,-1);
values=jedis.hmget("kid",newString[]{"name","age","sex"});
System.out.println(values);
SetsetValues=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(Exceptione){
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"));
}publicstaticvoidtestOther()throwsInterruptedException{
Jedisjedis=RedisUtil.getJedis();try{
//keys中传入的可以用通配符
System.out.println(jedis.keys("*"));//返回当前库中所有的key[sose,sanme,
//name,jarorwar,foo,
//sname,javaframework,
//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(Exceptione){
e.printStackTrace();
}finally{
RedisUtil.getPool().returnResource(jedis);
}}@org .junit.Test
publicvoidtestUnUsePipeline(){
longstart=newDate().getTime();Jedisjedis=RedisUtil.getJedis();
for(inti=0;i<10000;i++){
jedis.set("age1"+i,i+"");
jedis.get("age1"+i);//每个操作都发送请求给redis-server
}
longend=newDate().getTime();System.out.println("unusepipelinecost:"+(end-start)+"ms");RedisUtil.getPool().returnResource(jedis);
}@org .junit.Test
/**
*参考:http://blog.csdn.net/freebird_lb/article/details/7778919
*/
publicvoidtestUsePipeline(){
longstart=newDate().getTime();Jedisjedis=RedisUtil.getJedis();
jedis.flushDB();
Pipelinep=jedis.pipelined();
for(inti=0;i<10000;i++){
p.set("age2"+i,i+"");
System.out.println(p.get("age2"+i));
}
p.sync();//这段代码获取所有的responselongend=newDate().getTime();System.out.println("usepipelinecost:"+(end-start)+"ms");RedisUtil.getPool().returnResource(jedis);
}@org .junit.Test
/**
*时间复杂度:
O(N+M*log(M)),N为要排序的列表或集合内的元素数量,M为要返回的元素数量。
如果只是使用SORT命令的GET选项获取数据而没有进行排序,时间复杂度O(N)。
*/
publicvoidtestSort1(){
//排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
Jedisredis=RedisUtil.getJedis();
//一般SORT用法最简单的SORT使用方法是SORTkey。
redis.lpush("mylist","1");
redis.lpush("mylist","4");
redis.lpush("mylist","6");
redis.lpush("mylist","3");
redis.lpush("mylist","0");
//Listlist=redis.sort("sort");//默认是升序
SortingParamssortingParameters=newSortingParams();
sortingParameters.desc();
//sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用ALPHA
//修饰符(modifier)进行排序。
sortingParameters.limit(0,2);//可用于分页查询
Listlist=redis.sort("mylist",sortingParameters);//默认是升序
for(inti=0;i System.out.println(list.get(i));
}
redis.flushDB();
RedisUtil.closeJedis(redis);
}@org .junit.Test
/**
*sortlist
*LIST结合hash的排序
*/
publicvoidtestSort2(){
Jedisjedis=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");SortingParamssortingParameters=newSortingParams();
//符号"->"用于分割哈希表的键名(keyname)和索引域(hashfield),格式为"key->field"。
sortingParameters.get("user:*->name");
sortingParameters.get("user:*->add");
//sortingParameters.by("user:*->name");
//sortingParameters.get("#");
Listresult=jedis.sort("userlist",sortingParameters);
for(Stringitem:result){
System.out.println("item...."+item);
}
/**
*对应的redis客户端命令是:sortmlgetuser*->namesortmlgetuser:*->nameget
*user:*->add
*/
}@org .junit.Test
/**
*sortset
*SET结合String的排序
*/
publicvoidtestSort3(){
Jedisjedis=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'}");SortingParamssortingParameters=newSortingParams();sortingParameters.desc();
//sortingParameters.limit(0,2);
//注意GET操作是有序的,GETuser_name_*GETuser_password_*
//和GETuser_password_*GETuser_name_*返回的结果位置不同
sortingParameters.get("#");//GET还有一个特殊的规则——"GET#"
//,用于获取被排序对象(我们这里的例子是user_id)的当前元素。
sortingParameters.get("uid:*");
sortingParameters.get("score:uid:*");
sortingParameters.by("score:uid:*");
//对应的redis命令是./redis-clisorttom:friend:listbyscore:uid:*get#get
//uid:*getscore:uid:*
Listresult=jedis.sort("tom:friend:list",sortingParameters);
for(Stringitem:result){
System.out.println("item..."+item);
}}/**
*
*只获取对象而不排序BY修饰符可以将一个不存在的key当作权重,让SORT跳过排序操作。
*该方法用于你希望获取外部对象而又不希望引起排序开销时使用。#确保fake_key不存在redis>EXISTSfake_key
*(integer)0#以fake_key作BY参数,不排序,只GETname和GETpasswordredis>SORT
*user_idBYfake_keyGET#GETuser_name_*GETuser_password_*1)"222"#
*id2)"hacker"#user_name3)"hey,imin"#password4)"59230"5)"jack"
*6)"jack201022"7)"2"8)"huangz"9)"nobodyknows"10)"1"11)"admin"
*12)"a_long_long_password"
*/
publicvoidtestSort4(){}/**
*
保存排序结果默认情况下,SORT操作只是简单地返回排序结果,如果你希望保存排序结果,可以给STORE选项指定一个key
*作为参数,排序结果将以列表的形式被保存到这个key上。(若指定key已存在,则覆盖。)redis>EXISTS
*user_info_sorted_by_level#确保指定key不存在(integer)0redis>SORTuser_idBY
*user_level_*GET#GETuser_name_*GETuser_password_*STORE
*user_info_sorted_by_level#排序(integer)12#显示有12条结果被保存了redis>LRANGE
*user_info_sorted_by_level011#查看排序结果1)"59230"2)"jack"3)
*"jack201022"4)"2"5)"huangz"6)"nobodyknows"7)"222"8)"hacker"9)
*"hey,imin"10)"1"11)"admin"12)"a_long_long_password"一个有趣的用法是将SORT
*结果保存,用EXPIRE为结果集设置生存时间,这样结果集就成了SORT操作的一个缓存。这样就不必频繁地调用SORT
*操作了,只有当结果集过期时,才需要再调用一次SORT操作。
*有时候为了正确实现这一用法,你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端,同一时间进行SORT
*操作,并保存为结果集),具体参见SETNX命令。
*/
@Test
publicvoidtestSort5(){
//排序默认以数字作为对象,值被解释为双精度浮点数,然后进行比较
Jedisjedis=RedisUtil.getJedis();
//一般SORT用法最简单的SORT使用方法是SORTkey。
jedis.lpush("mylist","1");
jedis.lpush("mylist","4");
jedis.lpush("mylist","6");
jedis.lpush("mylist","3");
jedis.lpush("mylist","0");
//Listlist=redis.sort("sort");//默认是升序
SortingParamssortingParameters=newSortingParams();
sortingParameters.desc();
//sortingParameters.alpha();//当数据集中保存的是字符串值时,你可以用ALPHA
//修饰符(modifier)进行排序。
//sortingParameters.limit(0,2);//可用于分页查询//没有使用STORE参数,返回列表形式的排序结果.使用STORE参数,返回排序结果的元素数量。jedis.sort("mylist",sortingParameters,"mylist");//排序后指定排序结果到一个KEY中,这里讲结果覆盖原来的KEYListlist=jedis.lrange("mylist",0,-1);
for(inti=0;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=newSortingParams();
//sortingParameters.desc();
sortingParameters.get("#");//GET还有一个特殊的规则——"GET#"
//,用于获取被排序对象(我们这里的例子是user_id)的当前元素。
sortingParameters.by("score:uid:*");
jedis.sort("tom:friend:list",sortingParameters,"tom:friend:list");
Listresult=jedis.lrange("tom:friend:list",0,-1);
for(Stringitem:result){
System.out.println("item..."+item);
}jedis.flushDB();
RedisUtil.closeJedis(jedis);
}publicvoidtestMore(){
//ZRANGE取出最新的10个项目。
//使用LPUSH+LTRIM,确保只取出最新的1000条项目。
//HINCRBYkeyfieldincrement,为哈希表key中的域field的值加上增量increment
//INCRBY,HINCRBY等等,redis有了原子递增(atomicincrement),你可以放心的加上各种计数,用GETSET重置,或者是让它们过期。
//LREMgreet2morning#移除从表头到表尾,最先发现的两个morning,这个可以用来删除特定评论
//zrevranktesta查看a在sortedset中倒排序时排在第几名,查询结果按照INDEX,所以INDEX是3表示排在第四名
//zranktesta相反,表示正排序时候的名次
//zscoretestone表示one这个元素在sortedset中的score为多少
//zrevrangetest0-1表示sortedset倒排序,zrangetest0-1表示正排序
//将一个或多个member元素及其score值加入到有序集key当中。如果某个member已经是有序集的成员,那么更新这个member的score值,并通过重新插入这个member元素,来保证该member在正确的位置上。
//zremtestone删除sortedset中某个元素
}publicListget_latest_comments(intstart,intnum_items){
//获取最新评论
//LPUSHlatest.comments
//-我们将列表裁剪为指定长度,因此Redis只需要保存最新的5000条评论:
//LTRIMlatest.comments05000
//们做了限制不能超过5000个ID,因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候,才需要去访问数据库。
Jedisjedis=RedisUtil.getJedis();
Listid_list=jedis.lrange("latest.comments",start,start+num_items-1);if(id_list.size() //id_list=SQL.EXECUTE("SELECT...ORDERBYtimeLIMIT...");
}
returnid_list;
}
@Test
publicvoidtestDB(){
Jedisjedis=RedisUtil.getJedis();
System.out.println(jedis.select(0));//selectdb-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
publicvoidtestMget(){Jedisjedis=RedisUtil.getJedis();
jedis.flushDB();//删除当前数据库中所有key,此方法不会失败。慎用jedis.rpush("ids","aa");
jedis.rpush("ids","bb");
jedis.rpush("ids","cc");Listids=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}");
Listlist=jedis.mget(ids.toArray(newString[ids.size()]));
System.out.println(list);
}/**
*可以利用lrange对list进行分页操作
*/
@Test
publicvoidqueryPageBy(){
intpageNo=6;
intpageSize=6;
Jedisjedis=RedisUtil.getJedis();
jedis.del("a");
for(inti=1;i<=30;i++){
jedis.rpush("a",i+"");
}intstart=pageSize*(pageNo-1);//因为redis中list元素位置基数是0
intend=start+pageSize-1;Listresults=jedis.lrange("a",start,end);//从start算起,start算一个元素,到结束那个元素
for(Stringstr:results){
System.out.println(str);
}}@Test
/**
*[向Redislist压入ID而不是实际的数据]
在上面的例子里,我们将“对象”(此例中是简单消息)直接压入Redislist,但通常不应这么做,
由于对象可能被多次引用:例如在一个list中维护其时间顺序,在一个集合中保存它的类别,只要有必要,它还会出现在其他list中,等等。
让我们回到reddit.com的例子,将用户提交的链接(新闻)添加到list中,有更可靠的方法如下所示:
$redis-cliincrnext.news.id
(integer)1
$redis-clisetnews:1:title"Redisissimple"
OK
$redis-clisetnews:1:url"http://code.google.com/p/redis"
OK
$redis-clilpushsubmitted.news1
OK
我们自增一个key,很容易得到一个独一无二的自增ID,然后通过此ID创建对象–为对象的每个字段设置一个key。最后将新对象的ID压入submitted.newslist。
这只是牛刀小试。在命令参考文档中可以读到所有和list有关的命令。你可以删除元素,旋转list,根据索引获取和设置元素,当然也可以用LLEN得到list的长度。
*/
publicvoidtestListStrUsage(){
Stringtitle="太阳能是绿色能源4";
Stringurl="http://javacreazyer.iteye.com";
Jedisjedis=RedisUtil.getJedis();longadInfoId=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));StringresultTitle=jedis.get("ad:adinfo:"+adInfoId+":title");
StringresultUrl=jedis.get("ad:adinfo:"+adInfoId+":url");
Listids=jedis.lrange("ad:adinfo",0,-1);
System.out.println(resultTitle);
System.out.println(resultUrl);
System.out.println(ids);/**
*dbsize返回的是所有key的数目,包括已经过期的,而redis-clikeys"*"查询得到的是有效的key数目
*/
System.out.println(jedis.dbSize());jedis.flushAll();
}/**
*下面是一个简单的方案:对每个想加标签的对象,用一个标签ID集合与之关联,并且对每个已有的标签,一组对象ID与之关联。例如假设我们的新闻ID
*1000被加了三个标签tag1,2,5和77,就可以设置下面两个集合:$redis-clisaddnews:1000:tags1
*(integer)1$redis-clisaddnews:1000:tags2(integer)1$redis-cli
*saddnews:1000:tags5(integer)1$redis-clisaddnews:1000:tags77
*(integer)1$redis-clisaddtag:1:objects1000(integer)1$redis-cli
*saddtag:2:objects1000(integer)1$redis-clisaddtag:5:objects1000
*(integer)1$redis-clisaddtag:77:objects1000(integer)1
*要获取一个对象的所有标签,如此简单:$redis-clismembersnews:1000:tags1.52.13.774.
*2而有些看上去并不简单的操作仍然能使用相应的Redis命令轻松实现。例如我们也许想获得一份同时拥有标签1,2,
*10和27的对象列表。这可以用SINTER命令来做,他可以在不同集合之间取出交集。因此为达目的我们只需:$redis-clisinter
*tag:1:objectstag:2:objectstag:10:objectstag:27:objects...noresult
*inourdatasetcomposedofjustoneobject...
*在命令参考文档中可以找到和集合相关的其他命令,令人感兴趣的一抓一大把。一定要留意SORT命令,Redis集合和list都是可排序的。
*/
@Test
publicvoidtestSetUsage(){
Jedisjedis=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+"");Setsets=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
publicvoidtestSortedSetUsage(){
Jedisjedis=RedisUtil.getJedis();
jedis.zadd("zhongsou:hackers",1940,"AlanKay");
jedis.zadd("zhongsou:hackers",1953,"RichardStallman");
jedis.zadd("zhongsou:hackers",1943,"Jay");
jedis.zadd("zhongsou:hackers",1920,"Jellon");
jedis.zadd("zhongsou:hackers",1965,"YukihiroMatsumoto");
jedis.zadd("zhongsou:hackers",1916,"ClaudeShannon");
jedis.zadd("zhongsou:hackers",1969,"LinusTorvalds");
jedis.zadd("zhongsou:hackers",1912,"AlanTuring");Sethackers=jedis.zrange("zhongsou:hackers",0,-1);
System.out.println(hackers);Sethackers2=jedis.zrevrange("zhongsou:hackers",0,-1);
System.out.println(hackers2);//区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素(两个极值也包含了)。
Sethackers3=jedis.zrangeByScore("zhongsou:hackers","-inf",
"1920");
System.out.println(hackers3);//ZREMRANGEBYSCORE这个名字虽然不算好,但他却非常有用,还会返回已删除的元素数量。
longnum=jedis.zremrangeByScore("zhongsou:hackers","-inf","1920");
System.out.println(num);jedis.flushAll();
}}



Java代码 /**
*获取连接池.
*@return连接池实例
*/
privatestaticJedisPoolgetPool(Stringip,intport){
JedisPoolConfigconfig=newJedisPoolConfig();
config.setMaxActive(RedisConfig.getMaxactive());
config.setMaxIdle(RedisConfig.getMaxidle());
config.setMaxWait(RedisConfig.getMaxwait());
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
try{
/**
*如果你遇到java.net.SocketTimeoutException:Readtimedoutexception的异常信息
*请尝试在构造JedisPool的时候设置自己的超时值.JedisPool默认的超时时间是2秒(单位毫秒)
*/
pool=newJedisPool(config,ip,port,RedisConfig.getTimeout());
}catch(Exceptione){
e.printStackTrace();
}
returnpool;

/**
*Redis工具类,用于获取RedisPool.
*参考官网说明如下:
*Youshouldn'tusethesameinstancefromdifferentthreadsbecauseyou'llhavestrangeerrors.
*AndsometimescreatinglotsofJedisinstancesisnotgoodenoughbecauseitmeanslotsofsocketsandconnections,
*whichleadstostrangeerrorsaswell.AsingleJedisinstanceisnotthreadsafe!
*Toavoidtheseproblems,youshoulduseJedisPool,whichisathreadsafepoolofnetworkconnections.
*Thiswayyoucanovercomethosestrangeerrorsandachievegreatperformance.
*Touseit,initapool:
*JedisPoolpool=newJedisPool(newJedisPoolConfig(),"localhost");
*Youcanstorethepoolsomewherestatically,itisthread-safe.
*JedisPoolConfigincludesanumberofhelpfulRedis-specificconnectionpoolingdefaults.
*Forexample,JediswithJedisPoolConfigwillcloseaconnectionafter300secondsifithasnotbeenreturned.
*@authorwujintao
*/
publicclassJedisUtil{
protectedLoggerlog=LoggerFactory.getLogger(getClass());

/**
*私有构造器.
*/
privateJedisUtil(){

}
privatestaticMapmaps=newHashMap();


/**
*获取连接池.
*@return连接池实例
*/
privatestaticJedisPoolgetPool(Stringip,intport){
Stringkey=ip+":"+port;
JedisPoolpool=null;
if(!maps.containsKey(key)){
JedisPoolConfigconfig=newJedisPoolConfig();
config.setMaxActive(RedisConfig.getMaxactive());
config.setMaxIdle(RedisConfig.getMaxidle());
config.setMaxWait(RedisConfig.getMaxwait());
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
try{
/**
*如果你遇到java.net.SocketTimeoutException:Readtimedoutexception的异常信息
*请尝试在构造JedisPool的时候设置自己的超时值.JedisPool默认的超时时间是2秒(单位毫秒)
*/
pool=newJedisPool(config,ip,port,RedisConfig.getTimeout());
maps.put(key,pool);
}catch(Exceptione){
e.printStackTrace();
}
}else{
pool=maps.get(key);
}
returnpool;
}

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

/**
*当getInstance方法第一次被调用的时候,它第一次读取
*RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静
*态域,从而创建RedisUtil的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
*这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。
*/
publicstaticJedisUtilgetInstance(){
returnRedisUtilHolder.instance;
}

/**
*获取Redis实例.
*@returnRedis工具类实例
*/
publicJedisgetJedis(Stringip,intport){
Jedisjedis=null;
intcount=0;
do{
try{
jedis=getPool(ip,port).getResource();
//log.info("getredismaster1!");
}catch(Exceptione){
log.error("getredismaster1failed!",e);
//销毁对象
getPool(ip,port).returnBrokenResource(jedis);
}
count++;
}while(jedis==null&&countreturnjedis;
}

/**
*释放redis实例到连接池.
*@paramjedisredis实例
*/
publicvoidcloseJedis(Jedisjedis,Stringip,intport){
if(jedis!=null){
getPool(ip,port).returnResource(jedis);
}
}
}

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台