aop缓存，支持threadlocal、memory、redis

泛型反序列化

1. /**
2. * 字符串转换成对象 支持多级转换以及泛型等 比如 UCRoot<List<Hospital>> 、List<Hospital> 等
3. * eg：
4. *
5. * @param jsonStr
6. * @param types
7. * @return
8. */
9. public static Object parseObject(String jsonStr, Type[] types) {
10. if (isBlank(jsonStr) || ArrayUtils.isEmpty(types)) {
11. return null;
12. }
13. if (types.length == 1) {
14. if (jsonStr.startsWith("[{")) {
15. return JSONObject.parseArray(jsonStr, (Class) types[0]);
16. } else {
17. return JSONObject.parseObject(jsonStr, types[0]);
18. }
19. }
21. ParameterizedTypeImpl beforeType = null;
22. if (types != null && types.length > 0) {
23. for (int i = types.length - 1; i > 0; i--) {
24. beforeType = new ParameterizedTypeImpl(new Type[]{beforeType == null ? types[i] : beforeType}, null, types[i - 1]);
25. }
26. }
27. return JSONObject.parseObject(jsonStr, beforeType);
28. }

1.注解

1. import java.lang.annotation.*;
3. /**
4. * 是否启用自定义的 线程缓存
5. *
6. */
7. @Documented
8. @Retention(RetentionPolicy.RUNTIME)
9. @Target({ElementType.METHOD, ElementType.TYPE})
10. public @interface CacheAopFitter {
11. String value() default "";
13. int timeout() default 15; //缓存时间(单位：秒)
15. /**
16. * 缓存类型 1：线程缓存 2:内存缓存 3：Redis缓存
17. *
18. * @return
19. */
20. CacheUtils.CacheType cacheType() default CacheUtils.CacheType.Redis;
22. /**
23. * list 或者泛型 如果是 List 可以省略掉 List.class 反序列化时会判断是否是list类型
24. * eg UCRoot<List<Pharmacy>>:[UCRoot.class,List.class,Pharmacy.class] 、 List<Pharmacy>:[List.class,Pharmacy.class]
25. *
26. * @return
27. */
28. Class[] classes() default {};
30. }

2 aop拦截器

1. import cn.ucmed.baseline.d2d.service.Cache.RedisService;
2. import com.ucmed.common.util.CommonUtil;
3. import lombok.extern.log4j.Log4j;
4. import org.aspectj.lang.ProceedingJoinPoint;
5. import org.aspectj.lang.annotation.Around;
6. import org.aspectj.lang.annotation.Aspect;
7. import org.aspectj.lang.annotation.Pointcut;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.stereotype.Component;
11. /**
12. * AOP 对静态的方法没用
13. * 药事获取用户中心的数据都是 使用静态方法（aop没有生效） 暂时不修改
14. */
16. @Aspect
17. @Component
18. @Log4j
19. public class CacheAop {
21. @Autowired
22. RedisService redisService;
24. //控制器切点
25. @Pointcut("@annotation(cn.ucmed.baseline.d2d.aop.CacheAopFitter) || @within(cn.ucmed.baseline.d2d.aop.CacheAopFitter)")
26. public void cachePoint() {
27. }
29. @Around("cachePoint()")
30. public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
31. //获取注解参数
32. CacheUtils.MyAnnotation myAnnotation = CacheUtils.getAnnotation(joinPoint);
34. Object object = null;
35. //生成key
36. String key = "";
37. if (myAnnotation.cacheType == CacheUtils.CacheType.ThreadLocal) {
38. key = CacheUtils.createKey(joinPoint);
40. //获取缓存的值
41. object = CacheUtils.getByKey(key);
42. } else if (myAnnotation.cacheType == CacheUtils.CacheType.Memory) {
43. key = CacheUtils.createKeyForMemory(joinPoint);
45. //获取缓存的值
46. object = CacheUtils.getByKeyForMemory(key);
47. } else if (myAnnotation.cacheType == CacheUtils.CacheType.Redis) {
48. key = CacheUtils.createKeyForRedis(joinPoint);
50. //获取缓存的值
51. object = redisService.getObject(key, myAnnotation.getClasses());
52. }
53. //判断是否存在 如果有这直接返回
54. if (object != null) return object;
56. Object value = joinPoint.proceed();
58. //缓存结果
59. if (value != null) {
60. if (myAnnotation.cacheType == CacheUtils.CacheType.ThreadLocal) {
61. CacheUtils.setValueByKey(key, value, myAnnotation);
62. } else if (myAnnotation.cacheType == CacheUtils.CacheType.Memory) {
63. CacheUtils.setValueByKeyForMemory(key, value, myAnnotation);
64. } else if (myAnnotation.cacheType == CacheUtils.CacheType.Redis) {
65. redisService.setObject(key, value, myAnnotation.timeout);
66. }
67. }
69. //返回结果
70. return value;
71. }
73. }

3工具类

1. import com.alibaba.fastjson.JSONObject;
2. import lombok.Data;
3. import lombok.extern.log4j.Log4j;
4. import org.apache.commons.lang.ArrayUtils;
5. import org.aspectj.lang.ProceedingJoinPoint;
6. import org.aspectj.lang.reflect.MethodSignature;
8. import java.math.BigInteger;
9. import java.security.MessageDigest;
10. import java.security.NoSuchAlgorithmException;
11. import java.util.HashMap;
12. import java.util.Map;
13. import java.util.concurrent.ConcurrentHashMap;
15. /**
16. * @Description
17. * @auther machunsen
18. * @create 2019-07-22 15:31:12
19. */
20. @Log4j
21. public class CacheUtils {
22. //线程缓存
23. private static ThreadLocal<Map<String, MyValue>> localStorage = ThreadLocal.withInitial(HashMap::new);
25. //内存缓存
26. private static Map<String, MyValue> memoryCache = new ConcurrentHashMap<>();
28. //上一次清理时间
29. private static String cacheLastClearTime = "YSFWPT_cacheLastClearTime";
31. //清理缓存间隔
32. private static Long clearCacheInterval = 30 * 60 * 1000L;
35. //region ThreadLocal缓存
36. public static Map<String, MyValue> get() {
37. return localStorage.get();
38. }
40. public static void set(Map<String, MyValue> map) {
41. localStorage.set(map);
42. }
44. /**
45. * 移除本地变量
46. */
47. public static void remove() {
48. localStorage.remove();
49. }
52. /**
53. * 根据key 获取缓存的值
54. *
55. * @param key
56. * @return
57. */
58. public static Object getByKey(String key) {
59. Map<String, MyValue> map = getMyCache();
60. return getValueByKey(map, key);
61. }
63. /**
64. * 设置缓存的值
65. *
66. * @param key
67. * @param value
68. */
69. public static void setValueByKey(String key, Object value, MyAnnotation myAnnotation) {
70. Map<String, MyValue> map = getMyCache();
71. setValue(map, key, value, myAnnotation);
72. }
74. /**
75. * 获取缓存map
76. *
77. * @return
78. */
79. private static Map<String, MyValue> getMyCache() {
80. Map<String, MyValue> map = localStorage.get();
81. if (map == null) {
82. localStorage.set(new HashMap<>());
83. }
85. return map;
86. }
87. //endregion
90. //region 内存缓存
91. public static Object getByKeyForMemory(String key) {
92. return getValueByKey(memoryCache, key);
93. }
95. public static void setValueByKeyForMemory(String key, Object value, MyAnnotation myAnnotation) {
96. setValue(memoryCache, key, value, myAnnotation);
97. }
98. //endregion
101. private static Object getValueByKey(Map<String, MyValue> map, String key) {
102. if (map == null) return null;
104. //判断是否需要清空缓存
105. MyValue myValue = map.get(cacheLastClearTime);
106. boolean needInitStartTime = false;
107. if (myValue != null) {
108. //如果大于清除间隔则清除缓存
109. if (System.currentTimeMillis() - myValue.startTime > clearCacheInterval) {
110. map.clear();
111. return null;
112. }
113. } else {
114. needInitStartTime = true;
115. }
116. //出事化清除间隔的开始时间
117. if (needInitStartTime) {
118. map.put(cacheLastClearTime, new MyValue());
119. }
121. //获取值
122. myValue = map.get(key);
123. if (myValue != null) {
124. //如果超时了则移除
125. if (System.currentTimeMillis() - myValue.startTime > myValue.getMyAnnotation().getTimeout() * 1000) {
126. map.remove(key);
127. } else {
128. return myValue.getValue();
129. }
130. }
131. return null;
132. }
134. private static void setValue(Map<String, MyValue> map, String key, Object value, MyAnnotation myAnnotation) {
135. if (map == null) return;
136. MyValue myValue = new MyValue();
137. myValue.setValue(value);
138. myValue.setMyAnnotation(myAnnotation);
139. map.put(key, myValue);
140. }
143. /**
144. * 生成 key
145. *
146. * @param joinPoint
147. * @return
148. */
149. static String createKey(ProceedingJoinPoint joinPoint) {
150. //类名
151. String className = joinPoint.getTarget().getClass().getName();
152. //方法名
153. String methodName = joinPoint.getSignature().getName();
155. //参数对象
156. Object[] methodArgs = joinPoint.getArgs();
158. String key = className + "." + methodName + Thread.currentThread().getId() + MD5(JSONObject.toJSONString(methodArgs));
160. return key;
161. }
163. static String createKeyForMemory(ProceedingJoinPoint joinPoint) {
164. //类名
165. String className = joinPoint.getTarget().getClass().getName();
166. //方法名
167. String methodName = joinPoint.getSignature().getName();
169. //参数对象
170. Object[] methodArgs = joinPoint.getArgs();
172. String key = className + "." + methodName + MD5(JSONObject.toJSONString(methodArgs));
173. return key;
174. }
176. static String createKeyForRedis(ProceedingJoinPoint joinPoint) {
177. //类名
178. String className = joinPoint.getTarget().getClass().getName();
179. //方法名
180. String methodName = joinPoint.getSignature().getName();
182. //参数对象
183. Object[] methodArgs = joinPoint.getArgs();
185. String key = className + "." + methodName + JSONObject.toJSONString(methodArgs);
187. key = methodName + "_" + MD5(key);
189. return key;
191. }
194. /**
195. * md5 方法
196. *
197. * @param plainText
198. * @return
199. */
200. private static String MD5(String plainText) {
201. //定义一个字节数组
202. byte[] secretBytes = null;
203. try {
204. // 生成一个MD5加密计算摘要
205. MessageDigest md = MessageDigest.getInstance("MD5");
206. //对字符串进行加密
207. md.update(plainText.getBytes());
208. //获得加密后的数据
209. secretBytes = md.digest();
210. } catch (NoSuchAlgorithmException e) {
211. throw new RuntimeException("没有md5这个算法！");
212. }
213. //将加密后的数据转换为16进制数字
214. String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字
215. // 如果生成数字未满32位，需要前面补0
216. for (int i = 0; i < 32 - md5code.length(); i++) {
217. md5code = "0" + md5code;
218. }
219. return md5code;
220. }
222. /**
223. * 获取注解中的参数
224. *
225. * @param joinPoint
226. * @return
227. */
228. public static CacheUtils.MyAnnotation getAnnotation(ProceedingJoinPoint joinPoint) {
229. CacheUtils.MyAnnotation myAnnotation = new CacheUtils.MyAnnotation();
231. CacheAopFitter cacheAopFitter = ((MethodSignature) joinPoint.getSignature()).getMethod().getAnnotation(CacheAopFitter.class);
233. if (cacheAopFitter == null) {
234. cacheAopFitter = joinPoint.getTarget().getClass().getAnnotation(CacheAopFitter.class);
235. }
237. if (cacheAopFitter != null) {
238. myAnnotation.setTimeout(cacheAopFitter.timeout());
239. myAnnotation.setValue(cacheAopFitter.value());
240. myAnnotation.setCacheType(cacheAopFitter.cacheType());
241. if (!ArrayUtils.isEmpty(cacheAopFitter.classes())) {
242. myAnnotation.setClasses(cacheAopFitter.classes());
243. } else {
244. try {
245. Class classzz = Class.forName(joinPoint.getSignature().toLongString().split(" ")[1]);
246. myAnnotation.setClasses(new Class[]{classzz});
247. } catch (Exception ex) {
248. log.error("缓存转换类型失败", ex);
249. }
250. }
251. }
253. return myAnnotation;
254. }
256. // /**
257. // * 缓存类
258. // */
259. // @Data
260. // public static class MyCahce {
261. //
262. // private Map<String, MyValue> map = new HashMap<>();
263. // private MyAnnotation myAnnotation = new MyAnnotation();
264. // }
267. /**
268. * 值对象
269. */
270. @Data
271. public static class MyValue {
272. private Object value;
273. private Long startTime = System.currentTimeMillis();
274. MyAnnotation myAnnotation;
275. }
277. /**
278. * 缓存的类型 线程缓存和内存缓存不适合缓存比较大的数据
279. * 比较大的数据可以使用redis缓存
280. */
281. public static enum CacheType {
283. /**
284. * 线程缓存
285. */
286. ThreadLocal,
287. /**
288. * 直接缓存在内存中 ConcurrentHashMap中
289. */
290. Memory,
291. /**
292. * //使用redis 如果返回值是泛型 使用redis不能反序列化，导致获取失败
293. */
294. Redis;
295. }
297. /**
298. * 缓存类
299. */
300. @Data
301. public static class MyAnnotation {
303. String value = "";
305. int timeout = 15;//超时时间
307. CacheType cacheType = CacheType.Redis; //缓存类型
309. //返回值类型
310. Class[] classes;
312. }
314. }

[转载]fastjson反序列化多层嵌套泛型类与java中的Type类型