import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Test
public void testCohortsPassedThrough() {
  final Toggle<Integer> mockToggle = mock(Toggle.class);
  when(mockToggle.withCohort(anyString())).thenReturn(mockToggle);
  when(mockToggle.test(eq(1))).thenReturn(toggle.test(1));
  when(underlying.apply(onKey)).thenReturn(mockToggle);

  final CachingToggleMap<String, Integer> toggleMap =
    new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3"));

  toggleMap.apply(onKey)
    .withCohort("foo")
    .test(1);

  verify(underlying, times(1)).apply(eq(onKey));
  verify(mockToggle, times(1)).withCohort(eq("foo"));
  verify(mockToggle, times(1)).test(eq(1));
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
public static String validateCacheSpec(String cacheSpec) {
    if (cacheSpec == null) {
        return null;
    }

    try {
        CaffeineSpec.parse(cacheSpec);
        return cacheSpec;
    } catch (IllegalArgumentException e) {
        throw new IllegalArgumentException("cacheSpec: " + cacheSpec + " (" + e.getMessage() + ')');
    }
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Test
public void testReadFromUnderlyingToggleMapOnMiss() {
  when(underlying.apply(onKey)).thenReturn(toggle);

  final CachingToggleMap<String, Integer> toggleMap =
    new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3"));

  assertThat(toggleMap.apply(onKey).test(1)).isTrue();
  verify(underlying).apply(eq(onKey));
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Test
public void testReadFromCacheOnHit() {
  when(underlying.apply(onKey)).thenReturn(toggle);

  final CachingToggleMap<String, Integer> toggleMap =
    new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3"));

  toggleMap.apply(onKey).test(1);
  toggleMap.apply(onKey).test(2);
  verify(underlying, times(1)).apply(eq(onKey));
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Test
public void testFallsBackToLastReadToggleOnFailedReadFromUnderlying() {
  when(underlying.apply(onKey))
    .thenReturn(toggle)
    .thenThrow(new NoSuchElementException());

  final CachingToggleMap<String, Integer> toggleMap =
    new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=0"));

  final Toggle<Integer> t = toggleMap.apply(onKey);
  assertThat(t.test(1)).isTrue();
  assertThat(t.test(1)).isTrue();
  verify(underlying, times(2)).apply(eq(onKey));
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Test
public void testReadKeySetFromUnderlying() {
  final Set<String> expectedKeySet = new HashSet();
  expectedKeySet.add(onKey);
  expectedKeySet.add(offKey);
  when(underlying.keySet()).thenReturn(expectedKeySet);

  final CachingToggleMap<String, Integer> toggleMap =
    new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3"));

  assertThat(toggleMap.keySet()).containsOnly(onKey, offKey);
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
ProtobufRedisLoadingCache(
    String name,
    K keyPrototype,
    V valuePrototype,
    Duration redisTtl,
    @Nullable CaffeineSpec localCacheSpec,
    RedisClusterClient redisClient) {
  checkNotNull(keyPrototype, "keyPrototype");
  checkNotNull(valuePrototype, "valuePrototype");
  checkNotNull(redisTtl, "redisTtl");
  checkNotNull(redisClient, "redisClient");
  redis =
      redisClient
          .connect(
              new ProtobufRedisCodec<>(
                  (name + ":").getBytes(StandardCharsets.UTF_8), keyPrototype, valuePrototype))
          .async();
  final Caffeine<Object, Object> caffeineBuilder =
      localCacheSpec != null
          ? Caffeine.from(localCacheSpec)
          : Caffeine.newBuilder().maximumSize(0);
  cache =
      caffeineBuilder
          .executor(CurrentRequestContextExecutor.INSTANCE)
          .buildAsync((k, executor) -> redis.get(k).toCompletableFuture());
  setArgs = SetArgs.Builder.px(redisTtl.toMillis());
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
/**
 * Default cache spec configuration for all the caches. The default cache
 * size is 200 and would expire after a min (60sec) of write operation.
 *
 * @return {@link CaffeineSpec}
 */
@Bean
public CaffeineSpec caffeineSpec() {
    CaffeineSpec spec = CaffeineSpec.parse("maximumSize=200,expireAfterWrite=300s");
    log.info("Using CaffeineSpec " + spec.toParsableString());
    return spec;
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
CaffeineCacheConfiguration(CacheProperties cacheProperties,
		CacheManagerCustomizers customizers,
		ObjectProvider<Caffeine<Object, Object>> caffeineProvider,
		ObjectProvider<CaffeineSpec> caffeineSpecProvider,
		ObjectProvider<CacheLoader<Object, Object>> cacheLoaderProvider) {
	this.cacheProperties = cacheProperties;
	this.customizers = customizers;
	this.caffeine = caffeineProvider.getIfAvailable();
	this.caffeineSpec = caffeineSpecProvider.getIfAvailable();
	this.cacheLoader = cacheLoaderProvider.getIfAvailable();
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
private static Optional<String> caffeineSpec(String name, String defaultValue) {
    final String spec = get(name, defaultValue, value -> {
        try {
            if (!"off".equals(value)) {
                CaffeineSpec.parse(value);
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    });
    return "off".equals(spec) ? Optional.empty()
                              : Optional.of(spec);
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
public CachingToggleMap(ToggleMap<K, T> underlying, CaffeineSpec cacheSpec) {
  this.underlying = underlying;
  this.cache = Caffeine.from(cacheSpec)
    .build(underlying::apply);
  this.fallbackCache = new HashMap<>();
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
@Bean
CaffeineSpec caffeineSpec() {
	return CaffeineSpec.parse("recordStats");
}
 

import com.github.benmanes.caffeine.cache.CaffeineSpec; //导入依赖的package包/类
/**
 * Constructs a new {@link ProtobufRedisLoadingCache} that can write protobuf {@link Message}
 * keys and values to redis, with an optional local cache layer.
 *
 * @param name name of this cache, will be prefixed onto all keys.
 * @param keyPrototype a prototype for the key {@link Message}, usually gotten from {@code
 *     Key.getDefaultInstance()}.
 * @param valuePrototype a prototype for the value {@link Message}, usually gotten from {@code
 *     Value.getDefaultInstance()}.
 * @param redisTtl the time until expiration of a value in the redis cache. The local cache
 *     should be considered in localCacheSpec.
 * @param localCacheSpec a {@link CaffeineSpec} to control the local cache layer. If {@code
 *     null}, local caching will be disabled.
 */
public <K extends Message, V extends Message> ProtobufRedisLoadingCache<K, V> create(
    String name,
    K keyPrototype,
    V valuePrototype,
    Duration redisTtl,
    @Nullable CaffeineSpec localCacheSpec) {
  return new ProtobufRedisLoadingCache<>(
      name, keyPrototype, valuePrototype, redisTtl, localCacheSpec, redisClient);
}