Spring 注解面面通 之 @CrossOrigin 处理请求源码解析

  @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版本源码。

  若文中存在错误和不足，欢迎指正！