Redisson Lists

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Lists

Lists에는 주로 getDeque(), getList()를 사용하고, Blocking 명령에는 getBlockingDeque()를 사용한다.

Class 변수로 선언

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

LPUSH -> addFirst, addLast, addAll

// LPUSH key value [value ...] -> return Long
protected void lpush() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LPUSH key value [value ...] -> return void");
	try {
		// addFirst() -> LPUSH
		Redis.redissonMasterSlave.getDeque(key).addFirst(value+(idx++));
		// addLast() -> RPUSH
		Redis.redissonMasterSlave.getDeque(key).addLast(value+(idx++));
		// Add list -> RPUSH 1회 실행
		ArrayList<String> list = new ArrayList<String>();
		list.add(value+(idx++));
		list.add(value+(idx++));
		list.add(value+(idx++));
		list.add(value+(idx++));
		Redis.redissonMasterSlave.getDeque(key).addAll(list);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return int
	try {
		int ret1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LPUSH, key, value+(idx++));
		int ret2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LPUSH, key, value+(idx++), value+(idx++), value+(idx++));
		System.out.println("Low level command: lpush -> "+ret1+", "+ret2);
	} catch (Exception e) {
		System.out.println("Low level command: lpush Error-> "+e);
		e.printStackTrace();
	}
}

RPOP -> pollLast

// RPOP key -> return String
protected void rpop() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("RPOP key -> return String");
	try {
		// addFirst()로 입력한 것만 정성적으로 나옴. 
		// data가 없을 경우 Null Exception 발생함. 
		Object ret = Redis.redissonMasterSlave.getDeque(key).pollLast();
		System.out.println("rpop "+key+" -> " +ret.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.RPOP, key);
		System.out.println("Low level command: rpop -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: rpop Error-> "+e);
		e.printStackTrace();
	}
}

LPOP -> poll

// LPOP key -> return String
protected void lpop() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LPOP key -> return String");
	try {
		Object ret = Redis.redissonMasterSlave.getQueue(key).poll();
		System.out.println("lpop "+key+" -> " +ret.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		String ret = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LPOP, key);
		System.out.println("Low level command: lpop -> "+ret);
	} catch (Exception e) {
		System.out.println("Low level command: lpop Error-> "+e);
		e.printStackTrace();
	}
}

RPUSH -> add, addAll

// RPUSH key value [value ...] -> return Long
protected void rpush() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("RPUSH key value [value ...] -> return Long");
	try {
		// add -> RPUSH
		Boolean ret = Redis.redissonMasterSlave.getList(key).add(value+(idx++));
		System.out.println("rpush"+key+" -> " +ret);
		// Add list -> RPUSH
		ArrayList<String> list = new ArrayList<String>();
		list.add(value+(idx++));
		list.add(value+(idx++));
		list.add(value+(idx++));
		list.add(value+(idx++));
		Boolean ret2 = Redis.redissonMasterSlave.getList(key).addAll(list);
		System.out.println("rpush"+key+" -> " +ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return int
	try {
		int ret1 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.RPUSH, key, value+(idx++));
		int ret2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.RPUSH, key, value+(idx++), value+(idx++), value+(idx++));
		System.out.println("Low level command: rpush -> "+ret1+", "+ret2);
	} catch (Exception e) {
		System.out.println("Low level command: rpush Error-> "+e);
		e.printStackTrace();
	}
}

LRANGE -> readAll, subList

protected void lrange() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LRANGE key start stop -> return List<Object>");
	try {
		List<Object> list = Redis.redissonMasterSlave.getList(key).readAll();
		System.out.println("lrange "+key+" -> " +list);
		// subList 결과 오류 -> 결과에 3번째 값을 포함해야 하는데 2번째 값까지만 포함한다.
		// 범위를 초과하면 에러 발생 -> java.lang.IndexOutOfBoundsException: toIndex = 3
		List<Object> list2 = Redis.redissonMasterSlave.getList(key).readAll().subList(1, 3);
		System.out.println("lrange "+key+" 1 3 -> " +list2);	
		/*
		// Error -> READONLY You can't write against a read only slave.. channel: [id: 0xb7abc4f8, L:/127.0.0.1:8537 - R:127.0.0.1/127.0.0.1:6001] command: (SORT), params: [mylist, ASC]
		List<Object> list5 = Redis.redissonMasterSlave.getList(key).readSort(SortOrder.ASC);
		System.out.println("lrange "+key+" (sort asc) -> " +list5);
		List<Object> list6 = Redis.redissonMasterSlave.getList(key).readSort(SortOrder.DESC);
		System.out.println("lrange "+key+" (sort desc) -> " +list6);
		*/			
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	try {
		List<Object> list = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LRANGE, key, 0, -1);
		System.out.println("Low level command: lrange -> "+list.toString());
	} catch (Exception e) {
		System.out.println("Low level command: lrange Error-> "+e);
		e.printStackTrace();
	}
}

LLEN -> size

// LLEN key -> return Long
protected void llen() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LLEN key -> return int");
	try {
		int size = Redis.redissonMasterSlave.getList(key).size();
		System.out.println("llen "+key+" -> " +size);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Long 
	try {
		Long size = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LLEN, key);
		System.out.println("Low level command: llen -> "+size);
	} catch (Exception e) {
		System.out.println("Low level command: llen Error-> "+e);
	}
}

LINDEX -> get

// LINDEX key index -> return String
protected void lindex() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LINDEX key index -> return Object, List<Object>");
	try {
		Object v = Redis.redissonMasterSlave.getList(key).get(0);
		System.out.println("lindex "+key+" -> " +v.toString());
		// 여러 개 지정 가능
		List<Object> list = Redis.redissonMasterSlave.getList(key).get(0,1);
		System.out.println("lindex "+key+" -> " +list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Object 
	try {
		Object v = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LINDEX, key, 0);
		System.out.println("Low level command: lindex -> "+v);
	} catch (Exception e) {
		System.out.println("Low level command: lindex Error-> "+e);
	}
}

LSET -> fastSet

// LSET key index value -> return String
protected void lset() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LSET key index value -> return Void");
	try {
		Redis.redissonMasterSlave.getList(key).fastSet(0, value+(idx++));
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return 
	// \" 없이 저장됨. 사용에 주의가 필요함.
	try {
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LSET, key, 1, value+(idx++));
	} catch (Exception e) {
		System.out.println("Low level command: lset Error-> "+e);
	}
}

LINSERT -> addBefore, addAfter

// LINSERT key BEFORE|AFTER pivot value -> return Long
protected void linsert() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LINSERT key BEFORE|AFTER pivot value -> return int");
	try {
		int size = Redis.redissonMasterSlave.getList(key).addBefore("value1", value+(idx++));
		System.out.println("linsert "+key+" before -> " +size);
		int size2 = Redis.redissonMasterSlave.getList(key).addAfter("value1", value+(idx++));
		System.out.println("linsert "+key+" after -> " +size2);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Integer
	try {
		// 실패 -> 소문자 before, 대문자 BEFORE 했으나 실패 -1을 리턴함.
		Integer size = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LINSERT_INT, key, "BEFORE", "value1", value+(idx++));
		System.out.println("Low level command: linsert before -> "+size);
		Integer size2 = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LINSERT_INT, key, "AFTER", "value1", value+(idx++));
		System.out.println("Low level command: linsert after -> "+size2);
	} catch (Exception e) {
		System.out.println("Low level command: linsert Error-> "+e);
	}
}

LREM -> fastRemove, remove, removeFirst, removeFirstOccurrence, removeLast, removeLastOccurrence

// LREM key count value -> return Long
protected void lrem() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LREM key count value -> return ");
	try {
		// return void, 삭제만 한다.
		Redis.redissonMasterSlave.getList(key).fastRemove(0);
		System.out.println("lrem "+key+" (fastRemove) -> " +"OK");
		// return object, 삭제하고 해당 값을 리턴한다.
		Object o = Redis.redissonMasterSlave.getList(key).remove(0);
		System.out.println("lrem "+key+" (remove) -> " +o.toString());
		// return object
		Object o2 = Redis.redissonMasterSlave.getDeque(key).removeFirst();
		System.out.println("lrem "+key+" (Deque.removeFirst) -> " +o2.toString());
		// return boolean
		Boolean b = Redis.redissonMasterSlave.getDeque(key).removeFirstOccurrence("value1");
		System.out.println("lrem "+key+" (Deque.removeFirstOccurrence) -> " +b);
		// return object
		Object o3 = Redis.redissonMasterSlave.getDeque(key).removeLast();
		System.out.println("lrem "+key+" (Deque.removeLast) -> " +o3.toString());
		// return boolean
		Boolean b2 = Redis.redissonMasterSlave.getDeque(key).removeLastOccurrence("value1");
		System.out.println("lrem "+key+" (Deque.removeLastOccurrence) -> " +b2);
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Boolean
	try {
		// value2가 있는데 false로 나옴. 사용법을 모르겠음.
		Boolean b = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LREM_SINGLE, key, 1, "value2");
		System.out.println("Low level command: lrem -> "+b);
	} catch (Exception e) {
		System.out.println("Low level command: lrem Error-> "+e);
	}
}

LTRIM -> trim

// LTRIM key start stop -> return String
protected void ltrim() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LTRIM key start stop -> return String");
	try {
		Redis.redissonMasterSlave.getList(key).trim(1, 3);
		System.out.println("ltrim "+key+" 1, 3 -> " +"OK");
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return void
	try {
		Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.LTRIM, key, 1, 2);
		System.out.println("Low level command: ltrim -> "+"OK");
	} catch (Exception e) {
		System.out.println("Low level command: ltrim Error-> "+e);
	}
}

RPOPLPUSH -> pollLastAndOfferFirstTo

// RPOPLPUSH source_key destination_key -> return String
protected void rpoplpush() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("RPOPLPUSH source_key destination_key -> return String ");
	try {
		Object o = Redis.redissonMasterSlave.getDeque(key).pollLastAndOfferFirstTo("destkey");
		System.out.println("rpoplpush "+key+" -> " +o.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Object
	try {
		Object o = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.RPOPLPUSH, key, "destkey");
		System.out.println("Low level command: rpoplpush -> "+o.toString());
	} catch (Exception e) {
		System.out.println("Low level command: rpoplpush Error-> "+e);
	}
}

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

// LPUSHX key value -> return Long -> 해당하는 명령 없음.
protected void lpushx() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("LPUSHX key value -> return Long -> 해당하는 명령 없음.");
	try {

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

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

// RPUSHX key value -> return Long -> 해당하는 명령 없음.
protected void rpushx() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("RPUSHX key value -> return Long -> 해당하는 명령 없음.");
	try {

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

BLPOP -> take, takeAsync

// 대기동안 blocking이 발생한다. 화면에서 다른 동작을 할 수 없다.
// BLPOP key [key ...] timeout -> return RedisFuture<KeyValue<String, String>>
protected void blpop () {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BLPOP key [key ...] timeout -> return Object ");
	try {
		Object o = Redis.redissonMasterSlave.getBlockingDeque(key).take();
		System.out.println("blpop "+key+" -> " +o.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Object
	try {
		Object o = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BLPOP_VALUE, key, 0);
		System.out.println("Low level command: blpop -> "+o.toString());
	} catch (Exception e) {
		System.out.println("Low level command: blpop Error-> "+e);
	}
}

protected void blpopAsync () {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BLPOP Async ");
	try {
		RFuture<Object> o = Redis.redissonMasterSlave.getBlockingDeque(key).takeAsync();
		System.out.println("blpop Async "+key+" -> " +o.get());
	} catch (Exception e) {
		System.out.println(e);
	}
}

BLPOP -> takeLast, takeLastAsync

// BRPOP key [key ...] timeout -> return RedisFuture<KeyValue<String, String>>
protected void brpop() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BRPOP key [key ...] timeout -> return Object ");
	try {
		Object o = Redis.redissonMasterSlave.getBlockingDeque(key).takeLast();
		System.out.println("brpop "+key+" -> " +o.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Object
	try {
		Object o = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BRPOP_VALUE, key, 0);
		System.out.println("Low level command: brpop -> "+o.toString());
	} catch (Exception e) {
		System.out.println("Low level command: brpop Error-> "+e);
	}
}

protected void brpopAsync() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BRPOP Async ");
	try {
		RFuture<Object> o = Redis.redissonMasterSlave.getBlockingDeque(key).takeLastAsync();
		System.out.println("brpop Async "+key+" -> " +o.get());
	} catch (Exception e) {
		System.out.println(e);
	}
}

BRPOPLPUSH -> pollLastAndOfferFirstTo, pollLastAndOfferFirstToAsync

// BRPOPLPUSH source destination timeout -> return 
protected void brpoplpush() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BRPOPLPUSH source destination timeout -> return  ");
	try {
		Object o = Redis.redissonMasterSlave.getBlockingDeque(key).pollLastAndOfferFirstTo("destkey");
		System.out.println("brpoplpush "+key+" -> " +o.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return Object
	try {
		Object o = Redis.connLowLevel.sync(StringCodec.INSTANCE, RedisCommands.BRPOPLPUSH, key, "destkey", 0);
		System.out.println("Low level command: brpoplpush -> "+o.toString());
	} catch (Exception e) {
		System.out.println("Low level command: brpoplpush Error-> "+e);
	}
}

// BRPOPLPUSH source destination timeout -> return 
protected void brpoplpushAsync() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("BRPOPLPUSH Async  ");
	try {
		RFuture<Object> o = Redis.redissonMasterSlave.getBlockingDeque(key).pollLastAndOfferFirstToAsync("destkey");
		System.out.println("brpoplpush Async "+key+" -> " +o.get());
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Strings	Lists	Sets >>

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