EhCache的配置

JPA和Hibernate的二级缓存都是这样做的

代码目录：

这是基础的jar包，如果少的话，再去maven下载

<!-- Spring -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${org.springframework-version}</version>

            <exclusions>

                <!-- Exclude Commons Logging in favor of SLF4j -->

                <exclusion>

                    <groupId>commons-logging</groupId>

                    <artifactId>commons-logging</artifactId>

                 </exclusion>

            </exclusions>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-webmvc</artifactId>

            <version>${org.springframework-version}</version>

        </dependency>

        <!-- AspectJ -->

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjrt</artifactId>

            <version>${org.aspectj-version}</version>

        </dependency>

<!-- Test -->

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.11</version>

            <scope>test</scope>

        </dependency>  

        <!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache-core -->

        <dependency>

            <groupId>net.sf.ehcache</groupId>

            <artifactId>ehcache-core</artifactId>

            <version>2.6.</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-test</artifactId>

            <version>${org.springframework-version}</version>

        </dependency>

<!-- AspectJ -->

ehcache.xml :

<?xml version="1.0" encoding="UTF-8"?>

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"

         updateCheck="false">

    <cache name="baseCache"

           eternal="false"

           maxEntriesLocalHeap=""

           overflowToDisk="false"

           diskPersistent="false"

           timeToIdleSeconds=""

           statistics="true"

           timeToLiveSeconds=""/>

</ehcache>

这里采用两种bean的配置方式，一种是xml（EhCacheConfig.xml），一种是java（EhCacheConfig.java），如下：

EhCacheConfig.xml:

<?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:cache="http://www.springframework.org/schema/cache"

    xsi:schemaLocation="http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.1.xsd

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 启用缓存 -->

    <cache:annotation-driven cache-manager="cacheManager"/>

    <bean id="cm" class="com.spring.ehcache.CacheMethod"></bean>

     <bean id="ehCacheManagerFactory"

          class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">

        <property name="configLocation" value="classpath:ehcache.xml"/>

    </bean>

    <!-- 这个bean的id必须叫 cacheManager，不然会报错 No bean named 'cacheManager' is defined-->

    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">

        <property name="cacheManager" ref="ehCacheManagerFactory"/>

        <property name="transactionAware" value="true"/>

    </bean>

<!-- 可以使用ConcurrentMapCacheManager作为缓存管理器，
　　它非常简单，对应开发，测试或基础的应用来说，是个不错的选择。但对于生产级别的应用不理想
　　用这个替换掉上面的ehCacheManagerFactory和cacheManager这两个bean就行啦

　　<bean id="cacheManager"

　　　　class="org.springframework.cache.concurrent.ConcurrentMapCacheManager">
　　</bean>

-->

<!--

Spring3.1内置了五个缓存管理器实现

SimpleCacheManager

NoOpCacheManager

ConcurrentMapCacheManager

CompositeCacheManager

EhCacheCacheManager

Spring Data又提供了两个缓存器

RedisCacheManager

GemfireCacheManager

-->

</beans>

EhcacheConfig .java:

package com.spring.ehcache;

import net.sf.ehcache.CacheManager;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.cache.ehcache.EhCacheCacheManager;

import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.ClassPathResource;

@Configuration

@EnableCaching //启用缓存

public class EhcacheConfig {

    @Bean(name="ehCacheCacheManager")

    public EhCacheCacheManager ehCacheCacheManager(CacheManager cm){

        EhCacheCacheManager ehCacheCacheManager = new EhCacheCacheManager();

        ehCacheCacheManager.setTransactionAware(true);

        ehCacheCacheManager.setCacheManager(cm);

        return ehCacheCacheManager;

    }

    @Bean(name="ehCacheManagerFactoryBean")

    public EhCacheManagerFactoryBean ehCacheManagerFactoryBean(){

        String src = "ehcache.xml";

        System.out.println("EhCacheManagerFactoryBean..");

        EhCacheManagerFactoryBean ehFactoryBean =

                new EhCacheManagerFactoryBean();

        ehFactoryBean.setConfigLocation(new ClassPathResource(src));

        return ehFactoryBean;

    }

    @Bean(name="cm")

    public CacheMethod cacheMethod(){

        return new CacheMethod();

    }

}

CacheMethod.java: 这个是缓存测试的类，如果有缓存的话，里面的getStr()方法会执行一次，否则会执行多次

package com.spring.ehcache;

import org.springframework.cache.annotation.Cacheable;

public class CacheMethod {

    public CacheMethod(){

        System.out.println("CacheMethod..");

    }

//@Cacheable 表明Spring在调用方法之前，首先应该在缓存中查找方法的返回值。如果这个值能够找到，就返回缓存的值。否则方法被调用，返回值放入缓存中
//@CachePut 表明Spring应该将方式的缓存值放到缓存中。在方法的调用前并不会检查缓存，方法始终都会被调用
//@CacheEvict 表明Spring应该在缓存中清除一个或多个条目
//@Caching 这是一个分组的注解，能够同时应用多个其他的缓存注解

    @Cacheable("baseCache")

    public String getStr(){

        System.out.println("get Str..");

        return "test get str";

    }

}

TestCache.java

package com.spring.ehcache;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.ehcache.EhCacheCacheManager;

import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(classes=EhcacheConfig.class)

@RunWith(SpringJUnit4ClassRunner.class)

//SpringJUnit4ClassRunner.class使用时要注意，junit的版本要求9以上

public class TestCache {

    @Autowired

    private CacheMethod cm;

    @Autowired

    private EhCacheManagerFactoryBean ehCacheManagerFactoryBean;

    @Autowired

    private EhCacheCacheManager ehCacheCacheManager;

    /**

     * 使用java配置bean

     * */

    @Test

    public void getCache(){

        System.out.println(ehCacheManagerFactoryBean);

        System.out.println(ehCacheCacheManager);

        System.out.println(cm.getStr());

        System.out.println(cm.getStr());

        System.out.println(cm.getStr());

    }

    /**

     * 使用xml配置bean

     *

    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("com/spring/ehcache/EhCacheConfig.xml");

        System.out.println(app.getBean("ehCacheManagerFactory"));

        System.out.println(app.getBean("cacheManager"));

        System.out.println(((CacheMethod)app.getBean("cm")).getStr());

        System.out.println(((CacheMethod)app.getBean("cm")).getStr());

        System.out.println(((CacheMethod)app.getBean("cm")).getStr());

    }

    */

}

巴特西

EhCache的配置

最新文章

热门文章