@CrossOrigin
源码解析主要分为两个阶段:
① @CrossOrigin
注释的方法扫描注册。
② 请求匹配@CrossOrigin
注释的方法。
本文针对第②
阶段从源码角度进行解析,关于第①
阶段请参照《Spring 注解面面通 之 @CrossOrigin 注册处理方法源码解析》。
请求匹配@CrossOrigin
注释的方法
请求匹配@CrossOrigin
注释的方法流程:
1) DispatcherServlet.doDispatch(...)
、DispatcherServlet.getHandler(...)
、AbstractHandlerMapping.getHandler(...)
方法。
标题中所列方法在《Spring 注解面面通 之 @ModelAttribute 深入源码解析》均有介绍,可以查看进行参照,这里不再详细赘述。
2) AbstractHandlerMethodMapping.getCorsConfiguration(...)
方法。
① 若处理器为CorsConfigurationSource
类型,获取处理器CorsConfiguration
配置作为基础配置。
② 若处理方法为预处理方法,则返回默认配置CorsConfiguration
,其配置均为*
。
③ 若处理方法非预处理方法,根据处理方法查找CorsConfiguration
配置,同时与①
所得配置进行合并。
/**
* 获取CorsConfiguration.
*/
@Override
protected CorsConfiguration getCorsConfiguration(Object handler, HttpServletRequest request) {
// 若处理器为CorsConfigurationSource类型,直接获取处理器CorsConfiguration配置.
CorsConfiguration corsConfig = super.getCorsConfiguration(handler, request);
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 请求方法是预处理方法.
if (handlerMethod.equals(PREFLIGHT_AMBIGUOUS_MATCH)) {
return AbstractHandlerMethodMapping.ALLOW_CORS_CONFIG;
}
// 请求方法非预处理方法.
else {
// 根据处理器查找CorsConfiguration配置.
CorsConfiguration corsConfigFromMethod = this.mappingRegistry.getCorsConfiguration(handlerMethod);
// 合并corsConfig和corsConfigFromMethod.
corsConfig = (corsConfig != null ? corsConfig.combine(corsConfigFromMethod) : corsConfigFromMethod);
}
}
return corsConfig;
}
3) AbstractHandlerMapping.getCorsConfiguration(...)
方法。
若处理器为CorsConfigurationSource
类型,获取处理器CorsConfiguration
配置作为基础配置。
/**
* 检索给定处理程序的CORS配置.
* @param handler 处理器.
* @param request 当前请求.
* @return 处理程序的CORS配置,或者null(如果没有).
*/
@Nullable
protected CorsConfiguration getCorsConfiguration(Object handler, HttpServletRequest request) {
Object resolvedHandler = handler;
if (handler instanceof HandlerExecutionChain) {
resolvedHandler = ((HandlerExecutionChain) handler).getHandler();
}
if (resolvedHandler instanceof CorsConfigurationSource) {
return ((CorsConfigurationSource) resolvedHandler).getCorsConfiguration(request);
}
return null;
}
4) AbstractHandlerMethodMapping.MappingRegistry.getCorsConfiguration(...)
方法。
① 从HandlerMethod
解析实际的HandlerMethod
。
② 根据HandlerMethod
从corsLookup
中获取CorsConfiguration
配置。
/**
* 返回CORS配置.
* 线程安全并发使用.
*/
public CorsConfiguration getCorsConfiguration(HandlerMethod handlerMethod) {
// 解析实际的HandlerMethod.
HandlerMethod original = handlerMethod.getResolvedFromHandlerMethod();
// 从corsLookup中获取CorsConfiguration配置.
return this.corsLookup.get(original != null ? original : handlerMethod);
}
5) AbstractHandlerMapping.getCorsHandlerExecutionChain(...)
方法。
① 若请求为预处理请求,AbstractHandlerMapping.PreFlightHandler
作为处理器实现。
② 若请求非预处理请求,增加拦截器AbstractHandlerMapping.CorsInterceptor
对请求进行拦截处理。
/**
* 为CORS相关处理更新HandlerExecutionChain.
* 对于预处理请求,默认实现用一个简单的HttpRequestHandler替换所选的处理程序,
* 该处理程序调用配置的setCorsProcessor.
* 对于实际的请求,默认实现插入一个HandlerInterceptor,它进行CORS相关的检查并添加CORS头.
* @param request 当前请求.
* @param chain 处理链.
* @param config 适用的CORS配置(可能是null).
*/
protected HandlerExecutionChain getCorsHandlerExecutionChain(HttpServletRequest request,
HandlerExecutionChain chain, @Nullable CorsConfiguration config) {
// 是CORS预处理请求.
if (CorsUtils.isPreFlightRequest(request)) {
HandlerInterceptor[] interceptors = chain.getInterceptors();
chain = new HandlerExecutionChain(new PreFlightHandler(config), interceptors);
}
// 不是CORS预处理请求.
else {
chain.addInterceptor(new CorsInterceptor(config));
}
return chain;
}
6) AbstractHandlerMapping.PreFlightHandler
、AbstractHandlerMapping.CorsInterceptor
类。
① 若请求非CORS
请求,则跳过处理逻辑。
② 若响应已包含Access-Control-Allow-Origin
头,则跳过处理逻辑。
③ 若请求与服务同源,则跳过处理逻辑。
④ 当CORS
配置为null
时,若请求为预处理请求,则拒绝请求,否则跳过处理逻辑。
/**
* 处理请求.
*/
@Override
@SuppressWarnings("resource")
public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request,
HttpServletResponse response) throws IOException {
// 非CORS请求,不进行处理.
if (!CorsUtils.isCorsRequest(request)) {
return true;
}
// 响应已包含Access-Control-Allow-Origin,不进行处理.
ServletServerHttpResponse serverResponse = new ServletServerHttpResponse(response);
if (responseHasCors(serverResponse)) {
logger.debug("Skip CORS processing: response already contains \"Access-Control-Allow-Origin\" header");
return true;
}
// 请求来自同源,不进行处理.
ServletServerHttpRequest serverRequest = new ServletServerHttpRequest(request);
if (WebUtils.isSameOrigin(serverRequest)) {
logger.debug("Skip CORS processing: request is from same origin");
return true;
}
// 是否预处理请求.
boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
if (config == null) {
if (preFlightRequest) {
rejectRequest(serverResponse);
return false;
}
else {
return true;
}
}
// 请求处理方法.
return handleInternal(serverRequest, serverResponse, config, preFlightRequest);
}
① 获取请求Origin
头,检查并获取允许的源。
② 针对Vary
头,增加值:Origin
、Access-Control-Request-Method
、Access-Control-Request-Headers
。
③ 允许的源为空,则拒绝请求。
④ 获取请求方法,检查并获取允许的方法。
⑤ 允许的方法为空,则拒绝请求。
⑥ 获取请求头,检查并获取请求的头。
⑦ 若请求为预处理请求,且允许的头为空,拒绝请求。
⑧ 设置Access-Control-Allow-Origin
、Access-Control-Allow-Methods
、Access-Control-Allow-Headers
、Access-Control-Expose-Headers
、Access-Control-Allow-Credentials
、Access-Control-Max-Age
。
/**
* 请求处理方法.
*/
protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response,
CorsConfiguration config, boolean preFlightRequest) throws IOException {
// 获取请求的Origin头.
String requestOrigin = request.getHeaders().getOrigin();
// 检查并获取允许源.
String allowOrigin = checkOrigin(config, requestOrigin);
HttpHeaders responseHeaders = response.getHeaders();
// 增加Vary头,其值为:Origin、Access-Control-Request-Method、Access-Control-Request-Headers.
responseHeaders.addAll(HttpHeaders.VARY, Arrays.asList(HttpHeaders.ORIGIN,
HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
// 允许源为空,则拒绝请求.
if (allowOrigin == null) {
logger.debug("Rejecting CORS request because '" + requestOrigin + "' origin is not allowed");
rejectRequest(response);
return false;
}
// 获取请求方法.
HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
// 检查并获取允许的方法.
List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
// 允许方法为空,则拒绝请求.
if (allowMethods == null) {
logger.debug("Rejecting CORS request because '" + requestMethod + "' request method is not allowed");
rejectRequest(response);
return false;
}
// 获取请求头.
List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
// 检查并获取请求的头.
List<String> allowHeaders = checkHeaders(config, requestHeaders);
// 预处理请求,且允许的头为空,拒绝请求.
if (preFlightRequest && allowHeaders == null) {
logger.debug("Rejecting CORS request because '" + requestHeaders + "' request headers are not allowed");
rejectRequest(response);
return false;
}
// 设置允许的源.
responseHeaders.setAccessControlAllowOrigin(allowOrigin);
// 设置Access-Control-Allow-Methods.
if (preFlightRequest) {
responseHeaders.setAccessControlAllowMethods(allowMethods);
}
// 设置Access-Control-Allow-Headers.
if (preFlightRequest && !allowHeaders.isEmpty()) {
responseHeaders.setAccessControlAllowHeaders(allowHeaders);
}
// 设置Access-Control-Expose-Headers.
if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
}
// 设置Access-Control-Allow-Credentials.
if (Boolean.TRUE.equals(config.getAllowCredentials())) {
responseHeaders.setAccessControlAllowCredentials(true);
}
// 设置Access-Control-Max-Age.
if (preFlightRequest && config.getMaxAge() != null) {
responseHeaders.setAccessControlMaxAge(config.getMaxAge());
}
response.flush();
return true;
}
总结
只有在了解实现细节的情况下,才能解决那些棘手的问题。随着前后端分离程序变得极为普遍,@CrossOrigin
的应用变得尤为重要。
源码解析基于spring-framework-5.0.5.RELEASE
版本源码。
若文中存在错误和不足,欢迎指正!