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

Redisson Strings

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Strings

Strings에는 주로 getBucket()을 사용한다. 증가(INCR), 감소(DECR) 명령에는 getAtomicLong(), Binary 데이터는 getBinaryStream(), BIT operation에는 getBitSet()을 사용한다.

Class 변수로 선언

String key = "key";
String keyX = "keyX";
String keyB = "keyBinary-";
String keyLow = "keyLow-";
String value = "value";
long idx = 0;
Random random = new Random();

SET -> set

// SET key value [NX|XX] [EX seconds] [PX milliseconds] -> return String(OK)
protected void set() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SET key value [NX|XX] [EX seconds] [PX milliseconds] -> return String(OK)");
	// Options 사용할 수 없음.
	try {
		// set을 void로 만든것은 잘못이다. 다른 data type으로 키가 이미 있으면 에러가 발생한다.
		// 이렇게 하면 ""까지 저장됨. -> RBucket.get() 하면 ""은 나오지 않음.
		Redis.redissonMasterSlave.getBucket(key+idx).set(value+idx);
		Redis.redissonMasterSlave.getBucket("mykey").set("Hello Redis");
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return null
	// key를 2개 이상 지정하면 실행 시 에러 발생.
	try {
		String value = "value";
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SET, keyLow+idx, value+idx++);
		System.out.println("Low level command: set -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: set Error-> "+e);
		e.printStackTrace();
	}
}

DEL -> delete

// DEL key [key ...] -> return Long
protected void del() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("DEL key [key ...] -> return Boolean or Long");
	// Bucket
	try {
		Boolean ret = Redis.redissonMasterSlave.getBucket(key+idx).delete();
		System.out.println("del key Bucket.delete() -> "+ret);
		idx++;
		// Async delete
		RFuture<Boolean> ret2 = Redis.redissonMasterSlave.getBucket(key+idx).deleteAsync();
		System.out.println("del key Bucket.deleteAsync() -> "+ret2.get());
		
		long count = Redis.redissonMasterSlave.getKeys().delete(key+(idx++), key+(idx++));
		System.out.println("del key -> "+count);
		String keys[] = new String[3];
		keys[0] = key+(idx++);
		keys[1] = key+(idx++);
		keys[2] = key+(idx++);
		long count2 = Redis.redissonMasterSlave.getKeys().delete(keys);
		System.out.println("del key -> "+count2);
		
	} catch (Exception e) {
		System.out.println(e);
	}
	// Keys
	try {
		// 1 argument
		Long count = Redis.redissonMasterSlave.getKeys().delete(key+idx);
		System.out.println("del key 1 Keys.delete() -> "+count);
		idx++;
		// arguments
		Long count2 = Redis.redissonMasterSlave.getKeys().delete(key+idx++, key+idx++, key+idx++);
		System.out.println("del keys 3 Keys.delete() -> "+count2);
		
		String keysArray[] = new String[3];
		keysArray[0] = key+(idx++);
		keysArray[1] = key+(idx++);
		keysArray[2] = key+(idx++);
		// Array
		Long count3 = Redis.redissonMasterSlave.getKeys().delete(keysArray);
		System.out.println("del keys array Keys.delete() "+idx+" -> "+count3);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Long(count)
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.DEL, keyLow+idx++, keyLow+idx++);
		System.out.println("Low level command: del -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: del Error-> "+e);
		e.printStackTrace();
	}
}

GET -> get

// GET key -> return String(value)
protected void get() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("GET key -> return String");
	// Bucket으로 저장한 것을 Bucket으로 가져오면 됨. 이때 ""은 제거됨. 
	// 숫자가 들어있으면 숫자(long, double)로 리턴함. 값의 data type을 알고 있어야 함.
	// 이런 것은 레디스의 원래 기능과 달라서 혼란스러움. 
	// 잘 알고 사용하면 괜찮을 수도 있음.
	// RBucket<Object>를 사용하면 됨. 
	// 다시 정리: Data type을 정할 수 있다. String, Long, Double
	// 모두 받으려면 Object
	try {
		RBucket<Object> bucket = Redis.redissonMasterSlave.getBucket("key");
		System.out.println("get key [RBucket] -> "+bucket.get());
	} catch (Exception e) {
		System.out.println(e);
	}		
	// Low level command -> return String
	try {
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, keyLow+idx++); 
		System.out.println("Low level command: get -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: get Error-> "+e);
		e.printStackTrace();
	}
}

INCR -> getAtomicLong

// INCR key -> return Long
// OBJECT refcount key: 0 ~ 9999, 미리 만들어 놓은 숫자 사용. 1) 메모리 절약, 2) 성능 향상
protected void incr() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("INCR key -> return Long");
	try {
		RAtomicLong atomicLong = Redis.redissonMasterSlave.getAtomicLong(key);
		System.out.println("incr key [RAtomicLong] -> "+atomicLong.incrementAndGet());			
		// atomicLong.getAndIncrement();
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return long
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.INCR, keyLow);
		System.out.println("Low level command: incr -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: incr Error-> "+e);
		e.printStackTrace();
	}
}

DECR -> getAtomicLong

// DECR key -> return Long
protected void decr() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("DECR key -> return Long");
	try {
		RAtomicLong atomicLong = Redis.redissonMasterSlave.getAtomicLong(key);
		System.out.println("decr key [RAtomicLong] -> "+atomicLong.decrementAndGet());	
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return long
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.DECR, keyLow);
		System.out.println("Low level command: decr -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: decr Error-> "+e);
		e.printStackTrace();
	}
}

INCRBY -> getAtomicLong

// INCRBY key increment(long) -> return Long
protected void incrby() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("INCRBY key increment(long) -> return Long");
	try {
		RAtomicLong atomicLong = Redis.redissonMasterSlave.getAtomicLong(key);
		System.out.println("incrby key [RAtomicLong] -> "+atomicLong.addAndGet(random.nextInt(10)));
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return long
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.INCRBY, keyLow, random.nextInt(10));
		System.out.println("Low level command: incrby -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: incrby Error-> "+e);
		e.printStackTrace();
	}
}

DECRBY -> getAtomicLong

// DECRBY key decrement(long) -> return Long
protected void decrby() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("DECRBY key decrement(long) -> return Long");
	// decrby 명령이 명시적으로 없다. incrby에 -값을 주면 된다.
	try {
		RAtomicLong atomicLong = Redis.redissonMasterSlave.getAtomicLong(key);
		System.out.println("decrby key [RAtomicLong] -> "+atomicLong.addAndGet(-random.nextInt(10)));
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return long
	// decrby 명령이 명시적으로 없다. incrby에 -값을 주면 된다.
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.INCRBY, keyLow, -random.nextInt(10));
		System.out.println("Low level command: incrby -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: incrby Error-> "+e);
		e.printStackTrace();
	}
}

INCRBYFLOAT -> getAtomicDouble

// INCRBYFLOAT key increment -> return Double
protected void incrbyfloat() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("INCRBYFLOAT key increment -> return Double");
	double incr = random.nextDouble() * 10.0;
	// incrbyfloat 명령이 명시적으로 없다. addAndGet()을 이용한다.
	try {
		RAtomicDouble atomicDouble = Redis.redissonMasterSlave.getAtomicDouble("keyDouble");
		System.out.println("incrbyfloat key [RAtomicDouble] -> "+atomicDouble.addAndGet(incr));
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Double
	try {
		Double ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.INCRBYFLOAT, keyLow, incr);
		System.out.println("Low level command: incrbyfloat -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: incrbyfloat Error-> "+e);
		e.printStackTrace();
	}
}

SETNX -> trySet

// SETNX key value -> return Boolean
protected void setnx() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETNX key value -> return Boolean");
	try {
		RBucket<String> bucket = Redis.redissonMasterSlave.getBucket(key+idx);
		Boolean ret = bucket.trySet("value"+idx);
		System.out.println("setnx "+key+(idx++)+" [trySet] -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Boolean
	try {
		Boolean ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SETNX, keyLow+idx, "value"+(idx++));
		System.out.println("Low level command: setnx -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: setnx Error-> "+e);
		e.printStackTrace();
	}
}

SETEX -> set

// SETEX key seconds value -> return String
protected void setex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETEX key seconds value -> return String");
	try {
		// setex 명령이 명시적으로 없다. set에 expire time을 준다. 
		RBucket<String> bucket = Redis.redissonMasterSlave.getBucket(key+idx);
		bucket.set("value"+idx, 10, TimeUnit.SECONDS);
		System.out.println("setex "+key+idx+" [RBucket] -> Maybe success");
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Void
	// setex 명령이 명시적으로 없다. psetex에 ms로 expire time을 준다.
	try {
		Boolean ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.PSETEX, keyLow+idx, 10000, "value"+idx);
		System.out.println("Low level command: setex -> "+ret+" idx:"+idx);
		idx++;
	} catch (Exception e) {
		System.out.println("Low level command: setex Error-> "+e);
		e.printStackTrace();
	}
}

PSETEX -> set

// PSETEX key milliseconds value -> return String
protected void psetex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("PSETEX key milliseconds value -> return String");
	try {
		// psetex 명령이 명시적으로 없다. set에 expire time을 줄 때 TimeUnit을 사용한다.
		RBucket<String> bucket = Redis.redissonMasterSlave.getBucket(key+idx);
		bucket.set("value"+idx, 10000, TimeUnit.MILLISECONDS);
		System.out.println("psetex "+key+idx+" [RBucket] -> Maybe success");
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Void
	try {
		Boolean ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.PSETEX, keyLow+idx, 10000, "value"+idx);
		System.out.println("Low level command: psetex -> "+ret+" idx:"+idx);
		idx++;
	} catch (Exception e) {
		System.out.println("Low level command: psetex Error-> "+e);
		e.printStackTrace();
	}
}

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

// MSET key value [key value ...] -> return String
protected void mset() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MSET key value [key value ...] -> return String");
	// mset 명령이 명시적으로 없다. batch를 사용한다.
	RBatch batch = Redis.redissonMasterSlave.createBatch();
	try {
		for (int i=0; i<100; i++) {
			batch.getBucket(key+i).setAsync(value+i);
		}
	} catch (Exception e) {
		System.out.println(e);
	}
}

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

// MGET key [key ...] -> return List<String>
protected void mget() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MGET key [key ...] -> return List<String>");
	String keysArray[] = new String[10];
	keysArray[0] = key+(idx++);
	keysArray[1] = key+(idx++);
	keysArray[2] = key+(idx++);
	System.out.println(idx);
	try {
		// 에러 발생함. Unexpected exception while processing command
		Map<String, String> map = Redis.redissonMasterSlave.getBuckets().get(key+(idx++));
		for( Map.Entry<String, String> elem : map.entrySet() ){
			System.out.println( elem.getKey()+" -> "+ elem.getValue() );
		}
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return List<Object>
	try {
		// 성공. 잘됨.
		List<Object> ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.MGET, keyLow+(idx++), keyLow+(idx++));
		System.out.println("Low level command: mget -> "+ret.toString());
	} catch (Exception e) {
		System.out.println("Low level command: mget Error-> "+e);
		e.printStackTrace();
	}
}

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

// MSETNX key value [key value ...] -> return Boolean
protected void msetnx() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("MSETNX key value [key value ...] -> return Boolean");
	Map<String, String> map = new HashMap<String, String>();
	map.put(key+idx, value+(idx++));
	map.put(key+idx, value+(idx++));
	map.put(key+idx, value+(idx++));
	map.put(key+idx, value+(idx++));
	map.put(key+idx, value+(idx++));
	map.put(key+idx, value+(idx++));
	try {
		Boolean ret = Redis.redissonMasterSlave.getBuckets().trySet(map);
		System.out.println("msetnx [trySet(map)] -> "+ret);			
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return List<Object>
	try {
		Boolean ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.MSETNX, keyLow+idx, value+(idx++), keyLow+idx, value+(idx++));
		System.out.println("Low level command: msetnx -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: msetnx Error-> "+e);
		e.printStackTrace();
	}
}

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

// APPEND key value -> return Long
// 메모리 더 사용, debug sdslen key, memory usage key
protected void append() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("APPEND key value -> return Long");
	try {
		// append에 해당하는 명령 없음.
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.APPEND, keyLow, " Hello");
		System.out.println("Low level command: append -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: append Error-> "+e);
		e.printStackTrace();
	}
}

STRLEN -> size

// STRLEN key -> return Long
protected void strlen() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("STRLEN key -> return Long");
	try {
		long size = Redis.redissonMasterSlave.getBucket(key).size();
		System.out.println("strlen [Bucket] -> "+size);			
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.STRLEN, keyLow);
		System.out.println("Low level command: strlen -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: strlen Error-> "+e);
		e.printStackTrace();
	}
}

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

// SETRANGE key offset value -> return Long
protected void setrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETRANGE key offset value -> return Long");
	try {
		// 명령 없음.
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		long ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SETRANGE, keyLow, 6, "Redis");
		System.out.println("Low level command: setrange -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: setrange Error-> "+e);
		e.printStackTrace();
	}
}

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

// GETRANGE key start end -> return String
protected void getrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETRANGE key start end -> return String");
	try {
		// 명령 없음.
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GETRANGE, keyLow, 5, 10);
		System.out.println("Low level command: getrange -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: getrange Error-> "+e);
		e.printStackTrace();
	}
}

GETSET -> getAndSet

// GETSET key value -> return String
protected void getset() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETSET key value -> return String");
	try {
		// Error 발생: Unexpected exception while processing command
		Object ret = Redis.redissonMasterSlave.getBucket(key).getAndSet("new value");
		System.out.println("getset -> "+ret.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GETSET, keyLow, "new value2");
		System.out.println("Low level command: getset -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: getset Error-> "+e);
		e.printStackTrace();
	}
}

Binary command

protected void binary() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("Binary");
	try {
		// BinaryStream으로 저장(set)한 것은 Bucket으로 가져(get)오지 못함.
		Redis.redissonMasterSlave.getBinaryStream(keyB+idx).set(value.getBytes());
		idx++;
		// trySet()은 NX 옵션임. insert.
		Redis.redissonMasterSlave.getBinaryStream(keyB+idx).trySet(value.getBytes());

		RBinaryStream stream = Redis.redissonMasterSlave.getBinaryStream(keyB+ idx++);
		System.out.println("get key [RBinaryStream] "+idx+" -> "+ new String(stream.get(), 0, stream.get().length));

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

SETBIT -> set

// Bit operations
// SETBIT key offset value -> return Void
protected void setbit() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SETBIT key offset value -> return Void");
	try {
		// Bucket, BitSet 값이 바뀌지 않는다 -> 실패
		Redis.redissonMasterSlave.getBucket(key).set("A");
		Redis.redissonMasterSlave.getBitSet(key).set(6, true);
		Object value = Redis.redissonMasterSlave.getBucket(key).get();
		System.out.println("setbit key 6 1 [Bucket] -> get key -> "+value.toString());
		// BinaryStream -> 성공
		Redis.redissonMasterSlave.getBinaryStream(keyB).set("A".getBytes());
		Redis.redissonMasterSlave.getBitSet(key).set(6, true);
		byte[] value2 = Redis.redissonMasterSlave.getBinaryStream(keyB).get();
		System.out.println("setbit key 6 1 [BinaryStream] -> get key -> "+ new String(value2, 0, value2.length));
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SET, keyLow, "A");
		Boolean ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SETBIT, keyLow, 6, 1);
		String value = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, keyLow);
		System.out.println("Low level command: setbit -> "+ret+", value -> "+value);
	} catch (Exception e) {
		System.out.println("Low level command: setbit Error-> "+e);
		e.printStackTrace();
	}
}

GETBIT -> get

// GETBIT key offset -> return Long
protected void getbit() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("GETBIT key offset -> return Boolean");
	try {
		Boolean ret1 = Redis.redissonMasterSlave.getBitSet(key).get(6);
		Boolean ret2 = Redis.redissonMasterSlave.getBitSet(key).get(7);
		System.out.println("getbit key 6 -> " +ret1+", getbit key 7 -> "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		Boolean ret1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GETBIT, keyLow, 6);
		Boolean ret2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GETBIT, keyLow, 7);
		System.out.println("Low level command: getbit 6 -> "+ret1+", getbit 7 -> "+ret2);
	} catch (Exception e) {
		System.out.println("Low level command: getbit Error-> "+e);
		e.printStackTrace();
	}
}

BITOP -> and, or, xor, not

// BITOP operation destkey key [key ...] -> return Long
protected void bitop() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITOP operation destkey key [key ...] -> return Void");
	String destkey = "destkey", key1 = "key1", key2 = "key2";
	try {
		Redis.redissonMasterSlave.getBinaryStream(key1).set("A".getBytes());
		Redis.redissonMasterSlave.getBinaryStream(key2).set("B".getBytes());
		// bitop AND
		Redis.redissonMasterSlave.getBitSet(destkey).and(key1, key2);
		byte[] value1 = Redis.redissonMasterSlave.getBinaryStream(destkey).get();
		System.out.println("bitop AND destkey key1 key2 -> "+new String(value1));
		// bitop OR
		Redis.redissonMasterSlave.getBitSet(destkey).or(key1, key2);
		byte[] value2 = Redis.redissonMasterSlave.getBinaryStream(destkey).get();
		System.out.println("bitop OR destkey key1 key2 -> "+new String(value2));
		// bitop XOR
		Redis.redissonMasterSlave.getBitSet(destkey).xor(key1, key2);
		byte[] value3 = Redis.redissonMasterSlave.getBinaryStream(destkey).get();
		System.out.println("bitop XOR destkey key1 key2 -> "+new String(value3));
		// bitop NOT -> 결과를 어떻게 받지?
		Redis.redissonMasterSlave.getBitSet(destkey).not();
		System.out.println("bitop NOT key1 -> ");
	} catch (Exception e) {
		System.out.println(e);
	}
		
	// Low level command -> return 
	try {
		// bitop AND
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITOP, "AND", destkey, key1, key2);
		String ret1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, destkey);
		System.out.println("Low level command: bitop AND destkey key1 key2 -> "+ret1);
		// bitop OR
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITOP, "OR", destkey, key1, key2);
		String ret2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, destkey);
		System.out.println("Low level command: bitop OR destkey key1 key2 -> "+ret2);
		// bitop XOR
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITOP, "XOR", destkey, key1, key2);
		String ret3 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, destkey);
		System.out.println("Low level command: bitop XOR destkey key1 key2 -> "+ret3);
		// bitop NOT
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITOP, "NOT", destkey, key1);
		String ret4 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.GET, destkey);
		System.out.println("Low level command: bitop NOT destkey key1 -> "+ret4);
	} catch (Exception e) {
		System.out.println("Low level command: getbit Error-> "+e);
		e.printStackTrace();
	}
}

BITCOUNT -> cardinality

// BITCOUNT key [start end] -> return Long
protected void bitcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITCOUNT key [start end] -> return Long");
	try {
		// start end option 사용할 수 없음.
		Redis.redissonMasterSlave.getBinaryStream(keyB).set("ABC".getBytes());
		long count = Redis.redissonMasterSlave.getBitSet(key).cardinality();
		System.out.println("bitcount key -> "+count);			
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SET, keyLow, "ABC");
		long count1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITCOUNT, keyLow);
		// start end option 사용 가능함.
		long count2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITCOUNT, keyLow, 1, 2);
		System.out.println("Low level command: bitcount key -> "+count1+", bitcount key 1 2 -> "+count2);
	} catch (Exception e) {
		System.out.println("Low level command: bitcount Error-> "+e);
		e.printStackTrace();
	}
}

BITPOS -> length(비슷한 메소드)

// BITPOS key bit [start [end]] -> return Long
protected void bitpos() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("BITPOS key bit [start [end]] -> return Long");
	try {
		Redis.redissonMasterSlave.getBinaryStream(keyB).set("ABC".getBytes());
		// bispos와 length는 다른데 command mapping에는 같은 것으로 표시되어 있음.
		long pos = Redis.redissonMasterSlave.getBitSet(key).length();
		System.out.println("bitpos key -> "+pos);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.SET, keyLow, "ABC");
		int count1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITPOS, keyLow, 0);
		int count2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITPOS, keyLow, 1);
		int count3 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BITPOS, keyLow, 1, 2);			
		System.out.println("Low level command: bitpos key 0 -> "+count1+", bitpos key 1 -> "+count2+", bitpos key 1 2 -> "+count3);
	} catch (Exception e) {
		System.out.println("Low level command: bitpos Error-> "+e);
		e.printStackTrace();
	}
}

<< Lettuce Connection	Strings	Lists >>

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