diff --git a/pom.xml b/pom.xml index cf436d9..26b6ec5 100644 --- a/pom.xml +++ b/pom.xml @@ -87,31 +87,31 @@ -Dfile.encoding=UTF-8 - - maven-checkstyle-plugin - 3.1.0 - - ${basedir}/.circleci/checkstyle.xml - true - false - - - - compile - compile - - check - - - - - - com.puppycrawl.tools - checkstyle - 8.29 - - - + + maven-checkstyle-plugin + 3.1.0 + + ${basedir}/.circleci/checkstyle.xml + true + false + + + + compile + compile + + check + + + + + + com.puppycrawl.tools + checkstyle + 8.29 + + + - + \ No newline at end of file diff --git a/src/main/java/com/github/hcsp/annotation/Cache.java b/src/main/java/com/github/hcsp/annotation/Cache.java index b8651b5..63febca 100644 --- a/src/main/java/com/github/hcsp/annotation/Cache.java +++ b/src/main/java/com/github/hcsp/annotation/Cache.java @@ -1,5 +1,9 @@ package com.github.hcsp.annotation; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) public @interface Cache { // 标记缓存的时长（秒），默认60s int cacheSeconds() default 60; diff --git a/src/main/java/com/github/hcsp/annotation/CacheClassDecorator.java b/src/main/java/com/github/hcsp/annotation/CacheClassDecorator.java index fb5d531..971210b 100644 --- a/src/main/java/com/github/hcsp/annotation/CacheClassDecorator.java +++ b/src/main/java/com/github/hcsp/annotation/CacheClassDecorator.java @@ -1,5 +1,20 @@ package com.github.hcsp.annotation; +import net.bytebuddy.ByteBuddy; +import net.bytebuddy.implementation.MethodDelegation; +import net.bytebuddy.implementation.bind.annotation.AllArguments; +import net.bytebuddy.implementation.bind.annotation.Origin; +import net.bytebuddy.implementation.bind.annotation.RuntimeType; +import net.bytebuddy.implementation.bind.annotation.SuperCall; +import net.bytebuddy.implementation.bind.annotation.This; +import net.bytebuddy.matcher.ElementMatchers; + +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.Objects; +import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentHashMap; + public class CacheClassDecorator { // 将传入的服务类Class进行增强 // 使得返回一个具有如下功能的Class： @@ -7,10 +22,100 @@ public class CacheClassDecorator { // 这意味着，在短时间内调用同一个服务的同一个@Cache方法两次 // 它实际上只被调用一次，第二次的结果直接从缓存中获取 // 注意，缓存的实现需要是线程安全的 + @SuppressWarnings("unchecked") public static Class decorate(Class klass) { - return klass; + return (Class) new ByteBuddy() + // 对带有cache缓存的方法进行增强 + .subclass(klass) + .method(ElementMatchers.isAnnotatedWith(Cache.class)) + .intercept(MethodDelegation.to(CacheAdvisor.class)) + .make() + .load(klass.getClassLoader()) + .getLoaded(); + + } + + private static class CacheKey { + private Object thisObject; + private String methodName; + private Object[] arguments; + + CacheKey(Object thisObject, String methodName, Object[] arguments) { + this.thisObject = thisObject; + this.methodName = methodName; + this.arguments = arguments; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + CacheKey cacheKey = (CacheKey) o; + return Objects.equals(thisObject, cacheKey.thisObject) && + Objects.equals(methodName, cacheKey.methodName) && + Arrays.equals(arguments, cacheKey.arguments); + } + + @Override + public int hashCode() { + int result = Objects.hash(thisObject, methodName); + result = 31 * result + Arrays.hashCode(arguments); + return result; + } + } + + private static class CacheValue { + private Object value; + private long time; + + CacheValue(Object value, long time) { + this.value = value; + this.time = time; + } + } + + + public static class CacheAdvisor { + private static ConcurrentHashMap cache = new ConcurrentHashMap<>(); + + @RuntimeType + public static Object cache( + @SuperCall Callable superCall, + @Origin Method method, + @This Object thisObject, + @AllArguments Object[] arguments) throws Exception { + CacheKey cacheKey = new CacheKey(thisObject, method.getName(), arguments); + final CacheValue resultExistInCache = cache.get(cacheKey); + if (resultExistInCache != null) { + if (cacheExpires(resultExistInCache, method)) { + return invokeRealMethodAndPutIntoCache(superCall, cacheKey); + } else { + return resultExistInCache.value; + } + + } else { + return invokeRealMethodAndPutIntoCache(superCall, cacheKey); + } + } + + private static Object invokeRealMethodAndPutIntoCache(@SuperCall Callable superCall, CacheKey cacheKey) throws Exception { + Object realMethodInvocationResult = superCall.call(); + cache.put(cacheKey, new CacheValue(realMethodInvocationResult, System.currentTimeMillis())); + return realMethodInvocationResult; + } + + private static boolean cacheExpires(CacheValue cacheValue, Method method) { + long time = cacheValue.time; + int cacheSeconds = method.getAnnotation(Cache.class).cacheSeconds(); + return System.currentTimeMillis() - time > cacheSeconds * 1000; + } } + public static void main(String[] args) throws Exception { DataService dataService = decorate(DataService.class).getConstructor().newInstance(); @@ -18,6 +123,8 @@ public static void main(String[] args) throws Exception { System.out.println(dataService.queryData(1)); Thread.sleep(1 * 1000); System.out.println(dataService.queryData(1)); + Thread.sleep(3 * 1000); + System.out.println(dataService.queryData(1)); // 无缓存的查询：两次都执行了真正的查询操作 System.out.println(dataService.queryDataWithoutCache(1)); diff --git a/src/main/java/com/github/hcsp/annotation/DataService.java b/src/main/java/com/github/hcsp/annotation/DataService.java index fefb56c..d01da0d 100644 --- a/src/main/java/com/github/hcsp/annotation/DataService.java +++ b/src/main/java/com/github/hcsp/annotation/DataService.java @@ -12,7 +12,7 @@ public class DataService { * @param id 数据ID * @return 查询到的数据列表 */ - @Cache + @Cache(cacheSeconds = 2) public List queryData(int id) { // 模拟一个查询操作 Random random = new Random();