SpringCloud通用请求字段拦截处理，一篇文章给你讲的明明白白

绝地灬酷狼 2024-04-03 09:52 30阅读 0赞

#### 背景 ####

以SpringCloud构建的微服务系统为例，使用前后端分离的架构，每个系统都会提供一些通用的请求参数，例如移动端的系统版本信息、IMEI信息，Web端的IP信息，浏览器版本信息等，这些参数可能放在header里，也可以放在参数里，如果这些参数需要在每个方法内声明定义，一来工作量太大，二是这些通用参数与业务接口方法耦合过紧，本身就是一个不好的设计。

这个问题该如何优雅地解决呢？

#### 最佳实践 ####

实现思路

*  利用SpringMVC提供拦截器，对匹配的请求，抽取通用的header信息（假设通用字段全部放在header里）
 *  将每个请求的信息单独隔离开，互不干扰。
 *  Controller层使用时，可以将在该请求线程(http线程)里将通用的header信息提取出来使用。
 *  请求线程完成时，相应的header头信息对象需要回收销毁。

实现方式

*  SpringMVA提供的HandlerInterceptorAdapter可以拿来使用，继承实现即可。
 *  使用ThreadLocal记录每个请求的信息，ThreadLocal有隔离线程变量的作用。

HandlerInterceptorAdapter的源码实现及注释

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            // 在业务接口方法处理之前被调用，可以在这里对通用的header信息进行提取
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                @Nullable ModelAndView modelAndView) throws Exception {
            // 这个方法在业务接口方法执行完成后，生成SpringMVC ModelAndView之前被调用
            // 今天这个案例我们不用此方法，故可以不实现。
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                @Nullable Exception ex) throws Exception {
            // 这个方法在DispatcherServlet完全处理完成后被调用，可以在这里对ThreadLocal的内容进行释放
        }
    
        @Override
        public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
                Object handler) throws Exception {
            // 这个方法用来处理异步主动，但也会先行调用preHandle，然后执行此方法，异步线程完成后会执行postHandle和afterCompletion两方法，这里暂时用不上。
        }
    }

ThreadLocal的源码主要实现及注释

public class ThreadLocal<T> {
    
        protected T initialValue() {
            return null;
        }
    
        public T get() {
            // 获取当前的线程
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }
    
        private T setInitialValue() {
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
            return value;
        }
    
        public void set(T value) {
            // 获取当前的线程
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
        }
    
         public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }
    
        ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }
    
        void createMap(Thread t, T firstValue) {
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }
    }

简单来说，ThreadLocal最关键的get()和set()方法，都是针对当前线程来操作的，调用set()方法时把值放到ThreadMap(Map的一种实现)中，以当前线程的hash值为key，get()方法则对应以当前线程作为key来取值，从而实现每个线程的数据是隔离的效果。

另附上ThreadLocal类源码解读的导图，仅供参考

![c48a69e44cdd8227c7b1bf074ecff6d3.png][]

#### 案例实战 ####

我们对实际业务系统进行简化处理，假定header信息固定有ip，uid，deviceId三个信息，按照上文的实现思路，开始案例演示。

DTO定义

通用的header信息，使用Dto对象进行封装：

@Data
    public class CommonHeader implements Serializable {
    
        private static final long serialVersionUID = -3949488282201167943L;
    
        /**
         * 真实ip
         */
        private String ip;
    
        /**
         * 设备id
         */
        private String deviceId;
    
        /**
         * 用户uid
         */
        private Long uid;
    
        // 省略getter/setter/构造器
    }

定义Request请求的封装类Dto，并引入ThreadLocal：

/**
     * 将公共请求头信息放在ThreadLocal中去
     */
    public class RequestWrap {
    
        private static ThreadLocal<CommonHeader> current = new ThreadLocal<>();
    
        /**
         * 获取静态的ThreadLocal对象
         * @return
         */
        public static ThreadLocal<CommonHeader> getCurrent() {
            return current;
        }
    
        /**
         * 获取ip
         * @return
         */
        public static String getIp() {
            CommonHeader request = current.get();
            if (request == null) {
                return StringUtils.EMPTY;
            }
            return request.getIp();
        }
    
        /**
         * 获取uid
         * @return
         */
        public static Long getUid() {
            CommonHeader request = current.get();
            if (request == null) {
                return null;
            }
            return request.getUid();
        }
    
        /**
         * 获取封装对象
         * @return
         */
        public static CommonHeader getCommonReq() {
            CommonHeader request = current.get();
            if (request == null) {
                return new CommonHeader(StringUtils.EMPTY, StringUtils.EMPTY,0L);
            }
            return request;
        }
    }

工具类

这里添加一个简单的工具类，将HttpServletRequest通过getHeader方法，生成CommonHeader类：

public class HttpUtil {
        /**
         * 获取请求头信息
         *
         * @param request
         * @return
         */
        public static CommonHeader getCommonHeader(HttpServletRequest request) {
            String UID = request.getHeader("uid");
            Long uid = null;
            if (StringUtils.isNotBlank(UID)) {
                uid = Long.parseLong(UID);
            }
            return new CommonHeader(HttpUtil.getIp(request), request.getHeader("deviceId"), uid);
        }
    
        /**
         * 获取IP
         *
         * @param request
         * @return
         */
        public static String getIp(HttpServletRequest request) {
            String ip = request.getHeader("X-Forwarded-For");
    
            if (null != ip && !"".equals(ip.trim()) && !"unknown".equalsIgnoreCase(ip)) {
                int index = ip.indexOf(',');
                if (index != -1) {
                    return ip.substring(0, index);
                } else {
                    return ip;
                }
            }
            ip = request.getHeader("X-Real-IP");
            if (null != ip && !"".equals(ip.trim()) && !"unknown".equalsIgnoreCase(ip)) {
                return ip;
            }
            return request.getRemoteAddr();
        }
    }

拦截器类实现

最核心的实现终于出场了，这里继承HandlerInterceptorAdapter，这里作了简化处理：

/**
     * 请求头处理
     *
     * @author yangfei
     */
    @Component
    public class BaseInterceptor extends HandlerInterceptorAdapter {
    
        private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BaseInterceptor.class);
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
            RequestWrap.getThreadLocal().set(HttpUtil.getCommonHeader(request));
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                ModelAndView modelAndView) throws Exception {
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {
            RequestWrap.getThreadLocal().remove();
        }
    
        @Override
        public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler)
                throws Exception {
        }
    }

如上一章节描述的逻辑，在preHandle方法内将request中的ip,uid,deviceId封装到RequestWrap对象里，在afterCompletion中对该线程的ThreadLocal值进行释放。

业务接口方法的使用

在Controller类的接口方法中，如要获取uid信息，只需要调用RequestWrap.getUid()方法即可，再也不需要在每个接口上声明uid参数了，如下示例：

/**
     * 获取用户基础信息
     */
    @PostMapping(value = "/user/info")
    public Response<UserInfo> getUserInfo() {
        return userManager.getUserInfo(RequestWrap.getUid());
    }

#### 总结 ####

这个实战的目标是解决通用header信息的在接口的重复定义问题，基于HandlerInterceptorAdapter拦截器的实现，ThreadLocal对线程访问数据的隔离来实现的，在实际生产项目应用中有很好的借鉴意义，希望对你有帮助。

[c48a69e44cdd8227c7b1bf074ecff6d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/a78743bf0afb4939bf8e4ad7637ed508.png