tomcat问题记录-线程池引发的问题

拦截器配置

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/luxury/**" />
            <bean class="com.web.intercepter.ReqContextInterceptor" />
        </mvc:interceptor>
        <!-- <mvc:interceptor>
            <mvc:mapping path="/laundry/**" />
            <bean class="com.web.intercepter.ReqContextInterceptor" />
        </mvc:interceptor> -->
    </mvc:interceptors>

拦截器代码

/**
 * 拦截器--记录当前请求的request/reponse
 * 
 * @author zhujunchao
 */
public class ReqContextInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 统一处理逻辑
        RequestResponseContext.setRequestAndResponse(request,response);
        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 {
    }
}

RequestResponseContext代码

/**
 * 存放当前请求的request、response
 */
public class RequestResponseContext {
    private static ThreadLocal<HttpServletRequest> request_threadLocal = new ThreadLocal<HttpServletRequest>();

    private static ThreadLocal<HttpServletResponse> reponse_threadLocal = new ThreadLocal<HttpServletResponse>();

    private RequestResponseContext() {}

    public static void setRequestAndResponse(HttpServletRequest request,HttpServletResponse response) {
        request_threadLocal.set(request);
        reponse_threadLocal.set(response);
    }

    public static void clearRequestAndResponse() {
        request_threadLocal.remove();
        reponse_threadLocal.remove();
    }

    public static HttpServletRequest getRequest() {
        return request_threadLocal.get();
    }

    public static HttpServletResponse getResponse() {
        return reponse_threadLocal.get();
    }
}

页面1：/luxury/index?serviceCode=8002

    @RequestMapping(value = "/luxury/index")
    public String goodsList(IndexRequestVo reqVo) {
        RequestResponseContext.getResponse().addCookie("serviceCode", String.valueOf(serviceCode));
        return "/luxury/index";
    }

页面2：/laundry/index?serviceCode=8001

    @RequestMapping(value = "/laundry/index")
    public String goodsList(IndexRequestVo reqVo) {
        RequestResponseContext.getResponse().addCookie("serviceCode", String.valueOf(serviceCode));
        return "/laundry/index";
    }

因为没有对：/laundry 进行拦截，出现了

　　请求1：/laundry/index?serviceCode=8001...

　　请求2：访问/luxury/index?serviceCode=8002  查看cookie的serviceCode值为8001（应该为8002）

原因：

1.请求1：  ReqContextInterceptor 没有对 /laundry/* 进行拦截，即没有在RequestResponseContext（ThreadLocal）中 存放当前请求的request、response

2.请求1：  在调用RequestResponseContext.getResponse() 实际上获取的是由/luxury/*请求放入的response-->因为处理请求使用的是线程池里获取的线程

　　　　　　这时 response实际上是/luxury/*请求的response

3.请求1：调用response.addCookie,写值 serviceCode=8001

流程：

1.　　/luxury/index?serviceCode=8002   请求，将response放入ThreadLocal中，写入cookie（serviceCode=8002）======>请求结束

2.　　/laundry/index?serviceCode=8001 请求，因为没有写ThreadLocal 且同（1） 用的是同一个现成  从ThreadLocal中获取到（1）中的response

　　　　写入cookie（serviceCode=8001）======>请求结束

猜测两种情况：

1》请求（2）写请求（1） 的response 导致请求(1)看到的cookie值改变

2》请求（3）请求（1） 重新刷新页面 -->（新的response，新的线程），因为请求（2）的response和请求（3）的response 指向同一个用户、页面，请求（2）的response后执行addCookie(serviceCode=8001)，导致请求（1）或（3）最终看的的是cookie(serviceCode=8001)

具体需要研究response 和socket io流  这块还不熟。。。。。。