Redis学习笔记(1)-Key

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();
	}

}