Springboot项目中使用过滤器Filter+ThreadLocal实现对请求用户的拦截和保存

       由于jwt的出现，使请求方法的参数中不再携带用户的标识，而是将含有用户信息的token放入请求头中，在该请求进入业务之前就要进行层层过滤拦截，这时候就会牵扯出来了一个问题，如何在当前请求的线程中保存该请求用户的信息。

1. ThreadLocal

ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

       所以设计思路是，我们可以将每个访问的请求拦截下，为其分配线程变量，就先是全局变量一样，在这次请求访问的所有作用域处都可以从中拿出变量进行使用：

/**
*	存储/获取当前线程的用户信息工具类
*/
public abstract class UserUtils {

	//线程变量，存放user实体类信息，即使是静态的与其他线程也是隔离的
    private static ThreadLocal<User> userThreadLocal = new ThreadLocal<User>();

	//从当前线程变量中获取用户信息
    public static User getLoginUser() {
        User user = userThreadLocal.get();
        return user;
    }

    /**
     * 获取当前登录用户的ID
     * 未登录返回null
     *
     * @return
     */
    public static Long getLoginUserId() {
        User user = userThreadLocal.get();
        if (user != null && user.getId() != null) {
            return user.getId();
        }
        return null;
    }

 	//为当前的线程变量赋值上用户信息
    public static void setLoginUser(User user) {
        userThreadLocal.set(user);
    }

	//清除线程变量
    public static void removeUser() {
        userThreadLocal.remove();
    }
}

       我们可以看出LocalThread的应用场景：

1、在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

2、线程间数据隔离

3、进行事务操作，用于存储线程事务信息。

4、数据库连接，Session会话管理。

2. Filter中的使用

//接口业务均在api下
@WebFilter(filterName = "testFilter",urlPatterns = {"/api/*"})
public class CommonFilter implements Filter {
    private Logger logger = LoggerFactory.getLogger(AccessInterceptor.class);
    @Autowired
    private IUserService userService;

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String token = request.getHeader("Authorization");
        // 拿到token后，可以自行处理，这里假设从token获取到了id
        if(userId != null){
            User user = userService.getById(userId);
            UserUtils.setLoginUser(user);
        }else{
			UserUtils.setLoginUser(null);  
		}
        //执行,在后续的拦截器中还可以再进行权限拦截
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

3. 在拦截器中的使用

		// access为自定义权限注解，if条件指该接口访问权限至少要登录（具备token）
        if (access.level().getCode() >= AccessLevel.LOGIN.getCode()) {
        	//这里可以直接在拦截器中再次获取用户信息
            User user = UserUtils.getLoginUser();
            if (user == null || user.getId() == null) {
                response.setStatus(401);
                logger.info("access " + method.getName() + " Not logged in");
                return false;
            }
            if (user.getType() < access.level().getCode()) {
                response.setStatus(403);
                logger.info("access " + method.getName() + " No authority");
                return false;
            }
        }

4. Controller/Service层的使用

//在Controller或是Service中依然可以通过线程变量或取该用户信息
User user = UserUtils.getLoginUser();
long userId = UserUtils.getLoginUserId();

---

       我们可以看到，在进行对象跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。使用起来确实十分方便，但是也要有注意的地方：

上图详细的说明了ThreadLocal和Thread以及ThreadLocalMap三者之间的关系。

1、Thread中有一个map，即ThreadLocalMap。

2、ThreadLocalMap的key是ThreadLocal，值是我们自己赋值的。

3、ThreadLocal是一个弱引用，当为null时侯，会被当成垃圾回收。

4、如果我们ThreadLocal是null了，也就是要被垃圾回收器回收了，但是此时我们的ThreadLocalMap生命周期和Thread的一样，它不会回收，这时候就出现了一个现象。那就是ThreadLocalMap的key没了，但是value还在，这就造成了内存泄漏。

解决办法：使用完ThreadLocal后，即拦截器的后处理，执行remove操作，避免出现内存溢出情况。

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserUtils.removeUser();  //其中调用的就是 userThreadLocal.remove();
    }