guava cache与spring集成

缓存的背景

    缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。在cpu进行计算的时候， 首先是读取寄存器，然后内存，再是硬盘。由于寄存器容量很小，不太适合存储我们需要快速读取的数据，放在硬盘中话，效率太低，所以大多数人将一些静态资源或者不经常修改的数据放在内存中。 　

缓存的作用

    缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘 IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的 逻辑处理会导致硬盘和CPU资源的瓶颈出现。缓存的作用就是将这些来自不易的数据保存在内存中，当有其他线程或者客户端需要查询相同 的数据资源时，直接从缓存的内存块中返回数据，这样不但可以提高系统的响应时间，同时也可以节省对这些数据的处理流程的资源消耗，整体上来说，系统性能会有大大的提升。

guava cache与spring整合

    大家都清楚，相对于静态Map实现本地缓存而言guava cache提供了许多种对缓存管理策略，比如：缓存个数、缓存生存期、缓存提取策略（LRU）等, 也正是这样，guava cache在本地缓存层面上使用是开发人员的首选。而在企业开发中spring是用的最多的，如果将guava cache与spring整合，依靠spring强大的IOC和AOP在使用缓存时是很方便、 快捷的，而要实现spring与guava cache整合 只需要以下三个步骤就可以搞定：

建立spring-cache.xml

    首先建立spring-cache.xml 里面配置spring对guava cache基本参数的管理，如下：

<?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:c="http://www.springframework.org/schema/c" xmlns:p="http://www.springframework.org/schema/p" 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-4.0.xsd"> <!--启动注解 进行guava cache 管理--> <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/> <bean id="cacheManager" class="org.springframework.cache.support.CompositeCacheManager"> <property name="cacheManagers"> <list> <!--将guava cache交于spring管理 如果要实现redis 也可以加在这里--> <ref bean="guavaCacheManager"/> </list> </property> <property name="fallbackToNoOpCache" value="true"/> </bean> <!--配置guava cache需要缓存的key 以及建立方式--> <bean id="guavaCacheManager" class="com.daojia.open.confluence.worker.common.GuavaCacheManager"> <property name="configMap"> <map key-type="java.lang.String" value-type="com.google.common.cache.CacheBuilder"> <entry key="indexReptileKeyValue" value-ref="defaultCacheBuilder"/> </map> </property> </bean> <!--设置guava cache缓存策略 生存期为24小时 最大100个缓存数--> <bean id="defaultCacheBuilder" class="com.google.common.cache.CacheBuilder" factory-method="from"> <constructor-arg value="maximumSize=100, expireAfterWrite=24h"/> </bean> </beans> 

实现spring对外提供的接口

    上面配置了将guavaCacheManager交于spring管理，那么久要实现这个管理类，该类如果要被spring容器管理的话需要 实现AbstractTransactionSupportingCacheManager接口，该接口支持事物回滚，当缓存失败，会将错误数据还原。具体实现如下：

package com.daojia.open.confluence.worker.common; import com.google.common.cache.CacheBuilder; import com.google.common.collect.Maps; import org.springframework.cache.Cache; import org.springframework.cache.transaction.AbstractTransactionSupportingCacheManager; import java.util.Collection; import java.util.Map; import java.util.concurrent.ConcurrentMap; /** * guavacache支持事务回滚，重写manager。 * cache的构建使用builder配置构建 */ public class GuavaCacheManager extends AbstractTransactionSupportingCacheManager { private final ConcurrentMap<String, Cache> cacheMap = Maps.newConcurrentMap(); private boolean dynamic = true; private Map<String, CacheBuilder> builderMap = Maps.newHashMap(); private boolean allowNullValues = true; @Override protected Collection<? extends Cache> loadCaches() { Collection<Cache> values = cacheMap.values(); return values; } @Override public Cache getCache(String name) { Cache cache = this.cacheMap.get(name); if (cache == null && this.dynamic) { synchronized (this.cacheMap) { cache = this.cacheMap.get(name); if (cache == null && this.builderMap.containsKey(name)) { CacheBuilder builder = this.builderMap.get(name); cache = createGuavaCache(name, builder); this.cacheMap.put(name, cache); } } } return cache; } protected Cache createGuavaCache(String name, CacheBuilder builder) { com.google.common.cache.Cache<Object, Object> cache = null; if(builder == null){ cache = CacheBuilder.newBuilder().build(); }else{ cache = builder.build(); } return new GuavaCache(name, cache, isAllowNullValues()); } public boolean isAllowNullValues() { return this.allowNullValues; } public void setConfigMap(Map<String, CacheBuilder> configMap) { this.builderMap = configMap; } } 

    这仅仅是对guava cache管理 还需要一个具体的缓存操作类，该类也是一样要被spring管理，要实现一个cache接口，该接口是spring对外缓存管理的统一接口，只要实现该 接口的缓存，都能被spring管理起来，比如guava cache 如下：

package com.daojia.open.confluence.worker.common; import com.daojia.open.confluence.worker.utils.JsonMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cache.Cache; import org.springframework.cache.support.SimpleValueWrapper; import org.springframework.util.Assert; import java.io.Serializable; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; public class GuavaCache implements Cache { private static Logger log = LoggerFactory.getLogger(GuavaCache.class); private final JsonMapper mapper = new JsonMapper(); private static final Object NULL_HOLDER = new NullHolder(); private final String name; private final com.google.common.cache.Cache<Object, Object> cache; private final boolean allowNullValues; public GuavaCache(String name, com.google.common.cache.Cache<Object, Object> cache) { this(name, cache, true); } public GuavaCache(String name, com.google.common.cache.Cache<Object, Object> cache, boolean allowNullValues) { Assert.notNull(name, "Name must not be null"); Assert.notNull(cache, "Cache must not be null"); this.name = name; this.cache = cache; this.allowNullValues = allowNullValues; } @Override public String getName() { return this.name; } @Override public Object getNativeCache() { return this.cache; } @Override public ValueWrapper get(Object key) { key = getKey(key.toString()); Object value = this.cache.getIfPresent(key); log.info("获取缓存key={},获取对象={}", key, mapper.toJson(value)); return toWrapper(value); } @Override public <T> T get(Object key, Class<T> type) { key = getKey(key.toString()); Object value = fromStoreValue(this.cache.getIfPresent(key)); log.info("获取缓存key={},获取对象={}", key, mapper.toJson(value)); if (value != null && type != null && !type.isInstance(value)) { throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value); } return (T) value; } @Override public void put(Object key, Object value) { key = getKey(key.toString()); this.cache.put(key, toStoreValue(value)); log.info("存入缓存key=={},存入对象={}", key, mapper.toJson(value)); } @Override public ValueWrapper putIfAbsent(Object key, Object value) { try { PutIfAbsentCallable callable = new PutIfAbsentCallable(value); Object result = this.cache.get(key, callable); return (callable.called ? null : toWrapper(result)); } catch (ExecutionException ex) { throw new IllegalStateException(ex); } } @Override public void evict(Object key) { this.cache.invalidate(key); log.info("删除缓存key={}",key); } @Override public void clear() { this.cache.invalidateAll(); log.info("清空guavacache所有缓存"); } private ValueWrapper toWrapper(Object value) { return (value != null ? new SimpleValueWrapper(fromStoreValue(value)) : null); } protected Object fromStoreValue(Object storeValue) { if (this.allowNullValues && storeValue == NULL_HOLDER) { return null; } return storeValue; } public final boolean isAllowNullValues() { return this.allowNullValues; } @SuppressWarnings("serial") private static class NullHolder implements Serializable { } protected Object toStoreValue(Object userValue) { if (this.allowNullValues && userValue == null) { return NULL_HOLDER; } return userValue; } private class PutIfAbsentCallable implements Callable<Object> { private final Object value; private boolean called; public PutIfAbsentCallable(Object value) { this.value = value; } @Override public Object call() throws Exception { this.called = true; return toStoreValue(this.value); } } /**实现key增加cache名称**/ private String getKey(String key) { return name + "_" + key; } } 

编写sqel语法 对缓存进行管理

    当完成这上面两个步骤之后，表明你的guava cache已被spring管理起来了，这时可以熟悉一下sqel注释语法，这是spring 对缓存进行注解管理用到常用语法，比如获取缓存：

  /*当使用到该方法的时候 spring会首先判断缓存中是否含有该key的值 ，如果有则从本地缓存中获取 并以你输入的参数indexReptileKey为key获取，否则从执行方法体中的获取 并将获取的数据放入到缓存中*/ @Cacheable(value = "indexReptileKeyValue", key = "#indexReptileKey") public List<IndexReptilePJO> getReptile(int indexReptileKey) throws Exception { LOGGER.info("不走guava cache获取参数"); return super.handlerindexReptile(); } 

    放入缓存如下:

  /*设置某个值的时候，想将该值存入缓存 则用这个注解 将你需要设置的值设置到缓存中 另一个方法在获取的时候就是从缓存中获取*/ @CachePut(value = "indexReptileKeyValue", key = "#indexReptileKey") public List<IndexReptilePJO> setReptile(int indexReptileKey) throws Exception { LOGGER.info("将树节点项目路径 存入guava cache中"); return super.handlerindexReptile(); }