實戰SpringCloud通用請求欄位攔截處理

背景

以SpringCloud構建的微服務系統為例，使用前後端分離的架構，每個系統都會提供一些通用的請求引數，例如移動端的系統版本資訊、IMEI資訊，Web端的IP資訊，瀏覽器版本資訊等，這些引數可能放在header裡，也可以放在引數裡，如果這些引數需要在每個方法內宣告定義，一來工作量太大，二是這些通用引數與業務介面方法耦合過緊，本身就是一個不好的設計。

這個問題該如何優雅地解決呢？

最佳實踐

實現思路

• 利用SpringMVC提供攔截器，對匹配的請求，抽取通用的header資訊（假設通用欄位全部放在header裡）
• 將每個請求的資訊單獨隔離開，互不干擾。
• Controller層使用時，可以將在該請求執行緒(http執行緒)裡將通用的header資訊提取出來使用。
• 請求執行緒完成時，相應的header頭資訊物件需要回收銷燬。

實現方式

• SpringMVA提供的HandlerInterceptorAdapter可以拿來使用，繼承實現即可。
• 使用ThreadLocal記錄每個請求的資訊，ThreadLocal有隔離執行緒變數的作用。

HandlerInterceptorAdapter的原始碼實現及註釋

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
        // 在業務介面方法處理之前被呼叫，可以在這裡對通用的header資訊進行提取
		return true;
	}

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
		// 這個方法在業務介面方法執行完成後，生成SpringMVC ModelAndView之前被呼叫
		// 今天這個案例我們不用此方法，故可以不實現。
	}
	
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
		// 這個方法在DispatcherServlet完全處理完成後被呼叫，可以在這裡對ThreadLocal的內容進行釋放
	}

	@Override
	public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
		// 這個方法用來處理非同步主動，但也會先行呼叫preHandle，然後執行此方法，非同步執行緒完成後會執行postHandle和afterCompletion兩方法，這裡暫時用不上。
	}
}

ThreadLocal的原始碼主要實現及註釋

public class ThreadLocal<T> {
    
    protected T initialValue() {
        return null;
    }

    public T get() {
		// 獲取當前的執行緒
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

    public void set(T value) {
		// 獲取當前的執行緒
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
}

簡單來說，ThreadLocal最關鍵的get()和set()方法，都是針對當前執行緒來操作的，呼叫set()方法時把值放到ThreadMap(Map的一種實現)中，以當前執行緒的hash值為key，get()方法則對應以當前執行緒作為key來取值，從而實現每個執行緒的資料是隔離的效果。

另附上ThreadLocal類原始碼解讀的導圖，僅供參考

案例實戰

我們對實際業務系統進行簡化處理，假定header資訊固定有ip，uid，deviceId三個資訊，按照上文的實現思路，開始案例演示。

DTO定義

通用的header資訊，使用Dto物件進行封裝：

@Data
public class CommonHeader implements Serializable {

	private static final long serialVersionUID = -3949488282201167943L;
	
	/**
	 * 真實ip
 	 */
	private String ip;

	/**
	 * 裝置id
 	 */
	private String deviceId;

	/**
	 * 使用者uid
 	 */
	private Long uid;
	
	// 省略getter/setter/構造器
}

定義Request請求的封裝類Dto，並引入ThreadLocal：

/**
 * 將公共請求頭資訊放在ThreadLocal中去
 */
public class RequestWrap {

	private static ThreadLocal<CommonHeader> current = new ThreadLocal<>();

    /**
	 * 獲取靜態的ThreadLocal物件
	 * @return
	 */
	public static ThreadLocal<CommonHeader> getCurrent() {
		return current;
	}
	
	/**
	 * 獲取ip
	 * @return
	 */
	public static String getIp() {
		CommonHeader request = current.get();
		if (request == null) {
			return StringUtils.EMPTY;
		}
		return request.getIp();
	}

	/**
	 * 獲取uid
	 * @return
	 */
	public static Long getUid() {
		CommonHeader request = current.get();
		if (request == null) {
			return null;
		}
		return request.getUid();
	}

	/**
	 * 獲取封裝物件
	 * @return
	 */
	public static CommonHeader getCommonReq() {
		CommonHeader request = current.get();
		if (request == null) {
			return new CommonHeader(StringUtils.EMPTY, StringUtils.EMPTY,0L);
		}
		return request;
	}
}

工具類

這裡新增一個簡單的工具類，將HttpServletRequest通過getHeader方法，生成CommonHeader類：

public class HttpUtil {
	/**
	 * 獲取請求頭資訊
	 *
	 * @param request
	 * @return
	 */
	public static CommonHeader getCommonHeader(HttpServletRequest request) {
		String UID = request.getHeader("uid");
		Long uid = null;
		if (StringUtils.isNotBlank(UID)) {
			uid = Long.parseLong(UID);
		}
		return new CommonHeader(HttpUtil.getIp(request), request.getHeader("deviceId"), uid);
	}

	/**
	 * 獲取IP
	 *
	 * @param request
	 * @return
	 */
	public static String getIp(HttpServletRequest request) {
		String ip = request.getHeader("X-Forwarded-For");

		if (null != ip && !"".equals(ip.trim()) && !"unknown".equalsIgnoreCase(ip)) {
			int index = ip.indexOf(',');
			if (index != -1) {
				return ip.substring(0, index);
			} else {
				return ip;
			}
		}
		ip = request.getHeader("X-Real-IP");
		if (null != ip && !"".equals(ip.trim()) && !"unknown".equalsIgnoreCase(ip)) {
			return ip;
		}
		return request.getRemoteAddr();
	}
}

攔截器類實現

最核心的實現終於出場了，這裡繼承HandlerInterceptorAdapter，這裡作了簡化處理：

/**
 * 請求頭處理
 *
 * @author yangfei
 */
@Component
public class BaseInterceptor extends HandlerInterceptorAdapter {

	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BaseInterceptor.class);


	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		RequestWrap.getThreadLocal().set(HttpUtil.getCommonHeader(request));
		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 {
		RequestWrap.getThreadLocal().remove();
	}

	@Override
	public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	}
}

如上一章節描述的邏輯，在preHandle方法內將request中的ip,uid,deviceId封裝到RequestWrap物件裡，在afterCompletion中對該執行緒的ThreadLocal值進行釋放。

業務介面方法的使用

在Controller類的介面方法中，如要獲取uid資訊，只需要呼叫RequestWrap.getUid()方法即可，再也不需要在每個介面上宣告uid引數了，如下示例：

/**
 * 獲取使用者基礎資訊
 */
@PostMapping(value = "/user/info")
public Response<UserInfo> getUserInfo() {
	return userManager.getUserInfo(RequestWrap.getUid());
}

總結

這個實戰的目標是解決通用header資訊的在介面的重複定義問題，基於HandlerInterceptorAdapter攔截器的實現，ThreadLocal對執行緒訪問資料的隔離來實現的，在實際生產專案應用中有很好的借鑑意義，希望對你有幫助。

專注Java高併發、分散式架構，更多技術乾貨分享與心得，請關注公眾號：Java架構社群
可以掃左邊二維碼新增好友，邀請你加入Java架構社群微信群共同探討技術