1. Jedis Hashes Demos

对应redis命令参考：redis hashes组命令

package samples.cache.jedis;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.Jedis;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

/**
 * @author Zi Lai Ye
 * @date 2017/10/15
 */
public class JedisHashTests {
    public static final Logger logger = LoggerFactory.getLogger(JedisListTests.class);

    public static final String HOST = "localhost";
    public static final int PORT = 6379;

    private Jedis jedis;

    public static final String KEY = "user:20";
    public static final String ID = "id";
    public static final String NAME = "name";
    public static final String AGE = "age";

    public static final Long ONE = 1L;
    public static final Long ZERO = 0L;

    public static final String KEY1 = "key1";

    @Before
    public void beforeClass() {
        jedis = new Jedis(HOST, PORT);
//        jedis.flushDB();
    }

    @After
    public void afterClass() {
//        jedis.flushDB();
        jedis.close();
    }

    // hset 将哈希表 key 中的域 field 的值设为 value 。
    @Test
    public void hset() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果key不存在, 会先创建一个, 再执行hset操作, 如果field不存在, 设置成功返回1
        Long hsetResult = jedis.hset(KEY, ID, "20");
        assertEquals(Long.valueOf(1), hsetResult);
        assertEquals("20", jedis.hget(KEY, ID));

        // 如果field已存在, 值会被覆盖, 返回 0
        hsetResult = jedis.hset(KEY, ID, "21");
        assertEquals(Long.valueOf(0), hsetResult);
        assertEquals("21", jedis.hget(KEY, ID));

        // 如果 key 类型不是hash类型, 报错
        jedis.set("key1", "v1");

        try {
            hsetResult = jedis.hset("key1", ID, "20");
        } catch (Exception e) {
            logger.error("对非 hash 类型的key进行hset操作, 会抛异常:", e);
        }
    }

    // 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。
    @Test
    public void hsetnx() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果 key 不存在, 会先创建一个该key的hash表, 然后做hsetnx操作
        Long hsetnxResult = jedis.hsetnx(KEY, ID, "20");
        // 设置成功返回1
        assertEquals(ONE, hsetnxResult);
        assertEquals("20", jedis.hget(KEY, ID));

        // 如果field已存在, 不会进行任何操作, 返回0
        hsetnxResult = jedis.hsetnx(KEY, ID, "21");
        assertEquals(ZERO, hsetnxResult);
        assertEquals("20", jedis.hget(KEY, ID));

        // 如果key类型不是hash, 报错
        jedis.set(KEY1, "v1");
        try {
            jedis.hsetnx(KEY1, ID, "20");
        } catch (Exception e) {
            logger.info("对不是hash类型的key进行hsetnx操作, 报错:", e);
        }
    }

    // hget 返回哈希表 key 中给定域 field 的值。
    @Test
    public void hget() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果 key不存在, 返回null
        String hgetResult = jedis.hget(KEY, ID);
        assertNull(hgetResult);

        jedis.hset(KEY, ID, "20");
        // 如果 key 存在, field 不存在, 返回null
        hgetResult = jedis.hget(KEY, NAME);
        assertNull(hgetResult);

        // 如果 key 和 field 都存在, 返回 field的值
        hgetResult = jedis.hget(KEY, ID);
        assertEquals("20", hgetResult);

        // 如果 key 的类型不是hash, 报错
        jedis.set(KEY1, "v1");
        try {
            jedis.hget(KEY1, ID);
        } catch (Exception e) {
            logger.error("如果 hget 操作的key的类型不是hash类型, 报错:", e);
        }
    }

    @Test
    public void hgetall() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果给定的key不存在, 返回空集合
        Map<String, String> hgetAllResult = jedis.hgetAll(KEY);
        assertNotNull(hgetAllResult);
        assertEquals(0, hgetAllResult.size());

        jedis.hset(KEY, ID, "20");
        jedis.hset(KEY, NAME, "user20");
        jedis.hset(KEY, AGE, "18");

        hgetAllResult = jedis.hgetAll(KEY);
        assertEquals(3, hgetAllResult.size());
        assertEquals("20", hgetAllResult.get(ID));
        assertEquals("user20", hgetAllResult.get(NAME));
        assertEquals("18", hgetAllResult.get(AGE));

        // 如果给定的Key不是hash类型, 报错
        jedis.set(KEY1, "v1");

        try {
            jedis.hgetAll(KEY1);
        } catch (Exception e) {
            logger.info("key 类型错误, 报错:", e);
        }
    }

    @Test
    public void hdel() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果指定的key不存在, 返回 0
        Long hdelResult = jedis.hdel(KEY, ID);
        assertEquals(ZERO, hdelResult);

        // 如果指定的field不存在, 返回 0
        jedis.hset(KEY, ID, "20");
        hdelResult = jedis.hdel(KEY, NAME);
        assertEquals(ZERO, hdelResult);

        // 如果指定的 field 存在, 删除此域
        assertEquals("20", jedis.hget(KEY, ID));
        hdelResult = jedis.del(KEY, ID);
        assertEquals(ONE, hdelResult);
        assertNull(jedis.hget(KEY, ID));

        // 如果指定的key不是hash类型, 报错
        jedis.set(KEY1, "v1");
        try {
            jedis.hdel(KEY1, ID);
        } catch (Exception e) {
            logger.error("如果指定的key不是hash类型, 报错:", e);
        }
    }

    @Test
    public void hexists() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果指定的key不存在, 返回 false
        Boolean hexistsResult = jedis.hexists(KEY, ID);
        assertFalse(hexistsResult);

        // 如果指定的field不存在, 返回 false
        jedis.hset(KEY, ID, "20");
        hexistsResult = jedis.hexists(KEY, NAME);
        assertFalse(hexistsResult);

        // 如果指定的field存在, 返回true
        assertTrue(jedis.hexists(KEY, ID));

        // 如果key不是hash类型, 报错
        jedis.set(KEY1, "v1");
        try {
            jedis.hexists(KEY1, ID);
        } catch (Exception e) {
            logger.error("key 类型不是hash类型, 报错:", e);
        }
    }

    @Test
    public void hkeys() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果key不存在, 返回空set
        Set<String> hkeysResult = jedis.hkeys(KEY);
        assertNotNull(hkeysResult);
        assertEquals(0, hkeysResult.size());

        // 如果 key 存在, 返回 key 所有的field
        jedis.hset(KEY, ID, "20");
        jedis.hset(KEY, NAME, "user20");
        jedis.hset(KEY, AGE, "20");

        hkeysResult = jedis.hkeys(KEY);
        assertEquals(3, hkeysResult.size());

        // 如果 key类型不是hash, 报错
        jedis.set(KEY1, "v1");

        try {
            jedis.hkeys(KEY1);
        } catch (Exception e) {
            logger.error("key 不是 hash类型, 报错:", e);
        }
    }

    @Test
    public void hlen() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // key 不存在, 返回 0
        Long hlenResult = jedis.hlen(KEY);
        assertEquals(ZERO, hlenResult);

        // key 存在, 返回 fields 数量
        jedis.hset(KEY, ID, "20");
        jedis.hset(KEY, NAME, "user20");
        jedis.hset(KEY, AGE, "20");

        hlenResult = jedis.hlen(KEY);
        assertEquals(Long.valueOf(3), hlenResult);

        // key 非hash类型, 报错
        jedis.set(KEY1, "v1");

        try {
            jedis.hlen(KEY1);
        } catch (Exception e) {
            logger.error("key 非 hash 类型, 报错: ", e);
        }
    }

    @Test
    public void hvals() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        // 如果 key 不存在, 返回空列表
        List<String> hvalsValue = jedis.hvals(KEY);
        assertEquals(0, hvalsValue.size());

        // 如果 key 存在 ,返回fields的数量
        jedis.hset(KEY, ID, "20");
        jedis.hset(KEY, NAME, "user20");
        jedis.hset(KEY, AGE, "20");

        hvalsValue = jedis.hvals(KEY);

        assertEquals(3, hvalsValue.size());
        assertEquals("20", hvalsValue.get(0));
        assertEquals("user20", hvalsValue.get(1));
        assertEquals("20", hvalsValue.get(2));

        // 如果 key 不是 Hash 类型, 报错
        jedis.set(KEY1, "v1");

        try {
            jedis.hvals(KEY1);
        } catch (Exception e) {
            logger.error("如果 key 不是 Hash 类型, 报错", e);
        }
    }

    @Test
    public void hmset() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        Map<String, String> fieldValues = new HashMap<String, String>();
        fieldValues.put(ID, "20");
        fieldValues.put(NAME, "user20");
        fieldValues.put(AGE, "18");

        jedis.hmset(KEY, fieldValues);

        assertEquals("20", jedis.hget(KEY, ID));
        assertEquals("user20", jedis.hget(KEY, NAME));
        assertEquals("18", jedis.hget(KEY, AGE));
    }

    @Test
    public void hmget() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        Map<String, String> fieldValues = new HashMap<String, String>();
        fieldValues.put(ID, "20");
        fieldValues.put(NAME, "user20");
        fieldValues.put(AGE, "18");

        jedis.hmset(KEY, fieldValues);

        List<String> hmgetResult = jedis.hmget(KEY, ID, NAME, AGE, "NotExistsKey");
        assertEquals(4, hmgetResult.size());
        assertEquals("20", hmgetResult.get(0));
        assertEquals("user20", hmgetResult.get(1));
        assertEquals("18", hmgetResult.get(2));
        assertNull(hmgetResult.get(3));
    }

    @Test
    public void hincrby() {
        if (jedis.exists(KEY)) {
            jedis.del(KEY);
        }

        final String countStr = "count";

        // key 不存在, field不存在, 不影响
        Long count = jedis.hincrBy(KEY, countStr, 2);
        assertEquals(Long.valueOf(2), count);

        // 可以设置负值
        count = jedis.hincrBy(KEY, countStr, -1);
        assertEquals(ONE, count);

        // 如果field不是数值类型, 报错
        jedis.hset(KEY, NAME, "user20");
        try {
            jedis.hincrBy(KEY, NAME, 2);
        } catch (Exception e) {
            logger.error("field不是整数类型, hincrby报错:", e);
        }

        // 如果 key 不存在, 报错
        jedis.set(KEY1, "v1");
        try {
            jedis.hincrBy(KEY1, ID, 2);
        } catch (Exception e) {
            logger.error("key 不是 hash类型, hincrby报错:", e);
        }
    }
}