La migliore strategia per memorizzare una costosa chiamata al servizio web in Grails

Question

Ho una semplice applicazione Grails che deve effettuare una chiamata periodica a un servizio Web esterno più volte durante la sessione di un utente (mentre si usa l'interfaccia).

Vorrei memorizzare nella cache questa risposta al servizio web, ma i risultati del servizio cambiano ogni pochi giorni, quindi mi piacerebbe memorizzarlo nella cache per un breve periodo (aggiornamenti giornalieri).

Il plug-in della cache di Grails non sembra supportare le implementazioni "time to live", quindi ho esplorato alcune possibili soluzioni. Mi piacerebbe sapere quale plugin o soluzione programmatica sarebbe meglio risolvere questo problema.

Esempio:

BuildConfig.groovy

plugins{ 
    compile ':cache:1.0.0' 
} 

MyController.groovy

def getItems(){ 
    def items = MyService.getItems() 
    [items: items] 
} 

MyService.groovy

@Cacheable("itemsCache") 
class MyService { 
    def getItems() { 
     def results 

     //expensive external web service call 

     return results 
    } 
} 

UPDATE

C'erano molte buone opzioni. Ho deciso di seguire l'approccio plug-in suggerito da Burt. Ho incluso una risposta esemplificativa con piccole modifiche al precedente esempio di codice per aiutare gli altri a voler fare qualcosa di simile. Questa configurazione espira la cache dopo 24 ore.

BuildConfig.groovy

plugins{ 
    compile ':cache:1.1.7' 
    compile ':cache-ehcache:1.0.1' 
} 

Config.groovy

grails.cache.config = { 
    defaultCache { 
     maxElementsInMemory 10000 
     eternal false 
     timeToIdleSeconds 86400 
     timeToLiveSeconds 86400 
     overflowToDisk false 
     maxElementsOnDisk 0 
     diskPersistent false 
     diskExpiryThreadIntervalSeconds 120 
     memoryStoreEvictionPolicy 'LRU' 
    } 
} 

Answer 1

Il plug-in principale non supporta TTL, ma il plug-in Ehcache. Vedere http://grails-plugins.github.com/grails-cache-ehcache/docs/manual/guide/usage.html#dsl

Il plugin http://grails.org/plugin/cache-ehcache dipende http://grails.org/plugin/cache ma sostituisce il gestore della cache con uno che utilizza EHCache (quindi è necessario sia installato)

Answer 2

Dai test di unità grails-cache (cercare timeToLiveSeconds), vedo che è possibile configurare la cache a livello di cache , non per chiamata al metodo o simile. Utilizzando questo metodo, si configureranno le impostazioni per grails.cache.config.

Si crea una cache dedicata con le impostazioni time-to-live e quindi si fa riferimento al servizio.

Answer 3

Un hack/soluzione sarebbe quella di utilizzare una combinazione di @Cacheable ("itemsCache") e @CacheFlush ("itemsCache").

Comunica al metodo getItems() di memorizzare nella cache i risultati.

@Cacheable("itemsCache") 
def getItems() { 
} 

e quindi un altro metodo di servizio per svuotare la cache, che è possibile chiamare frequentemente da un lavoro.

@CacheFlush("itemsCache") 
def flushItemsCache() {} 

Answer 4

Dopo diverse ore di fallimenti in battaglie con SpEL ho vinto la guerra alla fine! Quindi, come sapete, la cache di Grails non ha TTL pronto all'uso. È possibile attenersi a ehcache e fare qualche configurazione di fantasia. O peggio aggiungere la logica vampate di calore sul salvataggio/aggiornamento ecc Ma la mia soluzione è:

@Cacheable(value = 'domainInstance', key="#someId.concat((new java.util.GregorianCalendar().getTimeInMillis()/10000))") 
def getSomeStuffOfDb(String someId){ 
     //extract something of db 
    }  
} 

e una cosa da sottolineare. Puoi saltare la configurazione in Config.groovy e verrà creata e aggiunta automaticamente. Tuttavia, se la tua app è in fase di caricamento subito dopo l'avvio, verranno generate alcune eccezioni.

2017-03-02 14:05:53,159 [http-apr-8080-exec-169] ERROR errors.GrailsExceptionResolver - CacheException occurred when processing request: [GET] /some/get 
Failed to get lock for campaignInstance cache creation. Stacktrace follows: 

quindi per evitare che si prega di aggiungere la configurazione così le strutture della cache saranno pronte in anticipo.

grails.cache.enabled = true 
grails.cache.clearAtStartup = true 
grails.cache.config = { 
    defaults { 
     maxElementsInMemory 10000 
     overflowToDisk false 
    } 
    cache { 
     name 'domainInstance' 
    } 
} 

GregorianCalendar(). GetTimeInMillis()/10000 farà TTL ~ 10sec./1000 ~ 1 sec. Pura matematica qui.