1、特性
- 使用key -value形式数据结构，读写简单。
- 遵循开闭原则
- 线程安全
- 良好的扩展性
- 良好的数据安全性（key不覆盖、方法可见性限制、使用入口唯一）
2、涉及技术\知识点\设计思路
-
spring
作用 ：本案例基于spring开发，做待缓存数据初始化到容器用。 -
java 1.8+
作用：JDK1.5 后提供了线程安全、且性能优于HashTable的并发容器：ConcurrentHashMap，作为本案例使用的数据存储容器。另外示例源码使用到JDK1.8特性，故使用1.8+。 -
策略模式
作用：公共方法抽象定义成抽象类，不同的场景业务数据类单独封装成策略子类，去继承实现，这样便提供了良好的扩展性。除此之外，提供唯一使用入口。用户不必关心底层细节实现，一步到位。 -
java四大修饰符
作用：保证底层核心定义不被修改
3、源码
- 抽象策略类
/**
* 抽象缓存公用方法
*/
public abstract class AbstractDataMemory {
protected void init(Class<? extends AbstractDataMemory> clazz, HashMap<String,String> initVal){
DataMemory.getInstance(clazz).init(initVal);
}
}
- 具体策略类
@Service
public class Amemory extends AbstractDataMemory implements ApplicationListener<ContextRefreshedEvent>
{
private static final Logger logger = Logger.getLogger(Amemory.class);
@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
String displayName = contextRefreshedEvent.getApplicationContext().getDisplayName();
displayName = org.apache.commons.lang3.StringUtils.isNotEmpty(displayName)?displayName.replace(" ", ""):"";
logger.error("xx业务数据初始化:"+"displayName:"+displayName);
//保证只执行一次
if ("RootWebApplicationContext".equals(displayName)) {
logger.error("xx业务数据初始化-开始");
//需要执行的方法
init(Amemory.class,getDataForMemory(applicationContext));
}
}
public HashMap<String,String> getDataForMemory(ApplicationContext applicationContext) {
//通过Dao类注解名可直接获取Dao类，但必须保证IxxDao只有一个实现类（正常情况只有一个）
// IxxDao xxDao = (IxxDao)applicationContext.getBean("clientDao");
HashMap<String,String> result = new HashMap<>();
// List<xx> all = xxDao.findAll();
// if(CollectionUtils.isNotEmpty(all)){
// for(xx xx : all){
//
// result.put(xx.getUuid(),xx);
// }
// }
logger.error("xx数据:"+ result);
return result;
}
}
- 统一管理入口类
/**
* @Description 缓存入口类（策略模式）
* @Author lzj
* @Date 2022-02-05
*/
public class DataMemory {
// private static final Logger logger = Logger.getLogger(DataMemory.class);
//使用 ConcurrentHashMap 存放数据，保证线程安全
private static ConcurrentHashMap<String,String> container = new ConcurrentHashMap<>();
//持有抽象工具类
private AbstractDataMemory memory;
//key修饰前缀,默认使用类名做前缀
private String decoratePrefix;
private DataMemory(AbstractDataMemory memory,String prefix){
this.memory = memory;
this.decoratePrefix = prefix;
}
/**
* 实例化具体某个缓存对象（继承AbstractDataMemory）
* @param clazz
* @return
*/
public static DataMemory getInstance(Class<? extends AbstractDataMemory> clazz){
try {
Object o = clazz.newInstance();
String className = clazz.getSimpleName();
return new DataMemory((AbstractDataMemory)o,className);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
/**
* 设置缓存，不能为空，否则concurrentHashMap报空指针异常
* @param key
* @param value
*/
public void set(String key,String value){
if(StringUtils.isEmpty(key) || StringUtils.isEmpty(value)){
return;
}
// String decorateKey = memory.decorateKey(key);
String decorateKey = this.decoratePrefix+key;
container.put(decorateKey,value);
}
/**
* 从缓存中获取数据
* @param key
* @return
*/
public String get(String key){
// String decorateKey = memory.decorateKey(key);
String decorateKey = this.decoratePrefix+key;
return container.get(decorateKey);
}
/**
* 初始化进缓存对象
* @param map
*/
protected void init(HashMap<String, String> map){
// container.clear();
if(map.size()>0){
map.forEach(
(key,value) ->{
set(key,value);
}
);
}
}
/**
* 删除某个缓存
* @param key
*/
public void removeOne(String key){
// String decorateKey = memory.decorateKey(key);
String decorateKey = this.decoratePrefix+key;
container.remove(decorateKey);
}
/**
* 根据Key前缀筛选容器中对应的实例缓存
* @return
*/
public HashMap<String,String> getCurrentData(){
// String keyPrefix = memory.getKeyPrefix();
String keyPrefix = this.decoratePrefix;
HashMap<String,String> resultMap = new HashMap<>();
if(container.size()>0){
container.forEach((key,value) ->{
if(key.startsWith(keyPrefix)){
resultMap.put(key,value);
}
});
}
return resultMap;
}
}
-
使用示例
image.png
