线上接口流量突增，扛不住了

#最小空闲连接，默认值10，小于0或大于maximum-pool-size，都会重置为maximum-pool-size
spring.datasource.hikari.minimum-idle=5
#最大连接数，小于等于0会被重置为默认值10；大于零小于1会被重置为minimum-idle的值
spring.datasource.hikari.maximum-pool-size=100
#自动提交从池中返回的连接，默认值为true
spring.datasource.hikari.auto-commit=true
#空闲连接超时时间，默认值600000（10分钟），大于等于max-lifetime且max-lifetime>0，会被重置为0；不等于0且小于10秒，会被重置为10秒。
#只有空闲连接数大于最大连接数且空闲时间超过该值，才会被释放
spring.datasource.hikari.idle-timeout=30000
#连接池名称，默认HikariPool-1
spring.datasource.hikari.pool-name=Hikari
#连接最大存活时间.不等于0且小于30秒，会被重置为默认值30分钟.设置应该比mysql设置的超时时间短；单位ms
spring.datasource.hikari.max-lifetime=55000
#连接超时时间:毫秒，小于250毫秒，会被重置为默认值30秒

public interface LocalCache<T> {
    /**
     * 根据key获取缓存信息
     * @param key 缓存key
     * @return 缓存对象
     */
    T get(String key);
    /**
     * 保存缓存信息, 存在了会覆盖
     * @param key 缓存key
     * @param cacheItem 缓存对象
     */
    void save(String key, T cacheItem);
    /**
     * 根据缓存key删除缓存信息
     *
     * @param key 缓存对象
     */
    void delete(String key);
}

public abstract class AbstractGuavaCache<T> implements LocalCache<T>, InitializingBean {
    private static final ScheduledExecutorService SCHEDULED_CACHE =
            new ScheduledThreadPoolExecutor(2, new ThreadFactoryBuilder().setNameFormat("guava cache-%d").build());
    protected long expireSeconds;
    protected long maximumSize;
    protected long initDelay;
    protected long delay;
    protected Function<String, T> loadFunction;
    protected boolean cacheTaskSwitch;
    /**
     * 定义缓存对象
     */
    private LoadingCache<String, T> guavaCache;
    public AbstractGuavaCache() {}
    @Override
    public void afterPropertiesSet() {
        // 初始化guavaCache对象
        this.guavaCache = CacheBuilder.newBuilder().expireAfterWrite(expireSeconds, TimeUnit.SECONDS)
                .maximumSize(maximumSize).build(new CacheLoader<String, T>() {
                    @Override
                    public T load(String key) {
                        return loadFunction != null ? loadFunction.apply(key) : null;
                    }
                });
        // 定时任务
        if(cacheTaskSwitch) {
            SCHEDULED_CACHE.scheduleWithFixedDelay(() -> {
                try {
                    this.reloadAllToCache();
                } catch (Exception e) {
                    log.error("cache error", e);
                }
            }, initDelay, delay, TimeUnit.SECONDS);
        }
    }
    @SneakyThrows
    @Override
    public T get(String key) {
        return guavaCache.get(key);
    }
    @Override
    public void save(String key, T cacheItem) {
        guavaCache.put(key, cacheItem);
    }
    @Override
    public void delete(String key) {
        guavaCache.invalidate(key);
    }
    /**
     * 更新缓存操作
     */
    protected void reloadAllToCache() {
    }
}

@Component("orgCache")
@Slf4j
public class SysOrgCacheManager extends AbstractGuavaCache<SysOrg> implements OrgCacheService {
    public SysOrgCacheManager(EventCacheProperties eventCacheProperties) {
        this.expireSeconds = eventCacheProperties.getExpireSeconds();
        this.maximumSize = eventCacheProperties.getMaximumSize();
        this.cacheTaskSwitch = eventCacheProperties.isTaskEnabled();
        this.initDelay = eventCacheProperties.getInitDelay();
        this.delay = eventCacheProperties.getDelay();
        this.loadFunction = key -> loadByKey(key);
    }
    private SysOrg loadByKey(String orgId) {
        log.warn("缓存未命中，直接查询数据库， orgId: [{}]", orgId);
        SysOrg org = OrgApi.getOrgById(orgId);
        SysOrg cacheOrg = transformCachedOrg(org);
        log.warn("缓存未命中，加载后的数据， data: [{}]", JSON.toJSONString(cacheOrg));
        return cacheOrg;
    }
    private SysOrg transformCachedOrg(SysOrg org) {
        if(org == null || StrUtil.isEmpty(org.getId())) {
            return null;
        }
        return new SysOrg().setId(org.getId()).setName(org.getName()).setFullPath(org.getFullPath());
    }
    @Override
    protected void reloadAllToCache() {
        log.info("-------cache org 【缓存机构】 开始 -------");
        TimeInterval timeInterval = new TimeInterval();
        // 查询全量的机构数据
        List<SysOrg> remoteOrgs = OrgApi.selectAll();
        remoteOrgs.forEach(org -> {
            SysOrg cacheOrg = this.transformCachedOrg(org);
            this.save(org.getId(), cacheOrg);
        });
        log.info("-------cache org【缓存机构】 结束, cost: [{}] -------", timeInterval.intervalSecond());
    }
    @Override
    public List<SysOrg> findOrgsByIds(Collection<String> orgIds) {
        if(CollUtil.isEmpty(orgIds)) {
            return Lists.newArrayListWithExpectedSize(16);
        }
        List<SysOrg> orgs = orgIds.stream().map(orgId -> this.get(orgId)).filter(Objects::nonNull).collect(Collectors.toList());
        return orgs;
    }
}