20190829【Spring】RequestContextHolder简析

爱被打了一巴掌 2024-04-17 17:08 58阅读 0赞

在Web开发中，service层或者某个工具类中需要获取到HttpServletRequest对象还是比较常见的。一种方式是将HttpServletRequest作为方法的参数从controller层一直放下传递，不过这种有点费劲，且做起来不是优雅；还有另一种则是RequestContextHolder，直接在需要用的地方使用如下方式取HttpServletRequest即可，使用代码如下：

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
            .getRequestAttributes()).getRequest();

要理解上面的为何可以这么使用，需要理解两个问题：

1.  RequestContextHolder为什么能获取到当前的HttpServletRequest
2.  HttpServletRequest是在什么时候设置到RequestContextHolder

对于第1个问题，熟悉ThreadLocal的人应该很容易看出来这个是ThreadLocal的应用，这个类的原理[【][Link 1]在每个线程的内部有个数据结构为Map的threadLocals变量，以<ThreadLocal,Value>的形式保存着线程变量和其对应的值。[】][Link 1]

## ThreadLocal使用场景 ##

在实际项目中，可以用来减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度，因为servlet是单例多线程的，每个请求执行的操作都是同一个线程中。比如：可以用ThreadLocal来存每一次请求用户的信息，定义了一个类UserContextHolder

public class UserContextHolder{
        private static ThreadLocal<User> userContextHolder = new ThreadLocal<>();
        public static setUser(User user){
            userContextHolder.set(user);
        }
        public static User getUser(){
            return userContextHolder.get();
        }
        public static void remove(){
            return userContextHolder.remove();
        }
    }

当用户每次请求进来时，在拦截器中获取用户信息调用UserContextHolder.setUser()将其放到userContext中，无论在哪我们只要调用UserContextHolder.getUser()可以很轻松的获取到用户的信息，而不用在函数调用时一层一层的传递。同时在拦截器结束时调用UserContextHolder.remove()移除掉即可。

第2个问题应该属于spring-mvc的问题，这个是在spring-mvc执行时设置进去的

## RequestContextHolder源码分析 ##

首先我们先来看下RequestContextHolder的源码，源码如下：

public abstract class RequestContextHolder  {
    
        private static final ThreadLocal<RequestAttributes> requestAttributesHolder =
                new NamedThreadLocal<RequestAttributes>("Request attributes");
    
        private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder =
                new NamedInheritableThreadLocal<RequestAttributes>("Request context");
    
    
        public static void resetRequestAttributes() {
            requestAttributesHolder.remove();
            inheritableRequestAttributesHolder.remove();
        }
    
    
        public static void setRequestAttributes(RequestAttributes attributes) {
            setRequestAttributes(attributes, false);
        }
    
        //将RequestAttributes对象放入到ThreadLocal中，而HttpServletRequest和HttpServletResponse等则封装在RequestAttributes对象中，在此处就不对RequestAttributes这个类展开。反正我们需要知道的就是要获取RequestAttributes对象，然后再从RequestAttributes对象中获取到我们所需要的HttpServletRequest即可
        public static void setRequestAttributes(RequestAttributes attributes, boolean inheritable) {
            if (attributes == null) {
                resetRequestAttributes();
            }
            else {
                if (inheritable) {
                    inheritableRequestAttributesHolder.set(attributes);
                    requestAttributesHolder.remove();
                }
                else {
                    requestAttributesHolder.set(attributes);
                    inheritableRequestAttributesHolder.remove();
                }
            }
        }
    
        public static RequestAttributes getRequestAttributes() {
            RequestAttributes attributes = requestAttributesHolder.get();
            if (attributes == null) {
                attributes = inheritableRequestAttributesHolder.get();
            }
            return attributes;
        }
    
    }

那么在spring-mvc中是怎么实现的呢，我们来简单分析的，想了解具体机制的可以去看看spring-mvc的源码。

我们看下FrameworkServlet这个类，也就是DispatcherServlet的父类，里面有个processRequest方法，根据方法名称我们也可以大概了解到这个是方法用于处理请求的。

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
    
            long startTime = System.currentTimeMillis();
            Throwable failureCause = null;
    
            LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
            LocaleContext localeContext = buildLocaleContext(request);
    
            RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
            ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    
            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    
            //将RequestAttributes设置到RequestContextHolder
            initContextHolders(request, localeContext, requestAttributes);
    
            try {
                //具体的业务逻辑
                doService(request, response);
            }
            catch (ServletException ex) {
                failureCause = ex;
                throw ex;
            }
            catch (IOException ex) {
                failureCause = ex;
                throw ex;
            }
            catch (Throwable ex) {
                failureCause = ex;
                throw new NestedServletException("Request processing failed", ex);
            }
    
            finally {
                //重置RequestContextHolder之前设置RequestAttributes
                resetContextHolders(request, previousLocaleContext, previousAttributes);
                if (requestAttributes != null) {
                    requestAttributes.requestCompleted();
                }
    
                if (logger.isDebugEnabled()) {
                    if (failureCause != null) {
                        this.logger.debug("Could not complete request", failureCause);
                    }
                    else {
                        if (asyncManager.isConcurrentHandlingStarted()) {
                            logger.debug("Leaving response open for concurrent processing");
                        }
                        else {
                            this.logger.debug("Successfully completed request");
                        }
                    }
                }
    
                publishRequestHandledEvent(request, response, startTime, failureCause);
            }
        }
        
        
        private void initContextHolders(
                HttpServletRequest request, LocaleContext localeContext, RequestAttributes requestAttributes) {
    
            if (localeContext != null) {
                LocaleContextHolder.setLocaleContext(localeContext, this.threadContextInheritable);
            }
            if (requestAttributes != null) {
                RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Bound request context to thread: " + request);
            }
        }

简单看下源码，我们可以知道HttpServletRequest是在执行doService方法之前，也就是具体的业务逻辑前进行设置的，然后在执行完业务逻辑或者抛出异常时重置RequestContextHolder移除当前的HttpServletRequest。

写本文的目的主要是记录下这个RequestContextHolder的使用，以及希望以后能在业务代码中巧用该工具让自己的代码更加简洁优雅。

[Link 1]: https://www.jianshu.com/p/6bf1adb775e0