Spring中使用ehcache缓存的方法及原理详解

        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.9.1</version>
        </dependency>

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false">
<diskStore path="java.io.tmpdir" />
<!-- name:缓存名称。 
maxElementsInMemory：缓存最大个数。 
eternal:对象是否永久有效，一但设置了，
timeout将不起作用。 
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。 仅当eternal=false对象
不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。 
timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和
失效时间之间。 仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。 
overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。 
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。
每个Cache都应该有自己的一个缓冲区。 
maxElementsOnDisk：硬盘最大缓存个数。 
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk 
store persists between restarts of the Virtual Machine. The default value 
is false. 
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的
策略去清理内存。 
默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。 
clearOnFlush：内存数量最大时是否清除。 -->
<defaultCache maxElementsInMemory="10000" eternal="false"
timeToIdleSeconds="60" timeToLiveSeconds="60" overflowToDisk="true"
maxElementsOnDisk="10000000" diskPersistent="false"
diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU" />


<cache name="applicationCache" maxElementsInMemory="10000"
eternal="false" timeToIdleSeconds="150" timeToLiveSeconds="600"
overflowToDisk="false" diskPersistent="false"
diskExpiryThreadIntervalSeconds="1" />


<cache name="indexCache" maxElementsInMemory="10000"
eternal="false" timeToIdleSeconds="60" timeToLiveSeconds="600"
overflowToDisk="false" diskPersistent="false"
diskExpiryThreadIntervalSeconds="1" />

</ehcache>

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

<!-- cacheManager工厂类，指定ehcache.xml的位置 -->
<beans:bean id="ehcacheManagerFactory"
class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
<beans:property name="configLocation" value="classpath:config/ehcache.xml" />
</beans:bean>

<!-- 声明cacheManager -->
<beans:bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
<beans:property name="cacheManager" ref="ehcacheManagerFactory" />
<beans:property name="transactionAware" value="true" />
</beans:bean>

    @Override
    @Cacheable("applicationCache")
    public Map<String, Object> getAppDetailById(long appId) {
        byte[] app = redisTemplate.getRaw(String.format(CacheKeys.APP_DETAIL_BY_ID, appId));
        if (null == app) {
            return Collections.EMPTY_MAP;
        }
        try {
            return CompressUtil.deCompress(app, appId);
        } catch (IOException t) {
            throw new FlymeTVServiceException(Errors.ServiceErrors.DE_COMPRESS_ERROR,
                    new Object[] { "appId:" + appId });
        }
    }
    @Cacheable(value = "categoryCache", key = "#categoryId + #sortType + #start + #max")
    @Override
    public MultiPage<Map<String, Object>> getCategoryApps(int categoryId, int sortType, 
int start, int max) {
        MultiPage<Map<String, Object>> result = new MultiPage<Map<String, Object>>();
        String key = String.format(CacheKeys.CATEGORY_APPS, categoryId, sortType);
        List<String> appIds = redisTemplate.lrange(key, start, max + BACKUP_APP_SIZE);
        .....
        return result;
    }

   public @interface Cacheable {  
            //缓存的名字，可以把数据写到多个缓存
    String[] value();          
     //缓存key，如果不指定将使用默认的KeyGenerator生成
    String key() default "";    
    //满足缓存条件的数据才会放入缓存，condition在调用方法之前和之后都会判断  
    String condition() default "";
     //用于否决缓存更新的，不像condition，该表达只在方法执行之后判断，此时可以拿到返回值result进行判断了
    String unless() default "";    
   }

@Cacheable(value = "user", key = "#id", condition = "#id lt 10")  
public User conditionFindById(final Long id) 

public interface KeyGenerator {  
    Object generate(Object target, Method method, Object... params);  
}  

  public Object generate(Object target, Method method, Object[] params)
  {
    if (params.length == 1) {
      return params[0] == null ? Integer.valueOf(53) : params[0];
    }
    if (params.length == 0) {
      return Integer.valueOf(0);
    }
    int hashCode = 17;
    for (Object object : params) {
      hashCode = 31 * hashCode + (object == null ? 53 : object.hashCode());
    }
    return Integer.valueOf(hashCode);
  }

@CachePut(value = "user", key = "#user.id")  
public User save(User user) {  
    users.add(user);  
    return user;  
}  

public @interface CachePut {  
    //缓存的名字，可以把数据写到多个缓存
    String[] value();     
    //缓存key，如果不指定将使用默认的KeyGenerator生成 
    String key() default "";     
    //满足缓存条件的数据才会放入缓存，condition在调用方法之前和之后都会判断  
    String condition() default ""; 
     //用于否决缓存更新的，不像condition，该表达只在方法执行之后判断，此时可以拿到返回值result进行判断了
    String unless() default "";     
} 

@CachePut(value = "user", key = "#user.id", unless = "#result.username eq 'zhang'")  
public User conditionSave2(final User user)