Best strategy to cache expensive web service call in Grails - caching

Question

I have a simple Grails application that needs to make a periodic call to an external web service several times during a user's session (while the use the interface).
I'd like to cache this web service response, but the results from the service change about every few days, so I'd like to cache it for a short time (perhaps daily refreshes).
The Grails cache plugin doesn't appear to support "time to live" implementations so I've been exploring a few possible solutions. I'd like to know what plugin or programatic solution would best solve this problem.
Example:
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
There were many good options. I decided to go with the plugin approach that Burt suggested. I've included a sample answer with minor changes to above code example to help others out wanting to do something similar. This configuration expires the cache after 24 hours.
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

The core plugin doesn't support TTL, but the Ehcache plugin does. See http://grails-plugins.github.com/grails-cache-ehcache/docs/manual/guide/usage.html#dsl
The http://grails.org/plugin/cache-ehcache plugin depends on http://grails.org/plugin/cache but replaces the cache manager with one that uses Ehcache (so you need both installed)

Answer 2

A hack/workaround would be to use a combination of #Cacheable("itemsCache") and #CacheFlush("itemsCache").
Tell the getItems() method to cache the results.
#Cacheable("itemsCache")
def getItems() {
}
and then another service method to flush the cache, which you can call frequently from a Job.
#CacheFlush("itemsCache")
def flushItemsCache() {}

Answer 3

After several hours of fails in battles with SpEL I have won the war in the end!
So as you know Grails cache does not have TTL out of the box. You can stick to ehcache and do some fancy configuration. Or worse add logic flushing it on save/update etc. But my solution is:
#Cacheable(value = 'domainInstance', key="#someId.concat((new java.util.GregorianCalendar().getTimeInMillis()/10000))")
def getSomeStuffOfDb(String someId){
//extract something of db
}
}
and one more thing to point out. You can skip configuration in Config.groovy and it will be created and added automatically itself.
However if your app is under load straight after start it will cause some exceptions.
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:
so to avoid that please add config so cache facilities will be ready beforehand.
grails.cache.enabled = true
grails.cache.clearAtStartup = true
grails.cache.config = {
defaults {
maxElementsInMemory 10000
overflowToDisk false
}
cache {
name 'domainInstance'
}
}
GregorianCalendar().getTimeInMillis()/10000 will make TTL ~10sec. /1000 ~1 sec. Pure maths here.

Answer 4

From the grails-cache unit tests(Look for timeToLiveSeconds), I see that you can configure caching at the cache level, not per method call or similar. Using this method, you would configure the settings for grails.cache.config.
You would create a dedicated cache with your time-to-live settings and then reference it in your service.