com.github.benmanes.caffeine.cache.Weigher Java Examples

@SuppressWarnings({ "rawtypes", "unchecked" })
public RepositoryCache(String cacheSpec, MeterRegistry meterRegistry) {
    this.cacheSpec = requireNonNull(validateCacheSpec(cacheSpec), "cacheSpec");
    requireNonNull(meterRegistry, "meterRegistry");

    final Caffeine<Object, Object> builder = Caffeine.from(cacheSpec);
    if (cacheSpec.contains("maximumWeight=")) {
        builder.weigher((Weigher<CacheableCall, Object>) CacheableCall::weigh);
    }
    cache = builder.recordStats()
                   .buildAsync((key, executor) -> {
                       logger.debug("Cache miss: {}", key);
                       return key.execute();
                   });

    CaffeineCacheMetrics.monitor(meterRegistry, cache, "repository");
}
 

/** Configures the maximum weight and returns if set. */
private boolean configureMaximumWeight() {
  if (config.getMaximumWeight().isPresent()) {
    caffeine.maximumWeight(config.getMaximumWeight().getAsLong());
    Weigher<K, V> weigher = config.getWeigherFactory().map(Factory::create)
        .orElseThrow(() -> new IllegalStateException("Weigher not configured"));
    caffeine.weigher((K key, Expirable<V> expirable) -> {
      return weigher.weigh(key, expirable.get());
    });
  }
  return config.getMaximumWeight().isPresent();
}
 

private void initScriptEngine() {
  LOG.debug("Initializing Nashorn script engine ...");
  NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
  scriptEngine =
      factory.getScriptEngine(s -> false); // create engine with class filter exposing no classes
  expressions =
      Caffeine.newBuilder()
          .maximumWeight(MAX_COMPILED_EXPRESSIONS_SCRIPTS_LENGTH)
          .weigher((Weigher<String, CompiledScript>) (key, value) -> key.length())
          .build(((Compilable) this.scriptEngine)::compile);
  LOG.debug("Initialized Nashorn script engine");
}
 

@Test
public void test() {
	Cache c =
		Caffeine.newBuilder().maximumWeight(1000).weigher(new Weigher<Object, Object>() {
			@Override
			public int weigh(final Object key, final Object value) {
				return value.hashCode() & 0x7f;
			}
		}).build();
	c.put(1, 123);
	c.put(1, 512);
	c.put(1, 0);
}
 

/**
 * Returns a {@link Weigher} that returns the given {@code constant} for every request.
 */
static Weigher<Object, Object> constantWeigher(int constant) {
  return new ConstantWeigher(constant);
}
 

/**
 * Returns a {@link Weigher} that uses the integer key as the weight.
 */
static Weigher<Integer, Object> intKeyWeigher() {
  return new IntKeyWeigher();
}
 

/**
 * Returns a {@link Weigher} that uses the integer value as the weight.
 */
static Weigher<Object, Integer> intValueWeigher() {
  return new IntValueWeigher();
}
 

/**
 * With an unlimited-size cache with maxWeight of 0, entries weighing 0 should still be cached.
 * Entries with positive weight should not be cached (nor dump existing cache).
 */
public void testEviction_maxWeight_zero() {
  CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener();
  IdentityLoader<Integer> loader = identityLoader();

  // Even numbers are free, odd are too expensive
  Weigher<Integer, Integer> evensOnly = (k, v) -> k % 2;

  LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder()
      .maximumWeight(0)
      .weigher(evensOnly)
      .removalListener(removalListener)
      .executor(MoreExecutors.directExecutor()),
      loader);

  // 1 won't be cached
  assertThat(cache.getUnchecked(1)).isEqualTo(1);
  assertThat(cache.asMap().keySet()).isEmpty();

  cache.cleanUp();
  assertThat(removalListener.getCount()).isEqualTo(1);

  // 2 will be cached
  assertThat(cache.getUnchecked(2)).isEqualTo(2);
  assertThat(cache.asMap().keySet()).containsExactly(2);

  cache.cleanUp();
  CacheTesting.checkValidState(cache);
  assertThat(removalListener.getCount()).isEqualTo(1);

  // 4 will be cached
  assertThat(cache.getUnchecked(4)).isEqualTo(4);
  assertThat(cache.asMap().keySet()).containsExactly(2, 4);

  cache.cleanUp();
  assertThat(removalListener.getCount()).isEqualTo(1);

  // 5 won't be cached, won't dump cache
  assertThat(cache.getUnchecked(5)).isEqualTo(5);
  assertThat(cache.asMap().keySet()).containsExactly(2, 4);

  cache.cleanUp();
  assertThat(removalListener.getCount()).isEqualTo(2);

  // Should we pepper more of these calls throughout the above? Where?
  CacheTesting.checkValidState(cache);
}
 

/**
 * Returns the {@link Factory} for the {@link Weigher} to be used for the cache.
 *
 * @return the {@link Factory} for the {@link Weigher}
 */
public Optional<Factory<Weigher<K, V>>> getWeigherFactory() {
  return Optional.ofNullable(weigherFactory);
}
 

/**
 * Set the {@link Factory} for the {@link Weigher}.
 *
 * @param factory the {@link Weigher} {@link Factory}
 */
@SuppressWarnings("unchecked")
public void setWeigherFactory(Optional<Factory<? extends Weigher<K, V>>> factory) {
  weigherFactory = (Factory<Weigher<K, V>>) factory.orElse(null);
}