feat: simplify spring cache

Author: easepan

src/main/java/org/code4everything/boot/cache/BootCacheManager.java

@@ -0,0 +1,74 @@
+package org.code4everything.boot.cache;
+
+import cn.hutool.core.util.ObjectUtil;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 缓存管理器
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public class BootCacheManager implements CacheManager {
+
+    protected final Map<String, Cache> cacheMap;
+
+    protected final Set<String> cacheNames;
+
+    protected final CacheCreator cacheCreator;
+
+    protected final boolean dynamic;
+
+    public BootCacheManager(CacheCreator cacheCreator) {
+        this(cacheCreator, 16);
+    }
+
+    public BootCacheManager(CacheCreator cacheCreator, int capacity) {
+        Objects.requireNonNull(cacheCreator, "cache creator must not be null");
+        this.dynamic = true;
+        this.cacheCreator = cacheCreator;
+        cacheMap = new ConcurrentHashMap<>(capacity);
+        cacheNames = new HashSet<>(capacity);
+    }
+
+    public BootCacheManager(Collection<Cache> caches, CacheCreator cacheCreator) {
+        Objects.requireNonNull(caches, "cache list must not null null");
+        this.dynamic = ObjectUtil.isNotNull(cacheCreator);
+        this.cacheCreator = cacheCreator;
+        int capacity = caches.size() * 4 / 3 + 1;
+        cacheMap = new ConcurrentHashMap<>(capacity);
+        cacheNames = new HashSet<>(capacity);
+        caches.forEach(cache -> {
+            cacheMap.put(cache.getName(), cache);
+            cacheNames.add(cache.getName());
+        });
+    }
+
+    public BootCacheManager(Collection<Cache> caches) {
+        this(caches, null);
+    }
+
+    @Override
+    public Cache getCache(String name) {
+        Cache cache = cacheMap.get(name);
+        if (cache == null && dynamic) {
+            synchronized (cacheMap) {
+                cache = cacheMap.get(name);
+                if (cache == null) {
+                    cache = cacheCreator.createCache(name);
+                    cacheNames.add(name);
+                }
+            }
+        }
+        return cache;
+    }
+
+    @Override
+    public Collection<String> getCacheNames() {
+        return cacheNames;
+    }
+}

src/main/java/org/code4everything/boot/cache/CacheCreator.java

@@ -0,0 +1,23 @@
+package org.code4everything.boot.cache;
+
+import org.springframework.cache.Cache;
+
+/**
+ * 缓存创建者
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public interface CacheCreator {
+
+    /**
+     * 创建缓存
+     *
+     * @param cacheName 缓存名
+     *
+     * @return 缓存
+     *
+     * @since 1.1.3
+     */
+    Cache createCache(String cacheName);
+}

src/main/java/org/code4everything/boot/cache/CacheUtils.java

@@ -0,0 +1,54 @@
+package org.code4everything.boot.cache;
+
+import cn.hutool.core.collection.CollUtil;
+import com.google.common.cache.CacheBuilder;
+import org.code4everything.boot.cache.guava.GuavaCacheCreator;
+import org.code4everything.boot.cache.guava.GuavaCacheManager;
+import org.springframework.cache.Cache;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Spring Cache工具类
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public class CacheUtils {
+
+    private CacheUtils() {}
+
+    public static GuavaCacheManager newGuavaCacheManager(CacheBuilder<Object, Object> cacheBuilder, String... names) {
+        return newGuavaCacheManager(cacheBuilder, Arrays.asList(names));
+    }
+
+    public static GuavaCacheManager newGuavaCacheManager(CacheBuilder<Object, Object> cacheBuilder,
+                                                         Collection<String> names) {
+        CacheCreator cacheCreator = new GuavaCacheCreator(cacheBuilder);
+        if (CollUtil.isEmpty(names)) {
+            return new GuavaCacheManager(cacheCreator);
+        }
+        Collection<Cache> caches = new ArrayList<>(names.size());
+        for (String name : names) {
+            caches.add(cacheCreator.createCache(name));
+        }
+        return new GuavaCacheManager(caches, cacheCreator);
+    }
+
+    public static BootCacheManager newCacheManager(CacheCreator cacheCreator, String... names) {
+        return newCacheManager(cacheCreator, Arrays.asList(names));
+    }
+
+    public static BootCacheManager newCacheManager(CacheCreator cacheCreator, Collection<String> names) {
+        if (CollUtil.isEmpty(names)) {
+            return new BootCacheManager(cacheCreator);
+        }
+        Collection<Cache> caches = new ArrayList<>(names.size());
+        for (String name : names) {
+            caches.add(cacheCreator.createCache(name));
+        }
+        return new BootCacheManager(caches, cacheCreator);
+    }
+}

src/main/java/org/code4everything/boot/cache/guava/GuavaCache.java

@@ -0,0 +1,96 @@
+package org.code4everything.boot.cache.guava;
+
+import com.google.common.cache.CacheBuilder;
+import org.code4everything.boot.config.BootConfig;
+import org.code4everything.boot.web.mvc.exception.ExceptionFactory;
+import org.springframework.cache.Cache;
+import org.springframework.cache.support.SimpleValueWrapper;
+import org.springframework.http.HttpStatus;
+
+import java.util.Objects;
+import java.util.concurrent.Callable;
+
+/**
+ * 谷歌Guava缓存
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public class GuavaCache implements Cache {
+
+    private final com.google.common.cache.Cache<Object, Object> cache;
+
+    private final String name;
+
+    public GuavaCache(String name, com.google.common.cache.Cache<Object, Object> cache) {
+        this.name = name;
+        this.cache = cache;
+    }
+
+    public GuavaCache(String name, CacheBuilder<Object, Object> cacheBuilder) {
+        this(name, cacheBuilder.build());
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Object getNativeCache() {
+        return cache;
+    }
+
+    @Override
+    public ValueWrapper get(Object key) {
+        Object value = cache.getIfPresent(key);
+        return Objects.isNull(value) ? null : new SimpleValueWrapper(value);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T get(Object key, Class<T> type) {
+        return (T) cache.getIfPresent(key);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T get(Object key, Callable<T> valueLoader) {
+        Object value = cache.getIfPresent(key);
+        if (Objects.isNull(value)) {
+            try {
+                return valueLoader.call();
+            } catch (Exception e) {
+                if (BootConfig.isDebug()) {
+                    throw ExceptionFactory.exception(HttpStatus.INTERNAL_SERVER_ERROR, "value loader error");
+                }
+                return null;
+            }
+        }
+        return (T) value;
+    }
+
+    @Override
+    public void put(Object key, Object value) {
+        cache.put(key, value);
+    }
+
+    @Override
+    public ValueWrapper putIfAbsent(Object key, Object value) {
+        Object val = cache.getIfPresent(key);
+        if (Objects.isNull(val)) {
+            put(key, value);
+        }
+        return new SimpleValueWrapper(val);
+    }
+
+    @Override
+    public void evict(Object key) {
+        cache.invalidate(key);
+    }
+
+    @Override
+    public void clear() {
+        cache.invalidateAll();
+    }
+}

src/main/java/org/code4everything/boot/cache/guava/GuavaCacheCreator.java

@@ -0,0 +1,32 @@
+package org.code4everything.boot.cache.guava;
+
+import com.google.common.cache.CacheBuilder;
+import org.code4everything.boot.cache.CacheCreator;
+import org.springframework.cache.Cache;
+
+import java.util.Objects;
+
+/**
+ * 谷歌Guava缓存创建者
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public class GuavaCacheCreator implements CacheCreator {
+
+    private final CacheBuilder<Object, Object> cacheBuilder;
+
+    public GuavaCacheCreator(CacheBuilder<Object, Object> cacheBuilder) {
+        Objects.requireNonNull(cacheBuilder, "guava cache builder must not be null");
+        this.cacheBuilder = cacheBuilder;
+    }
+
+    @Override
+    public Cache createCache(String cacheName) {
+        return new GuavaCache(cacheName, cacheBuilder.build());
+    }
+
+    public CacheBuilder<Object, Object> getCacheBuilder() {
+        return cacheBuilder;
+    }
+}

src/main/java/org/code4everything/boot/cache/guava/GuavaCacheManager.java

@@ -0,0 +1,45 @@
+package org.code4everything.boot.cache.guava;
+
+import com.google.common.cache.CacheBuilder;
+import org.code4everything.boot.cache.BootCacheManager;
+import org.code4everything.boot.cache.CacheCreator;
+import org.springframework.cache.Cache;
+
+import java.util.Collection;
+
+/**
+ * 谷歌Guava缓存管理器
+ *
+ * @author pantao
+ * @since 2019/6/13
+ **/
+public class GuavaCacheManager extends BootCacheManager {
+
+    public GuavaCacheManager(CacheBuilder<Object, Object> cacheBuilder) {
+        this(cacheBuilder, 16);
+    }
+
+    public GuavaCacheManager(CacheBuilder<Object, Object> cacheBuilder, int capacity) {
+        this(new GuavaCacheCreator(cacheBuilder), capacity);
+    }
+
+    public GuavaCacheManager(CacheCreator cacheCreator) {
+        this(cacheCreator, 16);
+    }
+
+    public GuavaCacheManager(CacheCreator cacheCreator, int capacity) {
+        super(cacheCreator, capacity);
+    }
+
+    public GuavaCacheManager(Collection<Cache> caches, CacheCreator cacheCreator) {
+        super(caches, cacheCreator);
+    }
+
+    public GuavaCacheManager(Collection<Cache> caches, CacheBuilder<Object, Object> cacheBuilder) {
+        super(caches, new GuavaCacheCreator(cacheBuilder));
+    }
+
+    public GuavaCacheManager(Collection<Cache> caches) {
+        super(caches);
+    }
+}