Clients

Hiredis for C
- Introduction
- Connection
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Pipeline
- Async
- Server
- Sentinel
- Cluster
Jedis for Java
- Introduction
- Connection
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Pipeline
- Sentinel
- Cluster
- Sharding
Lettuce for Java
- Introduction
- Strings
- Lists
- Sets
- ZSets
- Hashes
- Pub/Sub
- Common Keys
- Async
- Reactive
- Connection Pooling
- Sentinel
- Cluster
- Lettuce for Enterprise New
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 開発者教育 Redis Developer Course	Redis 定期点検/技術支援 Redis Technical Support	Redis エンタープライズサーバ 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 返事がかかってなれば、メールでお知らせします。