ThreadLoacal缓存 - 缓存一个线程频繁调用的方法结果

适用场景：如果一次请求需要多次调用另外一个方法（该方法获取到的数据不需要修改，如调用第三方的查询接口）可以缓存该方法的结果，以便在后续线程直接使用该结果
实现原理：缓存数据存放在ThreadLocal变量中，使用aop拦截需要缓存的方法，如果缓存中有该方法的缓存结果则直接返回，如果没有则执行该方法后缓存该方法的结果。
代码如下：

1. aop注解 定义切面

1. import java.lang.annotation.*;
3. /**
4. * 是否启用自定义的 线程缓存
5. */
6. @Documented
7. @Retention(RetentionPolicy.RUNTIME)
8. @Target({ElementType.METHOD, ElementType.TYPE})
9. public @interface CacheAopFitter {
10. String value() default "";
12. int timeout() default 10; //缓存时间(单位：秒) 默认10秒
13. }

2. aop 拦截类 拦截注解的方法

1. import lombok.extern.slf4j.Slf4j;
2. import org.aspectj.lang.ProceedingJoinPoint;
3. import org.aspectj.lang.annotation.Around;
4. import org.aspectj.lang.annotation.Aspect;
5. import org.aspectj.lang.annotation.Pointcut;
6. import org.springframework.stereotype.Component;
8. @Aspect
9. @Component
10. @Slf4j
11. public class CacheAop {
12. //控制器切点
13. @Pointcut("@annotation(com.mcs.cache.democache.aop.CacheAopFitter) || @within(com.mcs.cache.democache.aop.CacheAopFitter)")
14. public void cachePoint() {
15. }
17. @Around("cachePoint()")
18. public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
19. //生成key
20. String key = CacheUtils.createKey(joinPoint);
21. //判断是否存在 如果有这直接返回
22. if (CacheUtils.containsKey(key)) {
23. return CacheUtils.getByKey(key);
24. }
26. Object result = joinPoint.proceed();
27. //缓存结果
28. CacheUtils.setValueByKey(key, result);
29. //返回结果
30. return result;
31. }
32. }

3. 相应的工具类用户设置或者获取缓存

1. import com.alibaba.fastjson.JSONObject;
2. import lombok.Data;
3. import lombok.extern.slf4j.Slf4j;
4. import org.aspectj.lang.ProceedingJoinPoint;
5. import org.aspectj.lang.reflect.MethodSignature;
6. import org.springframework.beans.BeanUtils;
7. import java.math.BigInteger;
8. import java.security.MessageDigest;
9. import java.security.NoSuchAlgorithmException;
10. import java.util.HashMap;
11. import java.util.Map;
13. @Slf4j
14. public class CacheUtils {
15. //缓存对象 这里是线程缓存需要设置成静态 同一个线程内共享，不同线程不共享
16. //实现原理看 Threadlocal机制
17. static ThreadLocal localStorage = ThreadLocal.withInitial(() -> new MyCahce());
19. public static MyCahce get() {
20. return localStorage.get();
21. }
22. public static void set(MyCahce myCahce) {
23. localStorage.set(myCahce);
24. }
25. /**
26. * 移除本地变量
27. */
28. public static void remove() {
29. localStorage.remove();
30. }
31. /**
32. * 判断是否包含key
33. *
34. * @param key
35. * @return
36. */
37. public static Boolean containsKey(String key) {
38. MyCahce myCahce = getMyCahce();
39. log.debug(JSONObject.toJSONString(myCahce));
40. return myCahce.getMap().containsKey(key);
41. }
43. /**
44. * 根据key 获取缓存的值
45. *
46. * @param key
47. * @return
48. */
49. public static Object getByKey(String key) {
50. MyCahce myCahce = getMyCahce();
51. if (myCahce.getMap().containsKey(key)) {
52. return myCahce.getMap().get(key);
53. }
54. return null;
55. }
57. /**
58. * 设置缓存的值
59. *
60. * @param key
61. * @param value
62. */
63. public static void setValueByKey(String key, Object value) {
64. MyCahce myCahce = getMyCahce();
65. myCahce.getMap().put(key, value);
66. }
67. /**
68. * 获取缓存map
69. * @return
70. */
71. private static MyCahce getMyCahce() {
72. MyCahce myCahce = localStorage.get();
73. if (myCahce == null) {
74. myCahce = new MyCahce();
75. localStorage.set(myCahce);
76. }
77. Map map = myCahce.getMap();
78. String key = "startTime";
79. if (map.containsKey(key)) {
80. //超时时间
81. int timeout = myCahce.getMyAnnotation().getTimeout();
82. long startTime = (long) map.get(key);
83. //如果大于超时时间 则清空缓存
84. if (System.currentTimeMillis() - startTime > timeout * 1000) {
85. map.clear();
86. }
87. } else {
88. map.put(key, System.currentTimeMillis());
89. }
90. return myCahce;
91. }
94. /**
95. * 生成 key
96. *
97. * @param joinPoint
98. * @return
99. */
100. static String createKey(ProceedingJoinPoint joinPoint) {
101. //类名
102. String className = joinPoint.getTarget().getClass().getName();
103. //方法名
104. String methodName = joinPoint.getSignature().getName();
106. //参数对象
107. Object[] methodArgs = joinPoint.getArgs();
109. String key = className + "." + methodName + Thread.currentThread().getId() + "|" + MD5(JSONObject.toJSONString(methodArgs));
111. //初始化注解参数
112. initAnnotation(joinPoint);
114. return key;
115. }
117. /**
118. * 初始化注解参数
119. * @param joinPoint
120. * @return
121. */
122. static void initAnnotation(ProceedingJoinPoint joinPoint) {
123. MyAnnotation myAnnotation = getAnnotation(joinPoint);
124. if (myAnnotation != null) {
125. MyCahce myCahce = getMyCahce();
126. MyAnnotation myAnnotation1 = myCahce.getMyAnnotation();
127. BeanUtils.copyProperties(myAnnotation, myAnnotation1);
128. }
129. }
132. /**
133. * md5 方法
134. *
135. * @param plainText
136. * @return
137. */
138. private static String MD5(String plainText) {
139. //定义一个字节数组
140. byte[] secretBytes = null;
141. try {
142. // 生成一个MD5加密计算摘要
143. MessageDigest md = MessageDigest.getInstance("MD5");
144. //对字符串进行加密
145. md.update(plainText.getBytes());
146. //获得加密后的数据
147. secretBytes = md.digest();
148. } catch (NoSuchAlgorithmException e) {
149. throw new RuntimeException("没有md5这个算法！");
150. }
151. //将加密后的数据转换为16进制数字
152. String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字
153. // 如果生成数字未满32位，需要前面补0
154. for (int i = 0; i < 32 - md5code.length(); i++) {
155. md5code = "0" + md5code;
156. }
157. return md5code;
158. }
160. /**
161. * 获取注解中的参数
162. *
163. * @param joinPoint
164. * @return
165. */
166. private static CacheUtils.MyAnnotation getAnnotation(ProceedingJoinPoint joinPoint) {
167. CacheUtils.MyAnnotation myAnnotation = new CacheUtils.MyAnnotation();
169. CacheAopFitter cacheAopFitter = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(CacheAopFitter.class);
171. if (cacheAopFitter == null) {
172. cacheAopFitter = joinPoint.getTarget().getClass().getAnnotation(CacheAopFitter.class);
173. }
175. if (cacheAopFitter != null) {
176. myAnnotation.setTimeout(cacheAopFitter.timeout());
177. myAnnotation.setValue(cacheAopFitter.value());
178. }
179. return myAnnotation;
180. }
182. /**
183. * 缓存类 主要是存放缓存的数据 以及注解信息
184. */
185. @Data
186. public static class MyCahce {
187. private Map map = new HashMap<>();
188. private MyAnnotation myAnnotation = new MyAnnotation();
189. }
191. /**
192. * 注解信息类
193. */
194. @Data
195. public static class MyAnnotation {
196. String value = "";
197. int timeout = 10;
198. }
199. }