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.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="200"
           overflowToDisk="false"
           diskPersistent="false"
           timeToIdleSeconds="600"
           statistics="true"
           timeToLiveSeconds="600"/>
</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());
    }
    */

}