Clients

Redis Admin & Monitoring Tool
Hiredis for C
- Introduction
- Connection
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Pipeline
- Async
- Server
- Sentinel
- Cluster
Lettuce SpringBoot New
Lettuce Java Spring New
- Introduction
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Streams
- Common Keys
- Async(Future)
- Pipelining
- Pub/Sub
- Master/Replica
- Sentinel
- Cluster
- ReadFrom
Lettuce Java(Plain)
Jedis for Java
- Introduction
- Connection
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Pipeline
- Sentinel
- Cluster
- Sharding
Redisson for Java
- Introduction
- Connection
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Pipeline
- Sentinel
- Cluster
StackExchange.Redis for C#
- Standalone mode
- Cluster mode
PhpRedis for PHP
Predis for PHP
- Predis

Lettuce Common Keys

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Lettuce-6.1.7, Redis-7.0.2 Example

LettuceCommonCmd.java
import java.util.List; import java.util.Scanner; import io.lettuce.core.CopyArgs; import io.lettuce.core.KeyScanCursor; public class LettuceCommonCmd { Scanner scanner = new Scanner(System.in); Util util = new Util(); public LettuceCommonCmd() { while(true) { System.out.println("1:EXISTS 2:DEL 3:KEYS 4:SCAN 5:RENAME\n"+ "6:EXPIRE 7:TTL 8:PERSIST 9:COPY"); System.out.println("선택(exit:99)> "); String input = scanner.nextLine(); int i = util.checkInt(input); switch (i) { case 1: exists(); break; case 2: del(); break; case 3: keys(); break; case 4: scan(); break; case 5: rename(); break; case 6: expire(); break; case 7: ttl(); break; case 8: persist(); break; case 9: copy(); break; case 99: break; default: System.out.println("잘못 선택했습니다. 다시 선택하세요. "); } if (i==99) break; } } // EXISTS key1 [key2 ...] version 1.0.0 // 버전 3.0.3부터 key를 여러 개 사용할 수 있습니다. public void exists() { System.out.println("EXISTS key1 [key2 ...]"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("EXISTS") == false) return; if (cmd.length < 2) return; String cmd2[] = util.split(input.substring(cmd[0].length()+1)); try { Long ret = Main.syncCmd.exists(cmd2); System.out.println("EXISTS -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // DEL key1 [key2 ...] // 이 명령은 version 1.0.0 부터 사용할 수 있다. public void del() { System.out.println("DEL key1 [key2 ...]"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("DEL") == false) return; if (cmd.length < 2) return; String cmd2[] = util.split(input.substring(cmd[0].length()+1)); try { Long ret = Main.syncCmd.del(cmd2); System.out.println("DEL -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // KEYS pattern // 이 명령은 version 1.0.0 부터 사용할 수 있다. public void keys() { System.out.println("KEYS pattern"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("KEYS") == false) return; if (cmd.length != 2) return; try { List<String> ret = Main.syncCmd.keys(cmd[1]); System.out.println("KEYS -> "+ret.toString()); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // SCAN cursor [MATCH pattern] [COUNT count] // 이 명령은 version 2.8.0 부터 사용할 수 있다. public void scan() { try { KeyScanCursor<String> keys = new KeyScanCursor<String>(); keys.setCursor("0"); do { keys = Main.syncCmd.scan(keys); System.out.println("scan -> size: "+keys.getKeys().size()+", "+keys.getKeys().toString()+", nextCursor: "+keys.getCursor()+", Finish: "+keys.isFinished()); System.out.println("Continue: yes/no"); String input = scanner.nextLine(); if (input.equalsIgnoreCase("yes")) { keys.setFinished(false); } else { keys.setFinished(true); } } while (keys.isFinished() == false); } catch (Exception e) { System.out.println(e.getMessage()); } } // RENAME key new_key // 이 명령은 version 1.0.0 부터 사용할 수 있다. public void rename() { System.out.println("RENAME key new_key"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("RENAME") == false) return; if (cmd.length != 3) return; try { String ret = Main.syncCmd.rename(cmd[1], cmd[2]); System.out.println("RENAME -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // EXPIRE key seconds // 이 명령은 version 1.0.0 부터 사용할 수 있습니다. public void expire() { System.out.println("EXPIRE key seconds"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("EXPIRE") == false) return; if (cmd.length != 3) return; long sec = util.checkLong(cmd[2]); try { Boolean ret = Main.syncCmd.expire(cmd[1], sec); System.out.println("EXPIRE -> "+ret.toString()); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // TTL key // 이 명령은 version 1.0.0 부터 사용할 수 있다. public void ttl() { System.out.println("TTL key"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("TTL") == false) return; if (cmd.length != 2) return; try { Long ret = Main.syncCmd.ttl(cmd[1]); System.out.println("TTL -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // PERSIST key // 이 명령은 version 2.2.0 부터 사용할 수 있다. public void persist() { System.out.println("PERSIST key"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("PERSIST") == false) return; if (cmd.length != 2) return; try { Boolean ret = Main.syncCmd.persist(cmd[1]); System.out.println("PERSIST -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } // COPY source destination [DB destination-db] [REPLACE] // 이 명령은 version 6.2.0 부터 사용할 수 있다. public void copy() { System.out.println("COPY source destination [DB destination-db] [REPLACE]"); String input = scanner.nextLine(); String[] cmd = util.split(input); if (cmd[0].equalsIgnoreCase("COPY") == false) return; if (cmd.length < 3) return; CopyArgs args = new CopyArgs(); if (cmd.length > 3) { for (int i=3; i<cmd.length; i++) { switch(cmd[i].toUpperCase()) { case "DB": int dbno = util.checkInt(cmd[++i]); args.destinationDb(dbno); break; case "REPLASE": args.replace(true); break; default: System.out.println("옵션이 잘못되었습니다."); } } } try { Boolean ret = Main.syncCmd.copy(cmd[1], cmd[2], args); System.out.println("COPY -> "+ret); } catch (Exception e) { System.out.println(e.getMessage()); return; } } }

Lettuce-4.4.2, Redis-4.0.6 Example

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 답글이 올라오면 이메일로 알려드리겠습니다.