refactor cache module

festival-cache/build.gradle

@@ -0,0 +1,16 @@
+apply plugin: 'kotlin'
+
+def libs = rootProject.ext.libraries
+
+dependencies {
+    implementation "io.vertx:vertx-redis-client:${libs.vertx}"
+    implementation "io.vertx:vertx-lang-kotlin-coroutines:${libs.vertx}"
+    implementation project(':festival-context')
+}
+
+compileKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}
+compileTestKotlin {
+    kotlinOptions.jvmTarget = "1.8"
+}

festival-web/src/main/java/cn/bdqfork/web/cache/annotation/Cache.java → festival-cache/src/main/java/cn/bdqfork/cache/annotation/Cache.java

@@ -1,4 +1,4 @@
-package cn.bdqfork.web.cache.annotation;
+package cn.bdqfork.cache.annotation;
 
 import java.lang.annotation.*;
 

festival-web/src/main/java/cn/bdqfork/web/cache/annotation/Evict.java → festival-cache/src/main/java/cn/bdqfork/cache/annotation/Evict.java

@@ -1,4 +1,4 @@
-package cn.bdqfork.web.cache.annotation;
+package cn.bdqfork.cache.annotation;
 
 import java.lang.annotation.*;
 

festival-kotlin-web/src/main/kotlin/cn/bdqfork/kotlin/web/constant/CacheProperty.kt → festival-cache/src/main/java/cn/bdqfork/cache/constant/CacheProperty.kt

@@ -1,10 +1,12 @@
-package cn.bdqfork.kotlin.web.constant
+package cn.bdqfork.cache.constant
 
 /**
  * @author bdq
  * @since 2020/2/17
  */
 object CacheProperty {
+    const val DEFAULT_EXPIRE_TIME = 60
+
     const val CACHE_ENABLE = "cache.enable"
     const val CACHE_TYPE = "cache.type"
 }

festival-cache/src/main/java/cn/bdqfork/cache/processor/CacheSupportProcessor.java

@@ -0,0 +1,42 @@
+package cn.bdqfork.cache.processor;
+
+import cn.bdqfork.cache.provider.CacheProvider;
+import cn.bdqfork.cache.proxy.CacheInvocationHandler;
+import cn.bdqfork.context.aware.BeanFactoryAware;
+import cn.bdqfork.context.aware.ClassLoaderAware;
+import cn.bdqfork.core.exception.BeansException;
+import cn.bdqfork.core.factory.BeanFactory;
+import cn.bdqfork.core.factory.processor.BeanPostProcessor;
+import cn.bdqfork.core.proxy.javassist.Proxy;
+import cn.bdqfork.core.util.AopUtils;
+
+/**
+ * @author bdq
+ * @since 2020/2/21
+ */
+public class CacheSupportProcessor implements BeanPostProcessor, BeanFactoryAware, ClassLoaderAware {
+    private ClassLoader classLoader;
+    private BeanFactory beanFactory;
+
+    @Override
+    public Object postProcessBeforeInitializtion(String beanName, Object bean) throws BeansException {
+        return bean;
+    }
+
+    @Override
+    public Object postProcessAfterInitializtion(String beanName, Object bean) throws BeansException {
+        Class<?> targetClass = AopUtils.getTargetClass(bean);
+        CacheProvider cacheProvider = beanFactory.getBean(CacheProvider.class);
+        return Proxy.newProxyInstance(classLoader, targetClass.getInterfaces(), new CacheInvocationHandler(bean, cacheProvider));
+    }
+
+    @Override
+    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+        this.beanFactory = beanFactory;
+    }
+
+    @Override
+    public void setClassLoader(ClassLoader classLoader) throws BeansException {
+        this.classLoader = classLoader;
+    }
+}

festival-cache/src/main/java/cn/bdqfork/cache/provider/AbstractCacheProvider.java

@@ -0,0 +1,22 @@
+package cn.bdqfork.cache.provider;
+
+import cn.bdqfork.cache.constant.CacheProperty;
+
+import java.io.Serializable;
+
+/**
+ * @author bdq
+ * @since 2020/2/21
+ */
+public abstract class AbstractCacheProvider implements CacheProvider {
+    @Override
+    public void put(String key, Serializable value) {
+        put(key, value, CacheProperty.DEFAULT_EXPIRE_TIME);
+    }
+
+    @Override
+    public Object update(String key, Serializable value) {
+        return update(key, value, CacheProperty.DEFAULT_EXPIRE_TIME);
+    }
+
+}

festival-web/src/main/java/cn/bdqfork/web/cache/CacheProvider.java → festival-cache/src/main/java/cn/bdqfork/cache/provider/CacheProvider.java

@@ -1,6 +1,5 @@
-package cn.bdqfork.web.cache;
+package cn.bdqfork.cache.provider;
 
-import io.reactivex.Flowable;
 
 import java.io.Serializable;
 
@@ -17,58 +16,61 @@ public interface CacheProvider {
      *
      * @param key
      * @param value
-     * @return
      */
-    Flowable<Void> put(String key, Serializable value);
+    void put(String key, Serializable value);
 
     /**
      * 添加缓存
      *
      * @param key
      * @param value
-     * @return
      */
-    Flowable<Void> put(String key, Serializable value, long expireTime);
+    void put(String key, Serializable value, long expireTime);
 
     /**
      * 删除缓存
      *
      * @param key
-     * @return
      */
-    Flowable<Void> remove(String key);
+    void remove(String key);
 
     /**
      * 更新缓存
      *
      * @param key
      * @param value
-     * @return
+     * @return 旧的值
      */
-    Flowable<Void> update(String key, Serializable value);
+    Object update(String key, Serializable value);
 
     /**
      * 更新缓存
      *
      * @param key
      * @param value
-     * @return
+     * @return 旧的值
      */
-    Flowable<Void> update(String key, Serializable value, long expireTime);
+    Object update(String key, Serializable value, long expireTime);
 
     /**
      * 获取缓存
      *
      * @param key
-     * @return
+     * @return 缓存的值
      */
-    Flowable<Serializable> get(String key);
+    Object get(String key);
 
     /**
-     * 清楚所有缓存
+     * key对应的缓存是否存在
      *
+     * @param key
      * @return
      */
-    Flowable<Void> clear();
+    boolean containKey(String key);
+
+    /**
+     * 清空所有缓存
+     */
+    void clear();
 
 }

festival-cache/src/main/java/cn/bdqfork/cache/provider/RedisCacheProvider.java

@@ -0,0 +1,39 @@
+package cn.bdqfork.cache.provider;
+
+import java.io.Serializable;
+
+/**
+ * @author bdq
+ * @since 2020/2/21
+ */
+public class RedisCacheProvider extends AbstractCacheProvider {
+    @Override
+    public void put(String key, Serializable value, long expireTime) {
+
+    }
+
+    @Override
+    public void remove(String key) {
+
+    }
+
+    @Override
+    public Object update(String key, Serializable value, long expireTime) {
+        return null;
+    }
+
+    @Override
+    public Object get(String key) {
+        return null;
+    }
+
+    @Override
+    public boolean containKey(String key) {
+        return false;
+    }
+
+    @Override
+    public void clear() {
+
+    }
+}

festival-cache/src/main/java/cn/bdqfork/cache/proxy/CacheInvocationHandler.java

@@ -0,0 +1,48 @@
+package cn.bdqfork.cache.proxy;
+
+import cn.bdqfork.cache.provider.CacheProvider;
+import cn.bdqfork.cache.annotation.Cache;
+import cn.bdqfork.cache.annotation.Evict;
+import cn.bdqfork.core.util.AnnotationUtils;
+
+import java.io.Serializable;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+
+/**
+ * @author bdq
+ * @since 2020/2/21
+ */
+public class CacheInvocationHandler implements InvocationHandler {
+    private Object target;
+    private CacheProvider cacheProvider;
+
+    public CacheInvocationHandler(Object target, CacheProvider cacheProvider) {
+        this.target = target;
+        this.cacheProvider = cacheProvider;
+    }
+
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+
+        if (AnnotationUtils.isAnnotationPresent(method, Cache.class)) {
+            Cache cache = AnnotationUtils.getMergedAnnotation(method, Cache.class);
+            String cacheKey = cache.value();
+            if (cacheProvider.containKey(cacheKey)) {
+                return cacheProvider.get(cacheKey);
+            }
+            Object result = method.invoke(target, args);
+            cacheProvider.put(cacheKey, (Serializable) result, cache.expireTime());
+            return result;
+        }
+
+        if (AnnotationUtils.isAnnotationPresent(method, Evict.class)) {
+            Object result = method.invoke(target, args);
+            Evict evict = AnnotationUtils.getMergedAnnotation(method, Evict.class);
+            cacheProvider.remove(evict.value());
+            return result;
+        }
+
+        return method.invoke(target, args);
+    }
+}

festival-kotlin-web/build.gradle

@@ -5,7 +5,6 @@ def libs = rootProject.ext.libraries
 dependencies {
     api "io.vertx:vertx-web:${libs.vertx}"
     implementation "io.vertx:vertx-lang-kotlin-coroutines:${libs.vertx}"
-    implementation "com.caucho:hessian:${libs.hessian}"
     compileOnly "com.fasterxml.jackson.dataformat:jackson-dataformat-xml:${libs.jackson}"
     compileOnly "joda-time:joda-time:${libs.joda}"
     api project(':festival-context')

settings.gradle

@@ -9,4 +9,5 @@ include 'festival-example:kotlin-web'
 findProject(':festival-example:kotlin-web')?.name = 'kotlin-web'
 include 'festival-example:web'
 findProject(':festival-example:web')?.name = 'web'
+include 'festival-cache'