TransmittableThreadLocal应用（当前线程及子线程获得最新信息）

• 使用TransmittableThreadLocal保存当前请求用户信息到方法中，方便获取当前用户信息

package com.zhey.common.base;

import com.alibaba.ttl.TransmittableThreadLocal;
import com.orchard.common.constants.CommonConstants;
import com.orchard.common.util.ValidUtil;

import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;

public class baseContextHandler {
    
    
    static TransmittableThreadLocal> threadLocal = new TransmittableThreadLocal<>();
    
    public static void set(String key, Object value) {
        Map map = threadLocal.get();
        if (map == null) {
            map = new HashMap<>();
            threadLocal.set(map);
        }
        map.put(key, value);
    }
    
    public static Object get(String key){
        Map map = threadLocal.get();
        if (map == null) {
            map = new HashMap<>();
            threadLocal.set(map);
        }
        return map.get(key);
    }
    
    public static void remove(){
        threadLocal.remove();
    }
    
    
    public static BigInteger getUserID(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_ID);
        return value==null?BigInteger.valueOf(0):new BigInteger(value.toString());
    }
    
    public static String getUserAccount(){
        Object value = get(CommonConstants.CONTEXT_KEY_Account);
        return returnObjectValue(value);
    }
    
    public static String getUsername(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_NAME);
        return returnObjectValue(value);
    }

    public static Integer getLoginSource(){
        Object value = get(CommonConstants.LOGIN_SOURCE);
        return value==null?0:Integer.valueOf(returnObjectValue(value));
    }

    public static Integer getRequestSource() {
        Object value = get(CommonConstants.LOGIN_SOURCE);
        if (ValidUtil.isEmpty(value)) {
            return null;
        }
        return value==null?0:Integer.valueOf(returnObjectValue(value))-1;
    }

    public static String getToken(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_TOKEN);
        return returnObjectValue(value);
    }
    
    public static void setToken(String token){
		set(CommonConstants.CONTEXT_KEY_USER_TOKEN,token);
	}

    public static void setLoginSource(Integer source){
		set(CommonConstants.LOGIN_SOURCE,source);
	}

    public static void setName(String name){
		set(CommonConstants.CONTEXT_KEY_USER_NAME,name);
	}
    
    public static void setUserID(String userID){
        set(CommonConstants.CONTEXT_KEY_USER_ID,userID);
    }
    
    public static void setUserAccount(String username){
        set(CommonConstants.CONTEXT_KEY_Account,username);
    }
    
    private static String returnObjectValue(Object value) {
        return value==null?"":value.toString();
    }
    
    
    public static String getUserSession(){
        Object value = get(CommonConstants.CONTEXT_KEY_SESSION);
        return returnObjectValue(value);
    }
    
    public static void setUserSession(String userSession){
        set(CommonConstants.CONTEXT_KEY_SESSION,userSession);
    }
    
    public static Boolean isLogin()
    {
        if(ValidUtil.isEmpty(get(CommonConstants.JWT_TOKEN_HEADER)) || ValidUtil.isEmpty(get(CommonConstants.JWT_SPM_HEADER))) {
            return false;
        }
        return !get(CommonConstants.JWT_TOKEN_HEADER).toString().equals("")&&
                !get(CommonConstants.JWT_SPM_HEADER).toString().equals("");
    }
}

• 常量类

package com.orchard.common.constants;


public class CommonConstants {


    public static final String JWT_TOKEN_HEADER = "Authorization";


    public static final String JWT_SPM_HEADER = "Spm";
    
    
    public static final String CONTEXT_KEY_USER_ID = "currentUserId";
    
    
    public static final String CONTEXT_KEY_Account = "currentUserAccount";
    
    
    public static final String CONTEXT_KEY_SESSION = "currentUserSession";
    
    
    public static final String CONTEXT_KEY_USER_NAME = "currentUser";
    
    
    public static final String CONTEXT_KEY_USER_TOKEN = "currentUserToken";

    
    public static final String LOGIN_SOURCE = "loginSource";

}

• TransmittableThreadLocal赋值及销毁

package com.zhey.common.interceptor;

import com.orchard.common.annotation.IgnoreClientToken;
import com.orchard.common.base.baseContextHandler;
import com.orchard.common.constants.CommonConstants;
import com.orchard.common.entity.JWTInfo;
import com.orchard.common.exception.auth.ClientForbiddenException;
import com.orchard.common.jwt.JWTHelper;
import com.orchard.common.support.redis.RedisToken;
import com.orchard.common.util.ValidUtil;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.servlet.resource.ResourceHttpRequestHandler;

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


@Slf4j
public class ServiceAuthRestInterceptor extends HandlerInterceptorAdapter {
    @SuppressWarnings("unused")
    private Logger logger = LoggerFactory.getLogger(ServiceAuthRestInterceptor.class);
    
    @Autowired
    private RedisToken redisToken;

    private static final String HYSTRIX_WEB_PATH = "/hystrix";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        if(handler instanceof ResourceHttpRequestHandler) {
            throw new ClientForbiddenException("Client is Forbidden!");
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;

        String token = request.getHeader(CommonConstants.JWT_TOKEN_HEADER);
        String spm = request.getHeader(CommonConstants.JWT_SPM_HEADER);
        String session = request.getHeader(CommonConstants.BS_CRED);

		SetAuthTokenInfo(token, spm,session);

        return super.preHandle(request, response, handler);
    }

    
    private void SetAuthTokenInfo(String token, String spm,  String session) throws Exception {
    	//从jwt获取用户信息
        JWTInfo infoFromToken = JWTHelper.getInfoFromToken(token, spm.substring(0, 20));
        baseContextHandler.set(CommonConstants.JWT_TOKEN_HEADER, token);
        baseContextHandler.set(CommonConstants.JWT_SPM_HEADER, spm);
        baseContextHandler.setUserAccount(infoFromToken.getAccount());
        baseContextHandler.setName(infoFromToken.getUsername());
        baseContextHandler.setUserID(infoFromToken.getUserId());
        baseContextHandler.setLoginSource(infoFromToken.getTerminal());

        if(!ValidUtil.isEmpty(session)) {
            baseContextHandler.setUserSession(session);
        }
    }

	//线程结束，销毁当前线程数据
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        baseContextHandler.remove();
        super.afterCompletion(request, response, handler, ex);
    }
}

• 加入拦截器

package com.zhey.config;

import com.orchard.common.exception.GlobalExceptionHandler;
import com.orchard.common.interceptor.ServiceAuthRestInterceptor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebUserConfiguration implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(getServiceAuthRestInterceptor());
    }

    @Bean
    ServiceAuthRestInterceptor getServiceAuthRestInterceptor() {
        return new ServiceAuthRestInterceptor();
    }

}