Spring Cache@Cacheable-从同一bean的另一个方法调用时不工作

Question

从同一bean的另一个方法调用缓存的方法时，Spring缓存不工作。

这里有一个例子来清楚地解释我的问题。

配置：

<cache:annotation-driven cache-manager="myCacheManager" />

<bean id="myCacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
    <property name="cacheManager" ref="myCache" />
</bean>

<!-- Ehcache library setup -->
<bean id="myCache"
    class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" p:shared="true">
    <property name="configLocation" value="classpath:ehcache.xml"></property>
</bean>

<cache name="employeeData" maxElementsInMemory="100"/>  

缓存服务：

@Named("aService")
public class AService {

    @Cacheable("employeeData")
    public List<EmployeeData> getEmployeeData(Date date){
    ..println("Cache is not being used");
    ...
    }

    public List<EmployeeEnrichedData> getEmployeeEnrichedData(Date date){
        List<EmployeeData> employeeData = getEmployeeData(date);
        ...
    }

}

结果：

aService.getEmployeeData(someDate);
output: Cache is not being used
aService.getEmployeeData(someDate); 
output: 
aService.getEmployeeEnrichedData(someDate); 
output: Cache is not being used

方法调用在第二次调用中使用缓存。但是，当在AService类中调用get雇员数据方法时（在get雇员数据中），Cache未被使用。

这就是SpringCache的工作原理还是我遗漏了什么？

Answer 1

下面的例子是我用来从同一个bean中命中代理的，它类似于@marioeis'的解决方案，但我发现它更具可读性（可能不是：-）。无论如何，我喜欢将@Cacheable注释保持在服务级别：

@Service
@Transactional(readOnly=true)
public class SettingServiceImpl implements SettingService {

@Inject
private SettingRepository settingRepository;

@Inject
private ApplicationContext applicationContext;

@Override
@Cacheable("settingsCache")
public String findValue(String name) {
    Setting setting = settingRepository.findOne(name);
    if(setting == null){
        return null;
    }
    return setting.getValue();
}

@Override
public Boolean findBoolean(String name) {
    String value = getSpringProxy().findValue(name);
    if (value == null) {
        return null;
    }
    return Boolean.valueOf(value);
}

/**
 * Use proxy to hit cache 
 */
private SettingService getSpringProxy() {
    return applicationContext.getBean(SettingService.class);
}
...

另请参见在Springbean中启动新事务

Answer 2

自Spring 4.3以来，通过使用@Resource注释上的自自动布线可以解决该问题：

@Component
@CacheConfig(cacheNames = "SphereClientFactoryCache")
public class CacheableSphereClientFactoryImpl implements SphereClientFactory {

    /**
     * 1. Self-autowired reference to proxified bean of this class.
     */
    @Resource
    private SphereClientFactory self;

    @Override
    @Cacheable(sync = true)
    public SphereClient createSphereClient(@Nonnull TenantConfig tenantConfig) {
        // 2. call cached method using self-bean
        return self.createSphereClient(tenantConfig.getSphereClientConfig());
    }

    @Override
    @Cacheable(sync = true)
    public SphereClient createSphereClient(@Nonnull SphereClientConfig clientConfig) {
        return CtpClientConfigurationUtils.createSphereClient(clientConfig);
    }
}

Answer 3

我相信这就是它的工作原理。根据我记得读过的内容，生成了一个代理类，它截取所有请求并用缓存值响应，但是同一个类中的“内部”调用将不会获得缓存值。

从…起https://code.google.com/p/ehcache-spring-annotations/wiki/UsingCacheable

只有通过代理进来的外部方法调用才会被拦截。这意味着自调用（实际上，目标对象中的一个方法调用目标对象的另一个方法）不会在运行时导致实际的缓存拦截，即使调用的方法被标记为@Cacheable。