基于spring4.0配置分布式ehcache，以及相关使用

说明：本文是基于RMI手动同步的方式，使用程序动态注入配置缓存，抛弃传统的ehcache.xml配置方式

1，注入cacheManager管理所有缓存，添加各个缓存名及相关参数配置：

思路大致是：

在项目的主配置类中，通过@Bean注入cacheManager，统一管理所有cache，传统的用xml方式配置太累赘，其实只需要更该chacheName，其他参数变化不是很大，考虑用程序封装做到最大程度的代码重用所以采取拼接JSON串的形式，配置缓存名，及所有相关需要设置好的参数。然后通过解析JSON，拼接成带主机IP的RmiUrl，以manual手动rmi同步的方式配置peerDiscovery成员发现，再通过配置cacheManagerPeerListenerFactory这个类启动本机监听程序，来发现其他主机发来的同步请求。最后再用@EnableCaching注解开启spring支持对ehcache注解使用

下面是项目配置好的详细代码：

package com.cshtong.tower.web.init;

import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.cshtong.tower.service.UserService;
import com.cshtong.tower.util.StringUtil;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheException;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.DiskStoreConfiguration;
import net.sf.ehcache.config.FactoryConfiguration;
import net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory;
import net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory;
import net.sf.ehcache.distribution.RMICacheReplicatorFactory;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;

@EnableCaching
@Configuration
@EnableTransactionManagement
public class EhcacheConfig extends RMICacheReplicatorFactory{
    
    private static Logger logger = LoggerFactory.getLogger(EhcacheConfig.class);
    private static final String EHCACHE_PROPERTIES = "ehcache.properties";
    
    /** 最大缓存数量 0 = no limit. **/
    private static final Integer MAX_CACHE = 0;
    /** 缓存失效时间间隔/秒  **/
    private static final Integer TIME_TOLIVE_SECONDS = 24*60*60;
    /** 缓存闲置多少秒后自动销毁  **/
    private static final Integer TIME_TOIDLE_SECONDS = 60*60;
    /** 磁盘失效线程运行时间间隔/秒。 **/
    private static final Integer DISK_EXPIRY_Thread_INTERVAL_SENCONDS = 100;
    
    @Resource
    UserService userService;
    
    /** 注入cacheManager **/
    @Bean
    public org.springframework.cache.CacheManager cacheManager() {
        org.springframework.cache.CacheManager cm = new EhCacheCacheManager(putCache());
        return cm;
    }

    @Bean
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator();
    }
    
    @Bean
    public CacheManager putCache(){
        
        String rmiUrls = initRmiURLs();
        
        net.sf.ehcache.config.Configuration cf = new net.sf.ehcache.config.Configuration();
        Properties pro = initRmiUrlsProperties();
        if (null!=rmiUrls) {
            /** 临时文件目录 **/
            cf.diskStore(new DiskStoreConfiguration().path("java.io.tmpdir"))
            /**成员发现 peerDiscovery 方式：manual：手动，rmiUrls：主机名+端口号+缓存名，用来接受或者发送信息的接口，不同的缓存或者机器用“|”隔开 **/  
            .cacheManagerPeerProviderFactory(new FactoryConfiguration<FactoryConfiguration<?>>()
                    .className(RMICacheManagerPeerProviderFactory.class.getName())
                    .properties("peerDiscovery=manual,rmiUrls=" + rmiUrls)
            );
            /** 本机监听程序，来发现其他主机发来的同步请求  hostName=192.168.1.112 这里默认是本机可以不配置 **/
            cf.cacheManagerPeerListenerFactory(new FactoryConfiguration<FactoryConfiguration<?>>()
                    .className(RMICacheManagerPeerListenerFactory.class.getName())
                    .properties("port="+ pro.getProperty("rmiPortNumber") +",socketTimeoutMillis=2000")
            );
        }else{
            logger.debug("The rmiUrls is null!!");
        }

        CacheManager cm = null;
        
        try {
            cm = CacheManager.create(cf);
        } catch (UncheckedIOException e) {
            logger.debug("Fail to load config. message:{}", e.getMessage());
        }
        
        List<Cache> array = null;
        try {
            array = cacheCollection();
        } catch (CacheException e) {
            logger.error("collect cache Failed");
        }
        
        for (Cache list:array) {
            cm.addCache(list);
        }
        
        return cm;
    }
    
    public static List<Cache> cacheCollection(){
        String listParameters = cacheParametersCollection();
        return cacheConf(listParameters);
    }
    
    /**
     * 添加缓存的参数
     * 相关属性：  
             name : "缓存名称,cache的唯一标识(ehcache会把这个cache放到HashMap里)  
             maxElementsInMemory  : 缓存最大个数,0没有限制。
             eternal="false"  : 对象是否永久有效，一但设置了，timeout将不起作用。 (必须设置)
             maxEntriesLocalHeap="1000"  : 堆内存中最大缓存对象数,0没有限制(必须设置)
             maxEntriesLocalDisk= "1000"  : 硬盘最大缓存个数。 
             overflowToDisk="false"  : 当缓存达到maxElementsInMemory值是,是否允许溢出到磁盘(必须设设置)(内存不足时，是否启用磁盘缓存。)
             diskSpoolBufferSizeMB  : 这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。 
             diskPersistent="false"  : 磁盘缓存在JVM重新启动时是否保持(默认为false)硬盘持久化
             timeToIdleSeconds="0"  : 导致元素过期的访问间隔(秒为单位),即当缓存闲置n秒后销毁。 当eternal为false时，这个属性才有效，0表示可以永远空闲,默认为0
             timeToLiveSeconds="0"  : 元素在缓存里存在的时间(秒为单位)，即当缓存存活n秒后销毁. 0 表示永远存在不过期
             memoryStoreEvictionPolicy="LFU" : 当达到maxElementsInMemory时,如何强制进行驱逐默认使用"最近使用(LRU)"策略,其它还有先入先出FIFO,最少使用LFU,较少使用LRU
             diskExpiryThreadIntervalSeconds ：磁盘失效线程运行时间间隔，默认是120秒。
             clearOnFlush  : 内存数量最大时是否清除。 
             
             cacheEventListenerFactory : 给缓存添加监听
             replicateAsynchronously=true : 异步的方式
             replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=true,replicateRemovals= true  : 在put，update，copy，remove操作是否复制
             cationIntervalMillis=1000 : 同步时间1s
             bootstrapCacheLoaderFactory 启动是指一启动就同步数据
     * @return
     */
    public static String cacheParametersCollection(){
        
        String listParameters = "[" ;
        
        /** 排班:列表详情    **/
        listParameters += "{'cacheName':'schedule_listPatrol','maxEntriesLocalHeap':'0'}";
        
        /** APP:用户当月的排班    **/
        listParameters += "{'cacheName':'owner_schedule','maxEntriesLocalHeap':'0'}";
        
        /**考勤统计 ：echarts图表相关数据**/
        listParameters += "{'cacheName':'attendance_findByOrgIds','maxEntriesLocalHeap':'0'}";
        /**考勤统计 ：主界面表格相关的数据**/
        listParameters += "{'cacheName':'attendance_findByOrgIdsAndPage','maxEntriesLocalHeap':'0','timeToIdleSeconds':'0'}";
        
        /** 机构 **/
        listParameters += "{'cacheName':'org_findAll','maxEntriesLocalHeap':'0'}";
        
        /** 用户信息  key=userId  **/
        listParameters += "{'cacheName':'list_userInfo','maxEntriesLocalHeap':'0'}";
        
        /** APP 勤务圈  **/
        listParameters += "{'cacheName':'app_message','maxElementsInMemory':'0','maxEntriesLocalHeap':'0'}";
        
        /** 报警，最近1km内的用户 **/
        listParameters += "{'cacheName':'rescue_users','maxElementsInMemory':'0','maxEntriesLocalHeap':'0'}";
        
        /** 报警，最近1km内的用户 **/
        listParameters += "{'cacheName':'app_message_typeName','maxElementsInMemory':'0','maxEntriesLocalHeap':'0'}";
        
        listParameters += "]";
        
        return listParameters;
    }
    
    /**
     * 添加成员发现: //主机ip+端口号/
     * @return
     */
    public static List<String> cacheManagerPeerProviderCollection(){
        Properties pro = initRmiUrlsProperties();
        
        List<String> ip = new ArrayList<>();
        try {
            ip.add(pro.get("machine1").toString());
            ip.add(pro.get("machine2").toString());
        } catch (Exception e) {
            logger.error("Fail to provider cacheManagerPeer. config file [{}], message:{}", EHCACHE_PROPERTIES, e.getMessage());
        }
        
        InetAddress ia;
        try {
            ia = InetAddress.getLocalHost();
            String localip = ia.getHostAddress();
            for (int i = 0; i < ip.size(); i++) {
                /** 过滤本机ip **/
                if (localip.equalsIgnoreCase(ip.get(i))) {
                    ip.remove(i);
                }
            }
        } catch (UnknownHostException Host) {
            Host.printStackTrace();
            logger.error("Unknown to host Address. config file [{}], message:{}", EHCACHE_PROPERTIES, Host.getMessage());
        }
        
        List<String> peer = new ArrayList<>();
        for (int j = 0; j < ip.size(); j++) {
            peer.add("//" + ip.get(j) + ":" + pro.getProperty("rmiPortNumber").toString());
        }
        
        return peer;
    }
    
    public static String initRmiURLs(){
        String rmiUrls = "";
        String listParameters = cacheParametersCollection();
        JSONArray array = initCacheParameters(listParameters);
        for (Iterator<Object> iterator = array.iterator(); iterator.hasNext();) {
            JSONObject obj = (JSONObject)iterator.next();
            String cacheName = obj.get("cacheName").toString();
            List<String> peer = cacheManagerPeerProviderCollection();
            for (String list:peer) {
                rmiUrls += list + cacheName + "|";
            }
        }
        if (!"".equals(rmiUrls)) {
            rmiUrls = rmiUrls.substring(0,rmiUrls.length()-1);
        }
        return rmiUrls;
    }
    
    public static JSONArray initCacheParameters(String listParameters){
        JSONArray array = null;
        try {
            array = JSONArray.parseArray(listParameters);
        } catch (Exception e) {
            logger.error("Fail to init The cache parameters. message:{}", e.getMessage());
        }
        return array;
    }
    
    public static Properties initRmiUrlsProperties(){
        InputStream resourcesStream = EhcacheConfig.class.getClassLoader().getResourceAsStream(EHCACHE_PROPERTIES);
        Properties pro = new Properties();
        try {
            pro.load(resourcesStream);
        } catch (IOException e) {
            logger.error("Fail to load config. config file [{}], message:{}", EHCACHE_PROPERTIES, e.getMessage());
        }
        return pro;
    }
    
    /**
     * @param listPatrolParameters 缓存参数JSON数组
     * @return  缓存的集合
     */
    @SuppressWarnings("deprecation")
    public static List<Cache> cacheConf(String listParameters){
        
        List<Cache> listCache = new ArrayList<>();
        JSONArray array = initCacheParameters(listParameters);
        for (Iterator<Object> iterator = array.iterator(); iterator.hasNext();) {
            JSONObject obj = (JSONObject)iterator.next();
            
            String cacheName = obj.get("cacheName").toString();
            String maxElementsInMemory = obj.getString("maxElementsInMemory");
            String maxEntriesLocalHeap = obj.getString("maxEntriesLocalHeap");
            String timeToLiveSeconds = obj.getString("timeToLiveSeconds");
            String timeToIdleSeconds = obj.getString("timeToIdleSeconds");
            
            RMICacheReplicatorFactory rmi = new RMICacheReplicatorFactory();
            Properties pro = initRmiUrlsProperties();
            rmi.createCacheEventListener(pro);
            
            CacheConfiguration cacheConfiguration = new CacheConfiguration(cacheName,StringUtil.isNull(maxEntriesLocalHeap)?MAX_CACHE:Integer.parseInt(maxEntriesLocalHeap))
                    .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LFU)  
                    .maxElementsInMemory(StringUtil.isNull(maxElementsInMemory)?MAX_CACHE:Integer.parseInt(maxElementsInMemory))
                    .overflowToDisk(true)  
                    .eternal(false)  
                    .timeToLiveSeconds(StringUtil.isNull(timeToLiveSeconds)?TIME_TOLIVE_SECONDS:Integer.parseInt(timeToLiveSeconds))  
                    .timeToIdleSeconds(StringUtil.isNull(timeToIdleSeconds)?TIME_TOIDLE_SECONDS:Integer.parseInt(timeToIdleSeconds))  
                    .diskPersistent(false)  
                    .diskExpiryThreadIntervalSeconds(DISK_EXPIRY_Thread_INTERVAL_SENCONDS)
                    .clearOnFlush(true)
                    .cacheEventListenerFactory(new CacheConfiguration.CacheEventListenerFactoryConfiguration().className(RMICacheReplicatorFactory.class.getName()));
            Cache cache = new Cache(cacheConfiguration);
            
            listCache.add(cache);
        }
        
        return listCache;
    }
}

properties文件：

#RMICacheReplicatorFactory properties
replicateAsynchronously=true
replicatePuts=true
replicatePutsViaCopy=false
replicateUpdates=true
replicateUpdatesViaCopy=false
replicateRemovals=true
asynchronousReplicationIntervalMillis=1000
asynchronousReplicationMaximumBatchSize=1000

#RMI URLs 
machine1=//主机ip+端口号/

#RMI port 
rmiPortNumber=8010

到这里就注入好了缓存名为listParameters里面cacheName的所有缓存，如果后续添加或修改缓存，只需更改listParameters的相关属性，如果在集群环境，也只需在porperties文件中添加machine..配置即可。

2，基于注解方式的缓存使用：

1，为方便重用所有缓存建议在service层使用，当方法第一次执行时将返回值以key-value对象写进缓存，之后在执行该方法时，如果缓存的condition满足则直接取缓存返回，实际上方法都不会进!

2，在修改或添加方法使用@CachePut，查询方法使用@Cacheable，删除方法使用@CacheEvict，注意：缓存一定要配合使用，例如一个list方法将相应值缓存起来，如果有针对该值CUD操作时，一定要将新的返回值@CachePut，否则会出现数据脏读的情况！如果更新或修改方法的返回值与list不相同即该缓存@CacheEvict,否则会报数据映射错误！

3，注解说明：

@Cacheable (value="缓存值/SpEL/不填默认返回值", key="缓存key/SpEL") : 应用到读取数据的方法上，即可缓存的方法，如查找方法：先从缓存中读取，如果没有再调用方法获取数据，然后把数据添加到缓存中。如图:

 

@CachePut 应用到写数据的方法上，如新增/修改方法，调用方法时会自动把相应的数据放入缓存： 如图：

 

@CacheEvict: 移除数据，如图：

 

@Caching 组合多个Cache注解使用，如图：

 

注解参数说明：

value：必须指定，其表示当前方法的返回值是会被缓存在哪个Cache上的，对应Cache的名称， listparamentes中的cacheName

key:通过Spring的EL表达式来指定我们的key。这里的EL表达式可以使用方法参数及它们对应的属性。使用方法参数时我们可以直接使用“#参数名”或者“#p参数index。我们统一采用方法的参数做唯一key，没有参数不写！

condition：有的时候我们可能并不希望缓存一个方法所有的返回结果，condition属性默认为空，表示将缓存所有的调用情形。其值是通过SpringEL表达式来指定的，当为true时表示进行缓存处理；当为false时表示不进行缓存处理，即每次调用该方法时该方法都会执行一次。如下示例表示只有当user的id为偶数时才会进行缓存

@Cacheable(value="users",key="#user.id",condition="#user.id%2==0")
public User find(User user) {
    System.out.println("find user by user " + user);
    return user;
}

3，基于程序代码方式的缓存相关使用：

当注解不能完全满足需求，或需要在程序代码中实现动态操作时，就需要对ehcache实现相关封装，从而现对缓存手动进行增删改。可以考虑写成util，我这里是以service的形式现实的封装及相关调用，仅供参考。

package com.cshtong.tower.service;

import java.io.UncheckedIOException;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONObject;
import com.cshtong.tower.model.MessageType;
import com.cshtong.tower.model.User;
import com.cshtong.tower.repository.MessageTypeRepository;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;

@Service
public class EhcacheServiceImpl implements EhcacheService{
    
    private static Logger logger = LoggerFactory.getLogger(EhcacheServiceImpl.class);
    
    @Resource
    private UserService userSerivce;
    
    @Resource
    private MessageTypeRepository messageTypeRepository;
    
    public static CacheManager cacheManager(){
        
        CacheManager cm = null;
        try {
            cm = CacheManager.newInstance();
        } catch (UncheckedIOException e) {
            logger.error("Fail to load config, message:{}", e.getMessage());
        }
        return cm;
    }
    
    /**
     * key可以为空
     */
    @SuppressWarnings({"deprecation" })
    @Override
    public com.cshtong.tower.model.Ehcache findCache(String cacheName, String key) {
        com.cshtong.tower.model.Ehcache eh = null;
        if (null == key) {
            Ehcache cache = cacheManager().getEhcache(cacheName);
            eh = new com.cshtong.tower.model.Ehcache();
            eh.setCacheName(cache.getName());
            List<String> listKey = new ArrayList<>();
            for (int j = 0; j < cache.getKeys().size(); j++) {
                listKey.add(cache.getKeys().get(j).toString());
            }
            eh.setKeys(listKey);
            eh.setSize(cache.getSize());
            /*eh.setHitrate(cache.getStatistics().cacheHitRatio());*/
            eh.setDiskStoreSize(cache.getDiskStoreSize());
            eh.setMemoryStoreSize(cache.getMemoryStoreSize());
            eh.setStatus(cache.getStatus().toString());
        }else{
            Element el = cacheManager().getEhcache(cacheName).get(key);
            if (el == null) {
                el = cacheManager().getEhcache(cacheName).get(Integer.parseInt(key));
            }
            eh = new com.cshtong.tower.model.Ehcache();
            eh.setKeyHit(el.getHitCount());
            eh.setLastUpdateTime(el.getLastUpdateTime());
            eh.setValues(el.getValue());
        }
        return eh;
    }

    @SuppressWarnings("deprecation")
    @Override
    public List<com.cshtong.tower.model.Ehcache> listAllEhcahce() {
        List<com.cshtong.tower.model.Ehcache> list = new ArrayList<>();
        String[] cache = cacheManager().getCacheNames();
        List<Ehcache> cachelist = new ArrayList<>();
        for (int i = 0; i < cache.length; i++) {
            Ehcache c = cacheManager().getEhcache(cache[i]);
            cachelist.add(c);
        }
        for (int i = 0; i < cachelist.size(); i++) {
            com.cshtong.tower.model.Ehcache eh = new com.cshtong.tower.model.Ehcache();
            eh.setCacheName(cachelist.get(i).getName());
            List<String> listKey = new ArrayList<>();
            for (int j = 0; j < cachelist.get(i).getKeys().size(); j++) {
                listKey.add(cachelist.get(i).getKeys().get(j).toString());
            }
            eh.setKeys(listKey);
            eh.setSize(cachelist.get(i).getSize());
            eh.setStatus(cachelist.get(i).getStatus().toString());
            eh.setMemoryStoreSize(cachelist.get(i).getMemoryStoreSize());
            eh.setDiskStoreSize(cachelist.get(i).getDiskStoreSize());
            list.add(eh);
        }
        return list;
    }

    /**
     * 获取缓存
     * @param cacheName
     * @param key
     * @return json字符串
     */
    @Override
    public String getCache(String cacheName, Object key) {
        logger.debug("Getting Cache that name is " + cacheName + "and key is" + key);
        Element el = cacheManager().getCache(cacheName).get(key);
        return JSONObject.toJSONString(el.getObjectValue());
    }

    @Override
    public Cache getCache(String name) {
        logger.debug("Getting Cache that name is " + name);
        return cacheManager().getCache(name);
    }

    /**
     * 获取所有的缓存
     * @param names
     * @return
     */
    @Override
    public String[] getCacheNames() {
        logger.debug("All of the Cache is " + cacheManager().getCacheNames());
        return cacheManager().getCacheNames();
    }

    @Override
    public void update(String cacheName, Object key, Object value) {
        try {
            remove(cacheName, key);
            put(cacheName, key, value);
        } catch (Exception e) {
            logger.debug("Fail to update the Cache,which is " + cacheManager().getCacheNames());
        }
    }

    @Override
    public void put(String cacheName, Object key, Object value) {
        logger.debug("add Cache is " + cacheManager().getCacheNames() + ",and key is " + key + ",and value is" + value);
        Element el = new Element(key, value);
        cacheManager().getCache(cacheName).put(el);
    }

    @Override
    public boolean ishasCache(String cacheName, Object key) {
        boolean rs = false;
        Element value = cacheManager().getCache(cacheName).get(key);
        if (null != value) {
            rs = true;
        }
        return rs;
    }

    /**
     * 根据缓存名清除缓存key value
     * @param name
     */
    @Override
    public void evictName(String name) {
        logger.debug("delete Cache that name is " + name);
        cacheManager().getCache(name).removeAll();
    }

    /**
     * 根据缓存名对应的key清除缓存
     */
    @Override
    public void remove(String cacheName, Object key) {
         logger.debug("Delete Cache that Name is "+ cacheName +"and key is " + key );
         Cache cache = cacheManager().getCache(cacheName);  
         cache.remove(key); 
    }

    /**
     * 清除当前cacheManager的所有缓存
     */
    @Override
    public void clear() {
        logger.debug("clear all cache!!");
        cacheManager().clearAll();
    }
    
}

以上愚见，只是个人的理解，仅供参考。如有不对的地方，欢迎指正批评....