Question

我在服务器端使用Spring缓存（使用EHCache）来定义@Cacheable中的缓存密钥。问题是不同的客户端发送相同的字符串，这些字符串用作具有不同拼写的键，因为它们发送区分大小写。结果是我的缓存包含的对象多于它们所需的对象。

实施例：假设我为某种方法定义了以下缓存：

@Cacheable(value = "myCache", key="{#myString}")
public SomeBusinessObject getFoo(String myString, int foo){
...
}

现在，客户端A向控制器发送“abc”（全部小写）。控制器调用getFoo和“abc”用作将对象放入缓存的密钥。客户端B发送“abC”（大写C），而不是返回密钥“abc”的高速缓存对象，而是创建密钥“abC”的新高速缓存对象。

如何避免密钥区分大小写？

我知道我可以将缓存键定义为小写，如下所示：

@Cacheable(value = "myCache", key="{#myString.toLowerCase()}")
public SomeBusinessObject getFoo(String myString, int foo){
...
}

这当然有效。但我正在寻找更通用的解决方案。我有很多缓存和许多缓存键，并做一些@CacheEvict（s）和@CachePut（s），如果我使用“toLowerCase”方法，我总是要确保不要忘记它在任何地方。

Answer 1

正如@gaston所提到的，该解决方案正在取代默认的KeyGenerator。在org.springframework.cache.annotation.CachingConfigurer中实施org.springframework.cache.annotation.CachingConfigurerSupport或扩展Configuration。

@Configuration
@EnableCaching
public class AppConfig extends CachingConfigurerSupport {
    @Override
    public KeyGenerator keyGenerator() {
        return new MyKeyGenerator();
    }

    @Bean
    @Override
    public CacheManager cacheManager() {
        //replaced with prefered CacheManager...
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.addCaches(Arrays.asList(new ConcurrentMapCache("default")));
        return cacheManager;
    }
}

以下是从org.springframework.cache.interceptor.SimpleKeyGenerator修改的实现。

import java.lang.reflect.Method;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKey;

public class MyKeyGenerator implements KeyGenerator {

    @Override
    public Object generate(Object target, Method method, Object... params) {
        if (params.length == 0) {
            return SimpleKey.EMPTY;
        }
        if (params.length == 1) {
            Object param = params[0];
            if (param != null) {
                if (param.getClass().isArray()) {
                    return new MySimpleKey((Object[])param);
                } else {
                    if (param instanceof String) {
                        return ((String)param).toLowerCase();
                    }
                    return param;
                }
            }
        }
        return new MySimpleKey(params); 
    }
}

当SimpleKey方法具有多个参数时，原始实现使用@Cacheable类生成密钥。这是生成不区分大小写的键的另一个实现。

import java.io.Serializable;
import java.util.Arrays;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils; 
@SuppressWarnings("serial")
public class MySimpleKey implements Serializable {
    private final Object[] params;
    private final int hashCode;

    /**
     * Create a new {@link SimpleKey} instance.
     * @param elements the elements of the key
     */
    public MySimpleKey(Object... elements) {
        Assert.notNull(elements, "Elements must not be null");
        Object[] lceles = new Object[elements.length];
        this.params = lceles;
        System.arraycopy(elements, 0, this.params, 0, elements.length);
        for (int i = 0; i < elements.length; i++) {
            Object o = elements[i];
            if (o instanceof String) {
                lceles[i] = ((String)o).toLowerCase();
            } else {
                lceles[i] = o;
            }
        }
        this.hashCode = Arrays.deepHashCode(lceles);
    }

    @Override
    public boolean equals(Object obj) {
        return (this == obj || (obj instanceof MySimpleKey
                && Arrays.deepEquals(this.params, ((MySimpleKey) obj).params)));
    }

    @Override
    public final int hashCode() {
        return this.hashCode;
    }

    @Override
    public String toString() {
        return getClass().getSimpleName() + " [" + StringUtils.arrayToCommaDelimitedString(this.params) + "]";
    }
}

如何避免Spring缓存中的区分大小写的密钥？

1 个答案: