Redis——封裝通用的Redis組件

 

前言

鑒於公司Redis目前的使用現狀及問題，架構組將提供統一Redis使用方案，在通用組件包內置redis功能，提高開發效率，降低項目的耦合性。以下是我這次設計改造的過程。

 

一、Redis使用現狀

1、每個應用使用jedis自行配置並實現訪問redis的功能。具體依賴如下：

<dependency>
   <groupId>redis.clients</groupId>     
   <artifactId>jedis</artifactId>
   <version>2.9.0</version>
</dependency>

2、目前各應用redis使用情況如下：

 

 

二、Redis使用問題

1、每個應用單獨實現redis，造成冗余，增加使用復雜度；

2、每個應用單獨實現redis，不同應用之間，可能會出現重復的key；

3、每個應用單獨實現redis，目前沒有約束，容易造成一些不可預知的風險；

 

三、Redis使用方案

鑒於目前現狀及問題，基礎架構組提供統一redis使用方案，具體如下：

1、組件包提供redis功能，各應用直接使用它來操作redis。各應用無需在單獨實現redis功能；

2、組件包提供了對redis  中5種類型的常規操作方法；

3、組件包對redis所有的操作，會對key進行特殊處理（增加前綴：集群名稱:應用名稱），從而保證key的唯一性。但對各應用來說是透明的。

      例如：code  ——>  mrp:umpg:code

4、對【非字符串類型】，獲取所有元素的方法（如：hgetall、lrange、smembers、zrange等等），進行了限制（最多返回2000個元素）；

5、對【集合類型】，（sinter、sunion、sdiff）方法，進行了限制（單個key不能超過2000個元素）；

6、對【非字符串類型】，如果有bigkey，不要使用del方法刪除，組件提供了相關方法（delBigHash、delBigList、delBigSet、delBigZset）漸進式刪除。

………

 

四、實現設計

在通用組件包中，增加redis標簽定義，標簽解析，初始化jedisCluster的功能。新增加中間件包【zat-middleware】，將具體的實現邏輯放在這里。各應用如果標簽了這個標簽，在服務啟動時就進行相應的處理。

• 組件包【esbproxy】修改：

1. esb.xsd：增加redis標簽元素；
2. RedisConfig：增加redis配置類；
3. Namespacehandler：增加對redis標簽處理；
4. EsbBeanDefinitionParser：解析redis標簽，將標簽的屬性轉換成RedisConfig對象的屬性值；
5. Scanner：初始化 zat-middleware 包；
6. AnnotationBean：初始化jedisCluster對象；

 

• 中間件包【zat-middleware】： 

1. JedisClusterFactory：jedisCluster的工廠類， JedisPool連接池的實現；
2. RedisClusterUtil：操作redis集群的工具類；
3. AbstracRedisCluster：公共抽像類，包含一些通用的方法；
4. RedisConst：redis常量類；

 

五、Redis使用方法

配置redis標簽：

在*-config.xml 配置文件中，增加redis標簽，填寫相關屬性值（可固定值或從配置中心獲取）

<esb:redis address="${redis.url}" timeout="${redis.timeout}" maxRedirections="${redis.maxRedirections}" maxTotal="${redis.maxTotal}"
maxIdle="${redis.maxIdle}" minIdle="${redis.minIdle}" maxWaitMillis="${redis.maxWait}" testOnBorrow="${redis.testOnBorrow}" testOnCreate="${redis.testOnCreate}" testOnReturn="${redis.testOnReturn}"/>

使用方法：

RedisClusterUtils.getInstance().set(key, value);
RedisClusterUtils.getInstance().get(key);

注：這里只舉例了2個方法。

刪除應用原有redis 實現：

避免重復實現，如果應用中已經以實現redis的功能，需把它刪除掉，具體方法如下：

1、刪除配置文件，一般是：context-redis.xml或 context-beans.xml；

2、刪除初始化類，一般是：SimpleJedisCluster.java；

3、刪除具體實現類，一般是：RedisDao.java或RedisUtil.java；

 

六、注意事項

1、原有應用使用了redis，現改造成使用組件包中的redis后，需要進行壓力測試。

2、組件包中操作redis的所有方法，都沒有處理異常。對於有些應用要吃掉異常的場景，請在應用中自行處理。

 

七、單元測試

package com.zat.umpg.bus.redis;

import com.zat.redis.util.RedisClusterUtils;
import com.zat.sproxy.logger.Logger;
import com.zat.sproxy.logger.LoggerFactory;
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.Tuple;

import javax.servlet.annotation.WebListener;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Redis集群單元測試類.
 *
 * @author weixiong.cao
 * @date 22/04/2020
 * @version 1.0
 */
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@WebListener
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/context-*.xml","classpath:conf/*/*.xml"})
public class RedisClusterUtilTest extends TestCase {

    /**
     * logger.
     */
    private static Logger logger = LoggerFactory.getLogger(RedisClusterUtilTest.class);

    @Before
    public void before() throws Exception {
    }

    @After
    public void after() throws Exception {
    }

    public static final String value_end = "_value";

    /**
     * 存入並獲取數據.
     */
    @Test
    public void testSetAndGet() {
        String key = "unittest:set";
        String value = key + value_end;
        RedisClusterUtils.getInstance().set(key, value);
        String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【set】 {}={}", key, redisValue);
        assertEquals("set失敗，查詢結果不等於期望值", value, redisValue);
    }

    /**
     * 存入並獲取數據—不存在時.
     */
    @Test
    public void testSetnxAndGet() {
        String key = "unittest:setnx";
        String value = key + value_end;
        RedisClusterUtils.getInstance().setnx(key, value);
        String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【setnx】 {}={}", key, redisValue);
        assertEquals("setnx失敗，查詢結果不等於期望值", value, redisValue);
    }

    /**
     * 存入並獲取數據—自動刪除.
     */
    @Test
    public void testSetExpireAndGet() throws InterruptedException {
        String key = "unittest:setex";
        String value = key + value_end;
        RedisClusterUtils.getInstance().setex(key, value, 3);
        Thread.sleep(5000);
        String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【setex】 {}={}", key, redisValue);
        assertNull("setex失敗，過期時間后還能查到值", redisValue);
    }

    /**
     * 設置過期時間.
     */
    @Test
    public void testExpire() throws InterruptedException {
        String key = "unittest:expire";
        String value = key + value_end;
        RedisClusterUtils.getInstance().set(key, value);
        RedisClusterUtils.getInstance().expire(key, 3);
        Thread.sleep(5000);
        final String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【expire】 {}={}", key, redisValue);
        assertNull("expire失敗，過期時間后還能查到值", redisValue);
    }

    /**
     * 刪除key.
     */
    @Test
    public void testDel() {
        String key = "unittest:del";
        String value = key + value_end;
        RedisClusterUtils.getInstance().set(key, value);
        final Long del = RedisClusterUtils.getInstance().del(key);
        final String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【del】 {}={}", key, redisValue);
        assertEquals("del失敗，返回結果不為1", "1", del.toString());
        assertNull("del失敗，還能查到值", redisValue);
    }

    /**
     * 判斷是否存在.
     */
    @Test
    public void testExists() {
        String key = "unittest:exists";
        String value = key + value_end;
        RedisClusterUtils.getInstance().set(key, value);
        final boolean exists = RedisClusterUtils.getInstance().exists(key);
        logger.info("【exists】 {}={}", key, exists);
        assertEquals("exists失敗，返回結果不為true", "true", String.valueOf(exists));
    }

    /**
     * key的值加1.
     */
    @Test
    public void testIncr() {
        String key = "unittest:incr";
        RedisClusterUtils.getInstance().del(key);
        long incr = 0l;
        incr = RedisClusterUtils.getInstance().incr(key, 0);
        incr = RedisClusterUtils.getInstance().incr(key, 0);
        incr = RedisClusterUtils.getInstance().incr(key, 0);
        logger.info("【incr】 {}={}", key, incr);
        assertEquals("incr失敗，返回結果不為3", "3", String.valueOf(incr));
    }

    /**
     * key的值加給定值.
     */
    @Test
    public void testIncrBy() {
        String key = "unittest:incrby";
        RedisClusterUtils.getInstance().del(key);
        long incr = 0l;
        incr = RedisClusterUtils.getInstance().incrBy(key, 5);
        incr = RedisClusterUtils.getInstance().incrBy(key, 10);
        logger.info("【incrby】 {}={}", key, incr);
        assertEquals("incrby失敗，返回結果不為15", "15", String.valueOf(incr));
    }

    /**
     * key的值加給定值—自動刪除.
     */
    @Test
    public void testIncrExpirt() throws InterruptedException {
        long incr = 0l;
        String key = "unittest:incr_expirt";
        RedisClusterUtils.getInstance().del(key);
        incr = RedisClusterUtils.getInstance().incr(key, 5);
        incr = RedisClusterUtils.getInstance().incr(key, 5);
        incr = RedisClusterUtils.getInstance().incr(key, 5);
        logger.info("【incr_expirt】 {}={}", key, incr);
        Thread.sleep(6000);
        final String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【incr_expirt】 {}={}", key, redisValue);
        assertNull("incr_expirt失敗，還能查到值", redisValue);
    }

    /**
     * key的值減1.
     */
    @Test
    public void testDecr() {
        String key = "unittest:decr";
        RedisClusterUtils.getInstance().del(key);

        // 先增加3
        long incr = 0l;
        incr = RedisClusterUtils.getInstance().incr(key, 0);
        incr = RedisClusterUtils.getInstance().incr(key, 0);
        incr = RedisClusterUtils.getInstance().incr(key, 0);

        // 再減2
        incr = RedisClusterUtils.getInstance().decr(key, 0);
        incr = RedisClusterUtils.getInstance().decr(key, 0);

        // 最終等於1
        logger.info("【decr】 {}={}", key, incr);
        assertEquals("decr失敗，返回結果不為1", "1", String.valueOf(incr));
    }

    /**
     * key的值減給定值.
     */
    @Test
    public void testDecrBy() {
        String key = "unittest:decrby";
        RedisClusterUtils.getInstance().del(key);

        // 先增加30
        long incr = 0l;
        incr = RedisClusterUtils.getInstance().incrBy(key, 10);
        incr = RedisClusterUtils.getInstance().incrBy(key, 10);
        incr = RedisClusterUtils.getInstance().incrBy(key, 10);

        // 再減20
        incr = RedisClusterUtils.getInstance().decrBy(key, 10);
        incr = RedisClusterUtils.getInstance().decrBy(key, 10);

        // 最終等於10
        logger.info("【decrby】 {}={}", key, incr);
        assertEquals("decr失敗，返回結果不為10", "10", String.valueOf(incr));
    }

    /**
     * key的值減給定值—自動刪除.
     * @throws InterruptedException
     */
    @Test
    public void testDecrExpirt() throws InterruptedException {
        String key = "unittest:decr_expirt";
        RedisClusterUtils.getInstance().del(key);

        // 先增加3
        long incr = 0l;
        incr = RedisClusterUtils.getInstance().incr(key, 10);
        incr = RedisClusterUtils.getInstance().incr(key, 10);
        incr = RedisClusterUtils.getInstance().incr(key, 10);

        // 再減2
        incr = RedisClusterUtils.getInstance().decr(key, 10);
        incr = RedisClusterUtils.getInstance().decr(key, 10);
        logger.info("【decr_expirt】 {}={}", key, incr);
        Thread.sleep(11000);
        final String redisValue = RedisClusterUtils.getInstance().get(key);
        logger.info("【decr_expirt】 {}={}", key, redisValue);
        assertNull("decr_expirt失敗，還能查到值", redisValue);
    }


    // =================================================================================================================
    // list列表操作
    // =================================================================================================================
    @Test
    public void testlpush() {
        String key = "unittest:lpush";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go");

        final Long llen = RedisClusterUtils.getInstance().llen(key);
        logger.info("【lpush】 {}={}", key, llen);
        assertEquals("lpush失敗，返回結果不為2", "2", String.valueOf(llen));
    }

    @Test
    public void testrpush() {
        String key = "unittest:rpush";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().rpush(key, "payhon", "c++");

        final Long llen = RedisClusterUtils.getInstance().llen(key);
        logger.info("【rpush】 {}={}", key, llen);
        assertEquals("rpush失敗，返回結果不為2", "2", String.valueOf(llen));
    }

    @Test
    public void testlrem() {
        String key = "unittest:lrem";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "python", "c++");
        RedisClusterUtils.getInstance().lrem(key, "c++");
        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, 1);
        final String redisValue = lrange.get(0);
        logger.info("【lrem】 {}={}", key, redisValue);
        assertEquals("lrem失敗，返回結果不為1", "1", String.valueOf(lrange.size()));
        assertEquals("lrem失敗，返回結果不為python", "python", redisValue);
    }

    @Test
    public void testllen() {
        String key = "unittest:llen";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");

        final Long llen = RedisClusterUtils.getInstance().llen(key);
        logger.info("【llen】 {}={}", key, llen);
        assertEquals("llen失敗，返回結果不為4", "4", String.valueOf(llen));
    }

    @Test
    public void testlset() {
        String key = "unittest:lset";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");
        RedisClusterUtils.getInstance().lset(key, 0, "c++1");
        RedisClusterUtils.getInstance().lset(key, 2, "go1");

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        final String redisValue0 = lrange.get(0);
        final String redisValue2 = lrange.get(2);
        logger.info("【lset】 {}={}", key, redisValue0);
        logger.info("【lset】 {}={}", key, redisValue2);
        assertEquals("lset失敗，返回結果不為c++1", "c++1", redisValue0);
        assertEquals("lset失敗，返回結果不為go1", "go1", redisValue2);
    }

    @Test
    public void testlindex() {
        String key = "unittest:lindex";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");
        final String redisValue = RedisClusterUtils.getInstance().lindex(key, 0);
        logger.info("【lindex】 {}={}", key, redisValue);
        assertEquals("lindex失敗，返回結果不為c++", "c++", redisValue);
    }

    @Test
    public void testlrange() {
        String key = "unittest:lrange";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        logger.info("【lrange】 {}={}", key, lrange);
        assertEquals("lrange失敗，返回結果不為4", "4", String.valueOf(lrange.size()));
    }

    @Test
    public void testlrangeLimit() {
        String key = "unittest:lrange_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().lpush(key, "java" + i);
        }

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        logger.info("【lrange_limit】 {}={}", key, lrange.size());
        logger.info("【lrange_limit】 {}={}", key, lrange);
        assertEquals("lrange_limit失敗，返回結果不為2000", "2000", String.valueOf(lrange.size()));
    }

    @Test
    public void testltrim() {
        String key = "unittest:ltrim";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");
        RedisClusterUtils.getInstance().ltrim(key, 0, 1);

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        logger.info("【ltrim】 {}={}", key, lrange);
        assertEquals("ltrim失敗，返回結果不為2", "2", String.valueOf(lrange.size()));
    }

    @Test
    public void testlpop() {
        String key = "unittest:lpop";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");
        final String redisValue = RedisClusterUtils.getInstance().lpop(key);

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        logger.info("【lpop】 {}={}", key, redisValue);
        logger.info("【lpop】 {}={}", key, lrange);
        assertEquals("lpop失敗，返回結果不為c++", "c++", redisValue);
        assertEquals("lpop失敗，返回結果不為3", "3", String.valueOf(lrange.size()));
    }

    @Test
    public void testrpop() {
        String key = "unittest:rpop";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().lpush(key, "java", "go", "python", "c++");
        final String redisValue = RedisClusterUtils.getInstance().rpop(key);

        final List<String> lrange = RedisClusterUtils.getInstance().lrange(key, 0, -1);
        logger.info("【rpop】 {}={}", key, redisValue);
        logger.info("【rpop】 {}={}", key, lrange);
        assertEquals("rpop失敗，返回結果不為java", "java", redisValue);
        assertEquals("rpop失敗，返回結果不為3", "3", String.valueOf(lrange.size()));
    }

    @Test
    public void testdelBigList() {
        String key = "unittest:delbigList";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=10000; i++) {
            RedisClusterUtils.getInstance().lpush(key, "java" + i);
        }
        Long llen = RedisClusterUtils.getInstance().llen(key);
        logger.info("【delbigList】 {}={}", key, llen);
        assertEquals("delbigList失敗，返回結果不為10000", "10000", String.valueOf(llen));

        RedisClusterUtils.getInstance().delBigList(key);
        llen = RedisClusterUtils.getInstance().llen(key);
        logger.info("【delbigList】 {}={}", key, llen);
        assertEquals("delbigList失敗，返回結果不為0", "0", String.valueOf(llen));
    }



    // =================================================================================================================
    // map哈希操作
    // =================================================================================================================
    @Test
    public void testhset() {
        String key = "unittest:hset";
        String field = "name";
        String value = "caoweixiong";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().hset(key, field, value);
        final String redisValue = RedisClusterUtils.getInstance().hget(key, field);
        logger.info("【hset】 {}={}", key, redisValue);
        assertEquals("hset失敗，返回結果不為caoweixiong", value, redisValue);
    }

    @Test
    public void testhget() {
        String key = "unittest:hget";
        String field1 = "name";
        String value1 = "caoweixiong";
        String field2 = "age";
        String value2 = "35";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().hset(key, field1, value1);
        RedisClusterUtils.getInstance().hset(key, field2, value2);
        final String redisValue1 = RedisClusterUtils.getInstance().hget(key, field1);
        final String redisValue2 = RedisClusterUtils.getInstance().hget(key, field2);
        logger.info("【hget】 {}={}", key, redisValue1);
        logger.info("【hget】 {}={}", key, redisValue2);
        assertEquals("hset失敗，返回結果不為caoweixiong", value1, redisValue1);
        assertEquals("hget失敗，返回結果不為35", value2, redisValue2);
    }

    @Test
    public void testhsetnx() {
        String key = "unittest:hsetnx";
        String field = "name";
        String value = "caoweixiong";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().hsetnx(key, field, value);
        final String redisValue1 = RedisClusterUtils.getInstance().hget(key, field);
        logger.info("【hsetnx】 {}={}", key, redisValue1);
        assertEquals("hsetnx失敗，返回結果不為caoweixiong", value, redisValue1);

        RedisClusterUtils.getInstance().hsetnx(key, field, "caoweixiong2");
        final String redisValue2 = RedisClusterUtils.getInstance().hget(key, field);
        logger.info("【hsetnx】 {}={}", key, redisValue2);
        assertEquals("hsetnx失敗，返回結果不為caoweixiong", value, redisValue2);
    }

    @Test
    public void testhmset() {
        String key = "unittest:hmset";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final Long hlen = RedisClusterUtils.getInstance().hlen(key);
        logger.info("【hmset】 {}={}", key, hlen);
        assertEquals("hmset失敗，返回結果不為3", "3", String.valueOf(hlen));
    }

    @Test
    public void testhmget() {
        String key = "unittest:hmget";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final List<String> hmget = RedisClusterUtils.getInstance().hmget(key, "name", "age");
        logger.info("【hmget】 {}={}", key, hmget);
        assertEquals("hmget失敗，返回結果不為2", "2", String.valueOf(hmget.size()));
    }

    @Test
    public void testhlen() {
        String key = "unittest:hlen";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final Long hlen = RedisClusterUtils.getInstance().hlen(key);
        logger.info("【hlen】 {}={}", key, hlen);
        assertEquals("hlen失敗，返回結果不為3", "3", String.valueOf(hlen));
    }

    @Test
    public void testhdel() {
        String key = "unittest:hdel";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        RedisClusterUtils.getInstance().hdel(key, "name", "sex");

        final Long hlen = RedisClusterUtils.getInstance().hlen(key);
        logger.info("【hdel】 {}={}", key, hlen);
        assertEquals("hdel失敗，返回結果不為1", "1", String.valueOf(hlen));
    }

    @Test
    public void testhexists() {
        String key = "unittest:hexists";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        Boolean name = RedisClusterUtils.getInstance().hexists(key, "name");
        logger.info("【hexists】 {}={}", key, name);
        assertEquals("hexists失敗，返回結果不為true", "true", String.valueOf(name));

        RedisClusterUtils.getInstance().hdel(key, "name");
        name = RedisClusterUtils.getInstance().hexists(key, "name");
        logger.info("【hexists】 {}={}", key, name);
        assertEquals("hexists失敗，返回結果不為false", "false", String.valueOf(name));
    }

    @Test
    public void testhkeys() {
        String key = "unittest:hkeys";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final Set<String> hkeys = RedisClusterUtils.getInstance().hkeys(key);
        logger.info("【hkeys】 {}={}", key, hkeys);
        assertEquals("hkeys失敗，返回結果不為3", "3", String.valueOf(hkeys.size()));
    }

    @Test
    public void testhkeysLimit() {
        String key = "unittest:hkeys_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }
        final Set<String> hkeys = RedisClusterUtils.getInstance().hkeys(key);
        logger.info("【hkeys_limit】 {}={}", key, hkeys.size());
        logger.info("【hkeys_limit】 {}={}", key, hkeys);
        assertEquals("hkeys_limit失敗，返回結果不為2000", "2000", String.valueOf(hkeys.size()));
    }

    @Test
    public void testhvals() {
        String key = "unittest:hvals";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final List<String> hvals = RedisClusterUtils.getInstance().hvals(key);
        logger.info("【hvals】 {}={}", key, hvals);
        assertEquals("hvals失敗，返回結果不為3", "3", String.valueOf(hvals.size()));
    }

    @Test
    public void testhvalsLimit() {
        String key = "unittest:hvals_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }
        final List<String> hvals = RedisClusterUtils.getInstance().hvals(key);
        logger.info("【hvals_limit】 {}={}", key, hvals.size());
        logger.info("【hvals_limit】 {}={}", key, hvals);
        assertEquals("hvals_limit失敗，返回結果不為2000", "2000", String.valueOf(hvals.size()));
    }

    @Test
    public void testhgetall() {
        String key = "unittest:hgetall";
        RedisClusterUtils.getInstance().del(key);
        Map<String, String> hashValue = new HashMap<>();
        hashValue.put("name", "caoweixiong");
        hashValue.put("age", "35");
        hashValue.put("sex", "man");
        RedisClusterUtils.getInstance().hmset(key, hashValue);

        final Map<String, String> allMap = RedisClusterUtils.getInstance().hgetAll(key);
        logger.info("【hgetall】 {}={}", key, allMap);
        assertEquals("hgetall失敗，返回結果不為3", "3", String.valueOf(allMap.size()));
    }

    @Test
    public void testhgetallLimit() {
        String key = "unittest:hgetall_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }
        final Map<String, String> allMap = RedisClusterUtils.getInstance().hgetAll(key);
        logger.info("【hgetall_limit】 {}={}", key, allMap.size());
        logger.info("【hgetall_limit】 {}={}", key, allMap);
        assertEquals("hgetall_limit失敗，返回結果不為2000", "2000", String.valueOf(allMap.size()));
    }

    @Test
    public void testhscan() {
        String key = "unittest:hscan";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        do {
            final ScanResult<Map.Entry<String, String>> scanResult = RedisClusterUtils.getInstance().hscan(key, cursor);
            final List<Map.Entry<String, String>> entityList = scanResult.getResult();
            if (null != entityList && !entityList.isEmpty()) {
                for (Map.Entry<String, String> entry : entityList) {
                    allMap.put(entry.getKey(), entry.getValue());
                }
            }
            logger.info("cursor={}", cursor);
            cursor = scanResult.getStringCursor();
        } while (!"0".equals(cursor));

        logger.info("【hscan】 {}={}", key, allMap.size());
        logger.info("【hscan】 {}={}", key, allMap);
        assertEquals("hscan失敗，返回結果不為2100", "2100", String.valueOf(allMap.size()));
    }

    @Test
    public void testhscanParam() {
        String key = "unittest:hscan_param";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        ScanParams params = new ScanParams();
        params.count(200);
        params.match("name1*");
        do {
            final ScanResult<Map.Entry<String, String>> scanResult = RedisClusterUtils.getInstance().hscan(key, cursor, params);
            final List<Map.Entry<String, String>> entityList = scanResult.getResult();
            if (null != entityList && !entityList.isEmpty()) {
                for (Map.Entry<String, String> entry : entityList) {
                    allMap.put(entry.getKey(), entry.getValue());
                }
            }
            logger.info("cursor={}", cursor);
            cursor = scanResult.getStringCursor();
        } while (!"0".equals(cursor));

        logger.info("【hscan_param】 {}={}", key, allMap.size());
        logger.info("【hscan_param】 {}={}", key, allMap);
        assertEquals("hscan_param失敗，返回結果不為1111", "1111", String.valueOf(allMap.size()));
    }

    @Test
    public void testdelBigHash() {
        String key = "unittest:delBigHash";
        for (int i=1; i<=10000; i++) {
            RedisClusterUtils.getInstance().hset(key, "name" + i, "cwx" + i);
        }
        Long hlen = RedisClusterUtils.getInstance().hlen(key);
        logger.info("【delBigHash】 {}={}", key, hlen);
        assertEquals("delBigHash失敗，返回結果不為10000", "10000", String.valueOf(hlen));

        RedisClusterUtils.getInstance().delBigHash(key);

        hlen = RedisClusterUtils.getInstance().hlen(key);
        logger.info("【delBigHash】 {}={}", key, hlen);
        assertEquals("delBigHash失敗，返回結果不為0", "0", String.valueOf(hlen));
    }



    // =================================================================================================================
    // set集合操作
    // =================================================================================================================
    @Test
    public void testsadd() {
        String key = "unittest:sadd";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().sadd(key, "apple");
        RedisClusterUtils.getInstance().sadd(key, "orange", "banana");

        final Long scard = RedisClusterUtils.getInstance().scard(key);
        logger.info("【sadd】 {}={}", key, scard);
        assertEquals("sadd失敗，返回結果不為3", "3", String.valueOf(scard));
    }

    @Test
    public void testsrem() {
        String key = "unittest:srem";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().sadd(key, "apple", "orange", "banana");
        Long scard = RedisClusterUtils.getInstance().scard(key);
        logger.info("【srem】 {}={}", key, scard);
        assertEquals("srem失敗，返回結果不為3", "3", String.valueOf(scard));

        RedisClusterUtils.getInstance().srem(key, "apple");

        scard = RedisClusterUtils.getInstance().scard(key);
        logger.info("【srem】 {}={}", key, scard);
        assertEquals("srem失敗，返回結果不為2", "2", String.valueOf(scard));
    }

    @Test
    public void testscard() {
        String key = "unittest:scard";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().sadd(key, "orange", "banana");

        final Long scard = RedisClusterUtils.getInstance().scard(key);
        logger.info("【scard】 {}={}", key, scard);
        assertEquals("scard失敗，返回結果不為2", "2", String.valueOf(scard));
    }

    @Test
    public void testsismember() {
        String key = "unittest:sismember";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().sadd(key, "apple", "orange", "banana");
        boolean apple = RedisClusterUtils.getInstance().sismember(key, "apple");
        logger.info("【sismember】 {}={}", key, apple);
        assertEquals("sismember失敗，返回結果不為true", "true", String.valueOf(apple));

        RedisClusterUtils.getInstance().srem(key, "apple");

        apple = RedisClusterUtils.getInstance().sismember(key, "apple");
        logger.info("【sismember】 {}={}", key, apple);
        assertEquals("sismember失敗，返回結果不為false", "false", String.valueOf(apple));
    }

    @Test
    public void testsmembers() {
        String key = "unittest:smembers";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().sadd(key, "apple", "orange", "banana");

        final Set<String> smembers = RedisClusterUtils.getInstance().smembers(key);
        logger.info("【smembers】 {}={}", key, smembers);
        assertEquals("smembers失敗，返回結果不為3", "3", String.valueOf(smembers.size()));
    }

    @Test
    public void testsmembersLimit() {
        String key = "unittest:smembers_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().sadd(key, "apple" + i);
        }

        final Set<String> smembers = RedisClusterUtils.getInstance().smembers(key);
        logger.info("【smembers_limit】 {}={}", key, smembers.size());
        logger.info("【smembers_limit】 {}={}", key, smembers);
        assertEquals("smembers_limit失敗，返回結果不為2000", "2000", String.valueOf(smembers.size()));
    }

    @Test
    public void testsunion() {
        String key1 = "{unittest:sunion}1";
        String key2 = "{unittest:sunion}2";
        RedisClusterUtils.getInstance().del(key1);
        RedisClusterUtils.getInstance().del(key2);
        RedisClusterUtils.getInstance().sadd(key1, "apple", "orange", "banana");
        RedisClusterUtils.getInstance().sadd(key2, "apple", "pea", "red");

        final Set<String> smembers = RedisClusterUtils.getInstance().sunion(key1, key2);
        logger.info("【sunion】 {}", smembers);
        assertEquals("sunion失敗，返回結果不為5", "5", String.valueOf(smembers.size()));
    }

    @Test
    public void testsdiff() {
        String key1 = "{unittest:sdiff}1";
        String key2 = "{unittest:sdiff}2";
        RedisClusterUtils.getInstance().del(key1);
        RedisClusterUtils.getInstance().del(key2);
        RedisClusterUtils.getInstance().sadd(key1, "apple", "orange", "banana");
        RedisClusterUtils.getInstance().sadd(key2, "apple", "pea", "red");

        final Set<String> smembers = RedisClusterUtils.getInstance().sdiff(key1, key2);
        logger.info("【sdiff】 {}", smembers);
        assertEquals("sdiff，返回結果不為2", "2", String.valueOf(smembers.size()));
    }

    @Test
    public void testsinter() {
        String key1 = "{unittest:sinter}1";
        String key2 = "{unittest:sinter}2";
        RedisClusterUtils.getInstance().del(key1);
        RedisClusterUtils.getInstance().del(key2);
        RedisClusterUtils.getInstance().sadd(key1, "apple", "orange", "banana");
        RedisClusterUtils.getInstance().sadd(key2, "apple", "pea", "red");

        final Set<String> smembers = RedisClusterUtils.getInstance().sinter(key1, key2);
        logger.info("【sinter】 {}", smembers);
        assertEquals("sinter失敗，返回結果不為1", "1", String.valueOf(smembers.size()));
    }

    @Test
    public void testsscan() {
        String key = "unittest:sscan";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().sadd(key, "java" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        do {
            final ScanResult<String> scanResult = RedisClusterUtils.getInstance().sscan(key, cursor);
            final List<String> result = scanResult.getResult();
            if (null != result && !result.isEmpty()) {
                for (String member : result) {
                    allMap.put(member, member);
                }
            }
            logger.info("cursor={}", cursor);
            cursor = scanResult.getStringCursor();
        } while (!"0".equals(cursor));

        logger.info("【sscan】 {}={}", key, allMap.size());
        logger.info("【sscan】 {}={}", key, allMap);
        assertEquals("sscan失敗，返回結果不為2100", "2100", String.valueOf(allMap.size()));
    }

    @Test
    public void testhsscanParam() {
        String key = "unittest:sscan_param";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().sadd(key, "java" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        ScanParams params = new ScanParams();
        params.count(200);
        params.match("java1*");
        do {
            final ScanResult<String> scanResult = RedisClusterUtils.getInstance().sscan(key, cursor, params);
            final List<String> result = scanResult.getResult();
            if (null != result && !result.isEmpty()) {
                for (String member : result) {
                    allMap.put(member, member);
                }
            }
            logger.info("cursor={}", cursor);
            cursor = scanResult.getStringCursor();
        } while (!"0".equals(cursor));
        logger.info("【sscan_param】 {}={}", key, allMap.size());
        logger.info("【sscan_param】 {}={}", key, allMap);
        assertEquals("sscan_param失敗，返回結果不為1111", "1111", String.valueOf(allMap.size()));
    }

    @Test
    public void testdelBigSset() {
        String key = "unittest:delBigSset";
        for (int i=1; i<=10000; i++) {
            RedisClusterUtils.getInstance().sadd(key, "java" + i);
        }
        Long hlen = RedisClusterUtils.getInstance().scard(key);
        logger.info("【delBigSset】 {}={}", key, hlen);
        assertEquals("delBigSset失敗，返回結果不為10000", "10000", String.valueOf(hlen));

        RedisClusterUtils.getInstance().delBigSet(key);

        hlen = RedisClusterUtils.getInstance().scard(key);
        logger.info("【delBigSset】 {}={}", key, hlen);
        assertEquals("delBigSset失敗，返回結果不為0", "0", String.valueOf(hlen));
    }


    // =================================================================================================================
    // zset有序集合操作
    // =================================================================================================================
    @Test
    public void testzadd() {
        String key = "unittest:zadd";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");

        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zadd】 {}={}", key, zrange.size());
        logger.info("【zadd】 {}={}", key, zrange);
        assertEquals("zadd失敗，返回結果不為1", "1", String.valueOf(zrange.size()));
    }

    @Test
    public void testzaddMap() {
        String key = "unittest:zadd_map";
        RedisClusterUtils.getInstance().del(key);

        Map<String, Double> score = new HashMap<>();
        score.put("java", 80d);
        score.put("go", 90d);
        score.put("python", 100d);
        RedisClusterUtils.getInstance().zadd(key, score);

        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zadd_map】 {}={}", key, zrange.size());
        logger.info("【zadd_map】 {}={}", key, zrange);
        assertEquals("zadd_map失敗，返回結果不為3", "3", String.valueOf(zrange.size()));
    }

    @Test
    public void testzrange() {
        String key = "unittest:zrange";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zrange】 {}={}", key, zrange.size());
        logger.info("【zrange】 {}={}", key, zrange);
        assertEquals("zrange失敗，返回結果不為2", "2", String.valueOf(zrange.size()));
    }

    @Test
    public void testzrangeLimit() {
        String key = "unittest:zrange_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().zadd(key, 80 + i, "java" + i);
        }
        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zrange_limit】 {}={}", key, zrange.size());
        logger.info("【zrange_limit】 {}={}", key, zrange);
        assertEquals("zrange_limit失敗，返回結果不為2000", "2000", String.valueOf(zrange.size()));
    }

    @Test
    public void testzrangeWithScores() {
        String key = "unittest:zrangeWithScores";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        double score;
        final Set<Tuple> go = RedisClusterUtils.getInstance().zrangeWithScores(key, 0, -1);
        for (Tuple tuple : go) {
            score = tuple.getScore();
            logger.info("【zrangeWithScores】 {}={}", tuple.getElement(), score);
        }
        assertEquals("zrangeWithScores失敗，返回結果不為2", "2", String.valueOf(go.size()));
    }

    @Test
    public void testzrangeWithScoresLimit() {
        String key = "unittest:zrangeWithScores_limit";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().zadd(key, 80 + i, "java" + i);
        }

        double score;
        final Set<Tuple> go = RedisClusterUtils.getInstance().zrangeWithScores(key, 0, -1);
        logger.info("【zrangeWithScores_limit】 {}={}", key, go.size());
        for (Tuple tuple : go) {
            score = tuple.getScore();
            logger.info("【zrangeWithScores_limit】 {}={}", tuple.getElement(), score);
        }
        assertEquals("zrangeWithScores_limit失敗，返回結果不為2000", "2000", String.valueOf(go.size()));
    }

    @Test
    public void testzrevrangeByScore() {
        String key = "unittest:zrevrangeByScore";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        double score;
        final Set<String> strings = RedisClusterUtils.getInstance().zrevrangeByScore(key, "100", "90", 0, 100);
        for (String s : strings) {
            logger.info("【zrevrangeByScore】 {}={}", key, s);
        }
        assertEquals("zrevrangeByScore失敗，返回結果不為2", "2", String.valueOf(strings.size()));
    }

    @Test
    public void testzcard() {
        String key = "unittest:zcard";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        final Long zcard = RedisClusterUtils.getInstance().zcard(key);
        logger.info("【zcard】 {}={}", key, zcard);
        assertEquals("zcard失敗，返回結果不為2", "2", String.valueOf(zcard));
    }

    @Test
    public void testzrem() {
        String key = "unittest:zrem";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        Long zcard = RedisClusterUtils.getInstance().zcard(key);
        logger.info("【zrem】 {}={}", key, zcard);
        assertEquals("zrem失敗，返回結果不為2", "2", String.valueOf(zcard));

        RedisClusterUtils.getInstance().zrem(key, "java");

        zcard = RedisClusterUtils.getInstance().zcard(key);
        logger.info("【zrem】 {}={}", key, zcard);
        assertEquals("zrem失敗，返回結果不為1", "1", String.valueOf(zcard));
    }

    @Test
    public void testzremrangeByRank() {
        String key = "unittest:zremrangeByRank";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Long zcount = RedisClusterUtils.getInstance().zremrangeByRank(key, 2, 2);
        logger.info("【zremrangeByRank】 {}={}", key, zcount);

        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zremrangeByRank】 {}={}", key, zrange.size());
        logger.info("【zremrangeByRank】 {}={}", key, zrange);

        assertEquals("zremrangeByRank失敗，移除分值第3名的成員後，大小不等於2", "2", String.valueOf(zrange.size()));
    }

    @Test
    public void testzremrangeByScore() {
        String key = "unittest:zremrangeByScore";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Long zcount = RedisClusterUtils.getInstance().zremrangeByScore(key, 80, 90);
        logger.info("【zremrangeByScore】 {}={}", key, zcount);

        final Set<String> zrange = RedisClusterUtils.getInstance().zrange(key, 0, -1);
        logger.info("【zremrangeByScore】 {}={}", key, zrange.size());
        logger.info("【zremrangeByScore】 {}={}", key, zrange);

        assertEquals("zremrangeByScore失敗，移除分值80~90的成員後，大小不等於1", "1", String.valueOf(zrange.size()));
    }

    @Test
    public void testzscore() {
        String key = "unittest:zscore";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        final Double java = RedisClusterUtils.getInstance().zscore(key, "java");
        logger.info("【zscore】 {}={}", key, java);
        assertEquals("zscore失敗，成員java的分值不等於80", "80.0", String.valueOf(java));
    }

    @Test
    public void testzcount() {
        String key = "unittest:zcount";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Long zcount = RedisClusterUtils.getInstance().zcount(key, 90, 100);
        logger.info("【zcount】 {}={}", key, zcount);
        assertEquals("zcount失敗，分值在90~100之間的成員不等於2", "2", String.valueOf(zcount));
    }

    @Test
    public void testzincrby() {
        String key = "unittest:zincrby";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        final Double java = RedisClusterUtils.getInstance().zincrby(key, 1, "java");
        logger.info("【zincrby】 {}={}", key, java);

        final Double java1 = RedisClusterUtils.getInstance().zscore(key, "java");
        logger.info("【zincrby】 {}={}", key, java1);
        assertEquals("zincrby失敗，返回結果不為81", "81.0", String.valueOf(java1));
    }

    @Test
    public void testzrank() {
        String key = "unittest:zrank";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");

        final Long java = RedisClusterUtils.getInstance().zrank(key, "go");
        logger.info("【zrank】 {}={}", key, java);

        assertEquals("zrank失敗，返回結果不為1", "1", String.valueOf(java));
    }

    @Test
    public void testzrevrank() {
        String key = "unittest:zrevrank";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Long java = RedisClusterUtils.getInstance().zrevrank(key, "python");
        logger.info("【zrevrank】 {}={}", key, java);

        assertEquals("zrevrank失敗，返回結果不為0", "0", String.valueOf(java));
    }

    @Test
    public void testzrevrange() {
        String key = "unittest:zrevrange";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Set<String> zrevrange = RedisClusterUtils.getInstance().zrevrange(key, 0, -1);
        logger.info("【zrevrange】 {}={}", key, zrevrange);

        int i=0;
        String first = "";
        for (String s : zrevrange) {
            if (i==0) {
                first = s;
            }
            logger.info("【zrevrange】 {}{}={}", key, i, s);
            i++;
        }

        assertEquals("zrevrange失敗，排名第1的成員不是python", "python", first);
    }

    @Test
    public void testzrevrangeWithScores() {
        String key = "unittest:zrevrangeWithScores";
        RedisClusterUtils.getInstance().del(key);
        RedisClusterUtils.getInstance().zadd(key, 80, "java");
        RedisClusterUtils.getInstance().zadd(key, 90, "go");
        RedisClusterUtils.getInstance().zadd(key, 100, "python");

        final Set<Tuple> tuples = RedisClusterUtils.getInstance().zrevrangeWithScores(key, 0, -1);
        int i=0;
        String firstElement = "";
        double firstScore = 0;
        for (Tuple tuple : tuples) {
            if (i==0) {
                firstElement = tuple.getElement();
                firstScore = tuple.getScore();
            }
            logger.info("【zrevrangeWithScores】 {}_{}_{}={}", key, i, tuple.getElement(), tuple.getScore());
            i++;
        }
        assertEquals("zrevrangeWithScores失敗，排名第1的成員不是python", "python", firstElement);
        assertEquals("zrevrangeWithScores失敗，排名第1的成員的值不是100.0", "100.0", String.valueOf(firstScore));
    }

    @Test
    public void testzscan() {
        String key = "unittest:zscan";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().zadd(key, 80 + i, "java" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        do {
            final ScanResult<Tuple> zcanResult = RedisClusterUtils.getInstance().zscan(key, cursor);
            final List<Tuple> result = zcanResult.getResult();
            if (null != result && !result.isEmpty()) {
                for (Tuple tuple : result) {
                    allMap.put(tuple.getElement(), String.valueOf(tuple.getScore()));
                }
            }
            logger.info("cursor={}", cursor);
            cursor = zcanResult.getStringCursor();
        } while (!"0".equals(cursor));

        logger.info("【zscan】 {}={}", key, allMap.size());
        logger.info("【zscan】 {}={}", key, allMap);
        assertEquals("zscan失敗，返回結果不為2100", "2100", String.valueOf(allMap.size()));
    }

    @Test
    public void testhzcanParam() {
        String key = "unittest:zscan_param";
        RedisClusterUtils.getInstance().del(key);
        for (int i=1; i<=2100; i++) {
            RedisClusterUtils.getInstance().zadd(key, 80 + i, "java" + i);
        }

        final Map<String, String> allMap = new HashMap<>();
        String cursor = "0";
        ScanParams params = new ScanParams();
        params.count(200);
        params.match("java1*");
        do {
            final ScanResult<Tuple> zcanResult = RedisClusterUtils.getInstance().zscan(key, cursor, params);
            final List<Tuple> result = zcanResult.getResult();
            if (null != result && !result.isEmpty()) {
                for (Tuple tuple : result) {
                    allMap.put(tuple.getElement(), String.valueOf(tuple.getScore()));
                }
            }
            logger.info("cursor={}", cursor);
            cursor = zcanResult.getStringCursor();
        } while (!"0".equals(cursor));

        logger.info("【zscan_param】 {}={}", key, allMap.size());
        logger.info("【zscan_param】 {}={}", key, allMap);
        assertEquals("zscan_param失敗，返回結果不為1111", "1111", String.valueOf(allMap.size()));
    }

    @Test
    public void testdelBigZset() {
        String key = "unittest:delBigZset";
        for (int i=1; i<=10000; i++) {
            RedisClusterUtils.getInstance().zadd(key, 80 + i, "java" + i);
        }
        Long hlen = RedisClusterUtils.getInstance().zcard(key);
        logger.info("【delBigZset】 {}={}", key, hlen);
        assertEquals("delBigHash失敗，返回結果不為10000", "10000", String.valueOf(hlen));

        RedisClusterUtils.getInstance().delBigZset(key);

        hlen = RedisClusterUtils.getInstance().zcard(key);
        logger.info("【delBigZset】 {}={}", key, hlen);
        assertEquals("delBigZset失敗，返回結果不為0", "0", String.valueOf(hlen));
    }

}