Custom CacheResolver non funziona

Question

Ho un progetto Spring Boot con un custom CacheResolver in quanto ho bisogno di decidere sul runtime quale cache voglio usare, non ho errori di compilazione ma, quando faccio qualche test e posto una pausa punto al mio custom CacheResolver non ci entra mai.

Questa è la mia classe di configurazione per il cache:

@Configuration 
@EnableCaching(proxyTargetClass = true) 
@PropertySource(CacheConfig.CLASSPATH_DEPLOY_CACHE_PROPERTIES_PROPERTIES) 
public class CacheConfig extends CachingConfigurerSupport{ 

     public static final String CLASSPATH_DEPLOY_CACHE_PROPERTIES_PROPERTIES = "classpath:/deploy/cache-properties.properties"; 

     public static final String CACHEABLE_DOCUMENTS_PROPERTY = "cacheable.documents"; 
     public static final String TTL_CACHEABLE_DOCUMENTS_PROPERTY = "ttl.cacheable.documents"; 
     public static final String SIZED_CACHEABLE_DOCUMENTS_PROPERTY = "sized.cacheable.documents"; 
     public static final String CACHE_NAME = "permanentCache"; 
     public static final String TTL_CACHE = "ttlCache"; 
     public static final String SIZED_CACHE = "sizedCache"; 
     public static final String CACHEABLE_DOCUMENTS = "cacheableDocuments"; 
     public static final String SIZED_CACHEABLE_DOCUMENTS = "sizedCacheableDocuments"; 
     public static final int WEIGHT = 1000000; 
     public static final int TO_KBYTES = 1000; 

     @Inject 
     protected Environment environment; 

     //@Bean 
     @Override 
     public CacheManager cacheManager() { 
     SimpleCacheManager cacheManager = new SimpleCacheManager(); 
     GuavaCache sizedCache = new GuavaCache(SIZED_CACHE, CacheBuilder.newBuilder().maximumWeight(WEIGHT).weigher(
       (key, storable) -> { 
        String json = ((Storable) storable).toJson(); 
        return json.getBytes().length/TO_KBYTES; 
       } 
     ).build()); 
     GuavaCache permanentCache = new GuavaCache(CACHE_NAME,CacheBuilder.newBuilder().build()); 
     //GuavaCache ttlCache = new GuavaCache(TTL_CACHE, CacheBuilder.newBuilder().expireAfterWrite(30, TimeUnit.MINUTES).build()); 
     cacheManager.setCaches(Arrays.asList(permanentCache,sizedCache)); 
     return cacheManager; 
     } 

     @Bean(name = "wgstCacheResolver") 
     @Override 
     public CacheResolver cacheResolver(){ 
     CacheResolver cacheResolver = new WgstCacheResolver(cacheManager(),cacheableDocuments(),sizedCacheableDocuments()); 
     return cacheResolver; 
     } 


     @Bean(name = CACHEABLE_DOCUMENTS) 
     public List<String> cacheableDocuments(){ 
     String[] cacheableDocuments = StringUtils.commaDelimitedListToStringArray(environment.getProperty(CACHEABLE_DOCUMENTS_PROPERTY)); 
     return Arrays.asList(cacheableDocuments); 
     } 

     @Bean(name = SIZED_CACHEABLE_DOCUMENTS) 
     public List<String> sizedCacheableDocuments(){ 
     String[] sizedCacheableDocuments = StringUtils.commaDelimitedListToStringArray(environment.getProperty(SIZED_CACHEABLE_DOCUMENTS_PROPERTY)); 
     return Arrays.asList(sizedCacheableDocuments); 
     } 
    } 

Ecco il mio CacheResolver

public class WgstCacheResolver extends AbstractCacheResolver { 

    private final List<String> cacheableDocuments; 
    private final List<String> sizedCacheableDocuments; 

    public WgstCacheResolver(final CacheManager cacheManager,final List<String> cacheableDocuments, final List<String> sizedCacheableDocuments) { 
    super(cacheManager); 
    this.cacheableDocuments = cacheableDocuments; 
    this.sizedCacheableDocuments = sizedCacheableDocuments; 
    } 

    /** 
    * Resolves the cache(s) to be updated on runtime 
    * @param context 
    * @return*/ 
    @Override 
    protected Collection<String> getCacheNames(final CacheOperationInvocationContext<?> context) { 

    final Collection<String> cacheNames = new ArrayList<>(); 
    final AbstractDao dao = (AbstractDao)context.getTarget(); 
    final String documentType = dao.getDocumentType().toString(); 
    if (cacheableDocuments.contains(documentType)){ 
     cacheNames.add("permanentCache"); 
    } 
    if (sizedCacheableDocuments.contains(documentType)){ 
     cacheNames.add("sizedCache"); 
    } 
    return cacheNames; 
    } 
} 

E qui il mio DAO in cui io uso la cache:

@Component 
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.DEFAULT) 
    @CacheConfig(cacheResolver = "wgstCacheResolver") 
    public class CacheableDao<T extends Storable> extends AbstractDao<T> { 

     private final Logger logger = LoggerFactory.getLogger(CacheableDao.class); 

     public CacheableDao(final Bucket bucket, final Class<T> typeParameterClass, final DocumentType documentType) { 
     super(bucket, typeParameterClass, documentType); 
     } 

     @Cacheable(key = "{#root.methodName, #root.target.generateFullKey(#key)}") 
     public T get(final String key) throws DatastoreAccessException, ObjectMappingException { 
     //do something 
     } 
. 
. 
. 
} 

ho provato a implementare CacheResolver invece di estendere AbstractCacheResolver ma non ha fatto e qualsiasi differenza.

Grazie.

Answer 1

nomi cache devono essere inclusi ad un certo punto, basta specificare il CacheResolver utilizzare non abbastanza è, la classe @Cacheable ha bisogno di essere a conoscenza dei nomi cache disponibili, così li ho inclusi con il @CacheConfig della nota:

@CacheConfig(cacheNames = {WgstCacheConfig.PERMANENT_CACHE, WgstCacheConfig.SIZED_CACHE}, 
    cacheResolver = WgstCacheConfig.WGST_CACHE_RESOLVER) 
public class CacheableDao<T extends Storable> extends AbstractDao<T> { 

una cosa che non mi piace è che ho bisogno di fornire un NULL CacheManager, anche se non sto usando, altrimenti ottengo il seguente errore:

Caused by: java.lang.IllegalStateException: No CacheResolver specified, and no bean of type CacheManager found. Register a CacheManager bean or remove the @EnableCaching annotation from your configuration. 

Così ho lasciato in questo modo , un d funziona:

@Bean 
    public CacheManager cacheManager() { 
    return null; 
    } 

    @Bean(name = WGST_CACHE_RESOLVER) 
    public CacheResolver cacheResolver(){ 
    CacheResolver cacheResolver = new WgstCacheResolver(cacheableDocuments(),sizedCacheableDocuments(),getPermanentCache(), 
                 getSizedCache()); 
    return cacheResolver; 
    } 

reran mio test, passando attraverso il mio personalizzato CacheResolver e si comporta come previsto risolvere alla cache corretto (s)

La mia classe di configurazione non sta estendendo più CachingConfigurerSupport.

Answer 2

Dopo un po 'di avanti e indietro (mi dispiace per quello!) Si scopre che questo è davvero un bug in Spring Framework.

Ho creato SPR-13081. Aspettatevi una correzione per la prossima versione di manutenzione (4.1.7.RELEASE). Grazie per il progetto di esempio!