org.apache.ignite.cache.spring

Class SpringCacheManager

java.lang.Object

org.apache.ignite.cache.spring.SpringCacheManager

All Implemented Interfaces:

org.springframework.beans.factory.InitializingBean, org.springframework.cache.CacheManager

public class SpringCacheManager
extends Object
implements org.springframework.cache.CacheManager, org.springframework.beans.factory.InitializingBean

Implementation of Spring cache abstraction based on Ignite cache.

Overview

Spring cache abstraction allows to enable caching for Java methods so that the result of a method execution is stored in some storage. If later the same method is called with the same set of parameters, the result will be retrieved from that storage instead of actually executing the method. For more information, refer to Spring Cache Abstraction documentation.

How To Enable Caching

To enable caching based on Ignite cache in your Spring application, you will need to do the following:

• Start an Ignite node with proper configuration in embedded mode (i.e., in the same JVM where the application is running). It can already have predefined caches, but it's not required - caches will be created automatically on first access if needed.
• Configure SpringCacheManager as a cache provider in the Spring application context.

SpringCacheManager can start a node itself on its startup based on provided Ignite configuration. You can provide path to a Spring configuration XML file, like below (path can be absolute or relative to IGNITE_HOME):

 <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"
        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">
     <-- Provide configuration file path. -->
     <bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
         <property name="configurationPath" value="examples/config/spring-cache.xml"/>
     </bean>

     <-- Use annotation-driven caching configuration. -->
     <cache:annotation-driven/>
 </beans>
 

Or you can provide a IgniteConfiguration bean, like below:

 <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"
        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">
     <-- Provide configuration bean. -->
     <bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
         <property name="configuration">
             <bean id="gridCfg" class="org.apache.ignite.configuration.IgniteConfiguration">
                 ...
             </bean>
         </property>
     </bean>

     <-- Use annotation-driven caching configuration. -->
     <cache:annotation-driven/>
 </beans>
 

Note that providing both configuration path and configuration bean is illegal and results in IllegalArgumentException.

If you already have Ignite node running within your application, simply provide correct Grid name, like below (if there is no Grid instance with such name, exception will be thrown):

 <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"
        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">
     <-- Provide Grid name. -->
     <bean id="cacheManager" class="org.apache.ignite.cache.spring.SpringCacheManager">
         <property name="gridName" value="myGrid"/>
     </bean>

     <-- Use annotation-driven caching configuration. -->
     <cache:annotation-driven/>
 </beans>
 

This can be used, for example, when you are running your application in a J2EE Web container and use ServletContextListenerStartup for node startup.

If neither configurationPath, configuration, nor gridName are provided, cache manager will try to use default Grid instance (the one with the null name). If it doesn't exist, exception will be thrown.

Starting Remote Nodes

Keep in mind that the node started inside your application is an entry point to the whole topology it connects to. You can start as many remote standalone nodes as you need using bin/ignite.{sh|bat} scripts provided in Ignite distribution, and all these nodes will participate in caching the data.

Constructor Summary

Constructors

Constructor and Description
SpringCacheManager()

Method Summary

Methods

Modifier and Type	Method and Description
void	afterPropertiesSet()
org.springframework.cache.Cache	getCache(String name)
Collection<String>	getCacheNames()
IgniteConfiguration	getConfiguration() Gets configuration bean.
String	getConfigurationPath() Gets configuration file path.
CacheConfiguration<Object,Object>	getDynamicCacheConfiguration() Gets dynamic cache configuration template.
NearCacheConfiguration<Object,Object>	getDynamicNearCacheConfiguration() Gets dynamic near cache configuration template.
String	getGridName() Gets grid name.
void	setConfiguration(IgniteConfiguration cfg) Sets configuration bean.
void	setConfigurationPath(String cfgPath) Sets configuration file path.
void	setDynamicCacheConfiguration(CacheConfiguration<Object,Object> dynamicCacheCfg) Sets dynamic cache configuration template.
void	setDynamicNearCacheConfiguration(NearCacheConfiguration<Object,Object> dynamicNearCacheCfg) Sets dynamic cache configuration template.
void	setGridName(String gridName) Sets grid name.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SpringCacheManager

public SpringCacheManager()

Method Detail

getConfigurationPath

public String getConfigurationPath()

Gets configuration file path.

Returns:

Grid configuration file path.

setConfigurationPath

public void setConfigurationPath(String cfgPath)

Sets configuration file path.

Parameters:

cfgPath - Grid configuration file path.

getConfiguration

public IgniteConfiguration getConfiguration()

Gets configuration bean.

Returns:

Grid configuration bean.

setConfiguration

public void setConfiguration(IgniteConfiguration cfg)

Sets configuration bean.

Parameters:

cfg - Grid configuration bean.

getGridName

public String getGridName()

Gets grid name.

Returns:

Grid name.

setGridName

public void setGridName(String gridName)

Sets grid name.

Parameters:

gridName - Grid name.

getDynamicCacheConfiguration

public CacheConfiguration<Object,Object> getDynamicCacheConfiguration()

Gets dynamic cache configuration template.

Returns:

Dynamic cache configuration template.

setDynamicCacheConfiguration

public void setDynamicCacheConfiguration(CacheConfiguration<Object,Object> dynamicCacheCfg)

Sets dynamic cache configuration template.

Parameters:

dynamicCacheCfg - Dynamic cache configuration template.

getDynamicNearCacheConfiguration

public NearCacheConfiguration<Object,Object> getDynamicNearCacheConfiguration()

Gets dynamic near cache configuration template.

Returns:

Dynamic near cache configuration template.

setDynamicNearCacheConfiguration

public void setDynamicNearCacheConfiguration(NearCacheConfiguration<Object,Object> dynamicNearCacheCfg)

Sets dynamic cache configuration template.

Parameters:

dynamicNearCacheCfg - Dynamic cache configuration template.

afterPropertiesSet

public void afterPropertiesSet()
                        throws Exception

Specified by:

afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean

Throws:

Exception

getCache

public org.springframework.cache.Cache getCache(String name)

Specified by:

getCache in interface org.springframework.cache.CacheManager

getCacheNames

public Collection<String> getCacheNames()

Specified by:

getCacheNames in interface org.springframework.cache.CacheManager