每天学习一点点之 Hystrix 之 Request Cache

Posted 2021-03-29 冬瓜白

This browser does not support music or audio playback. Please play it in Weixin or another browser.

最近看了下 Hystrix，里面有很多设计还是蛮有意思的，这篇文章主要探讨的是 Request Cache，Request Cache 原理不难，单独看 Request Cache 作用也许并不大，还不如用 Spring Cache，但是与其他 Hystrix 机制联合会有很大的作用，其他核心原理会在后面的文章中再讨论。这里主要是做一个记录，学习一下其中的设计思想。这是在网上找的对 Request Cache 的一个描述：

❝

Hystrix 给我们提供了缓存功能，支持将一个请求结果缓存起来，下一个具有相同 key 的请求将直接从缓存中取出结果，减少请求开销。

❞

package com.example.demo.hystrix.framework;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

/**
 * @author Dongguabai
 * @description Request Cache 过滤器
 * @date 2021-02-03 22:08
 */
public final class RequestCacheFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        RequestContextHolder.init();
        try {
            filterChain.doFilter(servletRequest, servletResponse);
        } finally {
            RequestContextHolder.remove();
        }
    }
}

存储工具，主要是对缓存进行存储：

package com.example.demo.hystrix.framework;

import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Dongguabai
 * @description
 * @date 2021-02-04 13:42
 */
public final class RequestContextHolder {

    private static volatile ThreadLocal<ConcurrentHashMap<String, Object>> context;


    public static void init() {
        if (context == null) {
            synchronized (RequestContextHolder.class) {
                if (context == null) {
                    context = ThreadLocal.withInitial(ConcurrentHashMap::new);
                }
            }
        }
    }

    public static void remove() {
        ConcurrentHashMap<String, Object> concurrentHashMap = context.get();
        if (concurrentHashMap != null && !concurrentHashMap.isEmpty()) {
            concurrentHashMap.clear();
        }
        context.remove();
    }

    static boolean isCached(String key) {
        return key != null && context.get() != null && context.get().containsKey(key);
    }

    static Object getValue(String key) {
        return context.get().get(key);
    }

    static void setValue(String key, Object value) {
        context.get().put(key, value);
    }
}

逻辑处理类，包括定义缓存 key等：

package com.example.demo.hystrix.framework;

/**
 * @author Dongguabai
 * @description
 * @date 2021-02-03 22:26
 */
public abstract class AbstractCommand<R> {

    /**
     * 获取缓存key
     */
    protected String getCacheKey() {
        return null;
    }

    /**
     * 是否缓存
     */
    protected boolean isCaching() {
        try {
            return getCacheKey() != null && this.getClass().getDeclaredMethod("getCacheKey", null) != null;
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 具体执行逻辑
     */
    protected abstract R call();

    public R execute() {
        if(isCaching()){
            if (RequestContextHolder.isCached(getCacheKey())){
                return (R) RequestContextHolder.getValue(getCacheKey());
            }
            R value = call();
            RequestContextHolder.setValue(getCacheKey(),value);
            return value;
        }
        return call();
    }
}

接下来测试一下。注册 Filter：

package com.example.demo.hystrix.web.config;

import com.example.demo.hystrix.framework.RequestCacheFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author Dongguabai
 * @description
 * @date 2021-02-04 13:12
 */
@Configuration
public class WebConfiguration {

    @Bean
    public FilterRegistrationBean requestCacheFilterRegistrationBean() {
        FilterRegistrationBean<RequestCacheFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new RequestCacheFilter());
        registration.addUrlPatterns("/*");
        return registration;
    }
}

Controller：

package com.example.demo.hystrix.web.controller;

import com.example.demo.hystrix.web.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Dongguabai
 * @description
 * @date 2021-01-30 01:50
 */
@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @RequestMapping("hello/{ids}")
    public Object hello(@PathVariable String ids) {
        return helloService.getByIds(ids.split(","));
    }
}

Service：

package com.example.demo.hystrix.web.service;

import com.example.demo.hystrix.web.commond.HelloCommand;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Dongguabai
 * @description
 * @date 2021-02-04 13:16
 */
@Service
public class HelloService {

    public List<String> getByIds(String[] ids) {
        List<String> results = new ArrayList<>(ids.length);
        for (String id : ids) {
            //以 id 作为 key
            results.add(new HelloCommand(id).execute());
        }
        return results;
    }
}

对逻辑处理进行封装（当然也可以根据 AOP 实现类似 Spring Cache 的效果）：

package com.example.demo.hystrix.web.commond;

import com.example.demo.hystrix.framework.AbstractCommand;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Dongguabai
 * @description
 * @date 2021-02-04 13:20
 */
public class HelloCommand extends AbstractCommand<String> {

    //模拟数据库查询或 RPC
    private static final Map<String,String> REPOSITORY;

    private final String key;

    public HelloCommand(String key) {
        this.key = key;
    }

    @Override
    protected String call() {
        System.out.printf("------process------:%s\n",key);
        return REPOSITORY.get(key);
    }

    @Override
    public String getCacheKey() {
        return key;
    }

    static {
        REPOSITORY = new HashMap<>(5);
        REPOSITORY.putIfAbsent("1","a");
        REPOSITORY.putIfAbsent("2","b");
        REPOSITORY.putIfAbsent("3","c");
        REPOSITORY.putIfAbsent("4","d");
        REPOSITORY.putIfAbsent("5","e");
    }
}

测试一下，启动项目，浏览器访问：http://localhost:8080/hello/1,2,3,1,2：查看输出日志：

------process------:1
------process------:2
------process------:3

可以看到，根据传入 id 作为 key 进行缓存存储已经生效。

References

• https://www.jianshu.com/p/e2d1d319fadd