Spring Cache-缓存概述及使用

概述

伴随信息量的爆炸式增长以及构建的应用系统越来越多样化、复杂化，特别是企业级应用互联网化的趋势，缓存（Cache）对应用程序性能的优化变的越来越重要。 将所需服务请求的数据放在缓存中，既可以提高应用程序的访问效率，又可以减少数据库服务器的压力，从而让用户获得更好的用户体验。

Spring从3.1开始，以一贯的优雅风格提供了一种透明的缓存解决方案，这使得Spring可以在后台使用不同的缓存框架（如EhCache,GemFire、HazelCast和Guava）时保持编程的一致。

Spring从4.0开始则全面支持JSR-107 annotations和自定义的缓存标签。

---

缓存的概念

我们可以将缓存定义为一种存储机制，它将数据保存在某个地方，并以一种更快的方式提供服务。

要理解缓存，我们先了解下基本概念

缓存命中率

即从缓存中读取数据的次数与总读取次数的比率。 一般来讲，命中率越高也好。

命中率 = 从缓存中读取的次数  / (总读取次数[从缓存中读取的次数+从慢速设备上读取的次数])

Miss率 = 没从缓存中读取的次数/ (总读取次数[从缓存中读取的次数+从慢速设备上读取的次数])

这是一个非常重要的监控指标，如果要做缓存，就一定要监控这个指标，来看缓存是否工作良好。

---

过期策略

即如果缓存满了，从缓存中移除数据的策略，常见的有 LFU 、LRU、FIFO

• FIFO (First in First Out) 先进先出策略，即先放入缓存的数据先被移除

• LRU (Least Recently Used) 最久未使用策略， 即使用时间距离现在最久的那个数据被移除

• LFU (Leaset Frequently Used) 最近最少使用策略，即一定时间内使用次数（频率）最少的那个数据被移除

• TTL（Time To Live）存活期，即从缓存中创建时间点开始至到期的一个时间段（不管在这个时间段内有没被访问过都将过期）

• TTI （Time To Idle）空闲期，即一个数据多久没有被访问就从缓存中移除的时间。

至此，我们基本了解了缓存的一些基本知识。 在Java中一般会对调用方法进行缓存控制，比如 findUserById(Sting id),先从缓存中查找有没有符合查询条件的数据，如果没有，则执行改方法从数据库中查找该用户，然后添加到缓存中，下次调用时将从缓存中获取。

从Spring3.1开始，提供了缓存注解，并且提供了Cache层的抽象。 此外，JSR-107也从Spring4.0开始得到全面支持。

Spring提供可一种可以在方法级别进行缓存的缓存抽象。 通过使用AOP对方法机型织入，如果已经为特定方法入参执行过该方法，那么不必执行实际方法就可以返回被缓存的结果。

为了启用AOP缓存功能，需要使用缓存注解对类中的相关方法进行标记，以便Spring为其生成具备缓存功能的代理类。 需要注意的是，Spring Cache仅提供了一种抽象而未提供具体的实现。 我们以便会自己使用AIP来做一定程度的封装实现。

Spring Cache的好处

• 支持开箱即用（Out Of The Box），并提供基本的Cache抽象，方便切换各种底层Cache

• 通过Cache注解即可实现缓存逻辑透明化，让开发者关注业务逻辑

• 当事务回滚时，缓存也会自动回滚

• 支持比较复杂的缓存逻辑

• 提供缓存编程的一致性抽象，方便代码维护。

Spring Cache的缺点

• Spring Cache并不针对多进程的应用环境进行专门的处理。

• 另外Spring Cache抽象的操作中没有锁的概念，当多线程并发操作（更新或者删除）同一个缓存项时，有可能读取到过期的数据。

---

自定义缓存管理器（粗略实现）

我们首先自定义一个缓存的实现，即不通过任何第三方组件来实现的对象内存缓存， 然后我们再通过Spring Cache来实现缓存操作，对比体会下SpringCache的优雅和便捷。

假设：我们根据artisanName查询artisan信息是一个非常频繁的动作，自然会想到对一个artisan的查询方法做缓存，以避免频繁的数据库访问操作，提高页面的相应速度。

通常的做法是：以artisanName作为Key,以返回的用户信息对象作为Value值存储。 而当以相同的artisanName查询用户时，程序将直接从缓存中获取结果并返回，否则更新缓存。

首先定义一个实体列 LittleArtisan

package com.xgj.cache.selfCacheManagerDemo.domain;

import java.io.Serializable;

/**
 * 
 * 
 * @ClassName: LittleArtisan
 * 
 * @Description: Java中的缓存和序列化是息息相关的,注意实现Serializable接口
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月2日 下午1:40:53
 */

public class LittleArtisan implements Serializable {

    private static final long serialVersionUID = 1L;

    private String artisanId;
    private String artisanName;
    private String artisanDesc;

    public String getArtisanId() {
        return artisanId;
    }

    public void setArtisanId(String artisanId) {
        this.artisanId = artisanId;
    }

    public String getArtisanName() {
        return artisanName;
    }

    public void setArtisanName(String artisanName) {
        this.artisanName = artisanName;
    }

    public String getArtisanDesc() {
        return artisanDesc;
    }

    public void setArtisanDesc(String artisanDesc) {
        this.artisanDesc = artisanDesc;
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }

}

java对象的缓存和序列化是息息相关的，一般情况下，需要被缓存的实体类需要实现Serializable接口 。 只有实现了Serializable接口的类，JVM才可以对其对象进行序列化。

实体类始终实现Serializable接口是一个良好的变成习惯。 实现Serializable接口的实体类，一般需要声明一个serialVersionUID成员变量，以表明该实体类的版本，如果实体类的接口繁盛变化，则可以修改serialVersionUID的值以支持反序列化工作。

---

接下来定义一个缓存管理器，该管理器负责实现缓存逻辑，支持对象的增加、修改和删除，并且支持值对象的泛型。

package com.xgj.cache.selfCacheManagerDemo;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 
 * 
 * @ClassName: CacheManager
 * 
 * @Description: 泛型类-自定义缓存管理器的粗略实现
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月2日 下午1:10:13
 */

public class CacheManager<T> {

    /**
     * ConcurrentHashMap - 线程安全的集合容器
     */
    Map cacheMap = new ConcurrentHashMap();

    /**
     * 
     * 
     * @Title: getValue
     * 
     * @Description: 根据Key获取缓存数据
     * 
     * @param key
     * @return
     * 
     * @return: T
     */
    public T getValue(Object key) {
        return cacheMap.get(key);
    }

    /**
     * 
     * 
     * @Title: addOrUpdateCache
     * 
     * @Description: 添加或者更新缓存
     * 
     * @param key
     * @param value
     * 
     * @return: void
     */
    public void addOrUpdateCache(Object key, T value) {
        cacheMap.put(key, value);
    }

    /**
     * 
     * 
     * @Title: evictCache
     * 
     * @Description: 根据key， 从缓存中清除特定的key记录
     * 
     * @param key
     * 
     * @return: void
     */
    public void evictCache(Object key) {
        if (cacheMap.containsKey(key)) {
            cacheMap.remove(key);
        }
    }

    /**
     * 
     * 
     * @Title: evictCache
     * 
     * @Description: 清空缓存中的数据
     * 
     * 
     * @return: void
     */
    public void evictCache() {
        cacheMap.clear();
    }
}

---

有了实体类和缓存管理器，还需要一个查询Artisan的服务类，此服务使用缓存管理器来支持用户查询。

package com.xgj.cache.selfCacheManagerDemo.service;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Service;

import com.xgj.cache.selfCacheManagerDemo.CacheManager;
import com.xgj.cache.selfCacheManagerDemo.domain.LittleArtisan;

/**
 * 
 * 
 * @ClassName: LittleArtisanService
 * 
 * @Description: @Service标注的Service层，受Spring管理
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月2日 下午1:55:56
 */

@Service("littleArtisanService")
public class LittleArtisanService {

    private Logger logger = Logger.getLogger(LittleArtisanService.class);

    // 缓存管理器
    private CacheManager cacheManager;

    // JdbcTemplate
    private JdbcTemplate jdbcTemplate;

    private static final String selectArtisanSQL = "select artisan_id ,artisan_name ,artisan_desc from little_artisan where artisan_name = ?";

    /**
     * 
     * 
     * @Title: setJdbcTemplate
     * 
     * @Description: 通过@Autowired注入JdbcTemplate
     * 
     * @param jdbcTemplate
     * 
     * @return: void
     */
    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 
     * 
     * @Title:LittleArtisanService
     * 
     * @Description:构造函数
     */
    public LittleArtisanService() {
        // 初始化LittleArtisanService的时候，实例化CacheManager
        cacheManager = new CacheManager();
    }

    public LittleArtisan getLittleArtisan(String artisanName) {
        // 首先从缓存中查找LittleArtisan
        LittleArtisan littleArtisan = cacheManager.getValue(artisanName);
        // 缓存中不存在则从数据库中获取
        if (littleArtisan != null) {
            logger.info("get littleArtisan from Cache...");
            return littleArtisan;
        }
        // 从数据库中获取
        littleArtisan = getFromDB(artisanName);
        logger.info("get littleArtisan from DB...");
        // 如果数据库中存在记录，则将获取的新数据放在缓存中
        if (littleArtisan != null) {
            cacheManager.addOrUpdateCache(artisanName, littleArtisan);
            logger.info("put cache successfully");
        }
        return littleArtisan;
    }

    /**
     * 
     * 
     * @Title: reload
     * 
     * @Description: 清除缓存数据,重新加载
     * 
     * 
     * @return: void
     */
    public void reload() {
        cacheManager.evictCache();
    }

    /**
     * 
     * 
     * @Title: getFromDB
     * 
     * @Description: 从数据库中获取LittleArtisan
     * 
     * @param artisanName
     * @return
     * 
     * @return: LittleArtisan
     */
    private LittleArtisan getFromDB(String artisanName) {

        final LittleArtisan littleArtisan = new LittleArtisan();

        jdbcTemplate.query(selectArtisanSQL, new Object[] { artisanName },
                new RowCallbackHandler() {
                    @Override
                    public void processRow(ResultSet rs) throws SQLException {
                        littleArtisan.setArtisanId(rs.getString("artisan_id"));
                        littleArtisan.setArtisanName(rs
                                .getString("artisan_name"));
                        littleArtisan.setArtisanDesc(rs
                                .getString("artisan_desc"));
                    }
                });
        return littleArtisan;
    }
}

---

Spring配置文件如下

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd">

    
    <context:component-scan base-package="com.xgj.cache.selfCacheManagerDemo" />

    
    <context:property-placeholder location="classpath:spring/jdbc.properties" />

    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" 
        p:driverClassName="${jdbc.driverClassName}"
        p:url="${jdbc.url}" 
        p:username="${jdbc.username}" 
        p:password="${jdbc.password}" />

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />

beans>

---

下面来编写单元测试

package com.xgj.cache.selfCacheManagerDemo.service;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xgj.cache.selfCacheManagerDemo.domain.LittleArtisan;

public class LittleArtisanCacheTest {

    ClassPathXmlApplicationContext ctx = null;
    LittleArtisanService littleArtisanService = null;

    @Before
    public void initContext() {
        // 启动Spring 容器
        ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/cache/selfCacheManagerDemo/conf.xml");
        littleArtisanService = ctx.getBean("littleArtisanService",
                LittleArtisanService.class);
        System.out.println("initContext successfully");
    }

    @Test
    public void testLoadArtisanFromDBAndCache() {

        LittleArtisan littleArtisan = new LittleArtisan();

        // 第一次 从数据库中获取
        littleArtisan = littleArtisanService.getLittleArtisan("artisan");
        System.out.println("artisanDesc:" + littleArtisan.getArtisanDesc());

        // 再此调用，会从Cache中获取
        littleArtisan = littleArtisanService.getLittleArtisan("artisan");
        System.out.println("artisanDesc:" + littleArtisan.getArtisanDesc());

        // 清空缓存，再此读取,会再此从数据库中加载
        littleArtisanService.reload();
        littleArtisan = littleArtisanService.getLittleArtisan("artisan");
        System.out.println("artisanDesc:" + littleArtisan.getArtisanDesc());
    }

    @After
    public void closeContext() {
        if (ctx != null) {
            ctx.close();
        }
        System.out.println("close context successfully");
    }
}

运行结果

2017-10-02 14:39:27,876  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@611de50: startup date [Mon Oct 02 14:39:27 BOT 2017]; root of context hierarchy
2017-10-02 14:39:27,989  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/cache/selfCacheManagerDemo/conf.xml]
initContext successfully
2017-10-02 14:39:29,621  INFO [main] (LittleArtisanService.java:78) - get littleArtisan from DB...
2017-10-02 14:39:29,622  INFO [main] (LittleArtisanService.java:82) - put cache successfully
artisanDesc:Spring Cache
2017-10-02 14:39:29,622  INFO [main] (LittleArtisanService.java:73) - get littleArtisan from Cache...
artisanDesc:Spring Cache
2017-10-02 14:39:29,624  INFO [main] (LittleArtisanService.java:78) - get littleArtisan from DB...
2017-10-02 14:39:29,624  INFO [main] (LittleArtisanService.java:82) - put cache successfully
artisanDesc:Spring Cache
2017-10-02 14:39:29,625  INFO [main] (AbstractApplicationContext.java:984) - Closing org.springframework.context.support.ClassPathXmlApplicationContext@611de50: startup date [Mon Oct 02 14:39:27 BOT 2017]; root of context hierarchy
close context successfully

首先第一次从数据库中加载数据，然后放入缓存中，第二次读取从缓存中加载， 然后我们清空了缓存，再此运行，又从DB加载数据

缺点：

• 虽然，这种自定义的缓存可以正常工作，但是这种实现方式并不优雅，缓存代码和业务代码高度耦合， 业务代码穿插这大量的缓存控制逻辑，并且代码显式依赖缓存的具体实现。

• 并且我们的这个版本目前也不支持按照条件缓存，比如只缓存某些特定条件的Artisan等等。

---

---

使用Spring Cache

下面我们使用Spring Cache来重构上面的实现。

package com.xgj.cache.springCacheManagerDemo.service;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Service;

import com.xgj.cache.springCacheManagerDemo.domain.LittleArtisan;

/**
 * 
 * 
 * @ClassName: LittleArtisanSpringCacheService
 * 
 * @Description: @Service标注的服务层，受Spring管理
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月2日 下午5:34:29
 */

@Service
public class LittleArtisanSpringCacheService {
    private Logger logger = Logger
            .getLogger(LittleArtisanSpringCacheService.class);

    private static final String selectArtisanSQL = "select artisan_id ,artisan_name ,artisan_desc from little_artisan where artisan_name = ?";

    private JdbcTemplate jdbcTemplate;

    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    /**
     * 
     * 
     * @Title: getArtisan
     * 
     * @Description: @Cacheable(cacheNames = "littleArtisan")
     *               使用名为littleArtisan的缓存
     * 
     * 
     * @return
     * 
     * @return: LittleArtisan
     */

    @Cacheable(cacheNames = "littleArtisan")
    public LittleArtisan getArtisan(String artisanName) {
        // 方法内部实现不考虑缓存逻辑，直接实现业务
        System.out.println("查找Artisan：" + artisanName);
        return getFromDB(artisanName);
    }

    /**
     * 
     * 
     * @Title: getFromDB
     * 
     * @Description: 从数据库中获取LittleArtisan
     * 
     * @param artisanName
     * @return
     * 
     * @return: LittleArtisan
     */
    private LittleArtisan getFromDB(String artisanName) {
        System.out.println("getFromDB");
        final LittleArtisan littleArtisan = new LittleArtisan();

        jdbcTemplate.query(selectArtisanSQL, new Object[] { artisanName },
                new RowCallbackHandler() {
                    @Override
                    public void processRow(ResultSet rs) throws SQLException {
                        littleArtisan.setArtisanId(rs.getString("artisan_id"));
                        littleArtisan.setArtisanName(rs
                                .getString("artisan_name"));
                        littleArtisan.setArtisanDesc(rs
                                .getString("artisan_desc"));
                    }
                });
        return littleArtisan;
    }
}

@Cacheable(value=littleArtisan”)，这个注释的意思是，当调用这个方法的时候，会从一个名叫 littleArtisan的缓存中查询，如果没有，则执行实际的方法（即查询数据库），并将执行的结果存入缓存中，否则返回缓存中的对象。这里的缓存中的 key 就是参数 artisanName，value 就是 Artisan对象。“littleArtisan”缓存是在 spring*.xml 中定义的名称。

---

我们使用spring，所以肯定还需要一个 spring 的配置文件来支持基于注释的缓存 。

配置文件如下：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    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/context 
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/cache 
       http://www.springframework.org/schema/cache/spring-cache.xsd">

    
    <context:component-scan base-package="com.xgj.cache.springCacheManagerDemo" />

    
    <context:property-placeholder location="classpath:spring/jdbc.properties" />

    
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close" 
        p:driverClassName="${jdbc.driverClassName}"
        p:url="${jdbc.url}" 
        p:username="${jdbc.username}" 
        p:password="${jdbc.password}" />

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />

        
    
    <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/>
    
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager"
        p:caches-ref="cacheObjects">
    bean>

    
    <util:set id="cacheObjects">
        <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
            p:name="default"/>
        
        <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
            p:name="littleArtisan"/>
    util:set>

beans>

spring 配置文件有一个关键的支持缓存的配置项：，这个配置项缺省使用了一个名字叫 cacheManager 的缓存管理器，这个缓存管理器有一个 spring 的缺省实现，即 org.springframework.cache.support.SimpleCacheManager，这个缓存管理器实现了我们刚刚自定义的缓存管理器的逻辑，它需要配置一个属性 caches，即此缓存管理器管理的缓存集合。

除了缺省的名字叫 default 的缓存，我们还自定义了一个名字叫 littleArtisan的缓存，
使用了缺省的内存存储方案 ConcurrentMapCacheFactoryBean，它是基于 java.util.concurrent.ConcurrentHashMap 的一个内存缓存实现方案。

---

单元测试

package com.xgj.cache.springCacheManagerDemo.service;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xgj.cache.springCacheManagerDemo.domain.LittleArtisan;

public class LittleArtisanSCServiceTest {

    ClassPathXmlApplicationContext ctx = null;
    LittleArtisanSpringCacheService littleArtisanSpringCacheService = null;

    @Before
    public void initContext() {
        // 启动Spring 容器
        ctx = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/cache/springCacheManagerDemo/conf_spring.xml");
        littleArtisanSpringCacheService = ctx.getBean(
                "littleArtisanSpringCacheService",
                LittleArtisanSpringCacheService.class);
        System.out.println("initContext successfully");
    }

    @Test
    public void testLoadArtisanFromDBAndCache() {

        LittleArtisan artisan = new LittleArtisan();
        // 第一次查询，从数据库获取数据
        artisan = littleArtisanSpringCacheService.getArtisan("artisan");
        System.out.println("========load from db===========");
        System.out.println("artisanDesc:" + artisan.getArtisanDesc());

        // 第二次查询，直接返回缓存的值
        artisan = littleArtisanSpringCacheService.getArtisan("artisan");
        System.out.println("========hit cache========");
        System.out.println("artisanDesc:" + artisan.getArtisanDesc());
    }

    @After
    public void closeContext() {
        if (ctx != null) {
            ctx.close();
        }
        System.out.println("close context successfully");
    }
}

输出结果

2017-10-02 20:06:31,637  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@77c55a79: startup date [Mon Oct 02 20:06:31 BOT 2017]; root of context hierarchy
2017-10-02 20:06:31,751  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/cache/springCacheManagerDemo/conf_spring.xml]
initContext successfully
查找Artisan：artisan
getFromDB
========load from db===========
artisanDesc:Spring Cache
========hit cache========
artisanDesc:Spring Cache
2017-10-02 20:06:33,711  INFO [main] (AbstractApplicationContext.java:984) - Closing org.springframework.context.support.ClassPathXmlApplicationContext@77c55a79: startup date [Mon Oct 02 20:06:31 BOT 2017]; root of context hierarchy
close context successfully

可以看到第二次加载并没有打印getFromDB，说明没有从数据库加载，而是从缓存中加载。

---

示例源码

代码已托管到Github—> https://github.com/yangshangwei/SpringMaster