package cn.com;

import java.text.ParseException;

import java.util.List;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.SortingParams;

public class Redis_Key {

public static Jedis redis = new Jedis("localhost", 6379);// 连接redis

	/**

	 * 删除给定的一个或多个 key

	 * 不存在的 key 会被忽略

	 * */

	public static void del(){

		redis.set("name", "wangzhang");

		Long size=redis.del("name");

		Long size1=redis.del("name1");

		System.out.println("存在key 删除:"+size);

		System.out.println("不存在key 删除:"+size1);

		System.out.println("====================");

		redis.set("name", "wangzhang");

		redis.set("id", "123456");

		redis.set("address", "guangzhou");

		Long size2=redis.del("name","id","address");

		System.out.println("size2:"+size2);

	}

	/**

	 * 序列化给定 key,并返回被序列化的值,使用 RESTORE 命令可以将这个值反序列化为 Redis 键。

	 * 版本：>= 2.6.0

	 * 返回值：如果 key 不存在，那么返回 nil; 否则，返回序列化之后的值。

	 * */

	public static void dump(){

		redis.set("name", "wangzhang");

		byte[] b=redis.dump("name");

		System.out.println("b:"+b);

		byte [] c=redis.dump("name1");

		System.out.println("c:"+c);

	}

	/**

	 * RESTORE key ttl serialized-value

	 * key:保存序列化后的值存储对象; ttl:生命周期;serialized-value:序列化值

	 * 反序列化给定的序列化值，并将它和给定的 key 关联。

	 * 参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。

	 * */

	public static void restore(){

		redis.flushDB();//清除数据

		redis.set("name", "wangzhang");

		//先序列化

		byte [] b= redis.dump("name");

		System.out.println("序列化之后:name:"+redis.get("name")); 

		String operation=redis.restore("name2", 0,b);

		System.out.println("反序列化之后:operation:"+operation);

		System.out.println("反序列化之后:value:"+redis.get("name2"));

	}

	/**

	 * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。

	 * */

	public static void expire() throws InterruptedException{

		redis.flushDB();//清除数据

		redis.set("name", "100");

		redis.expire("name", 2);

		System.out.println(" "+redis.get("name"));

		Thread.sleep(2000);

		System.out.println("休眠两秒后:"+redis.get("name"));

	}

	/**

	 * PEXPIREAT key milliseconds-timestamp

	 * 这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。

	 * 如果生存时间设置成功，返回 1 。

	 * 如果生存时间设置成功，返回 1 。

	 * 当 key 不存在或没办法设置生存时间，返回 0 。

	 * */

	public static void pexpireAt() throws InterruptedException{

		redis.flushDB();//清除数据

		redis.set("name", "liliang");

		redis.pexpireAt("name",1457020000);

		System.out.println(" "+redis.get("name"));

		Thread.sleep(2000);

		System.out.println("休眠两秒后:"+redis.get("name"));

	}

	/**

	 * MIGRATE host port key destination-db timeout [COPY] [REPLACE]

	 * 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。

	 * 这个命令是一个原子操作

	 * @param host 传输目标主机

	 * @param port 传输目标主机端口

	 * @param key 传输的key

	 * @param destinationDb 目标数据库 redis 默认有 16个库(0-15)

	 * @param timeout 毫秒为格式，指定当前实例和目标实例进行沟通的最大间隔时间

	 * */

	public static void migrate(){

		redis.flushDB();//清除数据

		redis.migrate("127.0.0.1", 6040, "name", 0, 1000);

	}

	public static void keys(){

		redis.flushDB();//清除数据

		//初始化值

		redis.mset("one","1","two","2","three","3","four","4","five","5");

		//匹配含有o的 key

		Set<String> set=redis.keys("*o*");

		for(String s:set){

			System.out.println("s:"+s);

		}

		//匹配t开头后面是接两个长度的；注意t?? 查找到的事two 如是 t?则没有匹配的值

		System.out.println("=======================");

		Set<String> set1=redis.keys("t??");

		for(String s:set1){

			System.out.println("s:"+s);

		}

		//查询全部

		System.out.println("=======================");

		Set<String> set2=redis.keys("*");

		for(String s:set2){

			System.out.println("s:"+s);

		}

	}

	/**

	 * MOVE key db

	 * 将当前数据库的 key 移动到给定的数据库 db(数据库索引) 当中。

	 * 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，

	 * 或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。

	 * */

	public static void move(){

		redis.flushDB();//清除数据

		redis.select(0);//显示指定当前的数据库

		redis.set("name", "liliang");

		System.out.println("未移动之前:"+redis.get("name"));

		redis.move("name", 1);

		System.out.println("移动到1库之后:"+redis.get("name"));

		System.out.println("===============");

		redis.select(1);

		System.out.println("设置当前数据库为1库之后在查找:"+redis.get("name"));

	}

	public static void object(){

		//redis.ob

		redis.set("age", "12");

		String str=redis.objectEncoding("age");

		System.out.println("str:"+str);

		System.out.println("===============");

		redis.set("age", "12555555555555");//因整形长度过长 自动转为字符串

		String str1=redis.objectEncoding("age");

		System.out.println("str:"+str1);

	}

	/**

	 * 从当前数据库中随机返回(不删除)一个 key 。

	 * */

	public static void RANDOMKEY(){

		redis.flushDB();//清除数据

		redis.set("age1", "1");

		redis.set("age2", "2");

		redis.set("age3", "3");

		String key=redis.randomKey();

		System.out.println("random key:"+key);

	}

	/**

	 * RENAME oldkey newkey

	 * 1.当olekey 不存在报错

	 * 2.当newkey 存在那么newkey上的值被oldkey 覆盖

	 * @param olekey 要更名的key

	 * @param newkey 更名后的key

	 * */

	public static void rename(){

		redis.flushDB();//清除数据

		redis.set("name", "liliang");

		redis.set("username", "123456");

		redis.rename("name", "username");

		System.out.println("=====更名之后=======");

		System.out.println("name:"+redis.get("name"));

		System.out.println("username:"+redis.get("username"));

	}

	/**

	 * RENAMENX key newkey

	 * 当且仅当 newkey 不存在时，将 key 改名为 newkey ;如果存在不做任何操作。

	 * 当 key 不存在时，返回一个错误。

	 * */

	public static void renamenx(){

		redis.flushDB();//清除数据

		redis.set("name", "liliang");

		//redis.set("username", "123456");

		redis.renamenx("name", "username");

		System.out.println("=====更名之后=======");

		System.out.println("name:"+redis.get("name"));

		System.out.println("username:"+redis.get("username"));

	}

	public static void sort(){

		redis.flushDB();//清除数据

		redis.lpush("age", "1","15","13","5","16","2","3");

		System.out.println("==========排序前集合==========");

		List<String>  list=redis.lrange("age", 0, -1);

		for(String s:list){

			System.out.println("s:"+s);

		}

		//默认正序排序

		List<String>  list1=redis.sort("age");

		System.out.println("==========从小到大排序后集合==========");

		for(String s:list1){

			System.out.println("s:"+s);

		}

		//倒序的方式只能用以下方式

		SortingParams sortingParams=new SortingParams();

		sortingParams.desc();

		sortingParams.limit(0,7);

		List<String>  list2=redis.sort("age",sortingParams);

		System.out.println("==========从大到小排序后集合==========");

		for(String s:list2){

			System.out.println("s:"+s);

		}

	}

	/**

	 * 返回 key 所储存的值的类型。

	 * */

	public static void type(){

		redis.flushDB();//清除数据

		redis.set("name", "liliang");

		redis.set("age", "18");

		redis.lpush("list", "a","b","c");

		redis.hset("hset1", "username","zhangsan");

		redis.hset("hset1", "pwd", "123");

		redis.sadd("set1", "1","5","7");

		System.out.println("=====取值所存储的类型=======");

		System.out.println(redis.type("name"));//string

		System.out.println(redis.type("age"));//string

		System.out.println(redis.type("list"));//list

		System.out.println(redis.type("hset1"));//hash

		System.out.println(redis.type("set1"));//set

	}

	public static void main(String[] args) throws InterruptedException, ParseException {

		type();

	}

}