package com.xxx.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.apache.commons.lang.ArrayUtils;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.SortingParams;
import com.auto.util.redis.RedisClientTemplate;
/**
* @company:
* @description:
* @author:
* @createtime: 2014年4月4日 上午9:42:59
* @version $Id: RedisClientTemplateTest.java, v 0.1 2014年4月4日 上午9:42:59 Exp $
*/
@ContextConfiguration("classpath*:applicationContext.xml")
public class RedisClientTemplateTest extends AbstractJUnit4SpringContextTests {
@Autowired
public RedisClientTemplate redisClientTemplate;
@Test
public void test1(){
// 向key-->name中放入了value-->minxr
redisClientTemplate.set("name", "aaaa");
String ss = redisClientTemplate.get("name");
System.out.println(ss);
// 很直观，类似map 将jintao append到已经有的value之后
redisClientTemplate.append("name", "bbbb");
ss = redisClientTemplate.get("name");
System.out.println(ss);
// 2、直接覆盖原来的数据
redisClientTemplate.set("name", "cccccc");
System.out.println(redisClientTemplate.get("name"));
// 删除key对应的记录
redisClientTemplate.del("name");
System.out.println(redisClientTemplate.get("name"));// 执行结果：null
}
@Test
public void testKey() {
System.out.println("=============key==========================");
// 清空数据
System.out.println(redisClientTemplate.del("foo"));
// 判断key否存在
System.out.println(redisClientTemplate.exists("foo"));
redisClientTemplate.set("key", "values");
System.out.println(redisClientTemplate.exists("key"));
}
@Test
public void testString() {
System.out.println("==String==");
try {
// String
redisClientTemplate.set("key", "Hello World!");
String value = redisClientTemplate.get("key");
System.out.println(value);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("=============String==========================");
// 清空数据
System.out.println(redisClientTemplate.del("foo"));
// 存储数据
redisClientTemplate.set("foo", "bar");
System.out.println(redisClientTemplate.get("foo"));
// 若key不存在，则存储
redisClientTemplate.setnx("foo", "foo not exits");
System.out.println(redisClientTemplate.get("foo"));
// 覆盖数据
redisClientTemplate.set("foo", "foo update");
System.out.println(redisClientTemplate.get("foo"));
// 追加数据
redisClientTemplate.append("foo", " hello, world");
System.out.println(redisClientTemplate.get("foo"));
// 设置key的有效期，并存储数据
redisClientTemplate.setex("foo", 2, "foo not exits");
System.out.println(redisClientTemplate.get("foo"));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
}
System.out.println("已经过期啦："+redisClientTemplate.get("foo"));
// 获取并更改数据
redisClientTemplate.set("foo", "foo update");
System.out.println(redisClientTemplate.getSet("foo", "foo modify"));
// 截取value的值
System.out.println(redisClientTemplate.getrange("foo", 1, 3));
//System.out.println(redisClientTemplate.del(new String[] { "foo", "foo1", "foo3" }));
}
@Test
public void testList() {
System.out.println("==List==");
try {
// 开始前，先移除所有的内容
redisClientTemplate.del("messages");
redisClientTemplate.rpush("messages", "Hello how are you?");
redisClientTemplate.rpush("messages", "Fine thanks. I'm having fun with redis.");
redisClientTemplate.rpush("messages", "I should look into this NOSQL thing ASAP");
// 再取出所有数据redisClientTemplate.lrange是按范围取出，
// 第一个是key，第二个是起始位置，第三个是结束位置，redisClientTemplate.llen获取长度 -1表示取得所有
List<String> values = redisClientTemplate.lrange("messages", 0, -1);
System.out.println(values);
} catch (Exception e) {
e.printStackTrace();
}
// 清空数据
System.out.println(redisClientTemplate.del("lists"));
// 添加数据
redisClientTemplate.lpush("lists", "vector");
redisClientTemplate.lpush("lists", "ArrayList");
redisClientTemplate.lpush("lists", "LinkedList");
// 数组长度
System.out.println("llen"+redisClientTemplate.llen("lists"));
// 排序
//System.out.println(redisClientTemplate.sort("lists"));
// 字串
System.out.println("lrange"+redisClientTemplate.lrange("lists", 0, 3));
// 修改列表中单个值
redisClientTemplate.lset("lists", 0, "hello list!");
// 获取列表指定下标的值
System.out.println(redisClientTemplate.lindex("lists", 1));
// 删除列表指定下标的值
System.out.println(redisClientTemplate.lrem("lists", 1, "vector"));
// 删除区间以外的数据
System.out.println(redisClientTemplate.ltrim("lists", 0, 1));
// 列表出栈
System.out.println(redisClientTemplate.lpop("lists"));
// 整个列表值
System.out.println(redisClientTemplate.lrange("lists", 0, -1));
}
@Test
public void testSet() throws Exception {
System.out.println("==Set==");
try {
redisClientTemplate.sadd("myset", "1");
redisClientTemplate.sadd("myset", "2");
redisClientTemplate.sadd("myset", "3");
redisClientTemplate.sadd("myset", "4");
Set<String> setValues = redisClientTemplate.smembers("myset");
System.out.println(setValues);
// 移除noname
redisClientTemplate.srem("myset", "4");
System.out.println(redisClientTemplate.smembers("myset"));// 获取所有加入的value
System.out.println(redisClientTemplate.sismember("myset", "4"));// 判断 minxr
// 是否是sname集合的元素
System.out.println(redisClientTemplate.scard("sname"));// 返回集合的元素个数
} catch (Exception e) {
e.printStackTrace();
}
// 清空数据
System.out.println(redisClientTemplate.del("sets"));
// 添加数据
redisClientTemplate.sadd("sets", "HashSet");
redisClientTemplate.sadd("sets", "SortedSet");
redisClientTemplate.sadd("sets", "TreeSet");
// 判断value是否在列表中
System.out.println(redisClientTemplate.sismember("sets", "TreeSet"));
;
// 整个列表值
System.out.println(redisClientTemplate.smembers("sets"));
// 删除指定元素
System.out.println(redisClientTemplate.srem("sets", "SortedSet"));
// 出栈
System.out.println(redisClientTemplate.spop("sets"));
System.out.println(redisClientTemplate.smembers("sets"));
//
redisClientTemplate.sadd("sets1", "HashSet1");
redisClientTemplate.sadd("sets1", "SortedSet1");
redisClientTemplate.sadd("sets1", "TreeSet");
redisClientTemplate.sadd("sets2", "HashSet2");
redisClientTemplate.sadd("sets2", "SortedSet1");
redisClientTemplate.sadd("sets2", "TreeSet1");
// 交集
System.out.println(redisClientTemplate.sinter("sets1", "sets2"));
// 并集
System.out.println(redisClientTemplate.sunion("sets1", "sets2"));
// 差集
System.out.println(redisClientTemplate.sdiff("sets1", "sets2"));
}
@Test
public void sortedSet() {
System.out.println("==SoretedSet==");
try {
redisClientTemplate.zadd("hackers", 1940, "Alan Kay");
redisClientTemplate.zadd("hackers", 1953, "Richard Stallman");
redisClientTemplate.zadd("hackers", 1965, "Yukihiro Matsumoto");
redisClientTemplate.zadd("hackers", 1916, "Claude Shannon");
redisClientTemplate.zadd("hackers", 1969, "Linus Torvalds");
redisClientTemplate.zadd("hackers", 1912, "Alan Turing");
Set<String> setValues = redisClientTemplate.zrange("hackers", 0, -1);
System.out.println(setValues);
Set<String> setValues2 = redisClientTemplate.zrevrange("hackers", 0, -1);
System.out.println(setValues2);
} catch (Exception e) {
e.printStackTrace();
}
// 清空数据
System.out.println(redisClientTemplate.del("zset"));
// 添加数据
redisClientTemplate.zadd("zset", 10.1, "hello");
redisClientTemplate.zadd("zset", 10.0, ":");
redisClientTemplate.zadd("zset", 9.0, "zset");
redisClientTemplate.zadd("zset", 11.0, "zset!");
// 元素个数
System.out.println(redisClientTemplate.zcard("zset"));
// 元素下标
System.out.println(redisClientTemplate.zscore("zset", "zset"));
// 集合子集
System.out.println(redisClientTemplate.zrange("zset", 0, -1));
// 删除元素
System.out.println(redisClientTemplate.zrem("zset", "zset!"));
System.out.println(redisClientTemplate.zcount("zset", 9.5, 10.5));
// 整个集合值
System.out.println(redisClientTemplate.zrange("zset", 0, -1));
}
@Test
public void testHsh() {
System.out.println("==Hash==");
try {
Map<String, String> pairs = new HashMap<String, String>();
pairs.put("name", "Akshi");
pairs.put("age", "2");
pairs.put("sex", "Female");
redisClientTemplate.hmset("kid", pairs);
List<String> name = redisClientTemplate.hmget("kid", "name");// 结果是个泛型的LIST
// redisClientTemplate.hdel("kid","age"); //删除map中的某个键值
System.out.println(redisClientTemplate.hmget("kid", "pwd")); // 因为删除了，所以返回的是null
System.out.println(redisClientTemplate.hlen("kid")); // 返回key为user的键中存放的值的个数
System.out.println(redisClientTemplate.exists("kid"));// 是否存在key为user的记录
System.out.println(redisClientTemplate.hkeys("kid"));// 返回map对象中的所有key
System.out.println(redisClientTemplate.hvals("kid"));// 返回map对象中的所有value
Iterator<String> iter = redisClientTemplate.hkeys("kid").iterator();
while (iter.hasNext()) {
String key = iter.next();
System.out.println(key + ":" + redisClientTemplate.hmget("kid", key));
}
List<String> values = redisClientTemplate.lrange("messages", 0, -1);
values = redisClientTemplate.hmget("kid", new String[] { "name", "age", "sex" });
System.out.println(values);
Set<String> setValues = redisClientTemplate.zrange("hackers", 0, -1);
setValues = redisClientTemplate.hkeys("kid");
System.out.println(setValues);
values = redisClientTemplate.hvals("kid");
System.out.println(values);
pairs = redisClientTemplate.hgetAll("kid");
System.out.println(pairs);
} catch (Exception e) {
e.printStackTrace();
}
// 清空数据
System.out.println(redisClientTemplate.del("hashs"));
// 添加数据
redisClientTemplate.hset("hashs", "entryKey", "entryValue");
redisClientTemplate.hset("hashs", "entryKey1", "entryValue1");
redisClientTemplate.hset("hashs", "entryKey2", "entryValue2");
// 判断某个值是否存在
System.out.println(redisClientTemplate.hexists("hashs", "entryKey"));
// 获取指定的值
System.out.println(redisClientTemplate.hget("hashs", "entryKey")); // 批量获取指定的值
System.out.println(redisClientTemplate.hmget("hashs", "entryKey", "entryKey1"));
// 删除指定的值
System.out.println(redisClientTemplate.hdel("hashs", "entryKey"));
// 为key中的域 field 的值加上增量 increment
System.out.println(redisClientTemplate.hincrBy("hashs", "entryKey", 123l));
// 获取所有的keys
System.out.println(redisClientTemplate.hkeys("hashs"));
// 获取所有的values
System.out.println(redisClientTemplate.hvals("hashs"));
}
@Test
public void testOther() throws InterruptedException {
try {
// keys中传入的可以用通配符
System.out.println(redisClientTemplate.keys("*")); // 返回当前库中所有的key [sose, sanme,
// name, jarorwar, foo,
// sname, java framework,
// user, braand]
System.out.println(redisClientTemplate.keys("*name"));// 返回的sname [sname, name]
System.out.println(redisClientTemplate.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1
// 删除失败（或者不存在）返回 0
System.out.println(redisClientTemplate.ttl("sname"));// 返回给定key的有效时间，如果是-1则表示永远有效
redisClientTemplate.setex("timekey", 10, "min");// 通过此方法，可以指定key的存活（有效时间） 时间为秒
Thread.sleep(5000);// 睡眠5秒后，剩余时间将为<=5
System.out.println(redisClientTemplate.ttl("timekey")); // 输出结果为5
redisClientTemplate.setex("timekey", 1, "min"); // 设为1后，下面再看剩余时间就是1了
System.out.println(redisClientTemplate.ttl("timekey")); // 输出结果为1
System.out.println(redisClientTemplate.exists("key"));// 检查key是否存在
System.out.println(redisClientTemplate.rename("timekey", "time"));
System.out.println(redisClientTemplate.get("timekey"));// 因为移除，返回为null
System.out.println(redisClientTemplate.get("time")); // 因为将timekey 重命名为time
// 所以可以取得值 min
// redisClientTemplate 排序
// 注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
redisClientTemplate.del("a");// 先清除数据，再加入数据进行测试
redisClientTemplate.rpush("a", "1");
redisClientTemplate.lpush("a", "6");
redisClientTemplate.lpush("a", "3");
redisClientTemplate.lpush("a", "9");
System.out.println(redisClientTemplate.lrange("a", 0, -1));// [9, 3, 6, 1]
System.out.println(redisClientTemplate.sort("a")); // [1, 3, 6, 9] //输入排序后结果
System.out.println(redisClientTemplate.lrange("a", 0, -1));
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testUnUsePipeline() {
long start = new Date().getTime();
for (int i = 0; i < 10000; i++) {
redisClientTemplate.set("age1" + i, i + "");
redisClientTemplate.get("age1" + i);// 每个操作都发送请求给redis-server
}
long end = new Date().getTime();
System.out.println("unuse pipeline cost:" + (end - start) + "ms");
}
/**
* <pre>
* http://blog.csdn.net/freebird_lb/article/details/7778919
* </pre>
*/
@Test
public void testUsePipeline() {
long start = new Date().getTime();
redisClientTemplate.del("age2");
Pipeline p = redisClientTemplate.pipelined();
for (int i = 0; i < 10000; i++) {
p.set("age2" + i, i + "");
System.out.println(p.get("age2" + i));
}
for (int i = 0; i < 10000; i++) {
redisClientTemplate.get("age2" + i);// 每个操作都发送请求给redis-server
}
p.sync();// 这段代码获取所有的response
long end = new Date().getTime();
System.out.println("use pipeline cost:" + (end - start) + "ms");
}
/**
* 时间复杂度：
O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。
如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
*/
@Test
public void testSort1() {
// 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较
// 一般SORT用法 最简单的SORT使用方法是SORT key。
redisClientTemplate.del("mylist");
redisClientTemplate.lpush("mylist", "1");
redisClientTemplate.lpush("mylist", "4");
redisClientTemplate.lpush("mylist", "6");
redisClientTemplate.lpush("mylist", "3");
redisClientTemplate.lpush("mylist", "0");
// List<String> list = redisClientTemplate.sort("sort");// 默认是升序
SortingParams sortingParameters = new SortingParams();
sortingParameters.desc();
// sortingParameters.alpha();//当数据集中保存的是字符串值时，你可以用 ALPHA
// 修饰符(modifier)进行排序。
sortingParameters.limit(0, 2);// 可用于分页查询
List<String> list = redisClientTemplate.sort("mylist", sortingParameters);// 默认是升序
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
@Test
public void testSort2() throws Exception {
redisClientTemplate.del("user:66", "user:55", "user:33", "user:22", "user:11",
"userlist");
redisClientTemplate.lpush("userlist", "33");
redisClientTemplate.lpush("userlist", "22");
redisClientTemplate.lpush("userlist", "55");
redisClientTemplate.lpush("userlist", "11");
redisClientTemplate.lpush("userlist", "66");
redisClientTemplate.hset("user:66", "name", "66");
redisClientTemplate.hset("user:55", "name", "55");
redisClientTemplate.hset("user:33", "name", "33");
redisClientTemplate.hset("user:22", "name", "79");
redisClientTemplate.hset("user:11", "name", "24");
redisClientTemplate.hset("user:11", "add", "beijing");
redisClientTemplate.hset("user:22", "add", "shanghai");
redisClientTemplate.hset("user:33", "add", "guangzhou");
redisClientTemplate.hset("user:55", "add", "chongqing");
redisClientTemplate.hset("user:66", "add", "xi'an");
List<String> list = redisClientTemplate.lrange("userlist", 0, -1) ;
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 = redisClientTemplate.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
*/
}
/**
* sort set
* SET结合String的排序
* @throws Exception
*/
@Test
public void testSort3() throws Exception {
redisClientTemplate.del("tom:friend:list", "score:uid:123", "score:uid:456",
"score:uid:789", "score:uid:101", "uid:123", "uid:456",
"uid:789", "uid:101");
redisClientTemplate.sadd("tom:friend:list", "123"); // tom的好友列表
redisClientTemplate.sadd("tom:friend:list", "456");
redisClientTemplate.sadd("tom:friend:list", "789");
redisClientTemplate.sadd("tom:friend:list", "101");
redisClientTemplate.set("score:uid:123", "1000"); // 好友对应的成绩
redisClientTemplate.set("score:uid:456", "6000");
redisClientTemplate.set("score:uid:789", "100");
redisClientTemplate.set("score:uid:101", "5999");
redisClientTemplate.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
redisClientTemplate.set("uid:456", "{'uid':456,'name':'jack'}");
redisClientTemplate.set("uid:789", "{'uid':789,'name':'jay'}");
redisClientTemplate.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 = redisClientTemplate.sort("tom:friend:list", sortingParameters);
for (String item : result) {
System.out.println("item..." + item);
}
}
/**
*
保存排序结果 默认情况下， 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() {
// 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较
// 一般SORT用法 最简单的SORT使用方法是SORT key。
redisClientTemplate.del("mylist");
redisClientTemplate.lpush("mylist", "1");
redisClientTemplate.lpush("mylist", "4");
redisClientTemplate.lpush("mylist", "6");
redisClientTemplate.lpush("mylist", "3");
redisClientTemplate.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 参数，返回排序结果的元素数量。
redisClientTemplate.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中，这里讲结果覆盖原来的KEY
List<String> list = redisClientTemplate.lrange("mylist", 0, -1);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
redisClientTemplate.sadd("tom:friend:list", "123"); // tom的好友列表
redisClientTemplate.sadd("tom:friend:list", "456");
redisClientTemplate.sadd("tom:friend:list", "789");
redisClientTemplate.sadd("tom:friend:list", "101");
redisClientTemplate.set("score:uid:123", "1000"); // 好友对应的成绩
redisClientTemplate.set("score:uid:456", "6000");
redisClientTemplate.set("score:uid:789", "100");
redisClientTemplate.set("score:uid:101", "5999");
redisClientTemplate.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息
redisClientTemplate.set("uid:456", "{'uid':456,'name':'jack'}");
redisClientTemplate.set("uid:789", "{'uid':789,'name':'jay'}");
redisClientTemplate.set("uid:101", "{'uid':101,'name':'jolin'}");
sortingParameters = new SortingParams();
// sortingParameters.desc();
sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"
// ，用于获取被排序对象(我们这里的例子是 user_id )的当前元素。
sortingParameters.by("score:uid:*");
redisClientTemplate.sort("tom:friend:list", sortingParameters, "tom:friend:list");
List<String> result = redisClientTemplate.lrange("tom:friend:list", 0, -1);
for (String item : result) {
System.out.println("item..." + item);
}
}
@Test
public void testMget() throws Exception {
redisClientTemplate.del("ids");
redisClientTemplate.rpush("ids", "aa");
redisClientTemplate.rpush("ids", "bb");
redisClientTemplate.rpush("ids", "cc");
List<String> ids = redisClientTemplate.lrange("ids", 0, -1);
redisClientTemplate.set("aa", "{'name':'zhoujie','age':20}");
redisClientTemplate.set("bb", "{'name':'yilin','age':28}");
redisClientTemplate.set("cc", "{'name':'lucy','age':21}");
List<String> list = redisClientTemplate.mget(ids.toArray(new String[ids.size()]));
System.out.println(list);
}
/**
* 可以利用lrange对list进行分页操作
*/
@Test
public void queryPageBy() {
int pageNo = 1;
int pageSize = 3;
redisClientTemplate.del("a");
for (int i = 1; i <= 30; i++) {
redisClientTemplate.rpush("a", i + "");
}
int start = pageSize * (pageNo - 1);// 因为redis中list元素位置基数是0
int end = start + pageSize - 1;
List<String> results = redisClientTemplate.lrange("a", start, end);// 从start算起，start算一个元素，到结束那个元素
for (String str : results) {
System.out.println(str);
}
}
/**
* [向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的长度。
*/
@Test
public void testListStrUsage() {
String title = "嘀嘀派 选车 用车 一步到位";
String url = "http://javacreazyer.iteye.com";
long adInfoId = redisClientTemplate.incr("ad:adinfo:next.id");
redisClientTemplate.set("ad:adinfo:" + adInfoId + ":title", title);
redisClientTemplate.set("ad:adinfo:" + adInfoId + ":url", url);
redisClientTemplate.lpush("ad:adinfo", String.valueOf(adInfoId));
String resultTitle = redisClientTemplate.get("ad:adinfo:" + adInfoId + ":title");
String resultUrl = redisClientTemplate.get("ad:adinfo:" + adInfoId + ":url");
List<String> ids = redisClientTemplate.lrange("ad:adinfo", 0, -1);
System.out.println(resultTitle);
System.out.println(resultUrl);
System.out.println(ids);
}
/**
* 下面是一个简单的方案：对每个想加标签的对象，用一个标签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() {
redisClientTemplate.del("zhongsou:news*");
redisClientTemplate.sadd("zhongsou:news:1000:tags", "1");
redisClientTemplate.sadd("zhongsou:news:1000:tags", "2");
redisClientTemplate.sadd("zhongsou:news:1000:tags", "5");
redisClientTemplate.sadd("zhongsou:news:1000:tags", "77");
redisClientTemplate.sadd("zhongsou:news:2000:tags", "1");
redisClientTemplate.sadd("zhongsou:news:2000:tags", "2");
redisClientTemplate.sadd("zhongsou:news:2000:tags", "5");
redisClientTemplate.sadd("zhongsou:news:2000:tags", "77");
redisClientTemplate.sadd("zhongsou:news:3000:tags", "2");
redisClientTemplate.sadd("zhongsou:news:4000:tags", "77");
redisClientTemplate.sadd("zhongsou:news:5000:tags", "1");
redisClientTemplate.sadd("zhongsou:news:6000:tags", "5");
redisClientTemplate.sadd("zhongsou:tag:1:objects", 1000 + "");
redisClientTemplate.sadd("zhongsou:tag:2:objects", 1000 + "");
redisClientTemplate.sadd("zhongsou:tag:5:objects", 1000 + "");
redisClientTemplate.sadd("zhongsou:tag:77:objects", 1000 + "");
redisClientTemplate.sadd("zhongsou:tag:1:objects", 2000 + "");
redisClientTemplate.sadd("zhongsou:tag:2:objects", 2000 + "");
redisClientTemplate.sadd("zhongsou:tag:5:objects", 2000 + "");
redisClientTemplate.sadd("zhongsou:tag:77:objects", 2000 + "");
Set<String> sets = redisClientTemplate.sinter("zhongsou:tag:1:objects",
"zhongsou:tag:2:objects", "zhongsou:tag:5:objects",
"zhongsou:tag:77:objects");
System.out.println(sets);
}
@Test
public void testSortedSetUsage() {
redisClientTemplate.del("zhongsou:hackers*");
redisClientTemplate.zadd("zhongsou:hackers", 1940, "Alan Kay");
redisClientTemplate.zadd("zhongsou:hackers", 1953, "Richard Stallman");
redisClientTemplate.zadd("zhongsou:hackers", 1943, "Jay");
redisClientTemplate.zadd("zhongsou:hackers", 1920, "Jellon");
redisClientTemplate.zadd("zhongsou:hackers", 1965, "Yukihiro Matsumoto");
redisClientTemplate.zadd("zhongsou:hackers", 1916, "Claude Shannon");
redisClientTemplate.zadd("zhongsou:hackers", 1969, "Linus Torvalds");
redisClientTemplate.zadd("zhongsou:hackers", 1912, "Alan Turing");
Set<String> hackers = redisClientTemplate.zrange("zhongsou:hackers", 0, -1);
System.out.println(hackers);
Set<String> hackers2 = redisClientTemplate.zrevrange("zhongsou:hackers", 0, -1);
System.out.println(hackers2);
// 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素（两个极值也包含了）。
Set<String> hackers3 = redisClientTemplate.zrangeByScore("zhongsou:hackers", "-inf",
"1920");
System.out.println(hackers3);
// ZREMRANGEBYSCORE 这个名字虽然不算好，但他却非常有用，还会返回已删除的元素数量。
long num = redisClientTemplate.zremrangeByScore("zhongsou:hackers", "-inf", "1920");
System.out.println(num);
}
@Test
public void mysort(){
try {
redisClientTemplate.del(new String[]{"myuser.id","myuser.name.*","myuser.level.*"});
} catch (Exception e) {
logger.error("", e);
}
redisClientTemplate.lpush("myuser.id", "1");
redisClientTemplate.set("myuser.name.1", "admin");
redisClientTemplate.set("myuser.level.1", "9999");
redisClientTemplate.lpush("myuser.id", "2");
redisClientTemplate.set("myuser.name.2", "jack");
redisClientTemplate.set("myuser.level.2", "10");
redisClientTemplate.lpush("myuser.id", "3");
redisClientTemplate.set("myuser.name.3", "peter");
redisClientTemplate.set("myuser.level.3", "25");
redisClientTemplate.lpush("myuser.id", "4");
redisClientTemplate.set("myuser.name.4", "mary");
redisClientTemplate.set("myuser.level.4", "70");
System.out.println("===============BY=================");
List<String> list = redisClientTemplate.sort("myuser.id");
System.err.println("按照uid 进行排序: "+ArrayUtils.toString(list));
System.out.println("通过使用 BY 选项，可以让 uid 按其他键的元素来排序。");
SortingParams sortingParameters = new SortingParams();
//myuser.level.* 是一个占位符， 它先取出 uid 中的值， 然后再用这个值来查找相应的键。
sortingParameters.by(redisClientTemplate.getPrefixKey()+".myuser.level.*");
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println("按照myuser.level 进行排序: "+ArrayUtils.toString(list));
System.out.println("===============GET=================");
System.out.println("使用 GET 选项， 可以根据排序的结果来取出相应的键值");
sortingParameters = new SortingParams();
sortingParameters.get(redisClientTemplate.getPrefixKey()+".myuser.name.*");
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println("GET: 以下代码先排序 uid ， 再取出键 user_name_{uid} 的值: "+ArrayUtils.toString(list));
System.out.println("==================组合使用 BY 和 GET========================");
System.out.println("通过组合使用 BY 和 GET ， 可以让排序结果以更直观的方式显示出来。");
sortingParameters = new SortingParams();
sortingParameters.by(redisClientTemplate.getPrefixKey()+".myuser.level.*");
sortingParameters.get(redisClientTemplate.getPrefixKey()+".myuser.name.*");
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println("比如说， 以下代码先按 user_level_{uid} 来排序 uid 列表， 再取出相应的 user_name_{uid} 的值"+ArrayUtils.toString(list));
System.out.println("=====================获取多个外部键=============================");
System.out.println("可以同时使用多个 GET 选项， 获取多个外部键的值。");
sortingParameters = new SortingParams();
sortingParameters.get(new String[]{redisClientTemplate.getPrefixKey()+".myuser.name.*",redisClientTemplate.getPrefixKey()+".myuser.level.*"});
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println("按 uid 分别获取 user_level_{uid} 和 user_name_{uid} "+ArrayUtils.toString(list));
System.out.println("=======================获取外部键，但不进行排序=====================================");
System.out.println("通过将一个不存在的键作为参数传给 BY 选项， 可以让 SORT 跳过排序操作， 直接返回结果");
System.out.println("不过，通过将这种用法和 GET 选项配合， 就可以在不排序的情况下， 获取多个外部键， 相当于执行一个整合的获取操作（类似于 SQL 数据库的 join 关键字）。");
sortingParameters = new SortingParams();
sortingParameters.by("not-exists-key");
sortingParameters.get(new String[]{redisClientTemplate.getPrefixKey()+".myuser.name.*",redisClientTemplate.getPrefixKey()+".myuser.level.*"});
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println("如何在不引起排序的情况下，使用 SORT 、 BY 和 GET 获取多个外部键:"+ArrayUtils.toString(list));
System.out.println("=================================将哈希表作为 GET 或 BY 的参数===========================================");
System.out.println("我们可以不将用户的名字和级别保存在 user_name_{uid} 和 user_level_{uid} 两个字符串键中， 而是用一个带有 name 域和 level 域的哈希表 user_info_{uid} 来保存用户的名字和级别信息：");
HashMap<String, String> map = new HashMap<String, String>();
map.put("name", "admin");
map.put("level", "9999");
redisClientTemplate.hmset("user_info_1", map);
map.put("name", "jack");
map.put("level", "10");
redisClientTemplate.hmset("user_info_2", map);
map.put("name", "peter");
map.put("level", "25");
redisClientTemplate.hmset("user_info_3", map);
map.put("name", "mary");
map.put("level", "70");
redisClientTemplate.hmset("user_info_4", map);
sortingParameters = new SortingParams();
sortingParameters.by(redisClientTemplate.getPrefixKey()+".user_info_*->level");
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println(" BY选项都可以用 key->field 的格式来获取哈希表中的域的值， 其中 key 表示哈希表键， 而 field 则表示哈希表的域:"+ArrayUtils.toString(list));
sortingParameters = new SortingParams();
sortingParameters.by(redisClientTemplate.getPrefixKey()+".user_info_*->level");
sortingParameters.get(redisClientTemplate.getPrefixKey()+".user_info_*->name");
list = redisClientTemplate.sort("myuser.id",sortingParameters);
System.out.println(" BY 和 GET 选项都可以用 key->field 的格式来获取哈希表中的域的值， 其中 key 表示哈希表键， 而 field 则表示哈希表的域:"+ArrayUtils.toString(list));
System.out.println("=================================通过给 STORE 选项指定一个 key 参数，可以将排序结果保存到给定的键上===========================================");
sortingParameters = new SortingParams();
sortingParameters.by(redisClientTemplate.getPrefixKey()+".user_info_*->level");
sortingParameters.get(redisClientTemplate.getPrefixKey()+".user_info_*->name");
long i = redisClientTemplate.sort("myuser.id",sortingParameters,"myuserlistxxx");
list = redisClientTemplate.lrange("myuserlistxxx",0,-1);
System.out.println(" 如果被指定的 key 已存在，那么原有的值将被排序结果覆盖:"+ArrayUtils.toString(list));
System.out.println("可以通过将 SORT 命令的执行结果保存，并用 EXPIRE 为结果设置生存时间，以此来产生一个 SORT 操作的结果缓存");
System.out.println("这样就可以避免对 SORT 操作的频繁调用：只有当结果集过期时，才需要再调用一次 SORT 操作");
redisClientTemplate.expire("myuserlistxxx", 10) ; // 10s 后失效
try {
Thread.sleep(11000);// 睡眠11秒后
} catch (InterruptedException e) {
logger.error("", e);
}
list = redisClientTemplate.lrange("myuserlistxxx",0,-1);
System.out.println("myuserlistxxx 已经失效了，需要重新计算 "+ArrayUtils.toString(list));
}
}
相关推荐
spring和redis集成有很多方式，看到网上很多都是使用redistemplate自己去做redis 的一些操作，但是对于我们开发来说，肯定是使用越方便越好，于是乎就有了spring的对redis或者memcahe这些换成框架的封装，只需要引入...
标题“redis_Test.rar”指的是一个压缩包文件，其中包含了与Redis相关的C++示例代码，主要展示在Windows平台上如何使用hiredis库进行基本的数据操作，包括增、删、改、查以及订阅功能。Redis是一个高性能的键值...
在"RedisTest.rar"这个压缩包中，我们可以期待找到一个关于如何使用Redis的实践案例，特别是涉及到一个名为StackExchange.Redis.2.1.58的客户端库。StackExchange.Redis是.NET平台上广泛使用的Redis客户端，提供了...
在本项目"Redis-Test.rar"中，我们主要探讨的是如何在Java应用程序中集成和使用Redis作为缓存系统，以及配合日志框架log4j进行日志管理。Redis是一款高性能的键值对存储数据库，广泛应用于数据缓存、消息队列、...
【标题】"wangqi-redis-test.zip"是一个与Redis数据库相关的测试项目压缩包，其中包含了开发者wangqi用于测试Redis功能的代码...对于想要了解或学习如何使用Redis进行测试的开发人员，这个项目提供了宝贵的资源和参考。
【Redis适配器测试的家庭作业】是针对使用...总之，完成这个“homework for redis adaptor test”不仅要求你熟悉Redis的基础知识，还需要你具备良好的编程能力和问题解决技巧，以实现高效、稳定、安全的Redis适配器。
springBoot整合redis的demo，包括redis单点和集群构建，通过java连接redis，以及redis使用
RedisTest.zip是一个包含DotNet平台下使用C#与Redis交互的示例代码的压缩包。Redis是一个高性能的键值数据库，常被用作缓存、数据存储和消息中间件，而C#是Microsoft开发的面向对象的编程语言，广泛应用于Windows和...
"redis_test"可能是一个包含Redis测试代码的项目，用于验证Redis缓存的正确性、性能和稳定性。测试通常会涵盖各种操作，如写入、读取、更新和删除数据，以及并发访问场景下的性能测试。测试过程中，我们还需要关注...
总结来说，这个项目展示了如何在Spring应用中配置并使用Redis作为缓存，同时利用Spring Test进行测试。它涉及到Spring框架的缓存管理、Redis的使用以及集成测试的实践。通过这个项目，开发者可以学习到如何提高应用...
- **操作数据**：根据"redisTest"目录下的示例，尝试使用 SET、GET、HSET、LPOP 等命令操作数据。 - **测试事务**：通过 multi 和 exec 命令开启和结束事务，观察命令的原子性。 - **发布订阅**：创建发布者和...
spring+mybatis+redis 的一个测试项目，先用SQL语句创建表，然后替换数据库url和账号密码
5. **编写测试用例**：`RedisAnnotationTest.java`和`RedisTest.java`中，我们可以编写测试方法来验证缓存功能。例如，测试`@Cacheable`注解的方法是否能正确写入Redis，`@CacheEvict`注解的方法是否能清除指定缓存...
6. 若要测试编译结果，可执行`make test`来运行Redis的单元测试。 7. 最后，执行`make install`将Redis安装到系统指定的路径。 压缩包内的文件包括： - `redis.conf`: Redis的配置文件，用于设置Redis服务器的启动...
spark一个Linux下使用C++学习编写的并发服务器，使用redis作为缓存和MySQL作为数据库，并利用GoogleTest编写单元测试和webbench进行压力测试。.zipspark一个Linux下使用C++学习编写的并发服务器，使用redis作为缓存...
接下来，使用`redis-dump`命令导出数据到JSON文件，例如`test.json`： ```bash [root@localhost tank]# redis-dump -u 127.0.0.1:6379 > test.json ``` 导出完成后，如果你想恢复数据，首先需要清空Redis中的所有...