How to use Spring AOP aspects with Groovy and Grails, specific caching example

Question

We built a large insurance policy and claim management system using Grails and Groovy. Performance problems are slowing down the site because all 'READS' fetch from the database, which is not necessary since most data is static. We want to introduce a simple key/value cache in the Grails layer, but we don't want to litter the existing code with cache.get() and cache.set() code, we want to use aspects instead.

Here is a sample from our main controller....

InsuranceMainController {
  def customer {
    //handles all URI mappings for /customer/customerId
  }

  def policy {
    //handles all URI mappings for /policy/policyId, 
  }

  def claim {
    //handles all URL mappings for /claim/claimId
  }

As far as the cache goes, assume for the moment it's a simple Map named "cache" that's available as a globally-scoped object, and objects in the cache are keyed by request URI...

cache.put("/customer/99876", customerObject)
cache.put("/policy/99-33-ARYT", policyObject) 

Going back to the controller, if we just litter the code with cache.get()/set(), which is what we want to avoid using Spring AOP, we'll end up with messy code. We want to achieve the following functionality with apsects, or with just a simpler and cleaner implementation...

InsuranceMainController {
  def customer {

    Object customer = cache.get(request.getRequestURI())
    if ( customer != null)
       //render response with customer object
    }else
       //get the customer from the database, then add to cache
       CustomerPersistenceManager customerPM = ...
       customer = customerPM.getCustomer(customerId)
       cache.put(request.getRequestURI(), customer)
    }
  }

We need examples that show how we can achieve the above functionality using Spring AOP or something simpler in Grails while avoiding the littering of the code with cache.get()/set(). Suggestions to refactor the existing controller are welcome if it's required to get AOP working properly.

Thanks in advance

Answer 1

Rather than using AOP, you could adapt Mr Paul Woods' controller simplification pattern to move the cache handling out to a single method?

Something like this might work:

class InsuranceMainController {

  def customer = {
    Object customer = withCachedRef( 'customerId' ) { customerId ->
       CustomerPersistenceManager customerPM = ...
       customerPM.getCustomer(customerId)
    }
  }

  def policy = {
    //handles all URI mappings for /policy/policyId, 
    Object policy = withCachedRef( 'policyId' ) { policyId ->
       PolicyPersistenceManager policyPM = ...
       policyPM.getPolicy(policyId)
    }
  }

  // ...

  private def withCachedRef( String id, Closure c ) {
    Object ret = cache.get( request.requestURI )
    if( !ret ) {
      ret = c.call( params[ id ] )
      cache.put( request.requestURI, ret )
    }
    ret
  }
}

However, I haven't tested it at all :-( Just a suggestion of an alternative to AOP