retrial all the keys of the cached map

@param cacheConfigBean datasource configuration
@param key             cache key
@param kClazz          the key's class
@return all the keys of the cached map, or null if the key does not exist
197599
public static <T> Maybe<Set<T>> keys(CacheConfigBean cacheConfigBean, String key, Class<T> kClazz) {
        return keys(cacheConfigBean, key)
                .map(keySet -> {
                    Set<T> _keys = new TreeSet<>();
                    keySet.forEach(_key -> _keys.add(Reflection.toType(_key, kClazz)));
                    return _keys;
                });
    }
284317
public static Maybe<Set<String>> keys(CacheConfigBean cacheConfigBean, String key) {
        return SingleRxXian
                .call(CacheService.CACHE_SERVICE, "cacheMapKeys", new JSONObject() {{
                    put("cacheConfig", cacheConfigBean);
                    put("key", key);
                }})
                .flatMapMaybe(unitResponse -> {
                    unitResponse.throwExceptionIfNotSuccess();
                    if (unitResponse.getData() == null)
                        return Maybe.empty();
                    else
                        return Maybe.just(Reflection.toTypedSet(unitResponse.getData(), String.class));
                });
    }
20078
@Override
  public Iterable<K> keys() {
    return new Iterable<K>() {
      @Override
      public Iterator<K> iterator() {
        final Iterator<CacheEntry<K,V>> it = BaseCache.this.iterator();
        return new Iterator<K>() {
          @Override
          public boolean hasNext() {
            return it.hasNext();
          }

          @Override
          public K next() {
            return it.next().getKey();
          }

          @Override
          public void remove() {
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
175647
public static <T> T queryTryCache(Class<? extends BaseEntity> entityClass,String key,long expireSeconds,Callable<T> dataCaller){
		
		if(CacheHandler.cacheProvider == null){
			try {
				return dataCaller.call();
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		
		String entityClassName = entityClass.getSimpleName();
		key = entityClassName + CacheHandler.SPLIT_PONIT + key;
		T result = CacheHandler.cacheProvider.get(key);
		if(result == null){
			try {				
				result = dataCaller.call();
				if(result != null){
					CacheHandler.cacheProvider.set(key, result, expireSeconds);
					String cacheGroupKey = entityClassName + CacheHandler.GROUPKEY_SUFFIX;
					CacheHandler.cacheProvider.putGroup(cacheGroupKey, key, expireSeconds);
				}
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return result;
	}
559581
@Override
    public <K, V> Cache<K, V> getCache(String cacheName, boolean start) {
        Cache<K, V> cache = this.cm.getCache(this.getCacheName(cacheName), start);
        return (cache != null) ? new DelegatingCache<>(cache) : null;
    }
368615
public static Completable clear(CacheConfigBean cacheConfigBean, String cacheKey) {
        return SingleRxXian.call(CacheService.CACHE_SERVICE, "cacheListClear", new JSONObject() {{
            put("cacheConfig", cacheConfigBean);
            put("key", cacheKey);
        }}).toCompletable();
    }
1139503
@Override
	public void cache(final Object key, final Object object) {
		this.logger.debug("@cache ");

		if (object == null) {
			if (!isAllowNullable()) {
				return;
			}
			this.logger.debug("logging key :", key, " with null");
			getCachableMap(JKAbstractCacheManager.NULLABLE_MAP_CLASS).put(key, null);
		} else {
			cache(key, object, object.getClass());
		}
	}
1275703
@Override
    public Object get(String key) {
        Element element = cache.get(key);
        if (element != null) {
            return element.getObjectValue();
        }
        return null;
    }
831744
@SuppressWarnings("unchecked")
	public <T> Map<Serializable, T> get(Collection<? extends Serializable> keys) {
		Map<Serializable, T> result = Maps.newHashMapWithExpectedSize(keys.size());
		for (Serializable key : keys) {
			T value = (T) contents.getIfPresent(key);
			if (value != null) {
				result.put(key, value);
			}
		}
		if (log.isDebugEnabled() && !result.isEmpty()) {
			log.debug("Level 1 cache multiple hit: {}", result.keySet());
		}
		return result;
	}
10318
@SuppressWarnings({"unchecked", "SuspiciousMethodCalls"})
  private void makeGenericKeyCache(CoreLabel c) {
    genericAnnotationKeys = new HashSet<Class<? extends GenericAnnotation<?>>>();
    for (Class<?> key : c.keySet()) {
      if (CoreLabel.genericValues.containsKey(key)) {
        Class<? extends GenericAnnotation<?>> genKey = (Class<? extends GenericAnnotation<?>>) key;
        genericAnnotationKeys.add(genKey);
      }
    }
  }
522627
@VisibleForTesting
  public ReentrantReadWriteLock getRawReadWriteLock(K key) {
    return mCache.getOrDefault(key, new ValNode(new ReentrantReadWriteLock())).mValue;
  }
1203485
public CmsXmlGroupContainer getCacheGroupContainer(String key, boolean online) {

        try {
            m_lock.readLock().lock();
            CmsXmlGroupContainer retValue;
            if (online) {
                retValue = m_groupContainersOnline.get(key);
                if (LOG.isDebugEnabled()) {
                    if (retValue == null) {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MISSED_ONLINE_1,
                                new Object[] {key}));

                    } else {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MATCHED_ONLINE_2,
                                new Object[] {key, retValue}));
                    }
                }
            } else {
                retValue = m_groupContainersOffline.get(key);
                if (LOG.isDebugEnabled()) {
                    if (retValue == null) {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MISSED_OFFLINE_1,
                                new Object[] {key}));

                    } else {
                        LOG.debug(
                            Messages.get().getBundle().key(
                                Messages.LOG_DEBUG_CACHE_MATCHED_OFFLINE_2,
                                new Object[] {key, retValue}));
                    }
                }
            }
            return retValue;
        } finally {
            m_lock.readLock().unlock();
        }
    }
664192
@Override
	public <T> void cache(final Object key, final Object object, Class<T> clas) {
		this.logger.debug("@cache v2 ");

		if (object == null && !isAllowNullable()) {
			return;
		} else {
			this.logger.debug("logging key :", key, " with object : ", object, " with Class : ", clas);
			getCachableMap(clas).put(key, object);
		}
	}
223711
public static Single<Long> addAll(CacheConfigBean cacheConfigBean, String key, Set members) {
        return SingleRxXian.call(CacheService.CACHE_SERVICE, "cacheSetAdd", new JSONObject() {{
            put("cacheConfig", cacheConfigBean);
            put("key", key);
            put("members", members);
        }}).map(unitResponseObject -> {
            unitResponseObject.throwExceptionIfNotSuccess();
            if (unitResponseObject.getData() == null)
                return 0L;
            return unitResponseObject.dataToLong();
        });
    }
827367
public com.ibm.websphere.cache.CacheEntry getCacheEntry(Object key) {
        return super.common_getCacheEntry(key);
	}
462976
public InternalQueryCache<K, V> tryCreateQueryCache(String mapName, String cacheName,
                                                        ConstructorFunction<String, InternalQueryCache<K, V>> constructor) {

        ContextMutexFactory.Mutex mutex = lifecycleMutexFactory.mutexFor(mapName);
        try {
            synchronized (mutex) {
                ConcurrentMap<String, InternalQueryCache<K, V>> queryCacheRegistry
                        = getOrPutIfAbsent(queryCacheRegistryPerMap, mapName, queryCacheRegistryConstructor);

                InternalQueryCache<K, V> queryCache = queryCacheRegistry.get(cacheName);
                // if this is a recreation we expect to have a Uuid otherwise we
                // need to generate one for the first creation of query cache.
                String cacheId = queryCache == null
                        ? UuidUtil.newUnsecureUuidString() : queryCache.getCacheId();

                queryCache = constructor.createNew(cacheId);

                if (queryCache != NULL_QUERY_CACHE) {
                    queryCacheRegistry.put(cacheName, queryCache);
                    return queryCache;
                }

                return null;
            }
        } finally {
            closeResource(mutex);
        }
    }
976973
public static <T> Maybe<List<T>> values(String key, Class<T> vClazz) {
        return values(CacheService.CACHE_CONFIG_BEAN, key, vClazz);
    }