## 5.5.2.2 Caching Strategy

#### Setting up caching

Hibernate features a second-level cache with a customizable cache provider. This needs to be configured in the `grails-app/conf/DataSource.groovy` file as follows:

    hibernate {
        cache.use_second_level_cache=true
        cache.use_query_cache=true
        cache.provider_class='org.hibernate.cache.EhCacheProvider'
    }

You can of course customize these settings how you desire, for example if you want to use a distributed caching mechanism.

> For further reading on caching and in particular Hibernate's second-level cache, refer to the Hibernate documentation on the subject.

#### Caching instances

In your mapping block to enable caching with the default settings use a call to the `cache` method:

    class Person {
      ..
      static mapping = {
          table 'people'
          cache true
      }
    }

This will configure a 'read-write' cache that includes both lazy and non-lazy properties. If you need to customize this further you can do:

    class Person {
      ..
      static mapping = {
          table 'people'
          cache usage:'read-only', include:'non-lazy'
      }
    }

#### Caching associations

As well as the ability to use Hibernate's second level cache to cache instances you can also cache collections (associations) of objects. For example:

    class Person {
      String firstName
      static hasMany = [addresses:Address]
      static mapping = {
          table 'people'
          version false
          addresses column:'Address', cache:true
      }
    }
    class Address {
       String number
       String postCode
    }

This will enable a 'read-write' caching mechanism on the addresses collection. You can also use:

    cache:'read-write' // or 'read-only' or 'transactional'

To further configure the cache usage.

#### Caching Queries

You can cache queries such as dynamic finders and criteria. To do so using a dynamic finder you can pass the `cache` argument:

    def person = Person.findByFirstName("Fred", [cache:true])

> Note that in order for the results of the query to be cached, you still need to enable caching in your mapping as discussed in the previous section.

You can also cache criteria queries:

    def people = Person.withCriteria {
    	like('firstName', 'Fr%')
    	cache true
    }

#### Cache usages

Below is a description of the different cache settings and their usages:

- `read-only` - If your application needs to read but never modify instances of a persistent class, a read-only cache may be used.
- `read-write` - If the application needs to update data, a read-write cache might be appropriate.
- `nonstrict-read-write` - If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a `nonstrict-read-write` cache might be appropriate.
- `transactional` - The `transactional` cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify `hibernate.transaction.manager_lookup_class` in the `grails-app/conf/DataSource.groovy` file's `hibernate` config.