一、相关常用命令、及常用方法
1)连接操作命令
quit:关闭连接(connection)
auth:简单密码认证
help cmd: 查看cmd帮助,例如:help quit
2)持久化
save:将数据同步保存到磁盘
bgsave:将数据异步保存到磁盘
lastsave:返回上次成功将数据保存到磁盘的Unix时戳
shundown:将数据同步保存到磁盘,然后关闭服务
3)远程服务控制
info:提供服务器的信息和统计
monitor:实时转储收到的请求
slaveof:改变复制策略设置
config:在运行时配置Redis服务器
4)对value操作的命令
exists(key):确认一个key是否存在
del(key):删除一个key
type(key):返回值的类型
keys(pattern):返回满足给定pattern的所有key
randomkey:随机返回key空间的一个
keyrename(oldname, newname):重命名key
dbsize:返回当前数据库中key的数目
expire:设定一个key的活动时间(s)
ttl:获得一个key的活动时间
select(index):按索引查询
move(key, dbindex):移动当前数据库中的key到dbindex数据库
flushdb:删除当前选择数据库中的所有key
flushall:删除所有数据库中的所有key
5)String
set(key, value):给数据库中名称为key的string赋予值value
get(key):返回数据库中名称为key的string的value
getset(key, value):给名称为key的string赋予上一次的value
mget(key1, key2,…, key N):返回库中多个string的value
setnx(key, value):添加string,名称为key,值为value
setex(key, time, value):向库中添加string,设定过期时间time
mset(key N, value N):批量设置多个string的值
msetnx(key N, value N):如果所有名称为key i的string都不存在
incr(key):名称为key的string增1操作
incrby(key, integer):名称为key的string增加integer
decr(key):名称为key的string减1操作
decrby(key, integer):名称为key的string减少integer
append(key, value):名称为key的string的值附加value
substr(key, start, end):返回名称为key的string的value的子串
6)List
rpush(key, value):在名称为key的list尾添加一个值为value的元素
lpush(key, value):在名称为key的list头添加一个值为value的 元素
llen(key):返回名称为key的list的长度
lrange(key, start, end):返回名称为key的list中start至end之间的元素
ltrim(key, start, end):截取名称为key的list
lindex(key, index):返回名称为key的list中index位置的元素
lset(key, index, value):给名称为key的list中index位置的元素赋值
lrem(key, count, value):删除count个key的list中值为value的元素
lpop(key):返回并删除名称为key的list中的首元素
rpop(key):返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout):lpop命令的block版本。
brpop(key1, key2,… key N, timeout):rpop的block版本。
rpoplpush(srckey, dstkey):返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部
7)Set
sadd(key, member):向名称为key的set中添加元素member
srem(key, member) :删除名称为key的set中的元素member
spop(key) :随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member) :移到集合元素
scard(key) :返回名称为key的set的基数
sismember(key, member) :member是否是名称为key的set的元素
sinter(key1, key2,…key N) :求交集
sinterstore(dstkey, (keys)) :求交集并将交集保存到dstkey的集合
sunion(key1, (keys)) :求并集
sunionstore(dstkey, (keys)) :求并集并将并集保存到dstkey的集合
sdiff(key1, (keys)) :求差集
sdiffstore(dstkey, (keys)) :求差集并将差集保存到dstkey的集合
smembers(key) :返回名称为key的set的所有元素
srandmember(key) :随机返回名称为key的set的一个元素
8)Hash
hset(key, field, value):向名称为key的hash中添加元素field
hget(key, field):返回名称为key的hash中field对应的value
hmget(key, (fields)):返回名称为key的hash中field i对应的value
hmset(key, (fields)):向名称为key的hash中添加元素field
hincrby(key, field, integer):将名称为key的hash中field的value增加integer
hexists(key, field):名称为key的hash中是否存在键为field的域
hdel(key, field):删除名称为key的hash中键为field的域
hlen(key):返回名称为key的hash中元素个数
hkeys(key):返回名称为key的hash中所有键
hvals(key):返回名称为key的hash中所有键对应的value
hgetall(key):返回名称为key的hash中所有的键(field)及其对应的value
二、Java中操作Redis常用方法测试记录
(1) Java操作Redis所需要的jar包:jedis.jar;commons-pool2.jar;
(2) 创建项目连接Redis所需要的Java工具类:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
/**
* Redis操作工具类,提供获取Jedis(非切片的客户端连接)和ShardedJedis(切片的客户端连接)
* @author
*/
public class RedisUtils {
// private Jedis jedis; //非切片的客户端连接
private static JedisPool jedisPool; //非切片连接池
// private ShardedJedis shardedJedis; //切片的客户端连接
private static ShardedJedisPool shardedJedisPool; //切片连接池
static{
JedisPoolConfig config = new JedisPoolConfig(); //初始化非切片连接池
config.setBlockWhenExhausted(true); //连接超时时是否阻塞,false时报异常,ture阻塞直到超时, 默认true
config.setMaxTotal(20); //最大连接数, 默认8个
config.setMaxIdle(5); //最大空闲连接数, 默认8个
//获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
config.setMaxWaitMillis(10001);
config.setTestOnBorrow(false); //对拿到的connection进行validateObject校验
//逐出策略(默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数))
config.setEvictionPolicyClassName("org.apache.commons.pool2.impl.DefaultEvictionPolicy");
config.setMinEvictableIdleTimeMillis(1800000); //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
config.setMinIdle(0); //最小空闲连接数, 默认0
//每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
config.setNumTestsPerEvictionRun(3);
//对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
config.setSoftMinEvictableIdleTimeMillis(1800000);
config.setTestOnReturn(true); //在进行returnObject对返回的connection进行validateObject校验
//定时对线程池中空闲的链接进行validateObject校验
config.setTestWhileIdle(true);
//逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
config.setTimeBetweenEvictionRunsMillis(-1);
jedisPool = new JedisPool(config, "127.0.0.1", 6379); //127.0.0.1 ---> Redis服务地址; 6397 ---> 服务端口号
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo("127.0.0.1", 6379, "master"));
shardedJedisPool = new ShardedJedisPool(config, shards); //构造池
}
/**
* 获取非切片的客户端连接的方法
* @return
*/
public static Jedis getJedis(){
Jedis jedis = jedisPool.getResource();
return jedis;
}
/**
* 获取切片连接池的方法
* @return
*/
public static ShardedJedis getShardedJedis(){
ShardedJedis shardedJedis = shardedJedisPool.getResource();
return shardedJedis;
}
/**
* 遍历Set<String>集合
* @param setStr
*/
public static void iteratorResult(Set<String> setStr){
Iterator<String> iterator = setStr.iterator();
while(iterator.hasNext()){
System.out.print("key="+iterator.next()+"\t");
}
}
/**
* 遍历Set<String>集合
* @param setObj
* @param jedis
*/
public static void iteratorResultValue(Set<String> setObj, Jedis jedis){
Iterator<String> iterator = setObj.iterator();
while(iterator.hasNext()){
String key = iterator.next();
System.out.println("key="+key+"\t"+"value="+jedis.get(key));
}
}
}
(3) 创建测试所需的测试类以及主方法:
import com.sztxtech.testjavaconnredis.dao.RedisOperator;
public class TestJavaConnectionRedisMain {
public static void main(String[] args) {
RedisOperator operator = new RedisOperator();
operator.flushDatabase();
operator.keyOperate();
operator.stringOperatorMehodOne();
operator.stringOperatorMehodTwo();
operator.listOperator();
operator.setOperator();
operator.sortedSetOperator();
operator.hashOperator();
}
}
(4) 创建对Redis进行具体操作的类,对各种类型数据、相关方法进行具体测试:
import java.util.Iterator;
import java.util.Set;
import com.sztxtech.testjavaconnredis.utils.RedisUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.SortingParams;
/**
* Redis操作类
* @author
*/
public class RedisOperator {
/**
* 清空数据库中所有数据
*/
public void flushDatabase() {
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("清空数据库中所有数据:" + jedis.flushDB());
jedis.close();
shardedJedis.close();
}
/**
* 清空数据库中所有数据
* @param jedis
*/
public void flushDatabase(Jedis jedis) {
System.out.println("清空数据库中所有数据:" + jedis.flushDB());
}
public void keyOperate() {
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("===============================keyOperator is beginning ..........");
System.out.println("一、向redis中新增加键值对 ...... ");
System.out.println("增加键值对key=Tel; value=15802993040 " + shardedJedis.set("Tel", "15802993040"));
System.out.println("增加键值对key=username; value=Gavin Li " + shardedJedis.set("username", "Gavin Li"));
System.out.println("增加键值对key=password; value=Lg123123 " + shardedJedis.set("password", "Lg123123"));
// 查出Redis中所有的key
System.out.println("遍历Redis中所有的key:");
Set<String> keysOne = jedis.keys("*");
RedisUtils.iteratorResult(keysOne);
System.out.println();System.out.println();
System.out.println("二、调用非切片客户端的jedis.flushDB()方法,对redis中数据进行清空 ......");
flushDatabase(jedis);
System.out.println("向Redis中新增加键值对: key=1001、 value=VALUE1001; "+shardedJedis.set("1001", "VALUE1001"));
System.out.println("###########清空后的再次进行判断");
// 判断key是否存在
System.out.println("判断key=username的键是否存在:" + shardedJedis.exists("username"));
System.out.println("判断key=password的键是否存在:" + shardedJedis.exists("password"));
System.out.println("判断key=001的键是否存在:" + shardedJedis.exists("1001"));
// 查出Redis中所有的key
System.out.println("遍历Redis中所有的key:");
Set<String> keysTwo = jedis.keys("*");
RedisUtils.iteratorResult(keysTwo);
System.out.println();System.out.println();
System.out.println("三、删除指定的key,若不存在则数据没有任何影响 ......");
System.out.println("删除系统中key=1001的键:" + jedis.del("1001"));
System.out.println("遍历Redis中所有的key:");
Set<String> keysThree = jedis.keys("*");
RedisUtils.iteratorResult(keysThree);
System.out.println();System.out.println();
System.out.println("四、为指定key设置过期时间,并模拟超时查询 ......");
System.out.println("增加键值对key=Tel; value=15802993040 " + shardedJedis.set("Tel", "15802993040"));
System.out.println("增加键值对key=username; value=Hellen Tong " + shardedJedis.set("username", "Hellen Tong"));
System.out.println("增加键值对key=password; value=Ht123123 " + shardedJedis.set("password", "Ht123123"));
System.out.println("为以上新增username设置过期时间为5秒:"+jedis.expire("username", 5));
System.out.println("为以上新增password设置过期时间为8秒:"+jedis.expire("password", 8));
System.out.println("查询新增username:"+shardedJedis.get("username"));
try {
System.out.println("模拟超时中....");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("超时结束,再次查询新增username:"+shardedJedis.get("username"));
System.out.println("查看key:password的剩余生存时间:"+jedis.ttl("password"));
if(jedis.ttl("password")>=3){
System.out.println("key:password还未过期,移除其生存时间:"+jedis.persist("password"));
}
System.out.println("遍历Redis中所有的key:");
Set<String> keysFour = jedis.keys("*");
RedisUtils.iteratorResult(keysFour);
System.out.println();System.out.println();
System.out.println("五、查看key所对应value的类型 ....... ");
System.out.println("password类型:"+jedis.type("password"));
System.out.println("Tel类型:"+jedis.type("Tel"));
System.out.println("===============================keyOperator is ended ..........");
}
public void stringOperatorMehodOne(){
Jedis jedis = RedisUtils.getJedis();
// ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("===============================stringOperatorOne is beginning ..........");
flushDatabase(jedis);
System.out.println();
System.out.println("*****************增加数据*****************");
jedis.set("keyOne", "value1001");
jedis.set("keyTwo", "value1002");
jedis.set("keyThree", "value1003");
jedis.set("keyFour", "value1004");
jedis.set("userId", "1001");
jedis.set("username", "Jerry Lin");
jedis.set("password", "Lj123123");
jedis.set("telephone", "15623066132");
System.out.print("已向Redis新增加的值为:"+jedis.get("userId")+"\t"+jedis.get("username")+"\t"+jedis.get("password")+"\t"+jedis.get("telephone"));
System.out.println();
System.out.println("遍历当前系统中所有key:");
Set<String> setFive = jedis.keys("*");
RedisUtils.iteratorResult(setFive);
System.out.println();System.out.println();
System.out.println("*****************删除数据*****************");
System.out.println("删除Redis中key=keyFour的键值对:"+jedis.del("keyFour"));
System.out.println("查询Redis中key=keyFour的键值对:"+jedis.get("keyFour"));
System.out.println("遍历当前系统中所有key:");
Set<String> setSix = jedis.keys("*");
RedisUtils.iteratorResult(setSix);
System.out.println();System.out.println();
System.out.println("*****************修改数据*****************");
System.out.println("1. 直接覆盖原有value值:"+jedis.set("password", "321321Lj"));
System.out.println("查询当前key:password对应的value值:"+jedis.get("password"));
System.out.println("2. 在原有数据后面追加数据:"+jedis.append("password", "__appendMethod"));
System.out.println("查询当前key:password对应的value值:"+jedis.get("password"));
System.out.println();System.out.println();
System.out.println("*****************批量增、删、修改键值对数据*****************");
// flushDatabase(jedis);
System.out.println("新增用户:userId=1002, username=Jack Zhao, password=jz123123, telephone=15830219576");
jedis.mset("userId","1002", "username","Jack Zhao", "password","jz123123", "telephone","15830219576");
System.out.println("遍历当前系统中所有key:");
Set<String> setSeven = jedis.keys("*");
RedisUtils.iteratorResultValue(setSeven, jedis);
System.out.println("一次性获取keyOne、keyTwo、keyThree、username所对应的value值:");
System.out.println(jedis.mget("keyOne", "keyTwo", "keyThree", "username"));
System.out.println("一次性删除keyTwo、keyThree:");
System.out.println(jedis.del(new String[]{"keyTwo", "keyThree"}));
System.out.println("遍历当前系统中所有key:");
Set<String> setEighth = jedis.keys("*");
RedisUtils.iteratorResultValue(setEighth, jedis);
jedis.close();
System.out.println();
System.out.println("===============================stringOperatorOne is ended ..........");
}
public void stringOperatorMehodTwo(){
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("===============================stringOperatorOne is beginning ..........");
flushDatabase(jedis);
jedis.set("keyTwo", "第二个键所对应的值");
System.out.println("*****************新增加键值对时,防止覆盖原有值*****************");
System.out.println("原先没有keyOne时,新增keyOne:"+jedis.setnx("keyOne", "value__One"));
System.out.println("原先没有keyTwo时,新增keyTwo:"+jedis.setnx("keyTwo", "value__Two"));
System.out.println("原先没有keyThree时,新增keyThree:"+jedis.setnx("keyThree", "value__Three"));
System.out.println("遍历当前系统中所有key:");
Set<String> setEighth = jedis.keys("*");
RedisUtils.iteratorResultValue(setEighth, jedis);
System.out.println("*****************设置指定key的键值对,在超过指定时间后,自动删除*****************");
System.out.println("新增加keyFour,设置该键值对在5秒后自动删除:");
System.out.println(shardedJedis.setex("keyFour", 5, "五秒后会删除的键值对"));
int i=1;
while(i<7){
try {
System.out.println("keyFour的值:"+jedis.get("keyFour")+"\t"+i+"秒 ...");
i++;
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("*****************获取key对应的原有value值和将其更改为另一个值,一步完成*****************");
System.out.println("keyTwo的原始值为:"+jedis.getSet("keyTwo", "new_value_Two"));
System.out.println("keyTwo对应value更新后的值为:"+jedis.get("keyTwo"));
jedis.close();
shardedJedis.close();
System.out.println("===============================stringOperatorOne is ended ..........");
}
/**
* 对List集合数据的处理
*/
public void listOperator(){
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("===============================listOperator is beginning ..........");
flushDatabase(jedis);
System.out.println();
System.out.println("*****************增加list集合元素*****************");
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "arrayList");
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "map");
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "hashMap");
shardedJedis.lpush("list_number", "105");
shardedJedis.lpush("list_number", "268");
shardedJedis.lpush("list_number", "690");
shardedJedis.lpush("list_number", "325");
shardedJedis.lpush("list_number", "369");
shardedJedis.lpush("list_number", "258");
shardedJedis.lpush("list_number", "741");
shardedJedis.lpush("list_number", "159");
shardedJedis.lpush("list_number", "357");
shardedJedis.lpush("list_cnames", "张三");
shardedJedis.lpush("list_cnames", "李四");
shardedJedis.lpush("list_cnames", "王五");
shardedJedis.lpush("list_cnames", "马六");
System.out.println("*****************查询每个list集合所包含的元素*****************");
System.out.println("所有list_string:"+shardedJedis.lrange("list_string", 0, -1));
System.out.println("所有list_number:"+shardedJedis.lrange("list_number", 0, -1));
System.out.println("所有list_cnames:"+shardedJedis.lrange("list_cnames", 0, -1));
/**
* 删除指定list集合中、指定个数的某个元素,
* 并返回删除成功元素个数,
* 且,最先add进入的元素,先被删除掉。类似于出栈
*/
System.out.println();
System.out.println("*****************查询每个list集合所包含的元素*****************");
System.out.println("删除指定list集合中、指定个数的某个元素,并返回删除成功元素个数:");
System.out.println("删除指定list集合中"+shardedJedis.lrem("list_string", 3, "arrayList"));//删除list_string集合中3个arrayList
System.out.println("删除指定list集合中"+shardedJedis.lrem("list_string", 1, "map")); //删除list_string集合中1个map
System.out.println("删除指定list集合中"+shardedJedis.lrem("list_string", 2, "vector")); //删除list_string集合中2个vector
System.out.println("key=list_string的集合:"+shardedJedis.lrange("list_string", 0, -1));
System.out.println("key=list_number的集合:"+shardedJedis.lrange("list_number", 0, -1));
System.out.println("key=list_cnames的集合:"+shardedJedis.lrange("list_cnames", 0, -1));
System.out.println();
System.out.println("*****************删除指定下标区域之外的元素*****************");
System.out.println("删除key:list_number的集合中,下标在6至8之外的所有元素:"+shardedJedis.ltrim("list_number", 4, 8));
System.out.println("key=list_number的集合:"+shardedJedis.lrange("list_number", 0, -1));
System.out.println();
System.out.println("*****************获取指定key的value集合的出栈元素*****************");
System.out.println("key=list_cnames集合:"+shardedJedis.lpop("list_cnames"));
System.out.println("key=list_string集合:"+shardedJedis.lpop("list_string"));
System.out.println("key=list_number集合:"+shardedJedis.lpop("list_number"));
System.out.println("key=list_string的集合:"+shardedJedis.lrange("list_string", 0, -1));
System.out.println("key=list_number的集合:"+shardedJedis.lrange("list_number", 0, -1));
System.out.println("key=list_cnames的集合:"+shardedJedis.lrange("list_cnames", 0, -1));
System.out.println();
System.out.println("*****************修改指定的key对应value中指定下标的元素值*****************");
System.out.println(shardedJedis.lset("list_cnames", 1, "Li Si"));
System.out.println("key=list_cnames的集合:"+shardedJedis.lrange("list_cnames", 0, -1));
System.out.println();
System.out.println("*****************查询指定的key对应value的长度*****************");
System.out.println("key=list_string对应value的长度:"+shardedJedis.llen("list_string"));
System.out.println("key=list_cnames对应value的长度:"+shardedJedis.llen("list_cnames"));
System.out.println();
System.out.println("*****************对指定的key对应value所包含的元素进行排序*****************");
flushDatabase(jedis);
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "arrayList");
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "map");
shardedJedis.lpush("list_string", "vector");
shardedJedis.lpush("list_string", "hashMap");
shardedJedis.lpush("list_number", "105");
shardedJedis.lpush("list_number", "268");
shardedJedis.lpush("list_number", "690");
shardedJedis.lpush("list_number", "325");
shardedJedis.lpush("list_number", "369");
shardedJedis.lpush("list_number", "258");
shardedJedis.lpush("list_number", "741");
shardedJedis.lpush("list_number", "159");
shardedJedis.lpush("list_number", "357");
shardedJedis.lpush("list_cnames", "张三");
shardedJedis.lpush("list_cnames", "李四");
shardedJedis.lpush("list_cnames", "王五");
shardedJedis.lpush("list_cnames", "马六");
System.out.println("排序前的初始值:");
System.out.println("key=list_string的集合:"+shardedJedis.lrange("list_string", 0, -1));
System.out.println("key=list_number的集合:"+shardedJedis.lrange("list_number", 0, -1));
System.out.println("key=list_cnames的集合:"+shardedJedis.lrange("list_cnames", 0, -1));
/**
* 排序:list中存字符串时,必须指定参数为alpha,如果不使用SortingParams,
* 而直接使用sort("list"),则会出现"ERR One or more scores can't be converted into double"
*/
SortingParams params = new SortingParams();
params.alpha();
params.limit(0, 13); //0为排序起始下标,4为排序元素个数
System.out.println("对key=list_number对应的value进行排序后的结果为:"+shardedJedis.sort("list_number", params));
System.out.println("对key=list_string对应的value进行排序后的结果为:"+shardedJedis.sort("list_string", params));
System.out.println("对key=list_cnames对应的value进行排序后的结果为:"+shardedJedis.sort("list_cnames", params));
System.out.println();
System.out.println("*****************获取指定key对应value集合中指定下标的元素的值*****************");
System.out.println("获取key=list_number对应value中下标为5的元素的值:"+shardedJedis.lindex("list_number", 5));
System.out.println("获取key=list_string对应value中下标为4的元素的值:"+shardedJedis.lindex("list_string", 4));
System.out.println("获取key=list_cnames对应value中下标为3的元素的值:"+shardedJedis.lindex("list_cnames", 3));
jedis.close();
shardedJedis.close();
System.out.println("===============================listOperator is ended ..........");
}
/**
* 对Set集合数据的处理
*/
public void setOperator(){
System.out.println("===============================setOperator is ended ..........");
Jedis jedis = RedisUtils.getJedis();
// ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("清空库中所有数据: "+jedis.flushDB());
System.out.println();
System.out.println("**********************************增加set集合元素**********************************");
System.out.println("向sets集合中添加set元素: element_001;返回结果为:" + jedis.sadd("sets", "element_001"));
System.out.println("向sets集合中添加set元素: element_002;返回结果为:" + jedis.sadd("sets", "element_002"));
System.out.println("向sets集合中添加set元素: element_003;返回结果为:" + jedis.sadd("sets", "element_003"));
System.out.println("向sets集合中添加set元素: element_004;返回结果为:" + jedis.sadd("sets", "element_004"));
System.out.println("向sets集合中添加set元素: element_005;返回结果为:" + jedis.sadd("sets", "element_005"));
System.out.println("向sets集合中添加set元素: element_006;返回结果为:" + jedis.sadd("sets", "element_006"));
System.out.println("向sets集合中添加set元素: element_007;返回结果为:" + jedis.sadd("sets", "element_007"));
System.out.println("向sets集合中添加set元素: element_008;返回结果为:" + jedis.sadd("sets", "element_008"));
System.out.println("向sets集合中添加set元素: element_009;返回结果为:" + jedis.sadd("sets", "element_009"));
System.out.println();
System.out.println("**********************************查看set集合元素**********************************");
System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));
System.out.println("判断value: element_100是否存在于sets集合中:"+jedis.sismember("sets", "element_100"));
System.out.println("判断value: element_001是否存在于sets集合中:"+jedis.sismember("sets", "element_001"));
System.out.println("循环遍历sets集合中的每个元素:");
Set<String> setVal = jedis.smembers("sets");
Iterator<String> iterator = setVal.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
System.out.print(obj+"\t");
}
System.out.println();System.out.println();
System.out.println("**********************************删除set集合元素**********************************");
System.out.println("删除sets中value值为: element_009的元素;返回结果为:"+jedis.srem("sets", "element_009"));
System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));
System.out.println();
System.out.println("**********************************set集合运算**********************************");
System.out.println("向setsNames集合中添加Jack;返回结果为:"+jedis.sadd("setsNames", "Jack"));
System.out.println("向setsNames集合中添加Jerry;返回结果为:"+jedis.sadd("setsNames", "Jerry"));
System.out.println("向setsNames集合中添加Hellen;返回结果为:"+jedis.sadd("setsNames", "Hellen"));
System.out.println("向setsNames集合中添加Gavin;返回结果为:"+jedis.sadd("setsNames", "Gavin"));
System.out.println("向setsNames集合中添加Elics;返回结果为:"+jedis.sadd("setsNames", "Elics"));
System.out.println("向setsNames集合中添加Caball;返回结果为:"+jedis.sadd("setsNames", "Caball"));
System.out.println();
System.out.println("向setsEmps集合中添加Gavin;返回结果为:"+jedis.sadd("setsEmps", "Gavin"));
System.out.println("向setsEmps集合中添加Elics;返回结果为:"+jedis.sadd("setsEmps", "Elics"));
System.out.println("向setsEmps集合中添加Caball;返回结果为:"+jedis.sadd("setsEmps", "Caball"));
System.out.println("向setsEmps集合中添加Caball;返回结果为:"+jedis.sadd("setsEmps", "Even"));
System.out.println();
System.out.println("查看setsNames集合中所有元素:"+jedis.smembers("setsNames"));
System.out.println("查看setsEmps集合中所有元素:"+jedis.smembers("setsEmps"));
System.out.println();
System.out.println("查看setsNames集合与setsEmps集合的-->交集:"+jedis.sinter("setsNames", "setsEmps"));
System.out.println("查看setsNames集合与setsEmps集合的-->并集:"+jedis.sunion("setsNames", "setsEmps"));
System.out.println("查看setsNames集合与setsEmps集合的-->差集:"+jedis.sdiff("setsNames", "setsEmps")+" ------> setsNames集合中有,但setsEmps中没有的元素");
System.out.println("查看setsEmps集合与setsNames集合的-->差集:"+jedis.sdiff("setsEmps", "setsNames")+" ------> setsEmps集合中有,但setsNames中没有的元素");
System.out.println("===============================setOperator is ended ..........");
}
/**
* 对有序集合--SortedSet中数据的处理
*/
public void sortedSetOperator(){
System.out.println("===============================setOperator is beginning ..........");
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("清空库中所有数据: "+jedis.flushDB());
System.out.println();
System.out.println("**********************************增加SortedSet集合元素**********************************");
System.out.println("向zset集合中添加元素: element_001;返回结果为:" + shardedJedis.zadd("zset", 2.0, "element_001")); //第二个参数为权重值
System.out.println("向zset集合中添加元素: element_002;返回结果为:" + shardedJedis.zadd("zset", 4.0, "element_002"));
System.out.println("向zset集合中添加元素: element_003;返回结果为:" + shardedJedis.zadd("zset", 6.0, "element_003"));
System.out.println("向zset集合中添加元素: element_004;返回结果为:" + shardedJedis.zadd("zset", 9.0,"element_004"));
System.out.println("向zset集合中添加元素: element_005;返回结果为:" + shardedJedis.zadd("zset", 1.0, "element_005"));
System.out.println("向zset集合中添加元素: element_006;返回结果为:" + shardedJedis.zadd("zset", 3.0, "element_006"));
System.out.println("向zset集合中添加元素: element_007;返回结果为:" + shardedJedis.zadd("zset", 5.0, "element_007"));
System.out.println("向zset集合中添加元素: element_008;返回结果为:" + shardedJedis.zadd("zset", 7.0, "element_008"));
System.out.println("向zset集合中添加元素: element_009;返回结果为:" + shardedJedis.zadd("zset", 8.0, "element_009"));
System.out.println();
System.out.println("**********************************查看SortedSet集合元素**********************************");
System.out.println("查看SortedSet集合中的所有元素:"+shardedJedis.zrange("zset", 0, -1)); //按照权重值排序
System.out.println("统计zset集合中的元素个数:"+shardedJedis.zcard("zset"));
System.out.println("统计zset集合中权重某个范围内(1.0 ~ 6.0)的元素个数:"+shardedJedis.zcount("zset", 1.0, 6.0));
System.out.println();
System.out.println("**********************************删除SortedSet集合元素**********************************");
System.out.println("删除zset中value值为: element_009的元素;返回结果为:"+shardedJedis.zrem("zset", "element_009"));
System.out.println("统计zset集合中的元素个数:"+shardedJedis.zcard("zset"));
System.out.println("查看SortedSet集合中的所有元素:"+shardedJedis.zrange("zset", 0, -1));
System.out.println("查看zset集合中值为element_003的元素的权重值:"+shardedJedis.zscore("zset", "element_003"));
System.out.println("查看zset集合中,下标在1 ~ 6范围之内的元素的值: " + shardedJedis.zrange("zset", 1, 6));
System.out.println("===============================setOperator is ended ..........");
}
/**
* 对Hash集合数据的处理
*/
public void hashOperator(){
System.out.println("===============================hashOperator is beginning ..........");
Jedis jedis = RedisUtils.getJedis();
ShardedJedis shardedJedis = RedisUtils.getShardedJedis();
System.out.println("清空库中所有数据: "+jedis.flushDB());
System.out.println();
System.out.println("**********************************增加hashs集合元素**********************************");
System.out.println("向hashs集合中添加key=key01、value=value_001的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key01", "value_001"));
System.out.println("向hashs集合中添加key=key02、value=value_002的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key02", "value_002"));
System.out.println("向hashs集合中添加key=key03、value=value_003的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key03", "value_003"));
System.out.println("向hashs集合中添加key=key04、value=value_004的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key04", "value_004"));
System.out.println("向hashs集合中添加key=key05、value=value_005的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key05", "value_005"));
System.out.println("向hashs集合中添加key=key06、value=value_006的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key06", "value_006"));
System.out.println("向hashs集合中添加key=key07、value=value_007的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key07", "value_007"));
System.out.println("向hashs集合中添加key=key08、value=value_008的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key08", "value_008"));
System.out.println("向hashs集合中添加key=key09、value=88的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key09", "88"));
System.out.println("向hashs集合中添加key=key10、value=66的键值对; 返回结果为:"+shardedJedis.hset("hashs", "key10", "66"));
System.out.println("查看hashs集合中所有的元素:"+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("**********************************删除hashs集合元素**********************************");
System.out.println("删除hashs集合中key=key01的键值对;返回结果为:"+shardedJedis.hdel("hashs", "key01"));
System.out.println("查看hashs集合中所有的元素:"+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("**********************************修改hashs集合元素**********************************");
System.out.println("为hashs集合中key=key10所对应的值增加300:"+shardedJedis.hincrBy("hashs", "key10", 300));
System.out.println("查看hashs集合中所有的元素:"+shardedJedis.hvals("hashs"));
System.out.println("为hashs集合中key=key09所对应的值减去20:"+shardedJedis.hincrBy("hashs", "key09", -20));
System.out.println("查看hashs集合中所有的元素:"+shardedJedis.hvals("hashs"));
System.out.println();
System.out.println("**********************************查询hashs集合元素**********************************");
System.out.println("判断hashs集合中是否存在key=key100:"+shardedJedis.hexists("hashs", "key100"));
System.out.println("获取hashs集合中key=key09对应的value值:"+shardedJedis.hget("hashs", "key09"));
System.out.println("获取hashs集合中key=key02和key=key06的value值:"+shardedJedis.hmget("hashs", "key02", "key06"));
System.out.println("查看hashs集合中所有的key:"+shardedJedis.hkeys("hashs"));
System.out.println("查看hashs集合中所有的value:"+shardedJedis.hvals("hashs"));
System.out.println("===============================hashOperator is ended ..........");
}
}