Redisson ZSets

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

ZSets

스코어가 있으면 getScoredSortedSet()을 사용하고, 없으면 getLexSortedSet()을 사용한다.

Class 변수로 선언

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

ZADD -> add, addAll

// ZADD key [NX|XX] [CH] [INCR] score member [score member ...] -> return long or double
// add된 member 개수 리턴
protected void zadd() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZADD key [NX|XX] [CH] [INCR] score member [score member ...] -> return Boolean or Long");
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		// zadd
		Boolean ret = Redis.redissonMasterSlave.getScoredSortedSet(key).add(60, "경기");
		// zadd map
		Map<Object, Double> map = new HashMap<Object, Double>();
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		Long count = Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);
		System.out.println("zadd "+key+" -> "+ret+" "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREM -> remove, removeAll

// ZREM key member [member] -> return long
protected void zrem() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREM key member [member] ->  return Boolean");
	try {
		Boolean ret1 = Redis.redissonMasterSlave.getScoredSortedSet(key).remove("경기");
		// zadd map
		List<String> list = new ArrayList<String>();
		list.add("서울");
		list.add("부산");
		Boolean ret2 = Redis.redissonMasterSlave.getScoredSortedSet(key).removeAll(list);
		System.out.println("zrem "+key+" -> "+ret1+" "+ret2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGE -> valueRange

// ZRANGE key start stop [withscores] -> return List<String> 
protected void zrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGE key start stop [withscores] -> return Collection<Object> ");
	try {
		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRange(0,  -1);
		System.out.println("zrange "+key+" -> "+list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZCARD -> size

// ZCARD key -> return long
protected void zcard() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZCARD key -> return int");
	try {
		int size = Redis.redissonMasterSlave.getScoredSortedSet(key).size();
		System.out.println("zcard "+key+" -> "+size);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYSCORE -> valueRange

// ZRANGEBYSCORE key min max [withscores] [limit offset count] -> return List<String> 
protected void zrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGEBYSCORE key min max [withscores] [limit offset count] -> return List<String>  ");
	try {
		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRange(40, true, 80, true);
		System.out.println("zrangebyscore "+key+" -> "+list.toString());
		Collection<Object> list2 = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRange(40, false, 80, false);
		System.out.println("zrangebyscore "+key+" -> "+list2.toString());		
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZCOUNT -> count

// ZCOUNT key min max
protected void zcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZCOUNT key min max -> return long");
	try {
		Long count1 = Redis.redissonMasterSlave.getScoredSortedSet(key).count(40, true, 80,  true);
		Long count2 = Redis.redissonMasterSlave.getScoredSortedSet(key).count(40, false, 80,  false);
		System.out.println("zrangebyscore "+key+" -> "+count1+" "+count2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYLEX -> range

// ZRANGEBYLEX key min max [limit offset count] -> return List<String>
protected void zrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGEBYLEX key min max [limit offset count] -> return List<String>");
	try {
		Redis.redissonMasterSlave.getLexSortedSet(key).delete();
		// zadd list
		List<String> list = new ArrayList<String>();
		list.add("경기");
		list.add("서울");
		list.add("부산");
		list.add("대전");
		list.add("전라");
		Redis.redissonMasterSlave.getLexSortedSet(key).addAll(list);

		Collection<String> list1 = Redis.redissonMasterSlave.getLexSortedSet(key).range("경기", true, "전라", true);
		System.out.println("zrangebylex "+key+" -> "+list1.toString());
		Collection<String> list2 = Redis.redissonMasterSlave.getLexSortedSet(key).range("경기", false, "전라", false);
		System.out.println("zrangebylex "+key+" -> "+list2.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZLEXCOUNT -> count

// ZLEXCOUNT key min max -> return long
protected void zlexcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZLEXCOUNT key min max -> return long");
	try {
		int size1 = Redis.redissonMasterSlave.getLexSortedSet(key).count("경기", true, "전라", true);
		int size2 = Redis.redissonMasterSlave.getLexSortedSet(key).count("경기", false, "전라", false);
		System.out.println("zlexcount "+key+" -> "+size1+" "+size2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYRANK -> removeRangeByRank

// ZREMRANGEBYRANK key start stop -> return long
protected void zremrangebyrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYRANK key start stop -> return long");
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		// zadd map
		Map<Object, Double> map = new HashMap<Object, Double>();
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("경기", 60d);
		map.put("전라", 80d);
		map.put("대전", 100d);
		Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);
		// zremrangebyrank
		int count = Redis.redissonMasterSlave.getScoredSortedSet(key).removeRangeByRank(1, 3);
		System.out.println("zremrangebyrank "+key+" -> "+count);
		// zrange
		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRange(0,  -1);
		System.out.println("zrange "+key+" -> "+list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYSCORE -> removeRangeByScore

// ZREMRANGEBYSCORE key min max -> return long
protected void zremrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYSCORE key min max -> return int");
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		// zadd map
		Map<Object, Double> map = new HashMap<Object, Double>();
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("경기", 60d);
		map.put("전라", 80d);
		map.put("대전", 100d);
		Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);
		// zremrangebyscore
		int count = Redis.redissonMasterSlave.getScoredSortedSet(key).removeRangeByScore(40d, true, 80d, true);
		System.out.println("zremrangebyscore "+key+" -> "+count);
		// zrange
		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRange(0,  -1);
		System.out.println("zrange "+key+" -> "+list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYLEX -> removeRange

// ZREMRANGEBYLEX key min max -> return long
protected void zremrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYLEX key min max -> return long");
	try {
		Redis.redissonMasterSlave.getLexSortedSet(key).delete();
		// zadd list
		List<String> list = new ArrayList<String>();
		list.add("경기");
		list.add("서울");
		list.add("부산");
		list.add("대전");
		list.add("전라");
		Redis.redissonMasterSlave.getLexSortedSet(key).addAll(list);

		int count = Redis.redissonMasterSlave.getLexSortedSet(key).removeRange("부산", true, "전라", true);
		System.out.println("zremrangebylex "+key+" -> "+count);
		// zrange
		Collection<String> list2 = Redis.redissonMasterSlave.getLexSortedSet(key).range(0, -1);
		System.out.println("zrangebylex "+key+" -> "+list2.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGE -> valueRangeReversed

// ZREVRANGE key start stop [withscores] -> return List<String>
protected void zrevrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGE key start stop [withscores] -> return List<String>");
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		// zadd map
		Map<Object, Double> map = new HashMap<Object, Double>();
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("경기", 60d);
		map.put("전라", 80d);
		map.put("대전", 100d);
		Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);

		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRangeReversed(0, -1);
		System.out.println("zrevrange "+key+" -> "+list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYSCORE -> valueRangeReversed

// ZREVRANGEBYSCORE key max min [withscores] [limit offset count] -> return List<String>
protected void zrevrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGEBYSCORE key max min [withscores] [limit offset count] -> return List<String>");
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		// zadd map
		Map<Object, Double> map = new HashMap<Object, Double>();
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("경기", 60d);
		map.put("전라", 80d);
		map.put("대전", 100d);
		Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);

		Collection<Object> list = Redis.redissonMasterSlave.getScoredSortedSet(key).valueRangeReversed(40d, true, 80d, true);
		System.out.println("zrevrangebyscore "+key+" -> "+list.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYLEX -> range

// ZREVRANGEBYLEX key max min [limit offset count] -> return List<String>
protected void zrevrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGEBYLEX key max min [limit offset count] -> return Collection<String>");
	try {
		Redis.redissonMasterSlave.getLexSortedSet(key).delete();
		// zadd list
		List<String> list = new ArrayList<String>();
		list.add("서울");
		list.add("부산");
		list.add("경기");
		list.add("전라");
		list.add("대전");
		Redis.redissonMasterSlave.getLexSortedSet(key).addAll(list);

		Collection<String> list2 = Redis.redissonMasterSlave.getLexSortedSet(key).readAll();
		System.out.println("zrange "+key+" -> "+list2.toString());

		Collection<String> list3 = Redis.redissonMasterSlave.getLexSortedSet(key).range(0, -1);
		System.out.println("zrevrangebylex "+key+" -> "+list3.toString());

		Collection<String> list4 = Redis.redissonMasterSlave.getLexSortedSet(key).range(1, 3);
		System.out.println("zrevrangebylex "+key+" -> "+list4.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANK -> rank

// ZRANK key member -> return long
protected void zrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANK key member -> return Integer");
	try {
		Integer rank1 = Redis.redissonMasterSlave.getScoredSortedSet(key).rank("대전");
		Integer rank2 = Redis.redissonMasterSlave.getScoredSortedSet(key).rank("서울");
		System.out.println("zrank "+key+" -> "+rank1+" "+rank2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANK -> revRank

// ZREVRANK key member -> return long
protected void zrevrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANK key member -> return long");
	try {
		Integer rank1 = Redis.redissonMasterSlave.getScoredSortedSet(key).revRank("대전");
		Integer rank2 = Redis.redissonMasterSlave.getScoredSortedSet(key).revRank("서울");
		System.out.println("zrevrank "+key+" -> "+rank1+" "+rank2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCORE -> getScore

// ZSCORE key member -> return double
protected void zscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZSCORE key member -> return double");
	try {
		Double score1 = Redis.redissonMasterSlave.getScoredSortedSet(key).getScore("대전");
		Double score2 = Redis.redissonMasterSlave.getScoredSortedSet(key).getScore("서울");
		System.out.println("zscore "+key+" -> "+score1+" "+score2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINCRBY -> addScore

// ZINCRBY key increment member -> return double
protected void zincrby() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZINCRBY key increment member -> return double");
	long time = System.currentTimeMillis(); 
	String key = "daily_views";
	String mem = new SimpleDateFormat("yyyyMMdd").format(time);		
	try {
		Double score = Redis.redissonMasterSlave.getScoredSortedSet(key).addScore(mem, 1);
		System.out.println("zincrby "+key+" -> "+score);
		score = Redis.redissonMasterSlave.getScoredSortedSet(key).addScore(mem, 1);
		System.out.println("zincrby "+key+" -> "+score);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZUNIONSTORE -> union

// ZUNIONSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long
protected void zunionstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZUNIONSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long");
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey1).delete();
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey2).delete();
		// zadd map
		Map<Object, Double> map1 = new HashMap<Object, Double>();
		map1.put("A", 1d);
		map1.put("B", 2d);
		map1.put("C", 3d);
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey1).addAll(map1);

		Map<Object, Double> map2 = new HashMap<Object, Double>();
		map2.put("B", 4d);
		map2.put("C", 5d);
		map2.put("D", 6d);
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey2).addAll(map2);
		
		int size = Redis.redissonMasterSlave.getScoredSortedSet(destKey).union(srcKey1, srcKey2);
		Collection<Object> set = Redis.redissonMasterSlave.getScoredSortedSet(destKey).readAll();
		System.out.println("zunionstore "+destKey+" -> "+size+" "+set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINTERSTORE -> intersection

// ZINTERSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long
protected void zinterstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZINTERSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long");
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey1).delete();
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey2).delete();
		// zadd map
		Map<Object, Double> map1 = new HashMap<Object, Double>();
		map1.put("A", 1d);
		map1.put("B", 2d);
		map1.put("C", 3d);
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey1).addAll(map1);

		Map<Object, Double> map2 = new HashMap<Object, Double>();
		map2.put("B", 4d);
		map2.put("C", 5d);
		map2.put("D", 6d);
		Redis.redissonMasterSlave.getScoredSortedSet(srcKey2).addAll(map2);
		
		int size = Redis.redissonMasterSlave.getScoredSortedSet(destKey).intersection(srcKey1, srcKey2);
		Collection<Object> set = Redis.redissonMasterSlave.getScoredSortedSet(destKey).readAll();
		System.out.println("zinterstore "+destKey+" -> "+size+" "+set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCAN -> iterator

// ZSCAN key cursor [MATCH pattern] [COUNT count]
// zscan은 항상 withscores이다.
protected void zscan() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZSCAN key cursor [MATCH pattern] [COUNT count] -> return ");
	String p = "_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
	try {
		Redis.redissonMasterSlave.getScoredSortedSet(key).delete();
		Map<Object, Double> map = new HashMap<Object, Double>();
		for (int i=65; i<91; i++) {
			map.put( (Character.toString((char) i)+p), (double) i);
		}
		/* Long size = */ Redis.redissonMasterSlave.getScoredSortedSet(key).addAll(map);
		
		// Collection<Object> set = Redis.redissonMasterSlave.getScoredSortedSet(key).readAll();
		// System.out.println("zrange "+key+" -> "+size+" "+set.toString());

		Iterator<Object> iter = Redis.redissonMasterSlave.getScoredSortedSet(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);
	}
}

<< Sets	ZSets	Hashes >>

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