redis-key2

            package
             com.ztest.redis;


            import
             java.util.List;


            import
             redis.clients.jedis.Jedis;


            import
             com.sun.istack.internal.logging.Logger;

            import
             com.ztest.redis.util.JedisConnectionUtil;


            /**
            
* 
* 
            @author
             yafei.lv
*redis异步？？？

            */
            public
            class
             JedisKeyTestTwo {

            private
            final
            static Logger logger = Logger.getLogger(JedisKeyTestOne.class);

publicstaticvoid keyTest(){
Jedis jedis = null;
try{


jedis = JedisConnectionUtil.initJedis();
// 0.flushDb 和 flush all
/* 一个端口一个库？
* flush all : 清空整个 Redis 服务器的数据 (删除所有数据库的所有 key )。此命令从不失败。时间复杂度： 尚未明确.返回值： 总是返回 OK 。
* flush db : 清空当前数据库中的所有 key。此命令从不失败。时间复杂度： O(1)。返回值： 总是返回 OK 。
*/

jedis.flushDB();

// 1.migrate 将key和value原子性地从当前实例，传送到目标实例的指定库上，一旦传送成功，key保证会出现在目示实例上，当前会被删除
//是原子操作、阻塞
/*
* @Redis命令：migrate host port key destiontion-db timeout
* 
* @例子：把6379的redis里面的key移到6378里面
* migrate 127.0.0.1 6378 lvyf 0(库名) 1000
*/// 2.move 将当前数据库key移动到指定数据库中，如果当前数据库 (源数据库) 和给定数据库 (目标数据库) 有相同名字的给定 key ，或者 key 不存在于当前
//数据库，那么 MOVE 没有任何效果 
/*
* @Redis命令： move key db 
* 时间复杂度： O(1)
返回值： 移动成功返回 1 ，失败则返回 0

@例子：move lvyf 0
*/
jedis.set("lvyf1", "123");
jedis.move("lvyf1",1);

jedis.flushAll();

// 3. object OBJECT 命令允许从内部察看给定 key 的 Redis 对象
jedis.set("lvyf","1q23");
jedis.objectEncoding("lvyf");
Long count = jedis.objectRefcount("lvyf");
logger.info("obj==" + jedis.get("lvyf")+",count=="+count);

// 4. persist 移除key的存活时间
/*
* @Redis命令 persist lvyf
*/
jedis.expire("lvyf", 5);
jedis.persist("lvyf");


// 5. pexpire 给key设置存活时间，单位毫秒 
/*
@Redis命令 pexpire lvyf 1000 时间段
*/// 6.
/*
* PEXPIREAT key milliseconds-timestamp
这个命令和EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像EXPIREAT
那样，以秒为单位

@Redis命 PEXPIREAT lvyf 140999887766655 ，某一时间点
*/// 7. pttl 它以毫秒为单位返回 key 的剩余生存时间
/*
* @Redis命令 pttl lvyf
*/// 8. randomkey 从当前数据库中随机返回 (不删除) 一个 key 
/*
* @Redis命令 randomkey
*/
jedis.flushAll();
jedis.set("orange", "1");
jedis.set("apple", "2");
jedis.set("banana", "3");

logger.info("randomKey==" + jedis.randomKey());

// 9. rename 修改key
/*
* @Redis命令： rename key newkey
* 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
当 newkey 已经存在时，RENAME 命令将覆盖旧值。
* 从当前数据库中随机返回 (不删除) 一个 key 
*/
jedis.flushAll();
jedis.set("1", "orange");
jedis.set("2","apple");
logger.info("修改前 key是2的value==" + jedis.get("2"));

String result = jedis.rename("1", "2");
logger.info("修改结果==" + result + "修改后key是2的value==" + jedis.get("2"));

// 10.renamenx 当且仅当newkey 不存在时，才会修改
/*
* @Redis命令 renamenx lvyf lvyf1
* 时间复杂度： O(1)
返回值：
修改成功时，返回 1 。
如果 newkey 已经存在，返回 0 。
*/
jedis.flushAll();
jedis.set("1", "orange");
jedis.set("2","apple");
logger.info("修改前 key是2的value==" + jedis.get("2"));

Long result1 = jedis.renamenx("1", "3");
logger.info("修改结果==" + result1 + "修改后key是2的value==" + jedis.get("2") + ",3=="+jedis.get("3")+",1=="+jedis.get("1"));

// 11.restore 
/*
* @Redis命令
* RESTORE key ttl serialized-value
* 
* 反序列化给定的序列化值，并将它和给定的 key 关联。
参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间
返回值：
如果反序列化成功那么返回 OK ，否则返回一个错误。

DUMP greeting 再看看！！！
\x00\x15hello, dumping world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"
# 将序列化数据 RESTORE 到另一个键上面
RESTORE greeting-again 0 "\x00\x15hello, dumping world!\x06\x00E\xa0Z\x82\xd8r\xc1\xde"
OK
*/// 12. ttl 返回key的剩余生存时间 秒jedis.flushAll();
jedis.set("lvyf", "123");
Long timeNoExpire = jedis.ttl("lvyf");
Long timeNotKeyExist = jedis.ttl("lvyafei1");
logger.info("timeNoExpire=="+timeNoExpire+",timeNotKeyExist=="+timeNotKeyExist);
jedis.set("lv", "123");
jedis.expire("lv", 10);
Thread.currentThread();
//    Thread.sleep(1000*3);
Long rightTTl = jedis.ttl("lv");
logger.info("rightTTl=="+rightTTl);

/*
* 13.type 返回key所存value类型
* TYPE key
返回 key 所储存的值的类型。
可用版本： >= 1.0.0
时间复杂度： O(1)
返回值：
none (key 不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)
*/
jedis.flushAll();
jedis.set("lvyf", "123");
String type = jedis.type("lvyf");
logger.info("type=="+type+",not=="+jedis.type("123"));


/*
* 14. sort 对指定key的value排序 
* 
* SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC]
[ALPHA] [STORE destination]
返回或保存给定列表、集合、有序集合 key 中经过排序的元素。
排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较。

时间复杂度：
O(N+M*log(M))，N 为要排序的列表或集合内的元素数量，M 为要返回的元素数量。
如果只是使用SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。
返回值：
没有使用 STORE 参数，返回列表形式的排序结果。
使用 STORE 参数，返回排序结果的元素数量。
*/
jedis.lpush("cost", "10","5","20","3");
List<String> sortResult = jedis.sort("cost");
for(String str : sortResult){
logger.info("str=="+ str);
}

/*
* 15. SCAN 
* 命令是一个基于游标的迭代器（ cursor based iterator）：SCAN 命令每次被调用之后，都会向用户返
回一个新的游标，用户在下次迭代时需要使用这个新游标作为SCAN 命令的游标参数，以此来延续之前的
迭代过程。
当SCAN 命令的游标参数被设置为 0 时，服务器将开始一次新的迭代，而当服务器向用户返回值为 0 的游
标时，表示迭代已结束

*///    for(int i = 0 ; i < 20 ; i++){
//    jedis.set(i+"", i+"");
//    }
}catch(Exception e){
e.printStackTrace();
}finally{
if(jedis != null){
JedisConnectionUtil.returnJedis(jedis); //回收}
}

}

publicstaticvoid main(String[] args) {
keyTest();
}
}