Spring Cache-缓存概述及使用

原创 2017年10月02日 14:35:02

概述

伴随信息量的爆炸式增长以及构建的应用系统越来越多样化、复杂化,特别是企业级应用互联网化的趋势,缓存(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

版权声明:show me the code ,change the world

相关文章推荐

Spring缓存注解@Cache使用

参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/a...

Spring缓存注解@Cache,@CachePut , @CacheEvict,@CacheConfig使用

@Cacheable、@CachePut、@CacheEvict 注释介绍 表 1. @Cacheable 作用和配置方法 @Cacheable 的作用 主要针对方法配置,能够根据方法的请求参数对其...

Spring缓存注解@Cache使用

Spring缓存注解@Cache使用

Spring缓存注解@Cache使用

博客分类:  Spring   参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-ca...

Ehcache系列二:Spring缓存注解@Cache使用

参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/archi...

Spring缓存注解@Cache使用

参考资料 http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ http://swiftlet.net/a...

Spring缓存注解@Cache使用

简介: 介绍 spring 3.1 激动人心的新特性:注释驱动的缓存,本文通过一个简单的例子进行展开,通过对比我们原来的自定义缓存和 spring 的基于注释的 cache 配置方法,展现了 spri...

Spring缓存注解@Cache使用

Spring缓存注解@Cache使用 缓存注解有以下三个: @Cacheable      @CacheEvict     @CachePut @Cacheable(value=”acc...
  • zy_js
  • zy_js
  • 2017-03-20 10:46
  • 124

Spring缓存注解@Cache,@CachePut , @CacheEvict,@CacheConfig使用

@Cacheable、@CachePut、@CacheEvict 注释介绍 表 1. @Cacheable 作用和配置方法 @Cacheable 的作用 主要针对方法配置,能够根据方法的请求参数对其...

Spring Cache 缓存的使用

一句话说缓存缓存是一个能有效提升性能和节省资源的东西。Spring Cache 在Spring-context包下,所以引入了Spring Framework就可以使用Spring cache了,在m...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)