public class RedisTest {
public JedisPool jedisPool = null;
public void init(){
//创建配置信息
JedisPoolConfig pool = new JedisPoolConfig();
//设置最大的总链接数
pool.setMaxTotal(300);
//设置最大空闲链接数
pool.setMaxIdle(100);
//设置最大等待时间
pool.setMaxWaitMillis(10000);
//在获取实例的时候进行validate操作,从而使获得的实例都是可用的
pool.setTestOnBorrow(true);
//使用配置信息,ip和端口来初始化一个链接池
jedisPool = new JedisPool(pool,"192.168.0.85", 6379);
}
/**
*
* 测试在redis中使用map进行操作
*
*
* */
public void testMap(){
//获得一个实例
Jedis jedis = jedisPool.getResource();
//整个map的key(通过这个key来获取map对象)
String redisMapKey="test_map";
try {
//选用数据库13
jedis.select(13);
//删除test_map所对应的值(也就是map对象)
jedis.del(redisMapKey);
/**
* 往map中插入key-value开始
* */
//这个语句的意思可理解为:向test_map对应的map中插入一个key为key_1,value为1的key-value对
jedis.hset(redisMapKey, "key_1", "1");
jedis.hset(redisMapKey, "key_2", "2");
jedis.hset(redisMapKey, "key_3", "3");
jedis.hset(redisMapKey, "key_4", "4");
jedis.hset(redisMapKey, "key_5", "5");
jedis.hset(redisMapKey, "key_6", "6");
/**
* 往map中插入key-value结束
* */
/*测试map的get操作*/
System.out.println("test map's get:-----------");
/*给出map所对应的key(redisMapKey变量),以及想从map中获得的value的key(key_1)*/
String hget = jedis.hget(redisMapKey, "key_1");
System.out.println(hget);
/*获得map中的所有key值*/
System.out.println("test get all keys:--------------- ");
/*给出map所对应的key(redisMapKey变量)*//*返回的key是封装在set中的,因为key是唯一的*/
Set<String> hkeys = jedis.hkeys(redisMapKey);
for(String str:hkeys){//输出获得的map的所有key
System.out.println(str);
}
/*获得map中的所有value值*/
System.out.println("test get all values:------------------");
/*给出map所对应的key(redisMapKey变量)*//*反悔的值封装在list中,因为value的值是可重复的*/
List<String> hvals = jedis.hvals(redisMapKey);
for(String str:hvals){//输出获得的map的所有value
System.out.println(str);
}
/*查询在指定的map中是否包含某个key值对对应的key-value对*/
System.out.println("test if a key exist in the map:------------------");
/*给出map所对应的key(redisMapKey变量)和要在该map中查询的key的值*//*如果存在返回true,如果不存在返回false*/
Boolean hexists = jedis.hexists(redisMapKey, "key_1");
Boolean hexists2 = jedis.hexists(redisMapKey, "key_100");
System.out.println("key_1's exit result is: "+hexists+", key_100's exit result is: "+hexists2);
/*获得map中的所有key-value对*/
System.out.println("test get all :----------------------");
/*给出map所对应的key(redisMapKey变量)*/
Map<String, String> hgetAll = jedis.hgetAll(redisMapKey);
Set<Entry<String, String>> entrySet = hgetAll.entrySet();
for(Entry<String, String> en:entrySet){/*输出map中的所有key-value对*/
System.out.println(en.getKey()+":"+en.getValue());
}
/*获得map的长度*/
System.out.println("get the length of hmap:-------------------");
/*给出map所对应的key(redisMapKey变量)*/
Long hlen = jedis.hlen(redisMapKey);
System.out.println(hlen);
/*对map中的某个key的value进行累加操作*/
System.out.println("test increment:--------------");
System.out.println("before increment:");
List<String> hvals2 = jedis.hvals(redisMapKey);
for(String str:hvals2){/*输出在累加之前的值*/
System.out.println(str);
}
/*给redisMapKey变量对应的map中的key值为key_6的value的值累加2 返回值是累加后的结果*/
Long hincrBy = jedis.hincrBy(redisMapKey, "key_6", 2);
System.out.println("incremnt value is:"+hincrBy);
System.out.println("after increment:");
List<String> hvals3 = jedis.hvals(redisMapKey);
for(String str:hvals3){/*输出在累加之后的值*/
System.out.println(str);
}
/*删除map中的某个key对对应的key-value对*/
System.out.println("test del:-----------------------");
/*给出redisMapKey变量来指出要删除哪个map,然后key_1指出要删除该map中的哪个key-value对*/
jedis.hdel(redisMapKey, "key_1");
Set<String> afterDelKeys=jedis.hkeys(redisMapKey);
for(String str:afterDelKeys){//输出删除操作后map中的所有key值
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
jedis.close();
}
}
/**
*
* 测试redis中的list
* */
public void testLst(){
/*获得一个jedis链接实例*/
Jedis jedis = jedisPool.getResource();
try {
/*选择数据库13*/
jedis.select(13);
/*向test_lst所对应的list中插入123和223两个值 (可以一直往后写,因为采用的是。。。的传参方式)
* 与lpush对应的还有rpush
* lpush从左端插入元素,配合lpop就形成了栈,配合rpop就是队列
* rpush从右侧插入元素,配合rpop就形成了栈,配合lpup就是队列
*
* */
jedis.lpush("test_lst", "123","223");
/*获得test_lst中所有的值(从0开始,到-1结束就是所有的值;也可任意设置开始和结束下标)*/
List<String> lrange = jedis.lrange("test_lst", 0, -1);
System.out.println("before pop:");
/*输出test_lst的长度*/
System.out.println("list's length is: " + jedis.llen("test_lst"));
for(String str:lrange){
System.out.println(str);
}
/*向test_lst中下标为0的位置插入一个setted_value*/
jedis.lset("test_lst", 0, "setted_value");
/*从test_lst的右端弹出一个值(也有从左端弹出的为lpop),这个值会从lst中移除*/
/*如果我们一直在下标为0的位置插入元素,然后使用rpop,那么我们模拟的就是队列,先进先出
* 如果使用lpop,那么模拟的就是栈,后劲先出
* */
String rpop = jedis.rpop("test_lst");
System.out.println("rpoped value is : "+rpop);
lrange = jedis.lrange("test_lst", 0, -1);
System.out.println("after pop:");
for(String str:lrange){//输出pop操作后的test_lst中的值
System.out.println(str);
}
System.out.println("after trim");
/*对test_lst进行裁剪,指定了裁剪的开始位置和结束位置。裁剪之后test_lst只包含[开始位置,结束位置]区间的值*/
jedis.ltrim("test_lst", 0, 3);
lrange = jedis.lrange("test_lst", 0, -1);
for(String str:lrange){//输出裁剪结果
System.out.println(str);
}
/*从test_lst中移除值为setted_value的第二个值 如果把2换成0,那么所有的setted_value都会被移除*/
jedis.lrem("test_lst", 2, "setted_value");
System.out.println("after removed:");
lrange = jedis.lrange("test_lst", 0, -1);
for(String str:lrange){//输出移除后的test_lst的所有值
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
jedis.close();
}
}
/**
*
* 测试redis中的set
* */
public void testSet(){
Jedis jedis = jedisPool.getResource();//获得jedis链接实例
/*两个set 一个叫test_set 一个叫 test_set_two*/
String redisSetKey="test_set";
String redisSetKeyTwo="test_set_two";
try {
/*选择数据库13,并删除两个set*/
jedis.select(13);
jedis.del(redisSetKey);
jedis.del(redisSetKeyTwo);
System.out.println("test set's add:------------------------");
/*向redisSetKey中添加元素,这里添加了1~6供六个元素*/
jedis.sadd(redisSetKey, "1","2","3","4","5","6");
/*向redisSetKeyTwo中添加 2 4 6 8 10 这五个元素*/
jedis.sadd(redisSetKeyTwo, "2","4","6","8","10");
System.out.println("test get all memebers of a set:-----------");
/*获得set中的所有值,返回一个set*/
Set<String> smembers = jedis.smembers(redisSetKey);
for(String str:smembers){//遍历输出set中的值
System.out.println(str);
}
System.out.println("test if a member exits in the set:-------------");
/*分别判断1 和 7 是否属于redisSetKey所指向的set中*/
Boolean sismember = jedis.sismember(redisSetKey, "1");
Boolean sismember2 = jedis.sismember(redisSetKey, "7");
System.out.println("1 in set is:" +sismember+",7 in set is: "+sismember2);
System.out.println("test del set's memeber:-------------------------");
/*删除redisSetKey所指向的set中1这个值(set和list不同,所有的值都是唯一的,所以不存在指定要删除的个数一说)*/
jedis.srem(redisSetKey, "1");
System.out.println("after del:");
Set<String> smembers1 = jedis.smembers(redisSetKey);
for(String str:smembers1){//检验是否成功删除
System.out.println(str);
}
System.out.println("test set's pop:--------------------");
/*随机从redisSetKey所指向的set中取出一个值(在set中删除并返回)*/
String spop = jedis.spop(redisSetKey);
System.out.println("poped value is :"+spop);
System.out.println("after pop :");
Set<String> smembers2 = jedis.smembers(redisSetKey);
for(String str:smembers2){//检验弹出后的set
System.out.println(str);
}
System.out.println("test set's random:---------------------");
/*随机从redisSetKey所指向的set中返回一个值(不在set中删除仅返回)*/
String srandmember = jedis.srandmember(redisSetKey);
System.out.println("random value is :"+srandmember);
System.out.println("after random:");
Set<String> smembers3 = jedis.smembers(redisSetKey);
for(String str:smembers3){//检验random之后set中是否少了值(检验结果是没有少)
System.out.println(str);
}
System.out.println("test set's diff:-------------------");
/*求一个新的set,这set中包含在redisSetKey中出现但不再redisSetKeyTwo中出现的所有元素(即 redisSetKey-redisSetKeyTwo)*/
Set<String> sdiff = jedis.sdiff(redisSetKey,redisSetKeyTwo);
for(String str:sdiff){
System.out.println(str);
}
System.out.println("test set's inter:-------------------------");
/*求一个新的set,这set中包含在redisSetKey中出现且在redisSetKeyTwo中出现的所有元素*/
Set<String> sinter = jedis.sinter(redisSetKey,redisSetKeyTwo);
for(String str:sinter){
System.out.println(str);
}
System.out.println("test set's unino:-----------------------");
/*求一个新的set,这set中包含在redisSetKey中出现或在redisSetKeyTwo中出现的所有元素*/
Set<String> sunion = jedis.sunion(redisSetKey,redisSetKeyTwo);
for(String str:sunion){
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
jedis.close();
}
}
/**
*
* 测试有序的set
* */
public void testSortSet(){
/*获得redis链接实例*/
Jedis jedis = jedisPool.getResource();
/*有序的set的key,用来在redis中唯一标识一个有序的set 这里起名为 test_sort*/
String redisSortedKey="test_sort";
try {
/*选用数据库13,并删除以前的test_sort所指向的value*/
jedis.select(13);
jedis.del(redisSortedKey);
/*向有序set中插入zero,three,two,one,four这几个单词,
* 它们前面的0,3,2,1,4代表他们的分数(score),在有序set中就是根据这个分数进行排序的
* */
jedis.zadd(redisSortedKey, 0, "zero");
jedis.zadd(redisSortedKey, 3, "three");
jedis.zadd(redisSortedKey, 2, "two");
jedis.zadd(redisSortedKey, 1, "one");
jedis.zadd(redisSortedKey, 4, "four");
System.out.println("get the total number:----------------");
/*获得数据的总数*/
Long zcard = jedis.zcard(redisSortedKey);
System.out.println(zcard);
System.out.println("count the value between min-value and max-value:-----------------");
/*统计分数在0到2之间的数据的个数,也就是score在[0,2]闭区间上的数据的个数*/
Long zcount = jedis.zcount(redisSortedKey, 0, 2);
System.out.println(zcount);
System.out.println("test range:----------------------------");
/*获得从开始下标到结束下标的排好序的set中的值(结束为-1,标识全部),同样也是闭区间*/
Set<String> zrange = jedis.zrange(redisSortedKey, 0,-1);
for(String str:zrange){
System.out.println(str);
}
System.out.println("test rverse range:----------------------------");
/*反序 获得从开始下标到结束下标的排好序的set中的值(结束为-1,标识全部),同样也是闭区间*/
Set<String> zrevrange = jedis.zrevrange(redisSortedKey, 0, -1);
for(String str:zrevrange){
System.out.println(str);
}
System.out.println("test range by score:---------------------");
/*获得两个分数之间的排好序的set中的值 同样也是闭区间*/
Set<String> zrangeByScore = jedis.zrangeByScore(redisSortedKey, 2, 3);
for(String str:zrangeByScore){
System.out.println(str);
}
System.out.println("test range with scores:---------------------");
/*获得从开始下标到结束下标的排好序的set中的值(结束为-1,标识全部),同样也是闭区间 不同的是返回值中包含了值所对应的分数*/
Set<Tuple> zrangeWithScores = jedis.zrangeWithScores(redisSortedKey, 0, -1);
for(Tuple tuple:zrangeWithScores){//tuple中封装了element和score对应与元素和分数
System.out.println(tuple.getElement()+"------"+tuple.getScore());
}
System.out.println("test rank:---------------");
/*获得某个元素在有序set中的排名(也就是排序位置)*/
Long zrank = jedis.zrank(redisSortedKey, "three");
System.out.println("the rank of three is :"+zrank);
System.out.println("test rem:-----------------------------");
/*删除某个元素*/
jedis.zrem(redisSortedKey, "three");
Set<String> zrange1 = jedis.zrange(redisSortedKey, 0,-1);
for(String str:zrange1){
System.out.println(str);
}
System.out.println("test reverse rank:------------------------");
/*获得某个元素的倒序排名*/
Long zrevrank = jedis.zrevrank(redisSortedKey, "four");
System.out.println(zrevrank);
System.out.println("test get score:----------------------------------------");
/*获得某个元素所对应的分数*/
Double zscore = jedis.zscore(redisSortedKey, "two");
System.out.println("two's zscore is: "+zscore);
} catch (Exception e) {
}finally{
jedis.close();
}
}
public static void main(String[] args) {
RedisTest test = new RedisTest();
test.init();
test.testSortSet();
}
}
REDIS提供的map,list,set,sortedset使用测试
最新推荐文章于 2024-08-16 23:59:24 发布