Clients

Redisson Sets

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Sets

Sets에는 getSet(), getKeys()를 사용한다.

Class 변수로 선언

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

SADD -> add

// SADD key member [member ...] -> return Long
protected void sadd() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SADD key member [member ...] -> return Boolean");
	try {
		Boolean ret = Redis.redissonMasterSlave.getSet(key).add(value+idx);
		System.out.println("sadd "+key+" "+value+idx+" -> " +ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
	// Low level command -> return int
	/*
	try {
		int ret = Redis.conn.sync(StringCodec.INSTANCE, RedisCommands.SADD, key, value+idx);
		System.out.println("Low level command: sadd -> "+ret);
		idx++;
	} catch (Exception e) {
		System.out.println("Low level command: sadd Error-> "+e);
		e.printStackTrace();
	}
	*/
}

SREM -> remove

// SREM key member [member ...] -> return Long
protected void srem() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SREM key member [member ...] -> return Boolean");
	try {
		Boolean ret = Redis.redissonMasterSlave.getSet(key).remove(value+idx);
		System.out.println("srem "+key+" value"+idx+" -> " +ret);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMEMBERS -> readAll

// SMEMBERS key -> return Set<String>
protected void smembers() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SMEMBERS key -> return Set<Object>");
	try {
		Set<Object> set = Redis.redissonMasterSlave.getSet(key).readAll();
		System.out.println("smembers "+key+" -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SCARD -> size

// SCARD key -> return Long
protected void scard() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SCARD key -> return Long");
	try {
		long size = Redis.redissonMasterSlave.getSet(key).size();
		System.out.println("scard "+key+" -> " +size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SUNION -> readUnion

// SUNION key [key ...] -> return Set<String>
protected void sunion() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SUNION key [key ...] -> return Set<Object>");
	String key1 = "myset1", key2 = "myset2";
	try {
		Redis.redissonMasterSlave.getKeys().delete(key1, key2);
		
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("C");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		Set<Object> set3 = Redis.redissonMasterSlave.getSet(key1).readUnion(key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunion myset1 myset2 -> " +set3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTER -> readIntersection

// SINTER key [key ...] -> return Set<String>
protected void sinter() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SINTER key [key ...] -> return Set<Object>");
	String key1 = "myset1", key2 = "myset2";
	try {
		Redis.redissonMasterSlave.getKeys().delete(key1, key2);
		
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("C");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		Set<Object> set3 = Redis.redissonMasterSlave.getSet(key1).readIntersection(key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinter myset1 myset2 -> " +set3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFF -> readDiff

// SDIFF key [key ...] -> return Set<String>
protected void sdiff() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SDIFF key [key ...] -> return Set<Object>");
	String key1 = "myset1", key2 = "myset2";
	try {
		Redis.redissonMasterSlave.getKeys().delete(key1, key2);
		
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		Set<Object> set3 = Redis.redissonMasterSlave.getSet(key1).readDiff(key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiff myset1 myset2 -> " +set3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SUNIONSTORE -> union

// SUNIONSTORE destination_key source_key [source_key ...] -> return Long
protected void sunionstore() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SUNIONSTORE destination_key source_key [source_key ...] -> return Long");
	String key1 = "myset1", key2 = "myset2", dest_key = "dest_key";
	try {
		Redis.redissonMasterSlave.getKeys().delete(key1, key2);
		
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("C");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		int size = Redis.redissonMasterSlave.getSet(dest_key).union(key1, key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunionstore dest_key myset1 myset2 -> " +size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTERSTORE -> intersection

// SINTERSTORE destination_key source_key [source_key ...] -> return Long
protected void sinterstore() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SINTERSTORE destination_key source_key [source_key ...] -> return Long");
	String key1 = "myset1", key2 = "myset2", dest_key = "dest_key";
	try {
		Redis.redissonMasterSlave.getKeys().delete(key1, key2);
		
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("C");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		int size = Redis.redissonMasterSlave.getSet(dest_key).intersection(key1, key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinterstore dest_key myset1 myset2 -> " +size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFFSTORE -> diff

// SDIFFSTORE destination_key source_key [source_key ...] -> return Long
protected void sdiffstore() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SDIFFSTORE destination_key source_key [source_key ...] -> return Long");
	String key1 = "myset1", key2 = "myset2", dest_key = "dest_key";
	try {
		Set<Object> set1 = new HashSet<Object>();
		set1.add("A");
		set1.add("B");
		set1.add("C");
		Redis.redissonMasterSlave.getSet(key1).addAll(set1);
		
		Set<Object> set2 = new HashSet<Object>();
		set2.add("B");
		set2.add("D");
		Redis.redissonMasterSlave.getSet(key2).addAll(set2);

		int size  = Redis.redissonMasterSlave.getSet(dest_key).diff(key1, key2);
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiffstore dest_key myset1 myset2 -> " +size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SISMEMBER -> contains

// SISMEMBER key member -> return Boolean
protected void sismember() {
	System.out.println("-------------------------------------------------------------------------------------");
	System.out.println("SISMEMBER key member -> return Boolean");
	try {
		Redis.redissonMasterSlave.getKeys().delete(key);
		Set<Object> set = new HashSet<Object>();
		set.add("멤버_1");
		set.add("멤버_2");
		Redis.redissonMasterSlave.getSet(key).addAll(set);

		Set<Object> set2 = Redis.redissonMasterSlave.getSet(key).readAll();
		System.out.println("smembers "+key+" -> " +set2.toString());

		Boolean ret1 = Redis.redissonMasterSlave.getSet(key).contains("멤버_1");
		System.out.println("sismember "+key+" 멤버_1 -> " +ret1);
		Boolean ret2 = Redis.redissonMasterSlave.getSet(key).contains("멤버_X");
		System.out.println("sismember "+key+" 멤버_X -> " +ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMOVE -> move

// SMOVE source_key destination_key member -> return Boolean
protected void smove() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SMOVE source_key destination_key member -> return true/false");
	String src_key = "src_key", dest_key = "dest_key";
	try {
		Redis.redissonMasterSlave.getKeys().delete(src_key, dest_key);

		Set<Object> set = new HashSet<Object>();
		set.add("A");
		set.add("B");
		set.add("C");
		Redis.redissonMasterSlave.getSet(src_key).addAll(set);
	
		Set<Object> set2 = new HashSet<Object>();
		set2.add("D");
		Redis.redissonMasterSlave.getSet(dest_key).addAll(set2);

		Set<Object> set3 = Redis.redissonMasterSlave.getSet(src_key).readAll();
		System.out.println("smembers "+src_key+" -> " +set3.toString());
		Set<Object> set4 = Redis.redissonMasterSlave.getSet(dest_key).readAll();
		System.out.println("smembers "+dest_key+" -> " +set4.toString());

		Boolean move = Redis.redissonMasterSlave.getSet(src_key).move(dest_key, "A");
		System.out.println("smove src_key dest_key A -> "+move);
		
		Set<Object> set5 = Redis.redissonMasterSlave.getSet(src_key).readAll();
		System.out.println("smembers "+src_key+" -> " +set5.toString());
		Set<Object> set6 = Redis.redissonMasterSlave.getSet(dest_key).readAll();
		System.out.println("smembers "+dest_key+" -> " +set6.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SPOP -> removeRandom

// SPOP key [count] -> return String or Set<String>
protected void spop() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SPOP key [count] -> return String or Set<String>");
	try {
		Redis.redissonMasterSlave.getKeys().delete(key);
		
		Set<Object> set = new HashSet<Object>();
		set.add("멤버_1");
		set.add("멤버_2");
		set.add("멤버_3");
		Redis.redissonMasterSlave.getSet(key).addAll(set);
		
		Object m = Redis.redissonMasterSlave.getSet(key).removeRandom();
		System.out.println("spop "+key+" -> " +m);
		Set<Object> set2 = Redis.redissonMasterSlave.getSet(key).removeRandom(2);
		System.out.println("spop "+key+" 2 -> " +set2.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SRANDMEMBER -> random

// SRANDMEMBER key [count] -> return String
protected void srandmember() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SRANDMEMBER key [count] -> return String");
	try {
		Redis.redissonMasterSlave.getKeys().delete(key);
		
		Set<Object> set = new HashSet<Object>();
		set.add("멤버_1");
		set.add("멤버_2");
		set.add("멤버_3");
		set.add("멤버_4");
		set.add("멤버_5");
		set.add("멤버_6");
		set.add("멤버_7");
		set.add("멤버_8");
		set.add("멤버_9");
		Redis.redissonMasterSlave.getSet(key).addAll(set);
		Set<Object> set2 = Redis.redissonMasterSlave.getSet(key).readAll();
		System.out.println("smembers "+key+" -> " +set2.toString());
		// SRANDMEMBER
		Object m = Redis.redissonMasterSlave.getSet(key).random();
		System.out.println("srandmember "+key+" -> " +m);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SSCAN -> iterator

// SSCAN key cursor [MATCH pattern] [COUNT count] -> return 
protected void sscan() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("SSCAN key cursor [MATCH pattern] [COUNT count] -> return");
	try {
		Redis.redissonMasterSlave.getKeys().delete(key);

		Set<Object> set = new HashSet<Object>();
		set.add("A1");
		set.add("A2");
		set.add("A3");
		set.add("B1");
		set.add("B2");
		set.add("B3");
		set.add("C1");
		set.add("C2");
		set.add("C3");
		set.add("D1");
		set.add("D2");
		set.add("D3");
		set.add("E1");
		set.add("E2");
		set.add("E3");
		Redis.redissonMasterSlave.getSet(key).addAll(set);

		Set<Object> set2 = Redis.redissonMasterSlave.getSet(key).readAll();
		System.out.println("smembers "+key+" -> " +set2.toString());

		Iterator<Object> iter = Redis.redissonMasterSlave.getSet(key).iterator();
		int i=1;
		while (iter.hasNext()) {
							Object o = iter.next();
							System.out.println( (i++) +") "+o.toString());
					}
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Lists	Sets	ZSets >>

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