谈谈spring的缓存

缓存到底扮演了什么角色

请移步:  http://hacpai.com/article/1376986299174

在对项目进行优化的时候,我们可以主要从以下三个方面入手:

1 缓存

2 集群

3 异步





今天,就先说说缓存。先说说spring的缓存,下一节我们再聊聊redis





说到spring的缓存,得提到三个注解。

spring的三个注解

@Cacheable

  @Cacheable(value="accountCache")
	    public Account getAccountByName(String accountName) {
	    	System.out.println("我进来了");
	        // 方法内部实现不考虑缓存逻辑，直接实现业务
	        logger.info("real querying account... {}", accountName);
	        Account accountOptional = getFromDB(accountName);
	       return accountOptional;
	    }

在对上面的方法加上 @Cacheable(value="accountCache")后,第一次使用某个参数例如"张三"查询的时候,会执行getAccountByName的方法体,并且可以认为在spring内部会生成一个名叫accountCache的hashmap,里面的key就是"张三",value就是getAccountByName方法的返回值。

当第二次以参数"张三"调用getAccountByName的时候,spring就会先在accountCache里面找有没有哪个key是"张三",结果发现有,那就直接返回,也就不会执行getAccountByName的方法体了。

我再说简单点,第二次调用getAccountByName的时候(以张三为参数),就不会打印出"我进来了"。

说了这么久,那么accountCache是个什么东西呢?

请看下面的配置文件:

    <cache:annotation-driven/>
 
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
 
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
                    <property name="name" value="accountCache"/>
                </bean>
            </set>
        </property>
    </bean>

@CacheEvict

我们提到了缓存,上面的例子说明了建立缓存,那总得有方法来修改缓存吧。

    @CacheEvict(value="accountCache",key="#account.getName()")
    public Account updateAccount(Account account) {
        return updateDB(account);
    }

上面的意思是说,如果一旦调用了updateAccount这个方法,spring就会通过参数的getName方法获得一个值,并且用这个值删除accountCache中的某一个key。

这样做的效果就是,如果update某个对象后,这个对象在accountCache中的记录就没有了。

另外

    @CacheEvict(value="accountCache",allEntries=true)
    public void reload() {
    }

参数allEntyies=true是什么意思,还用我说么?

@CachePut

上面的方法感觉还是有点麻烦,我想更新缓存,而不想删除缓存。

    @CachePut(value="accountCache",key="#account.getName()")
    public Account updateAccount(Account account) {
      return updateDB(account);
    } 

上面的 @CachePut的意思就是说,一旦我调用updateAccount方法,spring就会通过getName()取得account参数的一个值,并且以这个值为key,以updateAccount的返回值为value,更新accountCache。

condition与多参数

3个最主要的标签的最主要的方法说完了,spring关于缓存还有一点小的"奇技淫巧"(呵呵,张晨的惯用语)我们一块来看看

关于condition

@Cacheable(value="accountCache",condition="#accountName.length() <= 4")
public Account getAccountByNameWithCondition(String accountName) {
    // 方法内部实现不考虑缓存逻辑，直接实现业务
    return getFromDB(accountName);
}

condaition会返回一个boolean值,如果是true,才进行缓存操作。

没看懂么?好吧,我自己也不是很清楚这句话。

accountService5.getAccountByNameWithCondition("dlf love glt");

    accountService5.getAccountByNameWithCondition("dlf love glt");

    accountService5.getAccountByNameWithCondition("dlf love glt");

运行这三行,每一行都会进入方法体,仿佛并没有关于缓存的任何事情。

关于多个参数的遴选

 @Cacheable(value="accountCache",key="#accountName.concat(#password)")
 public Account getAccount(String accountName,String password,boolean other) {
   // 方法内部实现不考虑缓存逻辑，直接实现业务
   return getFromDB(accountName,password);
 }

首先说明额,那个concat是java中String类的原生方法。

可是我把key="#accountName.concat(#password)"改成key="#accountName#password"就不成。至于为什么,暂时还没有考虑。

如果 @Cacheable中只有value参数,没有key参数,那么方法的所有参数将作为一个联合主键成为map中的key。如果是上面例子中的情况,虽然有三个参数,但是spring只会把accountName与password作为联合主键。

关于这个,大家都理解了吧。

如果大家都理解了,我这还有一个问题:就像上面的例子,咱们假定,第三个参数表示是否打印日志。

可是一旦前两个参数都已经存在于spirng的cache中了,这个方法体都不会运行了,那第三个参数还有个毛用?

直接把取数据的那段逻辑抽出来做一个方法,而且它只有两个参数,不就OK了?

最后我的想法是:

就算第三个参数是关于打印日志的,我第二次操作的时候,就没有访问数据库,也就不用打印日志了,所以这个关于遴选参数的key还是有用的。

扩展性

其实,就上面的内容而已,已经够我们在绝大部分场合使用了。

不过有时候,我们还需要扩展。例如,我想持久化缓存,但是我又不想侵入现有的代码。(我这个需求很操蛋,但就是为了说明这么一个场景:我们需要自定义缓存方案)

首先，我们需要提供一个 CacheManager 接口的实现，这个接口告诉 spring 有哪些 cache 实例，spring 会根据 cache 的名字查找 cache 的实例。另外还需要自己实现 Cache 接口，Cache 接口负责实际的缓存逻辑，例如增加键值对、存储、查询和清空等。



我们自定义了一个缓存,它的名字叫MyCache

 import java.util.HashMap; 

 import java.util.Map; 
 
 import org.springframework.cache.Cache;
 import org.springframework.cache.support.SimpleValueWrapper; 
 
 public class MyCache implements Cache {
   private String name;
   private Map<String,Account> store = new HashMap<String,Account>();; 
 
   public MyCache() {
   } 
 
   public MyCache(String name) {
     this.name = name;
   } 
 
   @Override
   public String getName() {
     return name;
   } 
 
   public void setName(String name) {
     this.name = name;
   } 
 
   @Override
   public Object getNativeCache() {
     return store;
   } 
 
   @Override
   public ValueWrapper get(Object key) {
     ValueWrapper result = null;
     Account thevalue = store.get(key);
     if(thevalue!=null) {
       thevalue.setPassword("from mycache:"+name);   //注意这一行
       result = new SimpleValueWrapper(thevalue);
     }
     return result;
   } 
 
   @Override
   public void put(Object key, Object value) {
     Account thevalue = (Account)value;
     store.put((String)key, thevalue);
   } 
 
   @Override
   public void evict(Object key) {
   } 
 
   @Override
   public void clear() {
   }
 }
 
 再看CacheManager
import java.util.Collection;
import org.springframework.cache.support.AbstractCacheManager;
 
public class MyCacheManager extends AbstractCacheManager { 
 
	   private Collection<? extends MyCache> caches; 
 
	   /**
	   * Specify the collection of Cache instances to use for this CacheManager.
	   */
	   public void setCaches(Collection<? extends MyCache> caches) {
	     this.caches = caches;
	   } 
 
	   @Override
	   protected Collection<? extends MyCache> loadCaches() {
	     return this.caches;
	   } 
 
	 }

上面的一切都已经OK,当然spring还不知道我们干的事情

所以,看xml

 <cache:annotation-driven /> 
 
 <bean id="cacheManager" class="com.cache.springannotation.step6.MyCacheManager">
     <property name="caches">
       <set>
         <bean
           class="com.rollenholt.spring.cache.MyCache"
           p:name="accountCache" />
       </set>
     </property>
   </bean> 

当我们用下面的代码测试的时候:

    @Test
    public void getCacheMySelf(){
    	Account account = accountService6.getAccountByName("someone");
    	System.out.println("***");
    	logger.info("passwd={}", account.getPassword());
    	account = accountService6.getAccountByName("someone");
    	logger.info("passwd={}", account.getPassword());
    }

输出如下:

INFO  2015-12-04 21:07:01,695 cache.springannotation.step6.AccountService6:26 --- real querying account... someone
INFO  2015-12-04 21:07:01,697 cache.springannotation.step6.AccountService6:60 --- real querying db... someone
***
INFO  2015-12-04 21:07:01,697 cache.springannotation.step6.AccountService6Test:74 --- passwd=null
INFO  2015-12-04 21:07:01,698 cache.springannotation.step6.AccountService6Test:76 --- passwd=from mycache:accountCache

注意和限制

上面介绍过 spring cache 的原理，即它是基于动态生成的 proxy 代理机制来对方法的调用进行切面，这里关键点是对象的引用问题.



如果对象的方法是内部调用（即 this 引用）而不是外部引用，则会导致 proxy 失效，那么我们的切面就失效，也就是说上面定义的各种注释包括 @Cacheable、@CachePut 和 @CacheEvict 都会失效，我们来演示一下。





public Account getAccountByName2(String accountName) { 

   return this.getAccountByName(accountName); 

 } 



 @Cacheable(value="accountCache")// 使用了一个缓存名叫 accountCache 

 public Account getAccountByName(String accountName) { 

   // 方法内部实现不考虑缓存逻辑，直接实现业务

   return getFromDB(accountName); 

 }

 上面我们定义了一个新的方法 getAccountByName2，其自身调用了 getAccountByName 方法，这个时候，发生的是内部调用（this），所以没有走 proxy，导致 spring cache 失效

简单的说:

spirng默认的缓存不支持内部调用

而且要缓存的方法必须是public的



就在刚才

glt想我了

glt是谁? 我媳妇

嘿嘿

参考资料:

我这篇博客基本上可以认为是对下面这篇博客做的读书笔记

http://www.cnblogs.com/rollenholt/p/4202631.html

rollenholt这篇文章写得很好,它的主要参考文章也是下面这篇

http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/