当前位置:网站首页>简直骚操作,ThreadLocal还能当缓存用

简直骚操作,ThreadLocal还能当缓存用

2020-11-06 01:28:26 尹吉欢

背景说明

有朋友问我一个关于接口优化的问题,他的优化点很清晰,由于接口中调用了内部很多的 service 去组成了一个完成的业务功能。每个 service 中的逻辑都是独立的,这样就导致了很多查询是重复的,看下图你就明白了。

图片

上层查询传递下去

对于这种场景最好的就是在上层将需要的数据查询出来,然后传递到下层去消费。这样就不用重复查询了。

图片

如果开始写代码的时候是这样做的没问题,但很多时候,之前写的时候都是独立的,或者复用的老逻辑,里面就是有独立的查询。

如果要做优化就只能将老的方法重载一个,将需要的信息直接传递过去。

  
  1. public void xxx(int goodsId) {
  2. Goods goods = goodsService.get(goodsId);
  3. .....
  4. }
  5. public void xxx(Goods goods) {
  6. .....
  7. }

加缓存

如果你的业务场景允许数据有一定延迟,那么重复调用你可以直接通过加缓存来解决。这样的好处在于不会重复查询数据库,而是直接从缓存中取数据。

更大的好处在于对于优化类的影响最小,原有的代码逻辑都不用改变,只需要在查询的方法上加注解进行缓存即可。

  
  1. public void xxx(int goodsId) {
  2. Goods goods = goodsService.get(goodsId);
  3. .....
  4. }
  5. public void xxx(Goods goods) {
  6. Goods goods = goodsService.get(goodsId);
  7. .....
  8. }
  9. class GoodsService {
  10. @Cached(expire = 10, timeUnit = TimeUnit.SECONDS)
  11. public Goods get(int goodsId) {
  12. return dao.findById(goodsId);
  13. }
  14. }

如果你的业务场景不允许有缓存的话,上面这个方法就不能用了。那么是不是还得改代码,将需要的信息一层层往下传递呢?

自定义线程内的缓存

我们总结下目前的问题:

  1. 同一次请求内,多次相同的查询获取 RPC 等的调用。
  2. 数据实时性要求高,不适合加缓存,主要是加缓存也不好设置过期时间,除非采用数据变更主动更新缓存的方式。
  3. 只需要在这一次请求里缓存即可,不影响其他地方。
  4. 不想改动已有代码。

总结后发现这个场景适合用 ThreadLocal 来传递数据,对已有代码改动量最小,而且也只对当前线程生效,不会影响其他线程。

  
  1. public void xxx(int goodsId) {
  2. Goods goods = ThreadLocal.get();
  3. if (goods == null) {
  4. goods = goodsService.get(goodsId);
  5. }
  6. .....
  7. }

上面代码就是使用了 ThreadLocal 来获取数据,如果有的话就直接使用,不用去重新查询,没有的话就去查询,不影响老逻辑。

虽然能实现效果,但是不太好,不够优雅。也不够通用,如果一次请求内要缓存多种类型的数据怎么处理? ThreadLocal 就不能存储固定的类型。还有就是老的逻辑还是得改,加了个判断。

下面介绍一种比较优雅的方式:

  1. 自定义缓存注解,加在查询的方法上。
  2. 定义切面切到加了缓存注解的方法上,第一次获取返回值存入 ThreadLocal。第二次直接从 ThreadLocal 中取值返回。
  3. ThreadLocal 中存储 Map,Key 为某方法的某一标识,这样可以缓存多种类型的结果。
  4. 在 Filter 中将 ThreadLocal 进行 remove 操作,因为线程是复用的,使用完需要清空。

注意:ThreadLocal 不能跨线程,如果有跨线程需求,请使用阿里的 ttl 来装饰。

图片

注解定义

  
  1. @Target({ ElementType.METHOD })
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface ThreadLocalCache {
  4. /**
  5. * 缓存key,支持SPEL表达式
  6. * @return
  7. */
  8. String key() default "";
  9. }

存储定义

  
  1. /**
  2. * 线程内缓存管理
  3. *
  4. * @作者 尹吉欢
  5. * @时间 2020-07-12 10:47
  6. */
  7. public class ThreadLocalCacheManager {
  8. private static ThreadLocal<Map> threadLocalCache = new ThreadLocal<>();
  9. public static void setCache(Map value) {
  10. threadLocalCache.set(value);
  11. }
  12. public static Map getCache() {
  13. return threadLocalCache.get();
  14. }
  15. public static void removeCache() {
  16. threadLocalCache.remove();
  17. }
  18. public static void removeCache(String key) {
  19. Map cache = threadLocalCache.get();
  20. if (cache != null) {
  21. cache.remove(key);
  22. }
  23. }
  24. }

切面定义

  
  1. /**
  2. * 线程内缓存
  3. *
  4. * @作者 尹吉欢
  5. * @时间 2020-07-12 10:48
  6. */
  7. @Aspect
  8. public class ThreadLocalCacheAspect {
  9. @Around(value = "@annotation(localCache)")
  10. public Object aroundAdvice(ProceedingJoinPoint joinpoint, ThreadLocalCache localCache) throws Throwable {
  11. Object[] args = joinpoint.getArgs();
  12. Method method = ((MethodSignature) joinpoint.getSignature()).getMethod();
  13. String className = joinpoint.getTarget().getClass().getName();
  14. String methodName = method.getName();
  15. String key = parseKey(localCache.key(), method, args, getDefaultKey(className, methodName, args));
  16. Map cache = ThreadLocalCacheManager.getCache();
  17. if (cache == null) {
  18. cache = new HashMap();
  19. }
  20. Map finalCache = cache;
  21. Map<String, Object> data = new HashMap<>();
  22. data.put("methodName", className + "." + methodName);
  23. Object cacheResult = CatTransactionManager.newTransaction(() -> {
  24. if (finalCache.containsKey(key)) {
  25. return finalCache.get(key);
  26. }
  27. return null;
  28. }, "ThreadLocalCache", "CacheGet", data);
  29. if (cacheResult != null) {
  30. return cacheResult;
  31. }
  32. return CatTransactionManager.newTransaction(() -> {
  33. Object result = null;
  34. try {
  35. result = joinpoint.proceed();
  36. } catch (Throwable throwable) {
  37. throw new RuntimeException(throwable);
  38. }
  39. finalCache.put(key, result);
  40. ThreadLocalCacheManager.setCache(finalCache);
  41. return result;
  42. }, "ThreadLocalCache", "CachePut", data);
  43. }
  44. private String getDefaultKey(String className, String methodName, Object[] args) {
  45. String defaultKey = className + "." + methodName;
  46. if (args != null) {
  47. defaultKey = defaultKey + "." + JsonUtils.toJson(args);
  48. }
  49. return defaultKey;
  50. }
  51. private String parseKey(String key, Method method, Object[] args, String defaultKey){
  52. if (!StringUtils.hasText(key)) {
  53. return defaultKey;
  54. }
  55. LocalVariableTableParameterNameDiscoverer nameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
  56. String[] paraNameArr = nameDiscoverer.getParameterNames(method);
  57. ExpressionParser parser = new SpelExpressionParser();
  58. StandardEvaluationContext context = new StandardEvaluationContext();
  59. for(int i = 0;i < paraNameArr.length; i++){
  60. context.setVariable(paraNameArr[i], args[i]);
  61. }
  62. try {
  63. return parser.parseExpression(key).getValue(context, String.class);
  64. } catch (SpelEvaluationException e) {
  65. // 解析不出SPEL默认为类名+方法名+参数
  66. return defaultKey;
  67. }
  68. }
  69. }

过滤器定义

  
  1. /**
  2. * 线程缓存过滤器
  3. *
  4. * @作者 尹吉欢
  5. * @个人微信 jihuan900
  6. * @微信公众号 猿天地
  7. * @GitHub https://github.com/yinjihuan
  8. * @作者介绍 http://cxytiandi.com/about
  9. * @时间 2020-07-12 19:46
  10. */
  11. @Slf4j
  12. public class ThreadLocalCacheFilter implements Filter {
  13. @Override
  14. public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  15. filterChain.doFilter(servletRequest, servletResponse);
  16. // 执行完后清除缓存
  17. ThreadLocalCacheManager.removeCache();
  18. }
  19. }

自动配置类

  
  1. @Configuration
  2. public class ThreadLocalCacheAutoConfiguration {
  3. @Bean
  4. public FilterRegistrationBean idempotentParamtFilter() {
  5. FilterRegistrationBean registration = new FilterRegistrationBean();
  6. ThreadLocalCacheFilter filter = new ThreadLocalCacheFilter();
  7. registration.setFilter(filter);
  8. registration.addUrlPatterns("/*");
  9. registration.setName("thread-local-cache-filter");
  10. registration.setOrder(1);
  11. return registration;
  12. }
  13. @Bean
  14. public ThreadLocalCacheAspect threadLocalCacheAspect() {
  15. return new ThreadLocalCacheAspect();
  16. }
  17. }

使用案例

  
  1. @Service
  2. public class TestService {
  3. /**
  4. * ThreadLocalCache 会缓存,只对当前线程有效
  5. * @return
  6. */
  7. @ThreadLocalCache
  8. public String getName() {
  9. System.out.println("开始查询了");
  10. return "yinjihaun";
  11. }
  12. /**
  13. * 支持SPEL表达式
  14. * @param id
  15. * @return
  16. */
  17. @ThreadLocalCache(key = "#id")
  18. public String getName(String id) {
  19. System.out.println("开始查询了");
  20. return "yinjihaun" + id;
  21. }
  22. }

功能代码: https://github.com/yinjihuan/kitty

案例代码: https://github.com/yinjihuan/kitty-samples

关于作者 :尹吉欢,简单的技术爱好者,《Spring Cloud 微服务-全栈技术与案例解析》, 《Spring Cloud 微服务 入门 实战与进阶》作者, 公众号 猿天地 发起人。个人微信 jihuan900 ,欢迎勾搭。

我整理了一份很全的学习资料,感兴趣的可以微信搜索 「猿天地」,回复关键字 「学习资料」获取我整理好了的Spring Cloud,Spring Cloud Alibaba,Sharding-JDBC分库分表,任务调度框架XXL-JOB,MongoDB,爬虫等相关资料。

版权声明
本文为[尹吉欢]所创,转载请带上原文链接,感谢
http://cxytiandi.com/blog/detail/36497