Spring Cache @Cacheable - ne fonctionne pas lors de l'appel depuis une autre méthode du même bean

Le cache Spring ne fonctionne pas lors de l'appel d'une méthode mise en cache à partir d'une autre méthode du même bean.

Voici un exemple pour expliquer mon problème de manière claire.

Configuration:

<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"/>  

Service mis en cache:

@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);
        ...
    }

}

Résultat :

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

L' getEmployeeDataappel de méthode utilise le cache employeeDatadans le deuxième appel comme prévu. Mais lorsque la getEmployeeDataméthode est appelée dans la AServiceclasse (in getEmployeeEnrichedData), Cache n'est pas utilisé.

Est-ce ainsi que fonctionne Spring Cache ou est-ce que je manque quelque chose?

Je crois que c'est ainsi que cela fonctionne. D'après ce que je me souviens avoir lu, il existe une classe proxy générée qui intercepte toutes les demandes et répond avec la valeur mise en cache, mais les appels «internes» au sein de la même classe n'obtiendront pas la valeur mise en cache.

Depuis https://code.google.com/p/ehcache-spring-annotations/wiki/UsingCacheable

Seuls les appels de méthode externes arrivant via le proxy sont interceptés. Cela signifie que l'auto-invocation, en fait, une méthode dans l'objet cible appelant une autre méthode de l'objet cible, ne conduira pas à une interception de cache réelle au moment de l'exécution, même si la méthode appelée est marquée @Cacheable.

Depuis le printemps 4.3, le problème peut être résolu en utilisant l' auto-autowiring sur l' @Resourceannotation:

@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);
    }
}

L'exemple ci-dessous est ce que j'utilise pour frapper le proxy depuis le même bean, il est similaire à la solution de @ mario-eis, mais je le trouve un peu plus lisible (peut-être que ce n'est pas :-). Quoi qu'il en soit, j'aime garder les annotations @Cacheable au niveau du service:

@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);
}
...

Voir aussi Démarrer une nouvelle transaction dans Spring Bean

Voici ce que je fais pour les petits projets avec une utilisation marginale des appels de méthode dans la même classe. La documentation dans le code est fortement conseillée, car elle peut sembler stridente aux collègues. Mais c'est facile à tester, simple, rapide à réaliser et m'épargne l'instrumentation AspectJ à part entière. Cependant, pour une utilisation plus intensive, je conseillerais la solution AspectJ.

@Service
@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
class AService {

    private final AService _aService;

    @Autowired
    public AService(AService aService) {
        _aService = aService;
    }

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

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

Dans mon cas, j'ajoute une variable:

@Autowired
private AService  aService;

J'appelle donc la getEmployeeDataméthode en utilisant leaService

@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 = aService.getEmployeeData(date);
    ...
}

}

Il utilisera le cache dans ce cas.

Utilisez le tissage statique pour créer un proxy autour de votre bean. Dans ce cas, même les méthodes `` internes '' fonctionneraient correctement

J'utilise le bean interne interne ( FactoryInternalCache) avec un vrai cache à cet effet:

@Component
public class CacheableClientFactoryImpl implements ClientFactory {

private final FactoryInternalCache factoryInternalCache;

@Autowired
public CacheableClientFactoryImpl(@Nonnull FactoryInternalCache factoryInternalCache) {
    this.factoryInternalCache = factoryInternalCache;
}

/**
 * Returns cached client instance from cache.
 */
@Override
public Client createClient(@Nonnull AggregatedConfig aggregateConfig) {
    return factoryInternalCache.createClient(aggregateConfig.getClientConfig());
}

/**
 * Returns cached client instance from cache.
 */
@Override
public Client createClient(@Nonnull ClientConfig clientConfig) {
    return factoryInternalCache.createClient(clientConfig);
}

/**
 * Spring caching feature works over AOP proxies, thus internal calls to cached methods don't work. That's why
 * this internal bean is created: it "proxifies" overloaded {@code #createClient(...)} methods
 * to real AOP proxified cacheable bean method {@link #createClient}.
 *
 * @see <a href="/programming/16899604/spring-cache-cacheable-not-working-while-calling-from-another-method-of-the-s">Spring Cache @Cacheable - not working while calling from another method of the same bean</a>
 * @see <a href="/programming/12115996/spring-cache-cacheable-method-ignored-when-called-from-within-the-same-class">Spring cache @Cacheable method ignored when called from within the same class</a>
 */
@EnableCaching
@CacheConfig(cacheNames = "ClientFactoryCache")
static class FactoryInternalCache {

    @Cacheable(sync = true)
    public Client createClient(@Nonnull ClientConfig clientConfig) {
        return ClientCreationUtils.createClient(clientConfig);
    }
}
}

la solution la plus simple est de loin de faire référence comme ceci:

AService.this.getEmployeeData(date);