一种简单的小报表本地缓存方案

适应如下场景：关联表多，接口响应慢，报表数据不多，可能就十多行。参数也固定，实时性要求不高，隔那么半小时刷新一次，查询性能要求高，给领导看的，要求很快。

使用示例：

// 主打一个简单高效粗爆，ConcurrentHashMap也懒得用了。
   private final static Map<String, MemberEnterCompositeVo> CACHE = new HashMap<>();
 
   public void handleContext(FindMemberByStationSelectRequest context) {
   		// 缓存键
        String areaId = context.getParentEnterAreaId();
        MemberEnterCompositeVo result = CACHE.get(areaId);
        if (null == result) {
            result = findItemCount(areaId);
            CACHE.put(areaId, result);
        } else {
            // 比对下是否有效
            Long expire= result.getExpire();
            // 有效期小于当前时间，过期了
            if (expire< now) {
                result = findItemCount(areaId);
                CACHE.put(areaId, result);
            }
        }

        context.setResult(result);
    }

2024-5-29
补充的工具类：

public class LocalCache<T> {

    private Map<String, LocalCacheWrapper<T>> cache = new HashMap<>();

    private long during;

    private LocalCache(long during) {
        // 1分钟*秒*毫秒
        this.during = during * 60 * 1000;
    }

    public static <T> LocalCache<T> getInstance() {
        return getInstance(10);
    }

    public static <T> LocalCache<T> getInstance(long during) {
        return new LocalCache<>(during);
    }

    public T getWithCache(String key, Supplier<T> modelFun) {
        LocalCacheWrapper<T> cacheWrapper = cache.get(key);
        long now = System.currentTimeMillis();
        if (null != cacheWrapper ) {
            long expire = cacheWrapper .getExpire();
            if (expire < now) {
                // 过期
                return flushCacheModel(key, modelFun, now);
            } else {
                // 正常缓存
                return cacheWrapper.getModel();
            }
        } else {
            // 无缓存记录
            return flushCacheModel(key, modelFun, now);
        }
    }

    public void flushDuring(long during) {
        this.during = during * 60 * 1000;
    }

    private T flushCacheModel(String key, Supplier<T> modelFun, long now) {
        T model = modelFun.get();
        if (null != model) {
            long cacheExpire = now + during;
            cache.put(key, new LocalCacheWrapper<>(cacheExpire, model));
            return model;
        }
        return null;
    }
}

public class LocalCacheWrapper<T> {

    private long expire;

    private T model;

    public LocalCacheWrapper() {
    }

    public LocalCacheWrapper(long expire, T model) {
        this.expire = expire;
        this.model = model;
    }
}

使用效果：

    private final static LocalCache<XXXVo> CACHE = LocalCache.getInstance(1);

    public XXXVo loadHomePageData(HomePageContext context) {
        return  CACHE.getWithCache(
                context.getBusinessCode(),
                () -> loadByBusinessCode(context, businessCode)
        );
    }