Lettuce Common Keys

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Common Keys

Class 변수로 선언

String key = "key";

EXISTS

// EXISTS key -> return Boolean or Long
protected void exists() {
	try {
		Boolean ex = Redis.syncCmd.exists("key");		// deprecated
		System.out.println("exists key -> "+ex);
		Long count = Redis.syncCmd.exists("key", "xxx");
		System.out.println("exists key xxx -> "+count);
		String keys[] = "key xxx".split(" ");
		Long count2 = Redis.syncCmd.exists(keys);
		System.out.println("exists key xxx -> "+count2+" (Array)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

UNLINK

// UNLINK key [key ...] -> return Long
protected void unlink() {
	try {
		Long count = Redis.syncCmd.unlink("key");
		System.out.println("unlink key -> "+count);;
		Long count2 = Redis.syncCmd.unlink("key", "xxx");
		System.out.println("unlink key xxx -> "+count2);;
		String keys[] = "key xxx".split(" ");
		Long count3 = Redis.syncCmd.unlink(keys);
		System.out.println("unlink key xxx -> "+count3+" (Array)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

KEYS

// KEYS pattern -> return
protected void keys() {
	try {
		List<String> keys = Redis.syncCmd.keys("*");
		System.out.println("keys * -> size: "+keys.size()+", "+keys.toString());
		List<String> keys2 = Redis.syncCmd.keys("my*");
		System.out.println("keys my* -> size: "+keys2.size()+", "+keys2.toString());
		List<String> keys3 = Redis.syncCmd.keys("myzset?");
		System.out.println("keys myzset* -> size: "+keys3.size()+", "+keys3.toString());
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("KeyStreamingChannel");
		Long count = Redis.syncCmd.keys(new KeyStreamingChannel<String>() {
			@Override
			public void onKey(String key) {
				System.out.println("keys (KeyStreamingChannel) -> " +key);
			}
		}, "*");
		System.out.println("keys * -> "+count+" (count)");			
	} catch (Exception e) {
		System.out.println(e);
	}
}

SCAN

// SCAN cursor [MATCH pattern] [COUNT count] -> return KeyScanCursor<String> or StreamScanCursor
protected void scan() {
	try {
		KeyScanCursor<String> keys = Redis.syncCmd.scan();
		System.out.println("scan -> size: "+keys.getKeys().size()+", "+keys.getKeys().toString()+", nextCursor: "+keys.getCursor()+", Finish: "+keys.isFinished());
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("KeyScanCursor");
		KeyScanCursor<String> keys2 = new KeyScanCursor<String>();
		keys2.setCursor("0");
		do {
			keys2 = Redis.syncCmd.scan(keys2);
			System.out.println("scan -> size: "+keys2.getKeys().size()+", "+keys2.getKeys().toString()+", nextCursor: "+keys2.getCursor()+", Finish: "+keys2.isFinished());
		} while (keys2.isFinished() == false);
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("KeyStreamingChannel(StreamScanCursor), do-while loop");
		StreamScanCursor stream = new StreamScanCursor();
		stream.setCursor("0");
		int loop = 1;
		do {
			System.out.println("Loop -> "+loop);
			stream = Redis.syncCmd.scan(new KeyStreamingChannel<String>() {
				@Override
				public void onKey(String key) {
					System.out.println("scan (KeyStreamingChannel) -> " +key);
				}
			}, stream);
			System.out.println("Size -> "+stream.getCount()+", nextCursor -> "+stream.getCursor()+", Finish: "+stream.isFinished());
			loop++;
		} while (stream.isFinished() == false);
		
		// ScanArgs: match, limit
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("match, limit");
		ScanArgs args = new ScanArgs().match("my*").limit(5);
		KeyScanCursor<String> keys3 = Redis.syncCmd.scan(args);
		System.out.println("scan match my* count 5 -> size: "+keys3.getKeys().size()+", "+keys3.getKeys().toString()+", nextCursor: "+keys3.getCursor()+", Finish: "+keys3.isFinished());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SORT

// SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination] -> return List<String>
protected void sort() {
	try {
		// Number : List
		Redis.syncCmd.del("myscore");
		String myScore[] = "30 20 60 40 50 90 80 10 70".split(" ");
		Long count = Redis.syncCmd.lpush("myscore", myScore);
		System.out.println("lpush myscore -> "+count);
		// sort : number
		List<String> myScore2 = Redis.syncCmd.sort("myscore");
		System.out.println("sort myscore -> "+myScore2.toString()+" (asc, default)");
		// sort desc
		SortArgs args = new SortArgs().desc();
		List<String> myScore3 = Redis.syncCmd.sort("myscore", args);
		System.out.println("sort myscore desc -> "+myScore3.toString()+" (desc)");
		// String : List
		Redis.syncCmd.del("myurl");
		String myUrl[] = "Google.com Facebook.com Youtube.com Yahoo.com Baidu.com".split(" ");
		Long count2 = Redis.syncCmd.lpush("myurl", myUrl);
		System.out.println("lpush myurl -> "+count2);
		// sort : alpha
		args.alpha().asc();
		List<String> myUrl2 = Redis.syncCmd.sort("myurl", args);
		System.out.println("sort myurl alpha -> "+myUrl2.toString()+" (alpha)");
		
		// mset
		Map<String, String> map = new HashMap<String, String>();
		map.put("rank-Google.com", "1");
		map.put("rank-Facebook.com", "2");
		map.put("rank-Youtube.com", "3");
		map.put("rank-Yahoo.com", "4");
		map.put("rank-Baidu.com", "5");
		Redis.syncCmd.mset(map);
		// sort get
		args.get("rank-*");
		List<String> myUrl3 = Redis.syncCmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl3.toString()+" (get)");
		// sort get #
		args.get("#");
		List<String> myUrl4 = Redis.syncCmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl4.toString()+" (get #)");
		// sort by
		args.by("rank-*");
		List<String> myUrl5 = Redis.syncCmd.sort("myurl", args);
		System.out.println("sort myurl -> "+myUrl5.toString()+" (by)");
		
		// store
		Long count3 = Redis.syncCmd.sortStore("myurl", args, "myurl2");
		System.out.println("sort myurl store myurl2 -> "+count3);
		
	} catch (Exception e) {
		System.out.println(e);
	}
}

RENAME

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

RENAMENX

// RENAMENX key new_key -> return Boolean
protected void renamenx() {
	try {
		Redis.syncCmd.set(key, "value");
		// 성공하면 true, 실패하면 false
		Boolean ret = Redis.syncCmd.renamenx(key, "new_key");
		System.out.println("renamenx key new_key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIRE

// EXPIRE key seconds -> return Boolean
protected void expire() {
	try {
		Redis.syncCmd.set(key, "value");
		Boolean ret = Redis.syncCmd.expire(key, 10);
		System.out.println("expire key 10 -> "+ret);
		// key가 없으면 false를 리턴
		Boolean ret2 = Redis.syncCmd.expire("xxx", 10);
		System.out.println("expire xxx 10 -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIREAT

// EXPIREAT key timestamp -> return Boolean
protected void expireat() {
	long time = System.currentTimeMillis();
	Date date = new Date(time+1000*3600); 		// plus 3600 seconds
	time = time/1000 + 3600;						// plus 3600 seconds
	try {
		Redis.syncCmd.set(key, "value");
		Boolean ret2 = Redis.syncCmd.expireat(key, date);
		System.out.println("expireat key "+date+" -> "+ret2);			
		Boolean ret = Redis.syncCmd.expireat(key, time);
		System.out.println("expireat key "+time+" -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

TTL

// TTL key -> return Long(seoncds)
protected void ttl() {
	try {
		Long seconds = Redis.syncCmd.ttl(key);
		System.out.println("ttl "+key+" -> "+seconds);
	} catch (Exception e) {
		System.out.println(e);
	}
}

PEXPIRE

// PEXPIRE key milliseconds
protected void pexpire() {
	try {
		Redis.syncCmd.set(key, "value");
		Boolean ret = Redis.syncCmd.pexpire(key, 10000);
		System.out.println("pexpire key 10000 -> "+ret);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

EXPIREAT

// PEXPIREAT key milliseconds-timestamp -> return Boolean
protected void pexpireat() {
	long time = System.currentTimeMillis();
	Date date = new Date(time + 1000*3600); 		// plus 3600 seconds
	time = time + 1000*3600;						// plus 3600 seconds
	try {
		Redis.syncCmd.set(key, "value");
		Boolean ret = Redis.syncCmd.pexpireat(key, date);
		System.out.println("pexpireat key "+date+" -> "+ret);			
		Boolean ret2 = Redis.syncCmd.pexpireat(key, time);
		System.out.println("pexpireat key "+time+" -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

PTTL

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

PERSIST

// PERSIST key -> return Boolean
protected void persist() {
	try {
		Boolean ret = Redis.syncCmd.persist(key);
		System.out.println("persist key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

TYPE

// TYPE key
protected void type() {
	try {
		Redis.syncCmd.set(key, "value");
		String ret = Redis.syncCmd.type(key);
		System.out.println("type key -> "+ret);			
		String ret2 = Redis.syncCmd.type("mylist");
		System.out.println("type mylist -> "+ret2);			
		String ret3 = Redis.syncCmd.type("myset");
		System.out.println("type myset -> "+ret3);			
		String ret4 = Redis.syncCmd.type("myzset");
		System.out.println("type myzset -> "+ret4);			
		String ret5 = Redis.syncCmd.type("myhash");
		System.out.println("type myhash -> "+ret5);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

OBJECT

// OBJECT subcommand [arguments [arguments ...]] -> return String or Long
protected void object() {
	try {
		String ret = Redis.syncCmd.objectEncoding(key);
		System.out.println("object encoding key -> "+ret);
		Long time = Redis.syncCmd.objectIdletime(key);
		System.out.println("object idletime key -> "+time);
		Long refCount = Redis.syncCmd.objectRefcount(key);
		System.out.println("object refcount key -> "+refCount);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

RANDOMKEY

// RANDOMKEY -> return String(key)
protected void randomkey() {
	try {
		String key = Redis.syncCmd.randomkey();
		System.out.println("randomkey -> "+key);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

MOVE

// MOVE key db -> return Boolean
protected void move() {
	try {
		Boolean ret = Redis.syncCmd.move(key, 1);
		System.out.println("move key 1 -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

DUMP

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

RESTORE

// RESTORE key ttl serialized-value [REPLACE] -> return String(OK)
protected void restore() {
	try {
		byte[] dump = Redis.syncCmd.dump(key);
		String ret = Redis.client2.restore(key, 0, dump);
		System.out.println("restore key 0 value -> "+ret);
		byte[] dump2 = Redis.syncCmd.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] -> return String
protected void migrate() {
	try {
		// source server에서 삭제된다.
		String ret = Redis.syncCmd.migrate("192.168.56.103", 6001, key, 0, 1000);
		System.out.println("migrate key -> "+ret);
		String ret2 = Redis.syncCmd.migrate("192.168.56.103", 6001, "mylist", 0, 1000);
		System.out.println("migrate mylist -> "+ret2);
		
		MigrateArgs<String> args = new MigrateArgs<String>();
		args.keys("myset", "myhash");	// key를 여러개 지정할 수 있다.
		args.copy();		// source server에서 지우지 않는다.
		args.replace();	// target server에 이미 key가 있으면 update한다.
		String ret3 = Redis.syncCmd.migrate("192.168.56.103", 6001, 0, 1000, args);
		System.out.println("migrate myset myhash -> "+ret3);
		
	} catch (Exception e) {
		System.out.println(e);
	}
}

TOUCH

// TOUCH key [key ...] -> return Long
protected void touch() {
	try {
		Long idletime = Redis.syncCmd.objectIdletime(key);
		System.out.println("object idletime key -> "+idletime+" (before touch)");
		Long count = Redis.syncCmd.touch(key);
		System.out.println("touch key -> "+count);
		Long idletime2 = Redis.syncCmd.objectIdletime(key);
		System.out.println("object idletime key -> "+idletime2+" (after touch)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Pub/Sub	Common Keys	Async >>

조회수 :

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