com.litongjava.redis.RedisCache Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-db Show documentation
Java Database
There is a newer version: 1.4.5
package com.litongjava.redis;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import com.jfinal.kit.StrKit;
import com.litongjava.db.kit.Func.F00;
import com.litongjava.db.kit.Func.F10;
import com.litongjava.db.kit.Func.F11;
import com.litongjava.redis.serializer.ISerializer;
import com.litongjava.tio.utils.json.JsonUtils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.params.SetParams;
import redis.clients.jedis.util.SafeEncoder;

/**
 * Cache. Cache api 添加了中文注释，便于工程师更方便使用，另外还原样保持了 Jedis api 的方法名称及使用方法，以便于仅仅通过查看
 * Redis 文档 即可快速掌握使用方法 Redis 命令参考: http://redisdoc.com/
 *
 * 注意：不要提供 strlen、append、setrange、getrange，经测试这类操作字符串的方法在序列化模式下无法工作 因为 String
 * 序列化后的 value 值为会多出来一些额外的字符
 */
public class RedisCache {

  protected String name;
  protected JedisPool jedisPool;
  protected ISerializer serializer;
  protected IKeyNamingPolicy keyNamingPolicy;

  protected final ThreadLocal threadLocalJedis = new ThreadLocal();

  /**
   * 使用 lambda 开放 Jedis API，建议优先使用本方法
   * 
   *    * 例子 1：
   *   Long ret = Redis.use().call(j -> j.incrBy("key", 1));
   *
   * 例子 2：
   *   Long ret = Redis.use().call(jedis -> {
   *       return jedis.incrBy("key", 1);
   *   });
   * 
   */
  public  R call(Function jedis) {
    Jedis jd = getJedis();
    try {
      return jedis.apply(jd);
    } finally {
      close(jd);
    }
  }

  protected RedisCache() {

  }

  public RedisCache(String name, JedisPool jedisPool, ISerializer serializer, IKeyNamingPolicy keyNamingPolicy) {
    this.name = name;
    this.jedisPool = jedisPool;
    this.serializer = serializer;
    this.keyNamingPolicy = keyNamingPolicy;
  }

  /**
   * 存放 key value 对到 redis 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。 对于某个原本带有生存时间（TTL）的键来说，
   * 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
   */
  public String set(Object key, Object value) {
    Jedis jedis = getJedis();
    try {
      return jedis.set(keyToBytes(key), valueToBytes(value));
    } finally {
      close(jedis);
    }
  }

  /**
   * setnx 的工作原理与 set 完全相同，唯一的区别是，如果 key 已经存在，则不执行任何操作
   * 
   * @return 1 表示 key 不存在，0 表示 key 存在
   */
  public Long setnx(Object key, Object value) {
    Jedis jedis = getJedis();
    try {
      return jedis.setnx(keyToBytes(key), valueToBytes(value));
    } finally {
      close(jedis);
    }
  }

  /**
   * 存放 key value 对到 redis，并将 key 的生存时间设为 seconds (以秒为单位)。 如果 key 已经存在， SETEX
   * 命令将覆写旧值。
   */
  public String setex(Object key, long seconds, Object value) {
    Jedis jedis = getJedis();
    try {
      return jedis.setex(keyToBytes(key), seconds, valueToBytes(value));
    } finally {
      close(jedis);
    }
  }

  /**
   * psetex 与 setex 功能相同，但是生存时间为 milliseconds (以毫秒为单位)。
   */
  public String psetex(Object key, long milliseconds, Object value) {
    Jedis jedis = getJedis();
    try {
      return jedis.psetex(keyToBytes(key), milliseconds, valueToBytes(value));
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回 key 所关联的 value 值 如果 key 不存在那么返回特殊值 nil 。
   */
  @SuppressWarnings("unchecked")
  public  T get(Object key) {
    Jedis jedis = getJedis();
    try {
      return (T) valueFromBytes(jedis.get(keyToBytes(key)));
    } finally {
      close(jedis);
    }
  }

  /**
   * 删除给定的一个 key 不存在的 key 会被忽略。
   */
  public Long del(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.del(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 删除给定的多个 key 不存在的 key 会被忽略。
   */
  public Long del(Object... keys) {
    Jedis jedis = getJedis();
    try {
      return jedis.del(keysToBytesArray(keys));
    } finally {
      close(jedis);
    }
  }

  /**
   * 查找所有符合给定模式 pattern 的 key 。 KEYS * 匹配数据库中所有 key 。 KEYS h?llo 匹配 hello ， hallo
   * 和 hxllo 等。 KEYS h*llo 匹配 hllo 和 heeeeello 等。 KEYS h[ae]llo 匹配 hello 和 hallo
   * ，但不匹配 hillo 。 特殊符号用 \ 隔开
   */
  public Set keys(String pattern) {
    Jedis jedis = getJedis();
    try {
      return jedis.keys(pattern);
    } finally {
      close(jedis);
    }
  }

  /**
   * 同时设置一个或多个 key-value 对。 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用
   * MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。 MSET 是一个原子性(atomic)操作，所有给定 key
   * 都会在同一时间内被设置，某些给定 key 被更新而另一些给定 key 没有改变的情况，不可能发生。
   * 
   *    * 例子：
   * Cache cache = RedisKit.use();			// 使用 Redis 的 cache
   * cache.mset("k1", "v1", "k2", "v2");		// 放入多个 key value 键值对
   * List list = cache.mget("k1", "k2");		// 利用多个键值得到上面代码放入的值
   * 
   */
  public String mset(Object... keysValues) {
    if (keysValues.length % 2 != 0)
      throw new IllegalArgumentException("wrong number of arguments for mset, keysValues length can not be odd");
    Jedis jedis = getJedis();
    try {
      byte[][] kv = new byte[keysValues.length][];
      for (int i = 0; i < keysValues.length; i++) {
        if (i % 2 == 0)
          kv[i] = keyToBytes(keysValues[i]);
        else
          kv[i] = valueToBytes(keysValues[i]);
      }
      return jedis.mset(kv);
    } finally {
      close(jedis);
    }
  }

  /**
   * 当且仅当所有给定键都不存在时， 为所有给定键设置值。 即使只有一个给定键已经存在， MSETNX 命令也会拒绝执行对所有键的设置操作。 MSETNX
   * 是一个原子性(atomic)操作， 所有给定键要么就全部都被设置， 要么就全部都不设置， 不可能出现第三种状态。
   */
  public Long msetnx(Object... keysValues) {
    if (keysValues.length % 2 != 0)
      throw new IllegalArgumentException("wrong number of arguments for msetnx, keysValues length can not be odd");
    Jedis jedis = getJedis();
    try {
      byte[][] kv = new byte[keysValues.length][];
      for (int i = 0; i < keysValues.length; i++) {
        if (i % 2 == 0)
          kv[i] = keyToBytes(keysValues[i]);
        else
          kv[i] = valueToBytes(keysValues[i]);
      }
      return jedis.msetnx(kv);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回所有(一个或多个)给定 key 的值。 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 nil
   * 。因此，该命令永不失败。
   */
  @SuppressWarnings("rawtypes")
  public List mget(Object... keys) {
    Jedis jedis = getJedis();
    try {
      byte[][] keysBytesArray = keysToBytesArray(keys);
      List data = jedis.mget(keysBytesArray);
      return valueListFromBytesList(data);
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 中储存的数字值减一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
   * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。
   * 关于递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
   */
  public Long decr(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.decr(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 所储存的值减去减量 decrement 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECRBY 操作。
   * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。
   * 关于更多递增(increment) / 递减(decrement)操作的更多信息，请参见 INCR 命令。
   */
  public Long decrBy(Object key, long longValue) {
    Jedis jedis = getJedis();
    try {
      return jedis.decrBy(keyToBytes(key), longValue);
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 中储存的数字值增一。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
   * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。
   */
  public Long incr(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.incr(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 获取记数器的值
   */
  public Long getCounter(Object key) {
    Jedis jedis = getJedis();
    try {
      String ret = (String) jedis.get(keyNamingPolicy.getKeyName(key));
      return ret != null ? Long.parseLong(ret) : null;
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 所储存的值加上增量 increment 。 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBY 命令。
   * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。 本操作的值限制在 64 位(bit)有符号数字表示之内。
   * 关于递增(increment) / 递减(decrement)操作的更多信息，参见 INCR 命令。
   */
  public Long incrBy(Object key, long longValue) {
    Jedis jedis = getJedis();
    try {
      return jedis.incrBy(keyToBytes(key), longValue);
    } finally {
      close(jedis);
    }
  }

  /**
   * 检查给定 key 是否存在。
   */
  public boolean exists(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.exists(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 检查给定 key 是否存在。
   */
  public boolean hasKey(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.exists(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 从当前数据库中随机返回(不删除)一个 key 。
   */
  public String randomKey() {
    Jedis jedis = getJedis();
    try {
      return jedis.randomKey();
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 改名为 newkey 。 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。 当 newkey 已经存在时，
   * RENAME 命令将覆盖旧值。
   */
  public String rename(Object oldkey, Object newkey) {
    Jedis jedis = getJedis();
    try {
      return jedis.rename(keyToBytes(oldkey), keyToBytes(newkey));
    } finally {
      close(jedis);
    }
  }

  /**
   * 当且仅当 newkey 不存在时，将 key 改名为 newkey 修改成功时，返回 1 ； 如果 newkey 已经存在，返回 0
   */
  public Long renamenx(Object oldkey, Object newkey) {
    Jedis jedis = getJedis();
    try {
      return jedis.renamenx(keyToBytes(oldkey), keyToBytes(newkey));
    } finally {
      close(jedis);
    }
  }

  /**
   * 将当前数据库的 key 移动到给定的数据库 db 当中。 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key
   * 不存在于当前数据库，那么 MOVE 没有任何效果。 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
   */
  public Long move(Object key, int dbIndex) {
    Jedis jedis = getJedis();
    try {
      return jedis.move(keyToBytes(key), dbIndex);
    } finally {
      close(jedis);
    }
  }

  /**
   * 将 key 原子性地从当前实例传送到目标实例的指定数据库上，一旦传送成功， key 保证会出现在目标实例上，而当前实例上的 key 会被删除。
   */
  public String migrate(String host, int port, Object key, int destinationDb, int timeout) {
    Jedis jedis = getJedis();
    try {
      return jedis.migrate(host, port, keyToBytes(key), destinationDb, timeout);
    } finally {
      close(jedis);
    }
  }

  /**
   * 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。 默认使用 0 号数据库。 注意：在 Jedis
   * 对象被关闭时，数据库又会重新被设置为初始值，所以本方法 select(...) 正常工作需要使用如下方式之一： 1：使用
   * RedisInterceptor，在本线程内共享同一个 Jedis 对象 2：使用 Redis.call(ICallback) 进行操作 3：自行获取
   * Jedis 对象进行操作
   */
  public String select(int databaseIndex) {
    Jedis jedis = getJedis();
    try {
      return jedis.select(databaseIndex);
    } finally {
      close(jedis);
    }
  }

  /**
   * 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 在 Redis 中，带有生存时间的 key
   * 被称为『易失的』(volatile)。
   */
  public Long expire(Object key, long seconds) {
    Jedis jedis = getJedis();
    try {
      return jedis.expire(keyToBytes(key), seconds);
    } finally {
      close(jedis);
    }
  }

  /**
   * EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX
   * 时间戳(unix timestamp)。
   */
  public Long expireAt(Object key, long unixTime) {
    Jedis jedis = getJedis();
    try {
      return jedis.expireAt(keyToBytes(key), unixTime);
    } finally {
      close(jedis);
    }
  }

  /**
   * 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
   */
  public Long pexpire(Object key, long milliseconds) {
    Jedis jedis = getJedis();
    try {
      return jedis.pexpire(keyToBytes(key), milliseconds);
    } finally {
      close(jedis);
    }
  }

  /**
   * 这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 unix 时间戳，而不是像 EXPIREAT 那样，以秒为单位。
   */
  public Long pexpireAt(Object key, long millisecondsTimestamp) {
    Jedis jedis = getJedis();
    try {
      return jedis.pexpireAt(keyToBytes(key), millisecondsTimestamp);
    } finally {
      close(jedis);
    }
  }

  /**
   * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。 当 key 存在但不是字符串类型时，返回一个错误。
   */
  @SuppressWarnings("unchecked")
  public  T getSet(Object key, Object value) {
    Jedis jedis = getJedis();
    try {
      return (T) valueFromBytes(jedis.getSet(keyToBytes(key), valueToBytes(value)));
    } finally {
      close(jedis);
    }
  }

  /**
   * 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
   */
  public Long persist(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.persist(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回 key 所储存的值的类型。
   */
  public String type(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.type(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
   */
  public Long ttl(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.ttl(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
   */
  public Long pttl(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.pttl(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 对象被引用的数量
   */
  public Long objectRefcount(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.objectRefcount(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 对象没有被访问的空闲时间
   */
  public Long objectIdletime(Object key) {
    Jedis jedis = getJedis();
    try {
      return jedis.objectIdletime(keyToBytes(key));
    } finally {
      close(jedis);
    }
  }

  /**
   * 将哈希表 key 中的域 field 的值设为 value 。 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。 如果域 field
   * 已经存在于哈希表中，旧值将被覆盖。
   */
  public Long hset(Object key, Object field, Object value) {
    Jedis jedis = getJedis();
    try {
      return jedis.hset(keyToBytes(key), fieldToBytes(field), valueToBytes(value));
    } finally {
      close(jedis);
    }
  }

  /**
   * Sets the value of a field in a hash stored at key. If the key does not exist,
   * a new hash is created and the field-value pair is added. If the field already
   * exists in the hash, the existing value is overwritten with the new value.
   *
   * @param key   The key of the hash.
   * @param field The field in the hash to set.
   * @param value The value to set for the field.
   * @return The number of fields that were added to the hash, not including
   *         fields already present and updated.
   */
  public Long hsetRawString(String key, String field, String value) {
    Jedis jedis = getJedis();
    try {
      return jedis.hset(key, field, value);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中给定域 field 的值。
   */
  public String hgetRawString(String key, String field) {
    Jedis jedis = getJedis();
    try {
      return jedis.hget(key, field);
    } finally {
      close(jedis);
    }
  }

  /**
   * 同时将多个 field-value (域-值)对设置到哈希表 key 中。 此命令会覆盖哈希表中已存在的域。 如果 key
   * 不存在，一个空哈希表被创建并执行 HMSET 操作。
   */
  public String hmset(Object key, Map hash) {
    Jedis jedis = getJedis();
    try {
      Map para = new HashMap();
      for (Entry e : hash.entrySet())
        para.put(fieldToBytes(e.getKey()), valueToBytes(e.getValue()));
      return jedis.hmset(keyToBytes(key), para);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中给定域 field 的值。
   */
  @SuppressWarnings("unchecked")
  public  T hget(Object key, Object field) {
    Jedis jedis = getJedis();
    try {
      return (T) valueFromBytes(jedis.hget(keyToBytes(key), fieldToBytes(field)));
    } finally {
      close(jedis);
    }
  }

  public String hmsetRawString(String key, Map hash) {
    Jedis jedis = getJedis();
    try {
      Map para = new HashMap<>();
      for (Entry entry : hash.entrySet()) {
        // 直接将键和值转换为字节，这里假设键和值都已经是 String 类型
        // 或者确保它们都能够以合适的方式转换为字节
        byte[] keyBytes = SafeEncoder.encode(entry.getKey());
        byte[] valueBytes = SafeEncoder.encode(entry.getValue());
        para.put(keyBytes, valueBytes);
      }
      return jedis.hmset(SafeEncoder.encode(key), para);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中给定域 field 的值。
   * 
   * @param key   哈希表的键
   * @param field 哈希表中的字段
   * @return 返回字段对应的值，如果字段不存在则返回 null
   */
  public String hmgetRawString(String key, String field) {
    Jedis jedis = getJedis();
    try {
      return jedis.hget(key, field); // 直接使用字符串参数
    } finally {
      close(jedis); // 确保在操作后关闭 Jedis 连接
    }
  }

  /**
   * 返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key
   * 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
   */
  @SuppressWarnings("rawtypes")
  public List hmget(Object key, Object... fields) {
    Jedis jedis = getJedis();
    try {
      List data = jedis.hmget(keyToBytes(key), fieldsToBytesArray(fields));
      return valueListFromBytesList(data);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中，一个或多个给定域的值。 如果给定的域不存在于哈希表，那么返回一个 nil 值。 因为不存在的 key
   * 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
   * 
   * @param key    哈希表的键，类型为 String
   * @param fields 哈希表中的字段，类型为 String... (可变参数)
   * @return 返回的 List 中包含每个字段对应的值，如果某个字段不存在，则对应位置为 null
   */
  public List hmget(String key, String... fields) {
    Jedis jedis = getJedis();
    try {
      List values = jedis.hmget(key, fields); // 直接调用 Jedis 的 hmget
      return values;
    } finally {
      close(jedis); // 确保 Jedis 实例在使用后被正确关闭
    }
  }

  /**
   * 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
   */
  public Long hdel(Object key, Object... fields) {
    Jedis jedis = getJedis();
    try {
      return jedis.hdel(keyToBytes(key), fieldsToBytesArray(fields));
    } finally {
      close(jedis);
    }
  }

  public Long hdelRaw(String key, String... fields) {
    Jedis jedis = getJedis();
    try {
      return jedis.hdel(key, fields);
    } finally {
      close(jedis);
    }
  }

  /**
   * 查看哈希表 key 中，给定域 field 是否存在。
   */
  public boolean hexists(Object key, Object field) {
    Jedis jedis = getJedis();
    try {
      return jedis.hexists(keyToBytes(key), fieldToBytes(field));
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中，所有的域和值。 在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
   */
  @SuppressWarnings("rawtypes")
  public Map hgetAll(Object key) {
    Jedis jedis = getJedis();
    try {
      Map data = jedis.hgetAll(keyToBytes(key));
      Map result = new HashMap();
      if (data == null) {
        return result;
      }

      for (Entry e : data.entrySet()) {
        result.put(fieldFromBytes(e.getKey()), valueFromBytes(e.getValue()));
      }
      return result;
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中所有域的值。
   */
  @SuppressWarnings("rawtypes")
  public List hvals(Object key) {
    Jedis jedis = getJedis();
    try {
      List data = jedis.hvals(keyToBytes(key));
      return valueListFromBytesList(data);
    } finally {
      close(jedis);
    }
  }

  /**
   * 返回哈希表 key 中的所有域。 底层实现此方法取名为 hfields 更为合适，在此仅为与底层保持一致
   */
  public Set