Lettuce Enterprise

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Hashes

Class 변수로 선언

String key = "user-1";

HSET

// HSET key field value -> return Boolean
protected void hset() {
	try {
		Redis.syncCmd.del(key);
		// return: 신규 필드이면 true, 이미 있는 필드이면 false, false라고 실패한 것이 아님.
		Boolean bool = Redis.syncCmd.hset(key, "email", "charlie@redisgate.com");
		System.out.println("hset "+key+" email charlie@redisgate.com -> "+bool);
		Boolean bool2 = Redis.syncCmd.hset(key, "language", "english");
		System.out.println("hset "+key+" language english -> "+bool2);
		Boolean bool3 = Redis.syncCmd.hset(key, "gender", "m");
		System.out.println("hset "+key+" gender m -> "+bool3);
		Boolean bool4 = Redis.syncCmd.hset(key, "gender", "f");
		System.out.println("hset "+key+" gender f -> "+bool4);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HDEL

// HDEL key field [field ...] -> return Long
protected void hdel() {
	try {
		// return: 삭제한 필드 개수
		Long count = Redis.syncCmd.hdel(key, "email");
		System.out.println("hdel "+key+" email -> "+count);
		Long count2 = Redis.syncCmd.hdel(key, "language", "gender");
		System.out.println("hdel "+key+" language gender -> "+count2);			
	} catch (Exception e) {
		System.out.println(e);
	}
}

HGET

// HGET key field -> return String
protected void hget() {
	try {
		// return: 해당 필드가 없으면 null
		String value = Redis.syncCmd.hget(key, "email");
		System.out.println("hget "+key+" email -> "+value);
		String value2 = Redis.syncCmd.hget(key, "language");
		System.out.println("hget "+key+" language -> "+value2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HLEN

// HLEN key -> return Long
protected void hlen() {
	try {
		// return: fields count
		Long count = Redis.syncCmd.hlen(key);
		System.out.println("hlen "+key+" -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HMSET

// HMSET key field value [field value ...] -> return String(OK)
protected void hmset() {
	Map<String, String> map = new HashMap<String, String>();
	map.put("email", "redisgate@gmail");
	map.put("language", "Korean");
	map.put("gender", "m");
	try {
		String ret = Redis.syncCmd.hmset(key, map);
		System.out.println("hmset "+key+" -> "+ret);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HMGET

// HMGET key field [field ...] -> return List<String>
protected void hmget() {
	try {
		List<String> list = Redis.syncCmd.hmget(key, "email", "language", "gender");
		System.out.println("hmget "+key+" -> "+list.toString());
		// Array
		String array[] = "email language gender".split(" ");
		List<String> list2 = Redis.syncCmd.hmget(key, array);
		System.out.println("hmget "+key+" -> "+list2.toString()+" (Array)");
		// ValueStreamingChannel
		Long count = Redis.syncCmd.hmget(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String value) {
				System.out.println("hmget (ValueStreamingChannel) -> " +value);
			}
		}, key, array);
		System.out.println("hmget (ValueStreamingChannel) -> "+count);
		// 해당 필드가 없으면 null을 리턴
	} catch (Exception e) {
		System.out.println(e);
	}
}

HKEYS

// HKEYS key -> return List<String>
protected void hkeys() {
	try {
		List<String> fields = Redis.syncCmd.hkeys(key);
		System.out.println("hkeys "+key+" -> "+fields.toString());
		// KeyStreamingChannel
		Long count = Redis.syncCmd.hkeys(new KeyStreamingChannel<String>() {
			@Override
			public void onKey(String value) {
				System.out.println("hkeys (KeyStreamingChannel) -> " +value);
			}
		}, key);
		System.out.println("hkeys (KeyStreamingChannel) -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HVALS

// HVALS key -> return List<String> or Long(ValueStreamingChannel)
protected void hvals() {
	try {
		List<String> values = Redis.syncCmd.hvals(key);
		System.out.println("hvals "+key+" -> "+values.toString());
		// ValueStreamingChannel
		Long count = Redis.syncCmd.hvals(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String value) {
				System.out.println("hkeys (ValueStreamingChannel) -> " +value);
			}
		}, key);
		System.out.println("hvals (ValueStreamingChannel) -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HGETALL

// HGETALL key
protected void hgetall() {
	try {
		Map<String, String> map = Redis.syncCmd.hgetall(key);
		System.out.println("hgetall "+key+" -> "+map.toString());
		// KeyValueStreamingChannel
		Long count = Redis.syncCmd.hgetall(new KeyValueStreamingChannel<String, String>() {
			@Override
			public void onKeyValue(String key, String value) {
				System.out.println("hgetall (KeyValueStreamingChannel) -> "+key+" "+value);
			}
		}, key);
		System.out.println("hgetall (KeyValueStreamingChannel) -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HSTRLEN

// HSTRLEN key field -> return Long
protected void hstrlen() {
	try {
		Long len = Redis.syncCmd.hstrlen(key, "email");
		System.out.println("hstrlen "+key+" email -> "+len);
		Long len2 = Redis.syncCmd.hstrlen(key, "language");
		System.out.println("hstrlen "+key+" language -> "+len2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HINCRBY

// HINCRBY key field incrment -> return Long
protected void hincrby() {
	try {
		Long value = Redis.syncCmd.hincrby(key, "visits", 1);
		System.out.println("hincrby "+key+" visits 1 -> "+value);
		Long value2 = Redis.syncCmd.hincrby(key, "visits", 5);
		System.out.println("hincrby "+key+" visits 5 -> "+value2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HINCRBYFLOAT

// HINCRBYFLOAT key field incrment -> return Double
protected void hincrbyfloat() {
	try {
		Double value = Redis.syncCmd.hincrbyfloat(key, "weight", 75.6);
		System.out.println("hincrbyfloat "+key+" weight 75.6 -> "+value);
		Double value2 = Redis.syncCmd.hincrbyfloat(key, "weight", 12.6);
		System.out.println("hincrbyfloat "+key+" weight 12.6 -> "+value2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HEXISTS

// HEXISTS key field -> return Boolean
protected void hexists() {
	try {
		Boolean bool = Redis.syncCmd.hexists(key, "email");
		System.out.println("hexists "+key+" email -> "+bool);
		Boolean bool2 = Redis.syncCmd.hexists(key, "XXX");
		System.out.println("hexists "+key+" XXX -> "+bool2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HSETNX

// HSETNX key field value -> return Boolean
protected void hsetnx() {
	try {
		Boolean bool = Redis.syncCmd.hsetnx(key, "email", "charlie@naver.com");
		System.out.println("hsetnx "+key+" email charlie@naver.com -> "+bool);
		Boolean bool2 = Redis.syncCmd.hsetnx(key, "email2", "charlie@naver.com");
		System.out.println("hsetnx "+key+" email2 charlie@naver.com -> "+bool2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

HSCAN

// HSCAN key cursor [MATCH pattern] [COUNT count] -> return MapScanCursor<String, String>
protected void hscan() {
	String key = "myhash";
	String p = "_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
	try {
		Redis.syncCmd.del(key);
		Map<String, String> map = new HashMap<String, String>();
		for (int i=65; i<91; i++) {
			map.put(Character.toString((char) i), (Character.toString((char) i)+p));
		}
		String ret = Redis.syncCmd.hmset(key, map);
		System.out.println("hmset "+key+" -> "+ret);
		// hscan 1
		MapScanCursor<String, String> mapScan = Redis.syncCmd.hscan(key);
		System.out.println("hscan "+key+" -> size: "+mapScan.getMap().size());
		for (Entry<String, String> m: mapScan.getMap().entrySet()) {
			System.out.println("hscan -> "+m.getKey()+" "+m.getValue());				
		}
		System.out.println("hscan "+key+" -> nextCursor: "+mapScan.getCursor()+", Finish: "+mapScan.isFinished());
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("do-while loop");
		MapScanCursor<String, String> mapScan2 = new MapScanCursor<String, String>();
		mapScan2.setCursor("0");
		int loop = 1;
		do {
			mapScan2 = Redis.syncCmd.hscan(key, mapScan2);
			System.out.println("Loop -> "+loop+", hscan "+key+" -> size: "+mapScan2.getMap().size());
			for (Entry<String, String> m: mapScan2.getMap().entrySet()) {
				System.out.println("hscan -> "+m.getKey()+" "+m.getValue());				
			}
			System.out.println("nextCursor -> "+mapScan2.getCursor()+", Finish: "+mapScan2.isFinished());
			loop++;
		} while (mapScan2.isFinished() == false);

		System.out.println("-------------------------------------------------------------------------");
		System.out.println("KeyValueStreamingChannel, do-while loop");
		StreamScanCursor stream = new StreamScanCursor();
		stream.setCursor("0");
		loop = 1;
		do {
			System.out.println("Loop -> "+loop);
			stream = Redis.syncCmd.hscan(new KeyValueStreamingChannel<String, String>() {
				@Override
				public void onKeyValue(String field, String value) {
					System.out.println("hscan (KeyValueStreamingChannel) -> " +field+" "+value);
				}
			}, key, stream);
			System.out.println("Size -> "+stream.getCount()+", nextCursor -> "+stream.getCursor()+", Finish: "+stream.isFinished());
			loop++;
		} while (stream.isFinished() == false);

		// match field name, limit
		System.out.println("-------------------------------------------------------------------------");
		ScanArgs args = new ScanArgs().match("F*").limit(5);
		MapScanCursor<String, String> mapScan3 = Redis.syncCmd.hscan(key, args);
		System.out.println("hscan "+key+" match F* limit 5 -> "+mapScan3.getMap().toString());

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

<< ZSets	Hashes	Pub/Sub >>

조회수 :

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