blocks|key|946673|text|答案是:不。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|946674|而且实现你想要的东西也不是一件容易的事情。|946675|946676|Spring+Cache注解必须简单，易于通过缓存实现provider.|ordered-list-item|946677|Efficient缓存必须简单。有一个键和一个值。如果在缓存中找到key，则使用该值，否则计算值并将其放入缓存。Efficient+key必须具有快速诚实的equals()和hashcode()。假设您缓存了来自一个租户的多个对(键、值)。为了提高效率，不同的键应该有不同的hashcode()。你决定把整个房客赶出去。在缓存中查找租户元素并非易事。您必须迭代所有缓存的对，并丢弃属于租户的对。它的效率不高。它不是原子的，所以它很复杂，需要一些同步。同步效率不高。|offset|length|style|BOLD|946678|946679|因此，不是。|946680|但是，如果你找到了解决方案，告诉我，因为你想要的功能真的很有用。|946681|entityMap^0|0|0|0|0|26|8|2F|A|3T|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|Y|8|@$J|Z|K|10|L|M]|$J|11|K|12|L|M]|$J|13|K|14|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

Answer is: No.

And it is no easy way to achieve what you want.

<ol>
<li>Spring Cache annotations must be simple to be easy to implement by cache provider.</li>
<li>Efficient caching must be simple. There is a key and value. If key is found in cache use the value, otherwise compute value and put to cache. Efficient key must have fast and honest equals() and hashcode(). Assume you cached many pairs (key,value) from one tenant. For efficiency different keys should have different hashcode(). And you decide to evict whole tenant. It is no easy to find tenant elements in cache. You have to iterate all cached pairs and discard pairs belonging to the tenant. It is not efficient. It is rather not atomic, so it is complicated and needs some synchronization. Synchronization is not efficient.</li>
</ol>

Therefore no.

But, if you find a solution tell me, because feature you want is really useful.

blocks|key|4656523|text|就像宇宙中99%25的问题一样，答案是:视情况而定。如果你的缓存管理器实现了一些处理这个问题的东西，那就太好了。但事实似乎并非如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4656524|如果您使用的是SimpleCacheManager，这是Spring提供的一个基本的内存缓存管理器，那么您可能正在使用Spring自带的ConcurrentMapCache。尽管不可能扩展ConcurrentMapCache来处理键中的通配符(因为缓存存储是私有的，您不能访问它)，但您可以将其作为自己实现的灵感。|offset|length|style|CODE|4656525|下面是一个可能的实现(除了检查它是否工作之外，我并没有真正测试它)。这是对evict()方法进行修改后的ConcurrentMapCache的普通副本。不同之处在于，这个版本的evict()处理关键字，以确定它是否是正则表达式。在这种情况下，它会遍历存储中的所有键，并逐出与正则表达式匹配的键。|4656526|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+["+%2B+type.getName()+%2B+"]:+"+%2B+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+{
++++}
}|code-block|syntax|javascript|4656527|我相信读者知道如何使用自定义缓存实现来初始化缓存管理器。有很多文档向您展示了如何做到这一点。正确配置项目后，您可以正常使用注释，如下所示：|4656528|@CacheEvict(value+=+{+"cacheName"+},+key+=+"'regex:#tenant'%2B'.*'")
public+myMethod(String+tenant){
...
}|4656529|同样，这还远远没有经过适当的测试，但它为您提供了一种做您想做的事情的方法。如果您正在使用另一个缓存管理器，则可以以类似的方式扩展其缓存实现。|4656530|entityMap^0|0|7|I|1W|I|2M|I|0|11|7|1G|I|2G|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]|$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|V|$]]

As with 99% of every question in the universe, the answer is: it depends. If your cache manager implements something that deals with that, great. But that doesn't seem to be the case.

If you're using <code>SimpleCacheManager</code>, which is a basic in-memory cache manager provided by Spring, you're probably using <code>ConcurrentMapCache</code> that also comes with Spring. Although it's not possible to extend <code>ConcurrentMapCache</code> to deal with wildcards in keys (because the cache store is private and you can't access it), you could just use it as an inspiration for your own implementation.

Below there's a possible implementation (I didn't really test it much other than to check if it's working). This is a plain copy of <code>ConcurrentMapCache</code> with a modification on the <code>evict()</code> method. The difference is that this version of <code>evict()</code> treats the key to see if it's a regex. In that case, it iterates through all the keys in the store and evict the ones that match the regex.

<pre><code>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&lt;Object, Object&gt; store;

 private final boolean allowNullValues;

 public RegexKeyCache(String name) {
 this(name, new ConcurrentHashMap&lt;Object, Object&gt;(256), true);
 }

 public RegexKeyCache(String name, boolean allowNullValues) {
 this(name, new ConcurrentHashMap&lt;Object, Object&gt;(256), allowNullValues);
 }

 public RegexKeyCache(String name, ConcurrentMap&lt;Object, Object&gt; 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&lt;Object, Object&gt; 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 &lt;T&gt; T get(Object key, Class&lt;T&gt; type) {
 Object value = fromStoreValue(this.store.get(key));
 if (value != null &amp;&amp; type != null &amp;&amp; !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 &amp;&amp; storeValue == NULL_HOLDER) {
 return null;
 }
 return storeValue;
 }

 protected Object toStoreValue(Object userValue) {
 if (this.allowNullValues &amp;&amp; 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 {
 }
}
</code></pre>

I trust that readers know how to initialize the cache manager with a custom cache implementation. There's lots of documentation out there that shows you how to do that. After your project is properly configured, you can use the annotation normally like so:

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

Again, this is far from being properly tested, but it gives you a way to do what you want. If you're using another cache manager, you could extends its cache implementation similarly.

blocks|key|4656555|text|下面是我在Redis+Cache上的工作。假设您想删除所有关键字前缀为'+Cache+-name:object-name:parentKey‘的cache条目。调用键值为cache-name:object-name:parentKey*的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4656556|import+org.springframework.data.redis.core.RedisOperations;++++
...
private+final+RedisOperations<Object,+Object>+redisTemplate;
...++++
public+void+evict(Object+key)
{
++++redisTemplate.delete(redisTemplate.keys(key));
}|code-block|syntax|javascript|4656557|来自RedisOperations.java|4656558|/**
+*+Delete+given+{@code+keys}.
+*
+*+@param+keys+must+not+be+{@literal+null}.
+*+@return+The+number+of+keys+that+were+removed.
+*+@see+<a+href="http://redis.io/commands/del">Redis+Documentation:+DEL</a>
+*/
void+delete(Collection<K>+keys);

/**
+*+Find+all+keys+matching+the+given+{@code+pattern}.
+*
+*+@param+pattern+must+not+be+{@literal+null}.
+*+@return
+*+@see+<a+href="http://redis.io/commands/keys">Redis+Documentation:+KEYS</a>
+*/
Set<K>+keys(K+pattern);|4656559|entityMap^0|2D|X|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Below worked for me on Redis Cache.
Suppose you want to delete all Cache entries with key prefix: 'cache-name:object-name:parentKey'. Call method with key value <code>cache-name:object-name:parentKey*</code>.

<pre><code>import org.springframework.data.redis.core.RedisOperations; 
...
private final RedisOperations&lt;Object, Object&gt; redisTemplate;
... 
public void evict(Object key)
{
 redisTemplate.delete(redisTemplate.keys(key));
}
</code></pre>

From RedisOperations.java

<pre><code>/**
 * Delete given {@code keys}.
 *
 * @param keys must not be {@literal null}.
 * @return The number of keys that were removed.
 * @see &lt;a href="http://redis.io/commands/del"&gt;Redis Documentation: DEL&lt;/a&gt;
 */
void delete(Collection&lt;K&gt; keys);

/**
 * Find all keys matching the given {@code pattern}.
 *
 * @param pattern must not be {@literal null}.
 * @return
 * @see &lt;a href="http://redis.io/commands/keys"&gt;Redis Documentation: KEYS&lt;/a&gt;
 */
Set&lt;K&gt; keys(K pattern);
</code></pre>

blocks|key|2531254|text|通过实现自定义CacheResolver；扩展和实现SimpleCacheResolver.getCacheName，将租户作为缓存名称的一部分|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2531255|那么一定要驱逐所有密钥|2531256|@CacheEvict(value+=+{CacheName.CACHE1,+CacheName.CACHE2},+allEntries+=+true)|2531257|但请注意，如果您使用redis作为后备缓存，那么在幕后spring使用的是KEYS命令，因此该解决方案将无法扩展。一旦你在redis中获得了很少的100K密钥，密钥将需要150ms，并且redis服务器将会在CPU上遇到瓶颈。顽皮的弹簧。|2531258|entityMap^0|Q|W|0|0|0|24|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|U|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|M|$]]

Include the tenant as part of the cache name, by implementing a custom CacheResolver; extending and implementing <code>SimpleCacheResolver.getCacheName</code>
then do evict all keys
<code>@CacheEvict(value = {CacheName.CACHE1, CacheName.CACHE2}, allEntries = true)</code>
But note that if you are using redis as your backing cache, then under the hood spring uses the KEYS command, so the solution will not scale. Once you get few 100K keys in redis, KEYS will take 150ms and the redis server will bottleneck on CPU. Naughty spring.

blocks|key|2531283|text|我也遇到过类似的问题。我就是这样解决的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2531284|我的配置类|offset|length|style|BOLD|2531285|@Bean
RedisTemplate+redisTemplate()+{
++++RedisTemplate+template+=+new+RedisTemplate();
++++template.setConnectionFactory(lettuceConnectionFactory());
++++template.setKeySerializer(new+StringRedisSerializer());
++++template.setValueSerializer(new+RedisSerializerGzip());
++++return+template;
}|code-block|syntax|javascript|2531286|我的实用程序类|2531287|public+class+CacheService+{

++++final+RedisTemplate+redisTemplate;

++++public+void+evictCachesByPrefix(String+prefix)+{
++++++++Set<String>+keys+=+redisTemplate.keys(prefix+%2B+"*");
++++++++for+(String+key+:+keys)+{
++++++++++++redisTemplate.delete(key);
++++++++}
++++}
}|2531288|2531289|警告:将密钥视为仅应在生产环境中极其小心地使用的命令。在对大型数据库执行时，它可能会破坏性能。https://redis.io/commands/keys|blockquote|2531290|2531291|entityMap|0|LINK|mutability|MUTABLE|url|https://redis.io/commands/keys^0|0|0|5|0|0|0|7|0|0|0|1B|U|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|U|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

I had a similar issue as well. I solved it that way.
My Config Class
<pre><code>@Bean
RedisTemplate redisTemplate() {
 RedisTemplate template = new RedisTemplate();
 template.setConnectionFactory(lettuceConnectionFactory());
 template.setKeySerializer(new StringRedisSerializer());
 template.setValueSerializer(new RedisSerializerGzip());
 return template;
}
</code></pre>
My Util Class
<pre><code>public class CacheService {

 final RedisTemplate redisTemplate;

 public void evictCachesByPrefix(String prefix) {
 Set&lt;String&gt; keys = redisTemplate.keys(prefix + &quot;*&quot;);
 for (String key : keys) {
 redisTemplate.delete(key);
 }
 }
}
</code></pre>
<blockquote>
Warning: consider KEYS as a command that should only be used in
production environments with extreme care. It may ruin performance
when it is executed against large databases.
<a href="https://redis.io/commands/keys" rel="nofollow noreferrer">https://redis.io/commands/keys</a>
</blockquote>

blocks|key|2531308|text|我想从缓存中删除所有存储的订单，并以这种方式完成了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2531309|@CacheEvict(value+=+"List<Order>",+allEntries+=+true)|code-block|syntax|javascript|2531310|据我所知，这种方式将删除存储有该值的所有列表。所以你可以创建另一种结构，它也可以是一种解决方案。|2531311|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I wanted to remove all stored orders from cache and i complited it this way.
<pre><code>@CacheEvict(value = &quot;List&lt;Order&gt;&quot;, allEntries = true)
</code></pre>
As i understand this way will be removed all lists stored with this value. So you can create another structure and it also can be a kind of solution.

Is there any way of using wildcards in @CacheEvict?

I have an application with multi-tenancy that sometimes needs to evict all the data from the cache of the tenant, but not of all tenants in the system.

Consider the following method:

<pre><code>@Cacheable(value="users", key="T(Security).getTenant() + #user.key")
public List&lt;User&gt; getUsers(User user) {
 ...
}
</code></pre>

So, I would like to do something like:

<pre><code>@CacheEvict(value="users", key="T(Security).getTenant() + *")
public void deleteOrganization(Organization organization) {
 ...
}
</code></pre>

Is there anyway to do it?

Spring @CacheEvict using wildcards

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有办法在@CacheEvict中使用通配符？我有一个具有多租户的应用程序，它有时需要从租户的缓存中逐出所有数据，而不是系统中所有租户的数据。考虑以下方法：@Cacheable(value="users", key="T(Security).getTenant() + #user.key")public List<U...

问Spring @CacheEvict使用通配符
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Spring @CacheEvict使用通配符EN