线程间共享 部分变量 Spring框架下向异步线程传递HttpServletRequest参数

参考
https://www.jianshu.com/p/6bf1adb775e0
https://blog.csdn.net/kid551/article/details/88703414

需求场景，
当前请求会话中任意位置获取到当前的请求和会话数据
以下方数据举例

HttpSession session,
HttpServletRequest request ,
HttpServletResponse response

解决方法：使用ThreadLocal 存储

定义工具类暂时存储每一个ThreadLocal
定义的时候使用了多态，当前线程的子线程，子子孙孙都可以使用，
只是用ThreadLocal 的话， 只在当前线程生效

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class Const {
    private static ThreadLocal<HttpServletRequest> requests = new InheritableThreadLocal<HttpServletRequest>();
    private static ThreadLocal<HttpServletResponse> responses = new InheritableThreadLocal<HttpServletResponse>();
    private static ThreadLocal<HttpSession> sessions = new InheritableThreadLocal<HttpSession>();

    public static void setSession(HttpSession value){
        sessions.set(value);
    }

    public static HttpSession getSession(){
        return sessions.get();
    }

    public static HttpServletRequest getReq(){
        return requests.get();
    }

    public static void setReq(HttpServletRequest value){
        requests.set(value);
    }

    public static void setRes(HttpServletResponse value){
        responses.set(value);
    }
    public static HttpServletResponse getRes(){
        return responses.get();
    }
}

有了存储工具类， 只需要在请求到来时，拦截并存储下来就好了

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("过滤器执行了。。。。。");
        Const.setReq((HttpServletRequest)servletRequest);
        Const.setRes((HttpServletResponse)servletResponse);
        Const.setSession(((HttpServletRequest) servletRequest).getSession());
        filterChain.doFilter(servletRequest,servletResponse);
    }

在当前线程，或是当前线程的子线程中，直接使用就好了
异步或是多线程情况下

至于网络上的其他说法
使用

        // 将request设置为子线程共享
        ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        RequestContextHolder.setRequestAttributes(sra, true);

这部分代码类线程或是异步开始前设置，一定程度上是可行的，
一定程度指：当子线程执行完毕，主线程还存活，主线程中被传输的参数映射还没有被销毁的时候。

当主线程执行完毕，子线程却刚刚开启，主线程中的request对象可能已经被干掉了，子线程中获取seesion为null 只对于session

测试部分

    @RequestMapping("/testSession1")
    public void testSession1(HttpServletRequest request , HttpServletResponse response)throws Exception{
        testSession("普通调用",request.getSession(),request,response);
    }
    @RequestMapping("/testSession2")
    public void testSession2(HttpServletRequest request , HttpServletResponse response)throws Exception{
        new Thread(() -> {
            testSession("线程调用",request.getSession(),request,response);
        }).start();
    }
    @RequestMapping("/testSession3")
    public void testSession3(HttpServletRequest request , HttpServletResponse response)throws Exception{
        CompletableFuture.runAsync(() -> {
            testSession("异步调用",request.getSession(),request,response);
        });
    }

    @RequestMapping("/testSession4")
    public void testSession4(HttpServletRequest request , HttpServletResponse response)throws Exception{
        new Thread(() -> {
            testSession("线程调用",Const.getSession(),request,response);
        }).start();
    }

    @RequestMapping("/testSession5")
    public void testSession5(HttpServletRequest request , HttpServletResponse response)throws Exception{
        CompletableFuture.runAsync(() -> {
            testSession("异步调用",Const.getSession(),request,response);
        });
    }

    private void testSession(String str , HttpSession session,HttpServletRequest request , HttpServletResponse response){
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------"+str+"-------");
        System.out.println(session);
        System.out.println(request);
        System.out.println(response);
        System.out.println("-------"+str+"-------");
    }