使用通配符的春季@CacheEvict

答案是：不可以。

这不是实现您想要的目标的简单方法。

1. Spring Cache 注释必须简单，以便缓存提供程序易于实现。
2. 高效的缓存必须简单。有一个键和值。如果在缓存中找到键，请使用该值，否则计算值并放入缓存。高效密钥必须具有快速和诚实的 equals（） 和 hashcode（）。假设您从一个租户缓存了许多对（键、值）。为了提高效率，不同的键应该有不同的哈希码（）。。你决定驱逐整个租户。在缓存中找到租户元素并不容易。必须迭代所有缓存的对并丢弃属于租户的对。它效率不高。它不是原子的，所以它很复杂，需要一些同步。同步效率不高。

因此不可以。

但是，如果你找到一个解决方案告诉我，因为你想要的功能真的很有用。

与宇宙中99%的问题一样，答案是：视情况而定。如果您的缓存管理器实现了与此相关的内容，那就太好了。但事实似乎并非如此。

如果您使用的是 ，这是 Spring 提供的基本内存中缓存管理器，则您可能使用的也是 Spring 附带的内存中缓存管理器。尽管无法扩展以处理键中的通配符（因为缓存存储是私有的，您无法访问它），但您可以将其用作自己实现的灵感。SimpleCacheManagerConcurrentMapCacheConcurrentMapCache

下面有一个可能的实现（除了检查它是否有效之外，我没有真正测试它）。这是 的纯副本，对方法进行了修改。不同之处在于，此版本的 会处理密钥以查看它是否为正则表达式。在这种情况下，它将循环访问存储中的所有密钥，并逐出与正则表达式匹配的密钥。ConcurrentMapCacheevict()evict()

package com.sigraweb.cache;

import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.util.Assert;

public class RegexKeyCache implements Cache {
    private static final Object NULL_HOLDER = new NullHolder();

    private final String name;

    private final ConcurrentMap<Object, Object> store;

    private final boolean allowNullValues;

    public RegexKeyCache(String name) {
        this(name, new ConcurrentHashMap<Object, Object>(256), true);
    }

    public RegexKeyCache(String name, boolean allowNullValues) {
        this(name, new ConcurrentHashMap<Object, Object>(256), allowNullValues);
    }

    public RegexKeyCache(String name, ConcurrentMap<Object, Object> store, boolean allowNullValues) {
        Assert.notNull(name, "Name must not be null");
        Assert.notNull(store, "Store must not be null");
        this.name = name;
        this.store = store;
        this.allowNullValues = allowNullValues;
    }

    @Override
    public final String getName() {
        return this.name;
    }

    @Override
    public final ConcurrentMap<Object, Object> getNativeCache() {
        return this.store;
    }

    public final boolean isAllowNullValues() {
        return this.allowNullValues;
    }

    @Override
    public ValueWrapper get(Object key) {
        Object value = this.store.get(key);
        return toWrapper(value);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T get(Object key, Class<T> type) {
        Object value = fromStoreValue(this.store.get(key));
        if (value != null && type != null && !type.isInstance(value)) {
            throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
        }
        return (T) value;
    }

    @Override
    public void put(Object key, Object value) {
        this.store.put(key, toStoreValue(value));
    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        Object existing = this.store.putIfAbsent(key, value);
        return toWrapper(existing);
    }

    @Override
    public void evict(Object key) {
        this.store.remove(key);
        if (key.toString().startsWith("regex:")) {
            String r = key.toString().replace("regex:", "");
            for (Object k : this.store.keySet()) {
                if (k.toString().matches(r)) {
                    this.store.remove(k);
                }
            }
        }
    }

    @Override
    public void clear() {
        this.store.clear();
    }

    protected Object fromStoreValue(Object storeValue) {
        if (this.allowNullValues && storeValue == NULL_HOLDER) {
            return null;
        }
        return storeValue;
    }

    protected Object toStoreValue(Object userValue) {
        if (this.allowNullValues && userValue == null) {
            return NULL_HOLDER;
        }
        return userValue;
    }

    private ValueWrapper toWrapper(Object value) {
        return (value != null ? new SimpleValueWrapper(fromStoreValue(value)) : null);
    }

    @SuppressWarnings("serial")
    private static class NullHolder implements Serializable {
    }
}

我相信读者知道如何使用自定义缓存实现初始化缓存管理器。有很多文档可以告诉你如何做到这一点。正确配置项目后，可以按如下方式正常使用注释：

@CacheEvict(value = { "cacheName" }, key = "'regex:#tenant'+'.*'")
public myMethod(String tenant){
...
}

同样，这远未经过适当的测试，但它为您提供了一种做自己想做的事情的方法。如果您使用的是其他缓存管理器，则可以类似地扩展其缓存实现。