关闭

Spring Cache抽象-基于XML的配置声明(基于ConcurrentMap的配置)

标签: springcachexml
1106人阅读 评论(0) 收藏 举报
分类:

概述

Spring Cache基于注解的配置

如果不想使用注解或者由于其他原因无法获得项目的源码等,Spring也支持使用XML的方式配置Spring Cache,主要是通过类似于aop:advice的cache:advice来进行的。

在cache命名空间下定义了一个cache:advice元素用来定义一个对于Cache的advice。其需要指定一个cache-manager属性,默认为cacheManager。

cache:advice下面可以指定多个cache:caching元素,其有点类似于使用注解时的@Caching注解。

cache:caching元素下又可以指定cache:cacheable、cache:cache-put和cache:cache-evict元素,它们类似于使用注解时的@Cacheable、@CachePut和@CacheEvict。


示例

项目结构:

这里写图片描述


数据库表数据(Oracle):

这里写图片描述


实体类

package com.xgj.cache.springCacheXml.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;
    }

}

服务层

package com.xgj.cache.springCacheXml.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 com.xgj.cache.springCacheXml.domain.LittleArtisan;

/**
 * 
 * 
 * @ClassName: LittleArtisanSpringCacheService
 * 
 * @Description:
 * 
 * @author: Mr.Yang
 * 
 * @date: 2017年10月4日 上午12:41:32
 */


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: getArtisan 通过在xml中配置 缓存数据
     * 
     * @param artisanName
     * @return
     * 
     * @return: LittleArtisan
     */
    public LittleArtisan getArtisan(String artisanName) {
        // 方法内部实现不考虑缓存逻辑,直接实现业务
        System.out.println("查找Artisan:" + artisanName);
        return getFromDB(artisanName);
    }

    /**
     * 
     * 
     * @Title: reloadArtisan
     * 
     * @Description: 清除缓存
     * 
     * 
     * @return: void
     */
    public void reloadArtisan() {
        System.out.println("cache cleared");
    }

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

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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    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/aop 
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/cache 
       http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!-- 扫描注入注解,比如@Autowired -->
    <context:component-scan base-package="com.xgj.cache.springCacheXml"/>

    <!-- 使用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}" />

    <!-- 配置namedParameterJdbcTemplate模板 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <constructor-arg ref="dataSource"/>
    </bean>



    <!-- 定义需要使用缓存的类 -->
    <bean id="littleArtisanSpringCacheService"  class="com.xgj.cache.springCacheXml.service.LittleArtisanSpringCacheService"/>

    <!-- 缓存管理器  使用SimpleCacheManager,基于JDK的实现-->
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
      <property name="caches">
         <set>
            <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="littleArtisan"/>
         </set>
      </property>
    </bean>

    <!-- 缓存定义 -->
    <cache:advice  id="cacheAdvice" cache-manager="cacheManager" >
        <cache:caching cache="littleArtisan"> <!-- 公共缓存littleArtisan -->
            <cache:cacheable method="getArtisan" key="#artisanName"/> <!-- getArtisan使用 Cacheable  -->
            <cache:cache-evict method="reloadArtisan" all-entries="true"/><!-- reloadArtisan使用 CacheEvict  -->
        </cache:caching>
    </cache:advice>

    <!-- 切面增强 -->
    <aop:config>
        <aop:pointcut id="cachePoint" expression="execution(* com.xgj.cache.springCacheXml.service.LittleArtisanSpringCacheService.*(..))" />
        <aop:advisor advice-ref="cacheAdvice" 
                     pointcut-ref="cachePoint"/>    
    </aop:config>

</beans>

单元测试

package com.xgj.cache.springCacheXml.service;

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

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

public class TestXmlCache {

    ClassPathXmlApplicationContext context = null;
    LittleArtisanSpringCacheService service = null;
    LittleArtisan littleArtisan;
    @Before
    public void initContext() {
        // 启动Spring 容器
        context = new ClassPathXmlApplicationContext(
                "classpath:com/xgj/cache/springCacheXml/conf_spring.xml");
    }

    @Test
    public void testXmlCache() {

        service = context.getBean(
                "littleArtisanSpringCacheService",
                LittleArtisanSpringCacheService.class);
        // 第一次 从数据库加载
        littleArtisan = service.getArtisan("masterArtisan");
        printArtisan();
        // 第二次 从缓存加载
        littleArtisan = service.getArtisan("masterArtisan");
        printArtisan();
        // 清空缓存
        service.reloadArtisan();
        // 再次查询,从数据库加载
        service.getArtisan("masterArtisan");
        printArtisan();
        // 又查询,从缓存加载
        service.getArtisan("masterArtisan");
        printArtisan();
    }

    private void printArtisan() {
        System.out.println(littleArtisan.getArtisanName() + "||"
                + littleArtisan.getArtisanDesc());
    }

    @After
    public void releaseContext() {

        if (context != null) {
            context.close();
        }
    }
}

日志输出

2017-10-04 08:40:00,529  INFO [main] (AbstractApplicationContext.java:583) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@403d0d64: startup date [Wed Oct 04 08:40:00 BOT 2017]; root of context hierarchy
2017-10-04 08:40:00,623  INFO [main] (XmlBeanDefinitionReader.java:317) - Loading XML bean definitions from class path resource [com/xgj/cache/springCacheXml/conf_spring.xml]
查找Artisan:masterArtisan
getFromDB
masterArtisan||Spring Cache
masterArtisan||Spring Cache
cache cleared
查找Artisan:masterArtisan
getFromDB
masterArtisan||Spring Cache
masterArtisan||Spring Cache
2017-10-04 08:40:03,433  INFO [main] (AbstractApplicationContext.java:984) - Closing org.springframework.context.support.ClassPathXmlApplicationContext@403d0d64: startup date [Wed Oct 04 08:40:00 BOT 2017]; root of context hierarchy

日志分析

第一次从数据库中加载,第二次没有打印getFromDB,说明是从缓存中取的数据。 然后清空缓存,第一次从数据库中加载,第二次从缓存中取的数据。


示例源码

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

1
0
查看评论

spring 基于XML配置的Cache支持

除了使用注解来声明对Cache的支持外,Spring还支持使用XML来声明对Cache的支持。这主要是通过类似于aop:advice的cache:advice来进行的。在cache命名空间下定义了一个cache:advice元素用来定义一个对于Cache的advice。其需要指定一个cache-ma...
  • qilixiang012
  • qilixiang012
  • 2015-07-16 12:18
  • 529

Spring基于XML配置的Cache支持

配置 ehcacheContext.xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-inst...
  • waysoflife
  • waysoflife
  • 2015-10-18 13:04
  • 2097

Spring 基于XML配置 基于注解配置 基于JAVA类配置比较以及适用场景

表格对比了Spring几种配置方式,及适用场景,供大家参考 三种配置方式比较 如下图 适用场景 如下图
  • majishushu
  • majishushu
  • 2016-12-12 20:59
  • 1248

Spring的AOP基于xml常用的几种配置

一般spring的AOP实现方式有二中 1、spring-aop自己实现与IOC结合使用,也是我们最常用的方式 2、使用AspectJ,即注解的方式 个人觉得,spring中使用配置文件还是比较简洁的。 spring中要想使用aop这种方式,需要以下jar包:  首先,如果要在工程...
  • u011955252
  • u011955252
  • 2016-10-27 14:10
  • 681

(11) 基于XML配置方式声明切面

public class LogPrint { public void doAccessCheck() {}定义前置通知 public void doReturnCheck() {}定义后置通知 public void doExceptionAction() {}定义例外通知 publ...
  • itm_hadf
  • itm_hadf
  • 2012-06-15 21:09
  • 1829

Spring MVC中,基于XML配置和基于注解的依赖注入实例

一、首先是基于XML配置的依赖注入实例   在本实例中,Spring MVC并非主要讲解内容,其文件范式不再重复,而有关依赖注入文件包括:接口类car.java,实现了car接口的Taxi,java和Train.java。在User类中,有一个Car对象属性。即此Car即为需要注入的对象。...
  • qq_28379809
  • qq_28379809
  • 2017-07-28 15:40
  • 439

Spring Cache抽象-基于XML的配置声明(基于EhCache的配置)

概述 完整示例 pomxml增加依赖 数据库表数据Oracle 实体类 服务层 ehcache的配置文件 Spring-EhCache配置文件 单元测试 日志输出 日志分析概述首先请阅读Spring Cache抽象-基于XML的配置声明(基于ConcurrentMap的配置),本篇博文基于XML的配...
  • yangshangwei
  • yangshangwei
  • 2017-10-04 23:23
  • 1021

spring中事务的管理基于xml和注解,以及spring在web中应用

spring中的核心内容就是aop(面向切面编程),姑且不谈spring中其他框架,但就谈spring本身,spring属于业务层的框架,最主要的核心内容就是实现各层解耦,和事务管理:但是aop如何如何实现事务管理呢,代这里列举的是经典的转账例子,代码如下: 这里不再贴接口字体实现类代码: dao层...
  • do_bset_yourself
  • do_bset_yourself
  • 2016-04-20 19:15
  • 720

3.4 使用Spring基于Java的配置

3.4.1 创建基于java的配置 配置极少量的XML来启动java配置: xml version="1.0" encoding="UTF-8"?> beans xmlns="http://www.springfra...
  • u010819416
  • u010819416
  • 2015-03-21 21:57
  • 946

springmvc基于xml文件的配置方式

首先在web.xml文件加入 DispatcherServlet org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:spring/springmvc.xml...
  • qq_22498277
  • qq_22498277
  • 2016-08-21 16:48
  • 937
    个人资料
    • 访问:1312318次
    • 积分:19058
    • 等级:
    • 排名:第557名
    • 原创:459篇
    • 转载:0篇
    • 译文:5篇
    • 评论:149条
    WeChat
      欢迎关注我的公众号,干货只有干货,还有更多惊喜和资源在等着你
    博客专栏