SpringBoot（十五）单个以及多个跨域的配置方法

同源策略是浏览器的一个安全限制，要求域名、协议、端口相同，如果不同则没办法进行数据交互。
而跨域配置，则是为了解除这方面的限制。
前后端分离的情况下，因为需要分开部署，后台开发基本都需要进行跨域配置了。
（当然，这也可以在 nginx 上处理，这里就不展开讨论了）

spring 提供的跨域拦截器是 CorsFilter，与 CorsFilter 强关联的类是 UrlBasedCorsConfigurationSource。

跨域配置实体类

参数介绍可以看代码注释

 * 跨域配置一览：
 * <p>
 * Access-Control-Allow-Origin:         允许访问的域名
 * Access-Control-Allow-Methods:        允许访问的请求方式
 * Access-Control-Allow-Headers:        允许使用的Header
 * Access-Control-Allow-Credentials:    是否允许用户发送、处理Cookie
 * Access-Control-Max-Age:              预检有效期，单位为秒。有效期内，不需要重复发送预检请求
 * Access-Control-Expose-Headers:       Header白名单，不设置的话，客户端读不到header的内容
 *
 * @author Mr.css
 * @date 2022-03-09 16:55
 */
public class CrossDomain implements Serializable {
    private static final long serialVersionUID = -3682297338044962128L;
    /**
     * 路径，Controller提供的接口
     */
    @Length(max = 64)
    @Schema(description = "路径")
    private String antPath;
    /**
     * 允许访问的IP
     */
    @Length(max = 64)
    @Schema(description = "允许访问的IP")
    private String allowedOrigin;
    /**
     * 开放请求头
     */
    @Length(max = 64)
    @Schema(description = "允许的请求头")
    private String allowedHeader;
    /**
     * 开放请求方式
     */
    @Length(max = 32)
    @Schema(description = "允许的请求方式")
    private String allowedMethod;
    /**
     * 白名单Header
     */
    @Length(max = 64)
    @Schema(description = "白名单Header")
    private String exposedHeader;
    /**
     * 预检请求有效期
     */
    @Schema(description = "预检请求有效期")
    private Integer maxAge;
    /**
     * 允许携带凭证
     */
    @Schema(description = "允许携带凭证")
    private Boolean allowCredentials;

    // 省略getter/setter
｝

Yml配置

YML配置方式，与实体类字段对应

boot-cross-domain:
  config:
      allowed-origin: 'http://localhost:8080'
      ant-path: '/**'
      allowed-header: '*'
      allowed-method: '*'
      allow-credentials: true

默认配置方式（单个跨域）

如果客户端不多，默认的配置就已经很好用了。

import cn.seaboot.common.core.CommonUtils;
import cn.seaboot.common.lang.Warning;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

/**
 * 跨域配置
 *
 * @author Mr.css
 * @date 2020-07-08 09:04
 **/
@Configuration
@ConfigurationProperties(prefix = "boot-cross-domain")
public class CrossDomainStarter {
    private Logger logger = LoggerFactory.getLogger(CrossDomainStarter.class);

    private CrossDomain config;

    public CrossDomain getConfig() {
        return config;
    }

    public void setConfig(CrossDomain config) {
        this.config = config;
    }

    @Bean
    @SuppressWarnings(Warning.UNCHECKED)
    public FilterRegistrationBean corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        logger.info("【Configuration】Cross domain setting: start...");
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        String origin = config.getAllowedOrigin();
        if (origin.endsWith("/") || origin.endsWith("\\")) {
            origin = origin.substring(0, origin.length() - 2);
        }
        corsConfiguration.addAllowedOrigin(origin);

        //AllowedHeader
        String allowHeader = config.getAllowedHeader();
        if (CommonUtils.isNotEmpty(allowHeader)) {
            for (String header : allowHeader.split(",")) {
                corsConfiguration.addAllowedHeader(header);
            }
        }

        //AllowedMethod
        String allowedMethod = config.getAllowedMethod();
        if (CommonUtils.isNotEmpty(allowedMethod)) {
            for (String method : allowedMethod.split(",")) {
                corsConfiguration.addAllowedMethod(method);
            }
        }//AllowedHeader
        String exposedHeader = config.getExposedHeader();
        if (CommonUtils.isNotEmpty(exposedHeader)) {
            for (String header : exposedHeader.split(",")) {
                corsConfiguration.addExposedHeader(header);
            }
        }

        //MaxAge
        if (config.getMaxAge() != null) {
            corsConfiguration.setMaxAge(config.getMaxAge().longValue());
        }

        //AllowCredentials
        if (config.getAllowCredentials() != null) {
            corsConfiguration.setAllowCredentials(config.getAllowCredentials());
        }
        logger.info("Cross domain using config: {}", config);
        source.registerCorsConfiguration(config.getAntPath(), corsConfiguration);
        logger.info("【Configuration】Cross domain setting: finish");
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new CorsFilter(source));
        filterRegistrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return filterRegistrationBean;
    }
}

配置多个跨域

 * Access-Control-Allow-Origin:         允许访问的域名
 * Access-Control-Allow-Methods:        允许访问的请求方式
 * Access-Control-Allow-Headers:        允许使用的Header
 * Access-Control-Allow-Credentials:    是否允许用户发送、处理Cookie

这些参数本身就可以配置多个，用逗号分隔即可。

增加更多的跨域配置

逗号拼接的方式，决定了功能上限，如果有很多个客户端，配置起来就会很乱，比如说，我有10个客户端要配置怎么办？
这种场景下，通常会选择直接使用通配符 *，放开跨域拦截，通过业务控制，或者通过鉴权系统控制。

虽说如此，强行实现一波，应当如何？

直接看源码，上面我们用到了 UrlBasedCorsConfigurationSource，
UrlBasedCorsConfigurationSource 的父类是 CorsConfigurationSource，
这个类，相当于Dao，参数是 request，根据 request 的内容查找对应的跨域配置。

我们可以自己实现一个 CorsConfigurationSource。
代码贴出来显得文章篇幅太大，而且代码功能单一，就是配置查询，这次就简单地说明一下，下面提供了伪代码作为参考。

    @Override
    @Nullable
    public CorsConfiguration getCorsConfiguration(@NotNull HttpServletRequest request) {
        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
        // 获取客户端域名
        String origin = request.getHeader(HttpHeaders.ORIGIN);
        // TODO: 根据客户端的域名，查找CorsConfiguration配置
        return null;
    }