Jedis Common Keys

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Common Keys

Class 변수로 선언

String key = "key";

EXISTS

// EXISTS key -> Integer reply, specifically:
//						1 if the key exists.
//						0 if the key does not exist.
protected void exists() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("EXISTS key -> return Boolean or Long");
	try {
		Boolean ex = Redis.cmd.exists("key");
		System.out.println("exists key -> "+ex);
		Long count = Redis.cmd.exists("key", "xxx");
		System.out.println("exists key xxx -> "+count);
		String keys[] = "key xxx".split(" ");
		Long count2 = Redis.cmd.exists(keys);
		System.out.println("exists key xxx -> "+count2+" (Array)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

UNLINK -> 해당하는 메소드 없음.

// UNLINK key [key ...] -> Integer reply: The number of keys that were unlinked.
protected void unlink() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("UNLINK key [key ...] -> 해당하는 메소드 없음. Jedis 2.9.0 (2018.02.08)");
	try {
		// 해당하는 메소드 없음. Jedis 2.9.0 (2018.02.08)			
	} catch (Exception e) {
		System.out.println(e);
	}
}

KEYS

// KEYS pattern -> Array reply: list of keys matching pattern
protected void keys() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("KEYS pattern -> return Set<String>");
	try {
		Set<String> keys = Redis.cmd.keys("*");
		System.out.println("keys * -> size: "+keys.size()+", "+keys.toString());
		Set<String> keys2 = Redis.cmd.keys("my*");
		System.out.println("keys my* -> size: "+keys2.size()+", "+keys2.toString());
		Set<String> keys3 = Redis.cmd.keys("myzset?");
		System.out.println("keys myzset* -> size: "+keys3.size()+", "+keys3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SCAN

// SCAN cursor [MATCH pattern] [COUNT count] -> array of elements is a list of keys.
protected void scan() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SCAN cursor [MATCH pattern] [COUNT count] -> return KeyScanCursor<String> or StreamScanCursor");
	try {
		ScanResult<String> set = Redis.cmd.scan("0");
		do {
			set = Redis.cmd.scan(set.getStringCursor());
			System.out.println(set.getResult()+" "+set.getStringCursor());
		} while ( !(set.getStringCursor().equals("0")) );			
	} catch (Exception e) {
		System.out.println(e);
	}
}

SORT

// SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination] -> 
//		Array reply: without passing the store option the command returns a list of sorted elements. 
//		Integer reply: when the store option is specified the command returns the number of sorted elements in the destination list.
protected void sort() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination] -> return List<String>");
	try {
		// Number : List
		Redis.cmd.del("myscore");
		String myScore[] = "30 20 60 40 50 90 80 10 70".split(" ");
		Long count = Redis.cmd.lpush("myscore", myScore);
		System.out.println("lpush myscore -> "+count);
		// sort : number
		List<String> myScore2 = Redis.cmd.sort("myscore");
		System.out.println("sort myscore -> "+myScore2.toString()+" (asc, default)");
		// sort desc
		SortingParams args = new SortingParams();
		List<String> myScore3 = Redis.cmd.sort("myscore", args.desc());
		System.out.println("sort myscore desc -> "+myScore3.toString()+" (desc)");
		// String : List
		Redis.cmd.del("myurl");
		String myUrl[] = "Google.com Facebook.com Youtube.com Yahoo.com Baidu.com".split(" ");
		Long count2 = Redis.cmd.lpush("myurl", myUrl);
		System.out.println("lpush myurl -> "+count2);
		// sort : alpha
		args.alpha().asc();
		List<String> myUrl2 = Redis.cmd.sort("myurl", args);
		System.out.println("sort myurl alpha -> "+myUrl2.toString()+" (alpha)");
		
		// mset
		Redis.cmd.mset("rank-Google.com", "1", "rank-Facebook.com", "2", "rank-Youtube.com", "3", "rank-Yahoo.com", "4", "rank-Baidu.com", "5");    
		// sort get
		args.get("rank-*");
		List<String> myUrl3 = Redis.cmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl3.toString()+" (get)");
		// sort get #
		args.get("#");
		List<String> myUrl4 = Redis.cmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl4.toString()+" (get #)");
		// sort by
		args.by("rank-*");
		List<String> myUrl5 = Redis.cmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl5.toString()+" (by)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

RENAME

// RENAME key new_key -> Simple string reply
protected void rename() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("RENAME key new_key -> return String(OK)");
	try {
		String ret = Redis.cmd.rename("key", "new_key");
		System.out.println("rename key new_key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

RENAMENX

// RENAMENX key new_key -> Integer reply, specifically:
//										1 if key was renamed to newkey.
//										0 if newkey already exists.
protected void renamenx() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("RENAMENX key new_key -> return Long");
	try {
		Redis.cmd.set(key, "value");
		Long ret = Redis.cmd.renamenx(key, "new_key");
		System.out.println("renamenx key new_key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIRE

// EXPIRE key seconds -> Integer reply, specifically:	 1 if the timeout was set. 0 if key does not exist.
protected void expire() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("EXPIRE key seconds -> return Long");
	try {
		Redis.cmd.set(key, "value");
		Long ret = Redis.cmd.expire(key, 10);
		System.out.println("expire key 10 -> "+ret);
		// key가 없으면 0를 리턴
		Long ret2 = Redis.cmd.expire("xxx", 10);
		System.out.println("expire xxx 10 -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIREAT

// EXPIREAT key timestamp -> Integer reply, specifically: 1 if the timeout was set. 0 if key does not exist.
protected void expireat() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("EXPIREAT key timestamp -> return Long");
	long time = System.currentTimeMillis();
	time = time/1000 + 3600;						// plus 3600 seconds
	try {
		Redis.cmd.set(key, "value");
		Long ret = Redis.cmd.expireAt(key, time);
		System.out.println("expireat key "+time+" -> "+ret);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

TTL

// TTL key -> Integer reply: TTL in seconds, or a negative value in order to signal an error
//										The command returns -2 if the key does not exist.
//										The command returns -1 if the key exists but has no associated expire.
protected void ttl() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("TTL key -> return Long(seoncds)");
	try {
		Long seconds = Redis.cmd.ttl(key);
		System.out.println("ttl "+key+" -> "+seconds);
	} catch (Exception e) {
		System.out.println(e);
	}
}

PEXPIRE

// PEXPIRE key milliseconds -> Integer reply, specifically: 1 if the timeout was set. 0 if key does not exist
protected void pexpire() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("PEXPIRE key milliseconds -> return Long");
	try {
		Redis.cmd.set(key, "value");
		Long ret = Redis.cmd.pexpire(key, 10000L);
		System.out.println("pexpire key 10000 -> "+ret);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIREAT

// EXPIREAT key milliseconds-timestamp -> Integer reply, specifically: 1 if the timeout was set. 0 if key does not exist.
protected void pexpireat() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("EXPIREAT key milliseconds-timestamp -> return Long");
	long time = System.currentTimeMillis();
	time = time + 1000*3600;						// plus 3600 seconds
	try {
		Redis.cmd.set(key, "value");
		Long ret = Redis.cmd.pexpireAt(key, time);
		System.out.println("pexpireat key "+time+" -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

PTTL

// PTTL key -> return Long(milliseconds)
protected void pttl() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("PTTL key -> return Long(milliseconds)");
	try {
		Long milli = Redis.cmd.pttl(key);
		System.out.println("pttl "+key+" -> "+milli);
	} catch (Exception e) {
		System.out.println(e);
	}
}

PERSIST

// PERSIST key -> Integer reply: TTL in milliseconds, or a negative value in order to signal an error. 
//								The command returns -2 if the key does not exist.
//								The command returns -1 if the key exists but has no associated expire.
protected void persist() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("PERSIST key -> return Long");
	try {
		Long ret = Redis.cmd.persist(key);
		System.out.println("persist key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

TYPE

// TYPE key -> Simple string reply: type of key, or none when key does not exist.
protected void type() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("TYPE key -> return String");
	try {
		Redis.cmd.set(key, "value");
		String ret = Redis.cmd.type(key);
		System.out.println("type key -> "+ret);			
		String ret2 = Redis.cmd.type("mylist");
		System.out.println("type mylist -> "+ret2);			
		String ret3 = Redis.cmd.type("myset");
		System.out.println("type myset -> "+ret3);			
		String ret4 = Redis.cmd.type("myzset");
		System.out.println("type myzset -> "+ret4);			
		String ret5 = Redis.cmd.type("myhash");
		System.out.println("type myhash -> "+ret5);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

OBJECT

// OBJECT subcommand [arguments [arguments ...]] -> Different return values are used for different subcommands.
//								Subcommands refcount and idletime return integers.
//								Subcommand encoding returns a bulk reply.
//								If the object you try to inspect is missing, a null bulk reply is returned. 
protected void object() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("OBJECT subcommand [arguments [arguments ...]] -> return String or Long");
	try {
		String ret = Redis.cmd.objectEncoding(key);
		System.out.println("object encoding key -> "+ret);
		Long time = Redis.cmd.objectIdletime(key);
		System.out.println("object idletime key -> "+time);
		Long refCount = Redis.cmd.objectRefcount(key);
		System.out.println("object refcount key -> "+refCount);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

RANDOMKEY

// RANDOMKEY -> Bulk string reply: the random key, or nil when the database is empty.
protected void randomkey() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("RANDOMKEY -> return String(key)");
	try {
		String key = Redis.cmd.randomKey();
		System.out.println("randomkey -> "+key);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

MOVE

// MOVE key db -> Integer reply, specifically: 1 if key was moved. 0 if key was not moved.
protected void move() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MOVE key db -> return Long");
	try {
		Long ret = Redis.cmd.move(key, 1);
		System.out.println("move key 1 -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

DUMP

// DUMP key -> Bulk string reply: the serialized value.
protected void dump() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("DUMP key -> return byte[]");
	try {
		Redis.cmd.set(key, "value");
		byte[] ret = Redis.cmd.dump(key);
		System.out.println("dump key -> "+ret);			
		byte[] ret2 = Redis.cmd.dump("mylist");
		System.out.println("dump mylist -> "+ret2);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

RESTORE

// RESTORE key ttl serialized-value [REPLACE] -> Simple string reply: The command returns OK on success.
protected void restore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("RESTORE key ttl serialized-value [REPLACE] -> return String(OK)");
	try {
		byte[] dump = Redis.cmd.dump(key);
		String ret = Redis.client2.restore(key, 0, dump);
		System.out.println("restore key 0 value -> "+ret);
		byte[] dump2 = Redis.cmd.dump("mylist");
		String ret2 = Redis.client2.restore("mylist", 0, dump2);
		System.out.println("restore mylist 0 listvalue -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

MIGRATE

// MIGRATE host port key destination-db timeout [COPY] [REPLACE] -> Simple string reply: 
//					The command returns OK on success, or NOKEY if no keys were found in the source instance.
protected void migrate() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MIGRATE host port key destination-db timeout [COPY] [REPLACE] -> return String");
	try {
		// source server에서 삭제된다.
		String ret = Redis.cmd.migrate("192.168.56.103", 6001, key, 0, 1000);
		System.out.println("migrate key -> "+ret);
		String ret2 = Redis.cmd.migrate("192.168.56.103", 6001, "mylist", 0, 1000);
		System.out.println("migrate mylist -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

TOUCH -> 해당하는 메소드 없음.

// TOUCH key [key ...] -> Integer reply: The number of keys that were touched.
protected void touch() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("TOUCH key [key ...] -> 해당하는 메소드 없음. Jedis 2.9.0 (2018.02.08)");
	try {
		// 해당하는 메소드 없음. Jedis 2.9.0 (2018.02.08)			
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Pub/Sub	Common Keys	Pipeline >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.