Redis：统一控制缓存逻辑

淩亂°似流年 2024-03-24 08:44 104阅读 0赞

#### **采用拦截器进行缓存命中** ####

编写拦截器：RedisCacheInterceptor。

import com.fasterxml.jackson.databind.ObjectMapper;
    import org.apache.commons.codec.digest.DigestUtils;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    @Component
    public class RedisCacheInterceptor implements HandlerInterceptor {
    
        private static ObjectMapper mapper = new ObjectMapper();
    
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
            if(StringUtils.equalsIgnoreCase(request.getMethod(), "OPTIONS")){
                return true;
            }
    
            // 判断请求方式，get还是post还是其他。。。
            if (!StringUtils.equalsIgnoreCase(request.getMethod(), "GET")) {
                // 非get请求，如果不是graphql请求，放行
                if (!StringUtils.equalsIgnoreCase(request.getRequestURI(), "/graphql")) {
                    return true;
                }
            }
    
            // 通过缓存做命中，查询redis，redisKey ?  组成：md5（请求的url + 请求参数）
            String redisKey = createRedisKey(request);
            String data = this.redisTemplate.opsForValue().get(redisKey);
            if (StringUtils.isEmpty(data)) {
                // 缓存未命中
                return true;
            }
    
            // 将data数据进行响应
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json; charset=utf-8");
            response.getWriter().write(data);
    
            return false;
        }
    
        public static String createRedisKey(HttpServletRequest request) throws Exception {
            String paramStr = request.getRequestURI();
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (parameterMap.isEmpty()) {
                paramStr += IOUtils.toString(request.getInputStream(), "UTF-8");
            } else {
                paramStr += mapper.writeValueAsString(request.getParameterMap());
            }
            String redisKey = "WEB_DATA_" + DigestUtils.md5Hex(paramStr);
            return redisKey;
        }
    }

注册拦截器到Spring容器：

import cn.itcast.haoke.dubbo.api.interceptor.RedisCacheInterceptor;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
    
        @Autowired
        private RedisCacheInterceptor redisCacheInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(this.redisCacheInterceptor).addPathPatterns("/**");
        }
    }

出现了错误：

'message": "Required request body is missing: public java.util.Map<java.lang.Stringava.lang.Object>

错误分析：由于在拦截器中读取了输入流的数据，在request中的输入流只能读取一次，请求进去Controller时，输入流中已经没有数据了，导致获取不到数据。

如何解决？

#### **通过包装request解决** ####

编写HttpServletRequest的包装类：

import org.apache.commons.io.IOUtils;
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    /**
     * 包装HttpServletRequest
     */
    public class MyServletRequestWrapper extends HttpServletRequestWrapper {
    
        private final byte[] body;
    
        /**
         * Construct a wrapper for the specified request.
         *
         * @param request The request to be wrapped
         */
        public MyServletRequestWrapper(HttpServletRequest request) throws IOException {
            super(request);
            body = IOUtils.toByteArray(super.getInputStream());
        }
    
        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(getInputStream()));
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            return new RequestBodyCachingInputStream(body);
        }
    
        private class RequestBodyCachingInputStream extends ServletInputStream {
            private byte[] body;
            private int lastIndexRetrieved = -1;
            private ReadListener listener;
    
            public RequestBodyCachingInputStream(byte[] body) {
                this.body = body;
            }
    
            @Override
            public int read() throws IOException {
                if (isFinished()) {
                    return -1;
                }
                int i = body[lastIndexRetrieved + 1];
                lastIndexRetrieved++;
                if (isFinished() && listener != null) {
                    try {
                        listener.onAllDataRead();
                    } catch (IOException e) {
                        listener.onError(e);
                        throw e;
                    }
                }
                return i;
            }
    
            @Override
            public boolean isFinished() {
                return lastIndexRetrieved == body.length - 1;
            }
    
            @Override
            public boolean isReady() {
                // This implementation will never block
                // We also never need to call the readListener from this method, as this method will never return false
                return isFinished();
            }
    
            @Override
            public void setReadListener(ReadListener listener) {
                if (listener == null) {
                    throw new IllegalArgumentException("listener cann not be null");
                }
                if (this.listener != null) {
                    throw new IllegalArgumentException("listener has been set");
                }
                this.listener = listener;
                if (!isFinished()) {
                    try {
                        listener.onAllDataRead();
                    } catch (IOException e) {
                        listener.onError(e);
                    }
                } else {
                    try {
                        listener.onAllDataRead();
                    } catch (IOException e) {
                        listener.onError(e);
                    }
                }
            }
    
            @Override
            public int available() throws IOException {
                return body.length - lastIndexRetrieved - 1;
            }
    
            @Override
            public void close() throws IOException {
                lastIndexRetrieved = body.length - 1;
                body = null;
            }
        }
    }

通过过滤器进行包装request对象：

import org.springframework.web.filter.OncePerRequestFilter;
    import javax.servlet.FilterChain;
    import javax.servlet.ServletException;
    
    
    /**
     * 替换Request对象
     */
    @Component
    public class RequestReplaceFilter extends OncePerRequestFilter {
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            if (!(request instanceof MyServletRequestWrapper)) {
                request = new MyServletRequestWrapper(request);
            }
            filterChain.doFilter(request, response);
        }
    }

#### **响应结果写入到缓存** ####

前面已经完成了缓存命中的逻辑，那么在查询到数据后，如果将结果写入到缓存呢？

通过ResponseBodyAdvice进行实现。

ResponseBodyAdvice是Spring提供的高级用法，会在结果被处理前进行拦截，拦截的逻辑自己实现，这样就可以实现拿到结果数据进行写入缓存的操作了。

具体实现：

import cn.itcast.haoke.dubbo.api.controller.GraphQLController;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.MethodParameter;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.http.MediaType;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.http.server.ServletServerHttpRequest;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    import java.time.Duration;
    
    @ControllerAdvice
    public class MyResponseBodyAdvice implements ResponseBodyAdvice {
    
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        private ObjectMapper mapper = new ObjectMapper();
    
        @Override
        public boolean supports(MethodParameter returnType, Class converterType) {
            if (returnType.hasMethodAnnotation(GetMapping.class)) {
                return true;
            }
    
            if (returnType.hasMethodAnnotation(PostMapping.class) &&
                    StringUtils.equals(GraphQLController.class.getName(), returnType.getExecutable().getDeclaringClass().getName())) {
                return true;
            }
    
            return false;
        }
    
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
            try {
                String redisKey = RedisCacheInterceptor.createRedisKey(((ServletServerHttpRequest) request).getServletRequest());
                String redisValue;
                if (body instanceof String) {
                    redisValue = (String) body;
                } else {
                    redisValue = mapper.writeValueAsString(body);
                }
                this.redisTemplate.opsForValue().set(redisKey, redisValue, Duration.ofHours(1));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return body;
        }
    }

#### **增加CORS的支持** ####

整合前端系统测试会发现，前面实现的拦截器中并没有对跨域进行支持，需要对CORS跨域支持：

import com.fasterxml.jackson.databind.ObjectMapper;
    import org.apache.commons.codec.digest.DigestUtils;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    @Component
    public class RedisCacheInterceptor implements HandlerInterceptor {
    
        private static ObjectMapper mapper = new ObjectMapper();
    
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
            if(StringUtils.equalsIgnoreCase(request.getMethod(), "OPTIONS")){
                return true;
            }
    
            // 判断请求方式，get还是post还是其他。。。
            if (!StringUtils.equalsIgnoreCase(request.getMethod(), "GET")) {
                // 非get请求，如果不是graphql请求，放行
                if (!StringUtils.equalsIgnoreCase(request.getRequestURI(), "/graphql")) {
                    return true;
                }
            }
    
            // 通过缓存做命中，查询redis，redisKey ?  组成：md5（请求的url + 请求参数）
            String redisKey = createRedisKey(request);
            String data = this.redisTemplate.opsForValue().get(redisKey);
            if (StringUtils.isEmpty(data)) {
                // 缓存未命中
                return true;
            }
    
            // 将data数据进行响应
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json; charset=utf-8");
    
            // =======================================================================================
            
            // 支持跨域
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
            response.setHeader("Access-Control-Allow-Credentials", "true");
            response.setHeader("Access-Control-Allow-Headers", "Content-Type,X-Token");
            response.setHeader("Access-Control-Allow-Credentials", "true");
    
            // =======================================================================================
            response.getWriter().write(data);
    
            return false;
        }
    
        public static String createRedisKey(HttpServletRequest request) throws
                Exception {
            String paramStr = request.getRequestURI();
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (parameterMap.isEmpty()) {
                paramStr += IOUtils.toString(request.getInputStream(), "UTF-8");
            } else {
                paramStr += mapper.writeValueAsString(request.getParameterMap());
            }
            String redisKey = "WEB_DATA_" + DigestUtils.md5Hex(paramStr);
            return redisKey;
        }
    }