说明：本文是基于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();
} }
以上愚见，只是个人的理解，仅供参考。如有不对的地方，欢迎指正批评....