top.hmtools.autoConfiguration.EHCMAutoConfiguration Maven / Gradle / Ivy
package top.hmtools.autoConfiguration;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySource;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
/**
* 自启动配置类（作为springboot自启动组件的入口）
* @author HyboJ
*
*/
@Configuration
public class EHCMAutoConfiguration implements ApplicationContextAware{
private final Logger logger = LoggerFactory.getLogger(EHCMAutoConfiguration.class);
private ApplicationContext applicationContext;
/**
* 所有配置信息内容
*/
private static Properties CONFIGS = new Properties();
/**
* 分隔符
*/
private static String regex = ",";
private static final String prefixConfigItem = "ehcm.";
private String EhCacheManagerClassName = prefixConfigItem+"manager-class-name";//当前使用的Manager class全限定名
private static final String ehcache_disk_store_path = prefixConfigItem+"disk-store-path";//缓存存储在磁盘上的路径
private static final String maxEntriesLocalHeap = prefixConfigItem+"maxEntriesLocalHeap";//缓存最大数目
private static final String eternal = prefixConfigItem+"eternal";//对象是否永久有效，一但设置了，timeout将不起作用。
private static final String timeToIdleSeconds = prefixConfigItem+"timeToIdleSeconds";//设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
private static final String timeToLiveSeconds = prefixConfigItem+"timeToLiveSeconds";//设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
private static final String diskSpoolBufferSizeMB = prefixConfigItem+"diskSpoolBufferSizeMB";//这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
private static final String maxEntriesLocalDisk = prefixConfigItem+"maxEntriesLocalDisk";//硬盘最大缓存个数。
private static final String diskExpiryThreadIntervalSeconds = prefixConfigItem+"diskExpiryThreadIntervalSeconds";//磁盘失效线程运行时间间隔，默认是120秒。
private static final String memoryStoreEvictionPolicy = prefixConfigItem+"memoryStoreEvictionPolicy";//当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
private static final String cacheName = prefixConfigItem+"cacheName";//当前缓存服务名称
/**
* 缓存存储在磁盘上的路径
* @return the ehcacheDiskStorePath
*/
public String getEhcacheDiskStorePath() {
this.refreshProperties();
return CONFIGS.getProperty(ehcache_disk_store_path, "java.io.tmpdir/ehCache").trim();
}
/**
* 缓存存储在磁盘上的路径
* @param path
*/
public void setEhcacheDiskStorePath(String path){
CONFIGS.put(ehcache_disk_store_path, path);
}
/**
* 缓存最大数目
* @return the maxentrieslocalheap
*/
public int getMaxentrieslocalheap() {
this.refreshProperties();
String string = CONFIGS.getProperty(maxEntriesLocalHeap, "1000").trim();
return Integer.parseInt(string);
}
/**
* 缓存最大数目
* @param Maxentrieslocalheap
*/
public void setMaxentrieslocalheap(int Maxentrieslocalheap){
CONFIGS.put(maxEntriesLocalHeap, Maxentrieslocalheap);
}
/**
* 对象是否永久有效，一但设置了，timeout将不起作用。
* @return the eternal
*/
public boolean getEternal() {
this.refreshProperties();
String str = CONFIGS.getProperty(eternal, "false").trim();
return Boolean.parseBoolean(str);
}
/**
* 对象是否永久有效，一但设置了，timeout将不起作用。
* @param value
*/
public void setEternal(boolean value){
CONFIGS.put(eternal, value);
}
/**
* 设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
* @return the timetoidleseconds
*/
public long getTimetoidleseconds() {
this.refreshProperties();
String trim = CONFIGS.getProperty(timeToIdleSeconds, "120").trim();
return Long.parseLong(trim);
}
/**
* 设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
* @param value
*/
public void setTimetoidleseconds(long value){
CONFIGS.put(timeToIdleSeconds, value);
}
/**
* 设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
* @return the timetoliveseconds
*/
public long getTimetoliveseconds() {
this.refreshProperties();
String trim = CONFIGS.getProperty(timeToLiveSeconds, "120").trim();
return Long.parseLong(trim);
}
/**
* 设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
* @param value
*/
public void setTimetoliveseconds(long value){
CONFIGS.put(timeToLiveSeconds, value);
}
/**
* 这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
* @return the diskspoolbuffersizemb
*/
public int getDiskspoolbuffersizemb() {
this.refreshProperties();
String trim = CONFIGS.getProperty(diskSpoolBufferSizeMB, "30").trim();
return Integer.parseInt(trim);
}
/**
* 这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
* @param value
*/
public void setDiskspoolbuffersizemb(int value) {
CONFIGS.put(diskSpoolBufferSizeMB, value);
}
/**
* 硬盘最大缓存个数。
* @return the maxentrieslocaldisk
*/
public int getMaxentrieslocaldisk() {
this.refreshProperties();
String trim = CONFIGS.getProperty(maxEntriesLocalDisk, "10000").trim();
return Integer.parseInt(trim);
}
/**
* 硬盘最大缓存个数。
* @param value
*/
public void setMaxentrieslocaldisk(int value){
CONFIGS.put(maxEntriesLocalDisk, value);
}
/**
* 磁盘失效线程运行时间间隔，默认是120秒。
* @return the diskexpirythreadintervalseconds
*/
public long getDiskexpirythreadintervalseconds() {
this.refreshProperties();
String trim = CONFIGS.getProperty(diskExpiryThreadIntervalSeconds, "120").trim();
return Long.parseLong(trim);
}
/**
* 磁盘失效线程运行时间间隔，默认是120秒。
* @param value
*/
public void setDiskexpirythreadintervalseconds(long value){
CONFIGS.put(diskExpiryThreadIntervalSeconds, value);
}
/**
* 当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
* @return the memorystoreevictionpolicy
*/
public MemoryStoreEvictionPolicy getMemorystoreevictionpolicy() {
this.refreshProperties();
String upperCase = CONFIGS.getProperty(memoryStoreEvictionPolicy, "LRU").trim().toUpperCase();
String[] keies = new String[]{"LRU","LFU","FIFO","CLOCK"};
List keyList = Arrays.asList(keies);
if(!keyList.contains(upperCase)){
upperCase = "LRU";
}
return MemoryStoreEvictionPolicy.fromString(upperCase);
}
/**
* 当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
* @param value
*/
public void setMemorystoreevictionpolicy(String value){
String[] keies = new String[]{"LRU","LFU","FIFO","CLOCK"};
List keyList = Arrays.asList(keies);
if(keyList.contains(value)){
CONFIGS.setProperty(memoryStoreEvictionPolicy, value);
}
}
/**
* 当前缓存服务名称
* @return the cachename
*/
public String getCachename() {
this.refreshProperties();
return CONFIGS.getProperty(cacheName, "ehcm").trim();
}
/**
* 当前缓存服务名称
* @param value
*/
public void setCachename(String value){
CONFIGS.setProperty(cacheName, value);
}
public String getEhCacheManagerClassName() {
this.refreshProperties();
return CONFIGS.getProperty(EhCacheManagerClassName , "top.hmtools.manager.EhCacheManagerDefault").trim();
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext=applicationContext;
this.refreshProperties();
}
/**
* 刷新配置容器中的数据
*
方法说明： refreshProperties
*
输入参数说明：
*
*
输出参数说明：
*
void
*
*/
public void refreshProperties(){
MutablePropertySources propertySources = ((ConfigurableApplicationContext)this.applicationContext).getEnvironment().getPropertySources();
Iterator> iterator = propertySources.iterator();
while (iterator.hasNext()) {
PropertySource ps = iterator.next();
this.logger.info("PropertySource ==>>"+ps.toString());
Object source = ps.getSource();
if(Properties.class.isInstance(source)){
Properties tmp = (Properties)source;
CONFIGS.putAll(tmp);
this.logger.info("成功加载配置信息："+source.toString());
}
}
}
/**
* 加载所有配置信息到配置文件
* @param properties
*/
public static void putAllToProperties(Properties properties){
CONFIGS.putAll(properties);
}
}