加入Caffeine，修改缓存处理

pom.xml

@@ -152,6 +152,13 @@
                 <version>${fastjson.version}</version>
             </dependency>
 
+            <!--Caffeine缓存-->
+            <dependency>
+                <groupId>com.github.ben-manes.caffeine</groupId>
+                <artifactId>caffeine</artifactId>
+                <version>2.9.3</version>
+            </dependency>
+
             <!-- Token生成与解析-->
             <dependency>
                 <groupId>io.jsonwebtoken</groupId>

project-common/pom.xml

@@ -65,6 +65,11 @@
             <artifactId>fastjson2</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+        </dependency>
+
         <!-- io常用工具类 -->
         <dependency>
             <groupId>commons-io</groupId>

project-common/src/main/java/com/project/common/core/redis/MyCache.java

@@ -1,84 +1,172 @@
 package com.project.common.core.redis;
 
-import org.springframework.cache.Cache;
-import org.springframework.cache.support.SimpleValueWrapper;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import org.springframework.stereotype.Component;
 
+import javax.annotation.PostConstruct;
 import java.util.Collection;
 import java.util.Objects;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
 @Component
-public class MyCache implements Cache {
+public class MyCache {
 
     // 使用ConcurrentHashMap作为数据的存储
-    private ConcurrentHashMap<String, Object> storage = new ConcurrentHashMap<>();
-
-    // getName获取cache的名称，存取数据的时候用来区分是针对哪个cache操作
-    @Override
-    public String getName() {
-        return null;
-    }
-
-    @Override
-    public Object getNativeCache() {
-        return null;
+//    private ConcurrentHashMap<String, Object> storage = new ConcurrentHashMap<>();
+
+    /**
+     * 使用caffeineCache作为数据的存储
+     */
+    private Cache<String, Object> caffeineCache;
+
+    /**
+     * 初始化 Caffeine Cache 配置
+     */
+    @PostConstruct
+    public void init() {
+        caffeineCache = Caffeine.newBuilder()
+                .expireAfterWrite(30, TimeUnit.MINUTES) // 设置缓存过期时间
+                .maximumSize(1000) // 设置缓存最大容量
+                .recordStats() // 启用缓存统计
+                .build();
     }
 
+    // getName获取cache的名称，存取数据的时候用来区分是针对哪个cache操作
+//    @Override
+//    public String getName() {
+//        return null;
+//    }
+
+//    @Override
+//    public Object getNativeCache() {
+//        return null;
+//    }
+
+//    public boolean hasKey(String key){
+//        return storage.containsKey(key);
+//    }
+
+    /**
+     * 查询某个缓存是否存在
+     * @param key
+     * @return
+     */
     public boolean hasKey(String key){
-        return storage.containsKey(key);
+        if (caffeineCache.getIfPresent(key) != null){
+            return true;
+        }
+        return false;
     }
 
-    @Override
-    public ValueWrapper get(Object key) {
+//    @Override
+//    public ValueWrapper get(Object key) {
+//        String k = key.toString();
+//        Object value = storage.get(k);
+//
+//        // 注意返回的数据，要和存放时接收到数据保持一致，要将数据反序列化回来。
+//        return Objects.isNull(value) ? null : new SimpleValueWrapper(value);
+//    }
+
+    /**
+     * get方法， 获取缓存数据，无需反序列化
+     * @param key
+     * @return
+     */
+    public Object get(Object key) {
         String k = key.toString();
-        Object value = storage.get(k);
-
-        // 注意返回的数据，要和存放时接收到数据保持一致，要将数据反序列化回来。
-        return Objects.isNull(value) ? null : new SimpleValueWrapper(value);
+        return caffeineCache.getIfPresent(k);
     }
 
-    @Override
-    public <T> T get(Object key, Class<T> type) {
-        return null;
-    }
+//    @Override
+//    public <T> T get(Object key, Class<T> type) {
+//        return null;
+//    }
 
-    @Override
-    public <T> T get(Object key, Callable<T> valueLoader) {
-        return null;
-    }
+//    @Override
+//    public <T> T get(Object key, Callable<T> valueLoader) {
+//        return null;
+//    }
 
     // put方法，就是执行将数据进行缓存
-    @Override
+//    @Override
+//    public void put(Object key, Object value) {
+//        if (Objects.isNull(value)) {
+//            return;
+//        }
+//        //存值
+//        storage.put(key.toString(), value);
+//    }
+
+    /**
+     * put方法，就是执行将数据进行缓存
+     * @param key
+     * @param value
+     */
     public void put(Object key, Object value) {
-        if (Objects.isNull(value)) {
-            return;
+        if (Objects.nonNull(value)) {
+            caffeineCache.put(key.toString(), value);
         }
-        //存值
-        storage.put(key.toString(), value);
     }
 
     // evict方法，是用来清除某个缓存项
-    @Override
+//    @Override
+//    public void evict(Object key) {
+//        storage.remove(key.toString());
+//    }
+
+    /**
+     * evict方法，是用来清除某个缓存项
+     * @param key
+     */
     public void evict(Object key) {
-        storage.remove(key.toString());
+        caffeineCache.invalidate(key.toString());
     }
 
     // 删除集合
+//    public boolean deleteObject(final Collection collection){
+//        collection.forEach(o -> {
+//            storage.remove(o.toString());
+//        } );
+//        return true;
+//    }
+
+    /**
+     * 删除集合
+     * @param collection
+     * @return
+     */
     public boolean deleteObject(final Collection collection){
         collection.forEach(o -> {
-            storage.remove(o.toString());
+            caffeineCache.invalidate(o.toString());
         } );
         return true;
     }
 
     // 获取所有的keys
+//    public Collection<String> keys(final String pattern){
+//        return storage.keySet();
+//    }
+
+    /**
+     * 获取所有的keys
+     * @param pattern
+     * @return
+     */
     public Collection<String> keys(final String pattern){
-        return storage.keySet();
+        return caffeineCache.asMap().keySet();
     }
 
-    @Override
-    public void clear() {
+//    @Override
+//    public void clear() {
+//
+//    }
 
+    /**
+     * 清除所有缓存
+     */
+    public void clear() {
+        caffeineCache.invalidateAll();
     }
 }

project-common/src/main/java/com/project/common/core/redis/RedisCache.java

@@ -92,6 +92,24 @@ public class RedisCache {
 //        return redisTemplate.hasKey(key + redisSuffix);
     }
 
+//    /**
+//     * 获得缓存的基本对象。
+//     *
+//     * @param key 缓存键值
+//     * @return 缓存键值对应的数据
+//     */
+//    public <T> T getCacheObject(final String key) {
+//        Cache.ValueWrapper valueWrapper = myCache.get(key + redisSuffix);
+//        if (valueWrapper == null){
+//            return null;
+//        }else {
+//            return (T) valueWrapper.get();
+//        }
+////
+////        ValueOperations<String, T> operation = redisTemplate.opsForValue();
+////        return operation.get(key + redisSuffix);
+//    }
+
     /**
      * 获得缓存的基本对象。
      *
@@ -99,17 +117,14 @@ public class RedisCache {
      * @return 缓存键值对应的数据
      */
     public <T> T getCacheObject(final String key) {
-        Cache.ValueWrapper valueWrapper = myCache.get(key + redisSuffix);
-        if (valueWrapper == null){
+        Object value = myCache.get(key + redisSuffix);
+        if (value == null) {
             return null;
-        }else {
-            return (T) valueWrapper.get();
         }
-//
-//        ValueOperations<String, T> operation = redisTemplate.opsForValue();
-//        return operation.get(key + redisSuffix);
+        return (T) value;
     }
 
+
     /**
      * 删除单个对象
      *