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

Jedis Strings

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Strings

Class 변수로 선언

String key = "key";
String value = "value";
long idx = 1;

SET

// SET key value [NX|XX] [EX seconds] [PX milliseconds] -> Simple string reply: 
//		OK if SET was executed correctly. 
//		Null reply: a Null Bulk Reply is returned if the SET operation was not performed because the user specified the NX or XX option but the condition was not met.
protected void set() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SET key value [NX|XX] [EX seconds] [PX milliseconds] -> return String(OK)");
	try {
		String ret = Redis.cmd.set(key+idx, value+idx);
		System.out.println("set "+ key+idx +" "+ value+idx +" -> "+ret);
		idx++;
		// NX
		ret = Redis.cmd.set(key+idx, value+idx, "NX");
		System.out.println("set "+ key+idx +" "+ value+idx +" NX -> "+ret);
		idx++;
		// XX
		ret = Redis.cmd.set(key+idx, value+idx, "XX");
		System.out.println("set "+ key+idx +" "+ value+idx +" XX -> "+ret);
		idx++;
		// EX
		ret = Redis.cmd.set(key+idx, value+idx, "NX", "EX", 5);
		System.out.println("set "+ key+idx +" "+ value+idx +" EX 5 -> "+ret);
		idx++;
		// PX
		ret = Redis.cmd.set(key+idx, value+idx, "NX", "PX", 5000);
		System.out.println("set "+ key+idx +" "+ value+idx +" PX 5 -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

DEL

// DEL key [key ...] -> Integer reply: The number of keys that were removed.
protected void del() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("DEL key [key ...] -> return Long");
	idx = 1;
	try {
		Long count = Redis.cmd.del(key+idx);
		System.out.println("del "+ key+idx +" -> "+count);
		count = Redis.cmd.del(key+(idx++), key+(idx++));
		System.out.println("del -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

GET

// GET key -> Bulk string reply: the value of key, or nil when key does not exist.
protected void get() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GET key -> return String(value)");
	idx = random.nextInt(10);
	try {
		String value = Redis.cmd.get(key+idx);
		System.out.println("get "+ key+idx +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

INCR

// INCR key -> Integer reply: the value of key after the increment.
// OBJECT refcount key: 0 ~ 9999, 미리 만들어 놓은 숫자 사용. 1) 메모리 절약, 2) 성능 향상
protected void incr() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("INCR key -> return Long");
	try {
		Long value = Redis.cmd.incr(key);
		System.out.println("incr "+ key +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

DECR

// DECR key -> Integer reply: the value of key after the decrement.
protected void decr() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("DECR key -> return Long");
	try {
		Long value = Redis.cmd.decr(key);
		System.out.println("decr "+ key +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

INCRBY

// INCRBY key increment(long) -> Integer reply: the value of key after the increment.
protected void incrby() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("INCRBY key increment(long) -> return Long");
	long incr = random.nextInt(10);
	try {
		Long value = Redis.cmd.incrBy(key, incr);
		System.out.println("incrby "+ key +" "+ incr +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

DECRBY

// DECRBY key decrement(long) -> Integer reply: the value of key after the decrement.
protected void decrby() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("DECRBY key decrement(long) -> return Long");
	long decr = random.nextInt(10);
	try {
		Long value = Redis.cmd.decrBy(key, decr);
		System.out.println("decrby "+ key +" "+ decr +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

INCRBYFLOAT

// INCRBYFLOAT key increment -> Bulk string reply: the value of key after the increment.
protected void incrbyfloat() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("INCRBYFLOAT key increment -> return Double");
	double incr = random.nextDouble() * 10.0;
	try {
		Double value = Redis.cmd.incrByFloat(key, incr);
		System.out.println("incrbyfloat "+ key +" "+ incr +" -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SETNX

// SETNX key value -> Integer reply, specifically:
//	1 if the key was set
//	0 if the key was not set
protected void setnx() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETNX key value -> return Long");
	try {
		Long ret = Redis.cmd.setnx(key+idx, value+idx);
		System.out.println("setnx "+ key+idx +" -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

SETEX

// SETEX key seconds value -> Simple string reply.
protected void setex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETEX key seconds value -> return String");
	try {
		String ret = Redis.cmd.setex(key+idx, 10, value+idx);
		System.out.println("setex "+ key+idx +" 10 -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

PSETEX

// PSETEX key milliseconds value -> Simple string reply.
protected void psetex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("PSETEX key milliseconds value -> return String");
	try {
		String ret = Redis.cmd.psetex(key+idx, 10000L, value+idx);
		System.out.println("psetex "+ key+idx +" 10000 -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

MSET

// MSET key value [key value ...] -> Simple string reply: always OK since MSET can't fail.
protected void mset() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MSET key value [key value ...] -> return String");
	try {
		String ret = Redis.cmd.mset(key+(idx++), value+(idx++), key+(idx++), value+(idx++));
		System.out.println("mset "+ " -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

MGET

// MGET key [key ...] -> Array reply: list of values at the specified keys.
protected void mget() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MGET key [key ...] -> return List<String>");
	idx = 0;
	try {
		List<String> list = Redis.cmd.mget(key+(idx++), key+(idx++));
		System.out.println("mget "+ " -> "+list);
	} catch (Exception e) {
		System.out.println(e);
	}
}

MSETNX

// MSETNX key value [key value ...] -> Integer reply, specifically:
//	1 if the all the keys were set.
//	0 if no key was set (at least one key already existed).
protected void msetnx() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MSETNX key value [key value ...] -> return Boolean");
	// msetnx: 키가 하나라도 있으면 실패
	try {
		Long ret = Redis.cmd.msetnx(key+(idx++), value+(idx++), key+(idx++), value+(idx++));
		System.out.println("msetnx "+ " -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

APPEND

// APPEND key value -> Integer reply: the length of the string after the append operation.
// 메모리 더 사용, debug sdslen key, memory usage key
protected void append() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("APPEND key value -> return Long");
	idx = 1;
	try {
		Long ret = Redis.cmd.append(key+idx, value+idx);
		System.out.println("append key1 -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

STRLEN

// STRLEN key -> Integer reply: the length of the string at key, or 0 when key does not exist.
protected void strlen() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("STRLEN key -> return Long");
	try {
		Long ret = Redis.cmd.strlen(key+1);
		System.out.println("strlen key1 -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SETRANGE

// SETRANGE key offset value -> Integer reply: the length of the string after it was modified by the command.
protected void setrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETRANGE key offset value -> return Long");
	try {
		Long ret = Redis.cmd.setrange(key, 10, "Redis");
		System.out.println("setrange key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

GETRANGE

// GETRANGE key start end -> Bulk string reply
protected void getrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETRANGE key start end -> return String");
	try {
		String ret = Redis.cmd.getrange(key, 10, 14);
		System.out.println("getrange key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

GETSET

// GETSET key value -> Bulk string reply: the old value stored at key, or nil when key did not exist.
protected void getset() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETSET key value -> return String");
	try {
		String ret = Redis.cmd.getSet(key, value);
		System.out.println("getset key -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SETBIT

// Bit operations
// SETBIT key offset value -> Integer reply: the original bit value stored at offset.
protected void setbit() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETBIT key offset value -> return Boolean");
	try {
		Redis.cmd.set(key, "A");
		Boolean ret = Redis.cmd.setbit(key, 6, true);
		String value = Redis.cmd.get(key);
		System.out.println("setbit key 6 1 -> " +ret+", get key -> "+value);
	} catch (Exception e) {
		System.out.println(e);
	}
}

GETBIT

// GETBIT key offset -> Integer reply: the bit value stored at offset.
protected void getbit() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETBIT key offset -> return Long");
	try {
		Boolean ret1 = Redis.cmd.getbit(key, 6);
		Boolean ret2 = Redis.cmd.getbit(key, 7);
		System.out.println("getbit key 6 -> " +ret1+", getbit key 7 -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

BITOP

// BITOP operation destkey key [key ...] -> Integer reply:
// The size of the string stored in the destination key, that is equal to the size of the longest input string.
protected void bitop() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITOP operation destkey key [key ...] -> return Long");
	try {
		Redis.cmd.set("key1", "A");
		Redis.cmd.set("key2", "B");
		// bitop AND
		Long ret1 = Redis.cmd.bitop(BitOP.AND, "destkey", "key1", "key2");
		String value1 = Redis.cmd.get("destkey");
		System.out.println("bitop AND destkey key1 key2 -> "+ret1+", destkey -> "+value1);
		// bitop OR
		Long ret2 = Redis.cmd.bitop(BitOP.OR, "destkey", "key1", "key2");
		String value2 = Redis.cmd.get("destkey");
		System.out.println("bitop OR destkey key1 key2 -> "+ret2+", destkey -> "+value2);
		// bitop XOR
		Long ret3 = Redis.cmd.bitop(BitOP.XOR, "destkey", "key1", "key2");
		String value3 = Redis.cmd.get("destkey");
		System.out.println("bitop XOR destkey key1 key2 -> "+ret3+", destkey -> "+value3);
		// bitop NOT
		Long ret4 = Redis.cmd.bitop(BitOP.NOT, "destkey", "key1");
		String value4 = Redis.cmd.get("destkey");
		System.out.println("bitop NOT destkey key1 -> "+ret4+", destkey -> "+value4);
	} catch (Exception e) {
		System.out.println(e);
	}
}

BITCOUNT

// BITCOUNT key [start end] -> Integer reply: The number of bits set to 1.
protected void bitcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITCOUNT key [start end] -> return Long");
	try {
		Redis.cmd.set(key, "ABC");
		Long count1 = Redis.cmd.bitcount(key);
		Long count2 = Redis.cmd.bitcount(key, 1, 2);
		System.out.println("bitcount key -> "+count1+", bitcount key 1 2 -> "+count2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

BITPOS

// BITPOS key bit [start [end]] -> Integer reply
protected void bitpos() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITPOS key bit [start [end]] -> return Long");
	try {
		Redis.cmd.set(key, "ABC");
		Long count1 = Redis.cmd.bitpos(key, false);
		Long count2 = Redis.cmd.bitpos(key, true);
		System.out.println("bitpos key 0 -> "+count1+", bitpos key 1 -> "+count2);

	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Jedis Connection	Strings	Lists >>

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