理想的情况是使用方面，但我不想深入研究，因为它只是为了调试以理解实际的底层行为。
所以我做了下面的，使用Kotlin，但你可以适应你的需要。
首先，创建一个delegator类：

class DelegatingCache<K, V>(
    val name: String,
    private val delegate: Cache<K, V>
) : Cache<K, V> {
    private val logger = LoggerFactory.getLogger(javaClass)

    override fun getIfPresent(key: K): V? = delegate.getIfPresent(key)
        .also { logger.warn("$name getIfPresent(key=$key) = $it") }

    override fun get(key: K, mappingFunction: Function<in K, out @PolyNull V>?): @PolyNull V =
        delegate.get(key, mappingFunction)
            .also { logger.warn("$name get(key=$key) = $it") }

    override fun getAllPresent(keys: Iterable<K>): Map<K, V> = delegate.getAllPresent(keys)
        .also { logger.warn("$name getAllPresent") }

    override fun getAll(
        keys: MutableIterable<K>?,
        mappingFunction: Function<in MutableSet<out K>, out MutableMap<out K, out V>>?
    ): MutableMap<K, V>? = delegate.getAll(keys, mappingFunction)
        .also { logger.warn("$name getAll") }

    override fun put(key: K, value: V) = delegate.put(key, value)
        .also { logger.warn("$name put(key=$key, value=$value)") }

    override fun putAll(map: Map<out K, V>) = delegate.putAll(map)
        .also { logger.warn("$name putAll") }

    override fun invalidate(key: K) = delegate.invalidate(key)
        .also { logger.warn("$name invalidate(key=$key)") }

    override fun invalidateAll(keys: Iterable<K>) = delegate.invalidateAll(keys)
        .also { logger.warn("$name invalidateAll(keys: Iterable<K>)") }

    override fun invalidateAll() = delegate.invalidateAll()
        .also { logger.warn("$name invalidateAll") }

    override fun estimatedSize(): Long = delegate.estimatedSize()
        .also { logger.warn("$name estimatedSize = $it") }

    override fun stats(): CacheStats = delegate.stats()
        .also { logger.warn("$name stats = $it") }

    override fun asMap(): ConcurrentMap<K, V> = delegate.asMap()
        .also { logger.warn("$name asMap") }

    override fun cleanUp() = delegate.cleanUp()
        .also { logger.warn("$name cleanUp") }

    override fun policy(): Policy<K, V> = delegate.policy()
        .also { logger.warn("$name policy = $it") }
}

字符串
然后，当您在@Configuration类上构建Cache示例时，只需在返回之前将该高速缓存 Package 在此委托程序类中。

private fun <K, V> buildCache(
    cacheName: String,
): Cache<K, V> {
    return Caffeine.newBuilder()
        // ...
        .build<K, V>()
        .let { DelegatingCache(cacheName, it) }
}

型
欢呼