<dependency>
 <groupId>net.sf.ehcache</groupId>
 <artifactId>ehcache</artifactId>
 <version>2.10.2</version>
 <type>pom</type>
</dependency>

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>4.1.4.RELEASE</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

 <!-- 磁盘缓存位置 -->
 <diskStore path="java.io.tmpdir/ehcache"/>

 <!-- 默认缓存 -->
 <defaultCache
   maxEntriesLocalHeap="10000"
   eternal="false"
   timeToIdleSeconds="120"
   timeToLiveSeconds="120"
   maxEntriesLocalDisk="10000000"
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU"/>

 <!-- helloworld缓存 -->
 <cache name="helloworld"
   maxElementsInMemory="1000"
   eternal="false"
   timeToIdleSeconds="5"
   timeToLiveSeconds="5"
   overflowToDisk="false"
   memoryStoreEvictionPolicy="LRU"/>
</ehcache>

public class EhcacheDemo {
 public static void main(String[] args) throws Exception {
  // Create a cache manager
  final CacheManager cacheManager = new CacheManager();

  // create the cache called "helloworld"
  final Cache cache = cacheManager.getCache("helloworld");

  // create a key to map the data to
  final String key = "greeting";

  // Create a data element
  final Element putGreeting = new Element(key, "Hello, World!");

  // Put the element into the data store
  cache.put(putGreeting);

  // Retrieve the data element
  final Element getGreeting = cache.get(key);

  // Print the value
  System.out.println(getGreeting.getObjectValue());
 }
}

// 使用Ehcache默认配置获取单例的CacheManager实例
CacheManager.create();
String[] cacheNames = CacheManager.getInstance().getCacheNames();

// 使用Ehcache默认配置新建一个CacheManager实例
CacheManager.newInstance();
String[] cacheNames = manager.getCacheNames();

// 使用不同的配置文件分别创建一个CacheManager实例
CacheManager manager1 = CacheManager.newInstance("src/config/ehcache1.xml");
CacheManager manager2 = CacheManager.newInstance("src/config/ehcache2.xml");
String[] cacheNamesForManager1 = manager1.getCacheNames();
String[] cacheNamesForManager2 = manager2.getCacheNames();

// 基于classpath下的配置文件创建CacheManager实例
URL url = getClass().getResource("/anotherconfigurationname.xml");
CacheManager manager = CacheManager.newInstance(url);

// 基于文件流得到配置文件，并创建CacheManager实例
InputStream fis = new FileInputStream(new File
("src/config/ehcache.xml").getAbsolutePath());
try {
 CacheManager manager = CacheManager.newInstance(fis);
} finally {
 fis.close();
}

// 除了可以使用xml文件中配置的缓存，你也可以使用API动态增删缓存
// 添加缓存
manager.addCache(cacheName);

// 使用默认配置添加缓存
CacheManager singletonManager = CacheManager.create();
singletonManager.addCache("testCache");
Cache test = singletonManager.getCache("testCache");

// 使用自定义配置添加缓存，注意缓存未添加进CacheManager之前并不可用
CacheManager singletonManager = CacheManager.create();
Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
singletonManager.addCache(memoryOnlyCache);
Cache test = singletonManager.getCache("testCache");

// 使用特定的配置添加缓存
CacheManager manager = CacheManager.create();
Cache testCache = new Cache(
 new CacheConfiguration("testCache", maxEntriesLocalHeap)
 .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LFU)
 .eternal(false)
 .timeToLiveSeconds(60)
 .timeToIdleSeconds(30)
 .diskExpiryThreadIntervalSeconds(0)
 .persistence(new PersistenceConfiguration().strategy(Strategy.LOCALTEMPSWAP)));
 manager.addCache(testCache);

CacheManager singletonManager = CacheManager.create();
singletonManager.removeCache("sampleCache1");

/**
 * 测试：使用默认配置或使用指定配置来创建CacheManager
 *
 * @author victor zhang
 */
public class CacheOperationTest {
 private final Logger log = LoggerFactory.getLogger(CacheOperationTest.class);

 /**
  * 使用Ehcache默认配置(classpath下的ehcache.xml)获取单例的CacheManager实例
  */
 @Test
 public void operation() {
  CacheManager manager = CacheManager.newInstance("src/test/resources/ehcache/ehcache.xml");

  // 获得Cache的引用
  Cache cache = manager.getCache("userCache");

  // 将一个Element添加到Cache
  cache.put(new Element("key1", "value1"));

  // 获取Element，Element类支持序列化，所以下面两种方法都可以用
  Element element1 = cache.get("key1");
  // 获取非序列化的值
  log.debug("key:{}, value:{}", element1.getObjectKey(), element1.getObjectValue());
  // 获取序列化的值
  log.debug("key:{}, value:{}", element1.getKey(), element1.getValue());

  // 更新Cache中的Element
  cache.put(new Element("key1", "value2"));
  Element element2 = cache.get("key1");
  log.debug("key:{}, value:{}", element2.getObjectKey(), element2.getObjectValue());

  // 获取Cache的元素数
  log.debug("cache size:{}", cache.getSize());

  // 获取MemoryStore的元素数
  log.debug("MemoryStoreSize:{}", cache.getMemoryStoreSize());

  // 获取DiskStore的元素数
  log.debug("DiskStoreSize:{}", cache.getDiskStoreSize());

  // 移除Element
  cache.remove("key1");
  log.debug("cache size:{}", cache.getSize());

  // 关闭当前CacheManager对象
  manager.shutdown();

  // 关闭CacheManager单例实例
  CacheManager.getInstance().shutdown();
 }
}

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

 <!-- 磁盘缓存位置 -->
 <diskStore path="java.io.tmpdir/ehcache"/>

 <!-- 默认缓存 -->
 <defaultCache
   maxEntriesLocalHeap="10000"
   eternal="false"
   timeToIdleSeconds="120"
   timeToLiveSeconds="120"
   maxEntriesLocalDisk="10000000"
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU">
 <persistence strategy="localTempSwap"/>
 </defaultCache>

 <cache name="userCache"
   maxElementsInMemory="1000"
   eternal="false"
   timeToIdleSeconds="3"
   timeToLiveSeconds="3"
   maxEntriesLocalDisk="10000000"
   overflowToDisk="false"
   memoryStoreEvictionPolicy="LRU"/>
</ehcache>

Cache cache = manager.getCache("sampleCache"); 
CacheConfiguration config = cache.getCacheConfiguration(); 
config.setTimeToIdleSeconds(60); 
config.setTimeToLiveSeconds(120); 
config.setmaxEntriesLocalHeap(10000); 
config.setmaxEntriesLocalDisk(1000000);

Cache cache = manager.getCache("sampleCache"); 
cache.disableDynamicFeatures();

<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd
  http://www.springframework.org/schema/cache
  http://www.springframework.org/schema/cache/spring-cache-3.2.xsd">

 <description>ehcache缓存配置管理文件</description>

 <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
 <property name="configLocation" value="classpath:ehcache/ehcache.xml"/>
 </bean>

 <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
 <property name="cacheManager" ref="ehcache"/>
 </bean>

 <!-- 启用缓存注解开关 -->
 <cache:annotation-driven cache-manager="cacheManager"/>
</beans>

<cache:annotation-driven cache-manager="cacheManager"/>

@Configuration
@EnableCaching
public class AppConfig {
}

@Service
public class UserService {
 // @Cacheable可以设置多个缓存，形式如：@Cacheable({"books", "isbns"})
 @Cacheable({"users"})
 public User findUser(User user) {
  return findUserInDB(user.getId());
 }

 @Cacheable(value = "users", condition = "#user.getId() <= 2")
 public User findUserInLimit(User user) {
  return findUserInDB(user.getId());
 }

 @CachePut(value = "users", key = "#user.getId()")
 public void updateUser(User user) {
  updateUserInDB(user);
 }

 @CacheEvict(value = "users")
 public void removeUser(User user) {
  removeUserInDB(user.getId());
 }

 @CacheEvict(value = "users", allEntries = true)
 public void clear() {
  removeAllInDB();
 }
}

@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
public Book importBooks(String deposit, Date date)

@CacheConfig("books")
public class BookRepositoryImpl implements BookRepository {
 @Cacheable
 public Book findBook(ISBN isbn) {...}
}