Chapter 33. Integration with the Spring Framework

The first step to integrating Red Hat JBoss Data Grid with Spring is to enable cache support in the application context. This step lets you use the @Cacheable and @CacheEvict annotations for adding and removing entries from the cache.

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

<cache:annotation-driven />

@EnableCaching @Configuration
public class Config {
}

Add the appropriate dependencies for Red Hat JBoss Data Grid and the Spring integration module to your pom.xml as follows:

<dependency>
    <groupId>org.infinispan</groupId>
    <artifactId>infinispan-spring4-embedded</artifactId>
    <version>${version.spring}</version>
</dependency>

<dependency>
    <groupId>org.infinispan</groupId>
    <artifactId>infinispan-spring4-remote</artifactId>
    <version>${version.spring}</version>
</dependency>

The Spring cache provider SPI has two interfaces through which it interacts with Red Hat JBoss Data Grid, org.springframework.cache.CacheManager and org.springframework.cache.Cache. The CacheManager interface acts as a factory for named Cache instances.

To use JBoss Data Grid acts as the caching provider, the Spring Framework requires a CacheManager implementation with a bean named cacheManager in the application context.

The following examples show how you can configure your application context either declaratively or programmatically:

<bean id="cacheManager"          class="org.infinispan.spring.provider.SpringEmbeddedCacheManagerFactoryBean"
         p:configurationFileLocation="classpath:/path/to/cache-config.xml" />

<bean id="cacheManager"          class="org.infinispan.spring.provider.SpringRemoteCacheManagerFactoryBean"
         p:configurationFileLocation="classpath:/path/to/hotrod-client.properties" />

@EnableCaching
@Configuration
public class Config {

   @Bean
   public CacheManager cacheManager() {
      return new SpringEmbeddedCacheManager(infinispanCacheManager());
   }

   private EmbeddedCacheManager infinispanCacheManager() {
      return new DefaultCacheManager();
   }

}

@EnableCaching
@Configuration
public class Config {

   @Bean
   public CacheManager cacheManager() {
      return new SpringRemoteCacheManager(infinispanCacheManager());
   }

   private RemoteCacheManager infinispanCacheManager() {
      return new DefaultCacheManager();
   }

}

You can add caching to your application with Spring annotations.

By annotating this method with @Cacheable:

@Transactional
@Cacheable(value = "books", key = "#bookId")
public Book findBook(Integer bookId) {...}

Any Book instances returned from findBook(Integer bookId) will be placed in a named cache books, using the bookId as the value’s key.

// Evict all entries in the "books" cache
@Transactional
@CacheEvict (value="books", key = "#bookId", allEntries = true)
public void deleteBookAllEntries() {...}

// Evict any entries in the "books" cache that match the passed in bookId
@Transactional
@CacheEvict (value="books", key = "#bookId")
public void deleteBook(Integer bookId) {...]}

The Red Hat JBoss Data Grid Spring Cache provider defaults to blocking behaviour when performing read and write operations. By default operations are synchronous and do not time out. However, you might want to set a maximum time to wait for operations before timing out in some situations. For example, timeouts are useful if you need to ensure that an operation completes within a certain time and you can ignore the cached value.

The following properties let you set timeouts for read and write operations:

To configure timeouts for cache operations, set the properties in the context XML for your application on either SpringEmbeddedCacheManagerFactoryBean or SpringRemoteCacheManagerFactoryBean as follows:

<bean id="springEmbeddedCacheManagerConfiguredUsingConfigurationProperties" class="org.infinispan.spring.provider.SpringEmbeddedCacheManagerFactoryBean">
    <property name="configurationProperties">
        <props>
           <prop key="infinispan.spring.operation.read.timeout">500</prop>
           <prop key="infinispan.spring.operation.write.timeout">700</prop>
        </props>
    </property>
</bean>

<bean id="springRemoteCacheManagerConfiguredUsingConfigurationProperties" class="org.infinispan.spring.provider.SpringRemoteCacheManagerFactoryBean">
    <property name="configurationProperties">
        <props>
           <prop key="infinispan.spring.operation.read.timeout">500</prop>
           <prop key="infinispan.spring.operation.write.timeout">700</prop>
        </props>
    </property>
</bean>

Spring Session lets you externalize user session information to JBoss Data Grid in both library mode and remote client-server mode.

To configure Spring Session integration in your application, do the following:

The following provides an example configuration for JBoss Data Grid in library mode:

@EnableInfinispanEmbeddedHttpSession
@Configuration
public class Config {

   @Bean
   public SpringEmbeddedCacheManagerFactoryBean springCacheManager() {
      return new SpringEmbeddedCacheManagerFactoryBean();
   }

   //An optional configuration bean that replaces the default cookie
   //for obtaining configuration.
   //For more information refer to Spring Session documentation.
   @Bean
   public HttpSessionStrategy httpSessionStrategy() {
      return new HeaderHttpSessionStrategy();
   }
}