Spring Cache-缓存概述及使用

最新推荐文章于 2024-03-14 01:11:47 发布

小小工匠

最新推荐文章于 2024-03-14 01:11:47 发布

阅读量1.2w

点赞数 3

分类专栏：【Spring-Cache】文章标签： spring cache

本文链接：https://blog.csdn.net/yangshangwei/article/details/78150954

版权

【Spring-Cache】同时被 2 个专栏收录

9 篇文章 1 订阅

订阅专栏

Spring-Cache手札

7 篇文章 3 订阅

订阅专栏

概述
缓存的概念
自定义缓存管理器粗略实现
使用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<Object, T> cacheMap = new ConcurrentHashMap<Object, T>();

    /**
     * 
     * 
     * @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<LittleArtisan> 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<LittleArtisan>();
    }

    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配置文件如下

<?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: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">

    <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    <context:component-scan base-package="com.xgj.cache.selfCacheManagerDemo" />

    <!-- 使用context命名空间，加载数据库的properties文件 -->
    <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}" />

    <!-- 配置Jdbc模板 -->
    <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 的配置文件来支持基于注释的缓存。

配置文件如下：

<?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: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">

    <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    <context:component-scan base-package="com.xgj.cache.springCacheManagerDemo" />

    <!-- 使用context命名空间，加载数据库的properties文件 -->
    <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}" />

    <!-- 配置Jdbc模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />

    <!-- （1）添加cache命名空间和schema文件 -->    
    <!-- （2）开启支持缓存的配置项 -->
    <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/>
    <!-- (3)配置cacheManger -->
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager"
        p:caches-ref="cacheObjects">
    </bean>

    <!-- (4)caches集合 -->
    <util:set id="cacheObjects">
        <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
            p:name="default"/>
        <!-- @Cacheable(cacheNames = "littleArtisan")标注的cache名称 -->
        <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
            p:name="littleArtisan"/>
    </util:set>

</beans>

spring 配置文件有一个关键的支持缓存的配置项：<cache:annotation-driven />，这个配置项缺省使用了一个名字叫 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

小小工匠

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
2
评论
Spring Cache-缓存概述及使用

概述缓存的概念缓存命中率过期策略Spring Cache的好处Spring Cache的缺点自定义缓存管理器粗略实现使用Spring Cache示例源码概述伴随信息量的爆炸式增长以及构建的应用系统越来越多样化、复杂化，特别是企业级应用互联网化的趋势，缓存（Cache）对应用程序性能的优化变的越来越重要。将所需服务请求的数据放在缓存中，既可以提高应用程序的访问效率，又可以减少数据库服
复制链接

扫一扫