SpringBoot-实现CORS跨域原理及解决方案

﹏ヽ暗。殇╰゛Y 2021-08-27 00:49 427阅读 0赞

Cors的原理就不介绍了，直接先上解决方案，以下转自 [https://segmentfault.com/a/1190000019550329][https_segmentfault.com_a_1190000019550329]

也可以看这个，[https://blog.csdn.net/c5113620/article/details/79132968][https_blog.csdn.net_c5113620_article_details_79132968]

[https://segmentfault.com/a/1190000012364985][https_segmentfault.com_a_1190000012364985]，[https://www.jianshu.com/p/470de10b9eec][https_www.jianshu.com_p_470de10b9eec]

### 比较好的方法：（同时设置过滤器顺序order，避免先加载其他filter导致的问题，同时可以解决拦截器与过滤器加载优先级的问题，可查看  ###

### 1、[https://blog.csdn.net/z69183787/article/details/109483337][https_blog.csdn.net_z69183787_article_details_109483337] ###

### 2、[https://blog.csdn.net/z69183787/article/details/53102398][https_blog.csdn.net_z69183787_article_details_53102398]  **CorsInterceptor**） ###

如果需要动态从配置中心获取 allowOrigin，可重写cosConfiguration的checkOrigin方法

@Configuration
    public class CorsConfig {
        @Bean
        public FilterRegistrationBean corsFilter() {
            UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
            CorsConfiguration config = new CorsConfiguration(){
                //动态匹配
                @Override
                public String checkOrigin(String requestOrigin) {
                    //TODO nacos配置中心获取，正则匹配
                    return null;
                }
            };
            config.setAllowCredentials(true);
            // 设置你要允许的网站域名，如果全允许则设为 *
            config.addAllowedOrigin("http://localhost");
            // 如果要限制 HEADER 或 METHOD 请自行更改
            config.addAllowedHeader("*");
            config.addAllowedMethod("*");
            source.registerCorsConfiguration("/**", config);
            FilterRegistrationBean bean = new FilterRegistrationBean(new CorsFilter(source));
            // 这个顺序很重要哦，为避免麻烦请设置在最前
            bean.setOrder(-1);
            return bean;
        }
    }

### 第一种办法（会造成与其他拦截器优先级加载的问题，导致跨域配置失效 [https://blog.csdn.net/z69183787/article/details/109483337][https_blog.csdn.net_z69183787_article_details_109483337]）: ###

import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    @Configuration
    public class CorsConfig implements WebMvcConfigurer {
    
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/**")
                    .allowedOrigins("*")
                    .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
                    .allowCredentials(true)
                    .maxAge(3600)
                    .allowedHeaders("*");
        }
    }

这种方式是全局配置的，网上也大都是这种解决办法，但是很多都是基于旧的spring版本，比如：

[Spring Boot如何解决前端的Access-Control-Allow-Origin跨域问题][Spring Boot_Access-Control-Allow-Origin]

文中**WebMvcConfigurerAdapter**在spring5.0已经被标记为Deprecated，点开源码可以看到：

/**
     * An implementation of {@link WebMvcConfigurer} with empty methods allowing
     * subclasses to override only the methods they're interested in.
     *
     * @author Rossen Stoyanchev
     * @since 3.1
     * @deprecated as of 5.0 {@link WebMvcConfigurer} has default methods (made
     * possible by a Java 8 baseline) and can be implemented directly without the
     * need for this adapter
     */
    @Deprecated
    public abstract class WebMvcConfigurerAdapter implements WebMvcConfigurer {}

像这种过时的类或者方法，spring的作者们一定会在注解上面说明原因，并告诉你新的该用哪个，这是非常优秀的编码习惯，点赞！

spring5最低支持到jdk1.8，所以注释中明确表明，你可以直接实现WebMvcConfigurer接口，无需再用这个适配器，因为jdk1.8支持接口中存在default-method。

--------------------

### 第二种办法: ###

import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    //缺省 /*
    @WebFilter(filterName = "CorsFilter")
    @Configuration
    public class CorsFilter implements Filter {
        @Override
        public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
            HttpServletResponse response = (HttpServletResponse) res;
            response.setHeader("Access-Control-Allow-Origin","*");
            response.setHeader("Access-Control-Allow-Credentials", "true");
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, PATCH, DELETE, PUT");
            response.setHeader("Access-Control-Max-Age", "3600");
            response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
            chain.doFilter(req, res);
        }
    }

这种办法，是基于过滤器的方式，方式简单明了，就是在response中写入这些响应头，好多文章都是第一种和第二种方式都叫你配置，其实这是没有必要的，只需要一种即可。

这里也吐槽一下，大家不求甚解的精神。

--------------------

### 第三种办法： ###

public class GoodsController {
    
        @CrossOrigin(origins = "http://localhost:4000")
        @GetMapping("goods-url")
        public Response queryGoodsWithGoodsUrl(@RequestParam String goodsUrl) throws Exception {}
    }

没错就是**@CrossOrigin**注解，点开注解

@Target({ ElementType.METHOD, ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface CrossOrigin {}

从元注解@Target可以看出，注解可以放在method、class等上面，类似RequestMapping，也就是说，整个controller下面的方法可以都受控制，也可以单个方法受控制。

也可以得知，这个是最小粒度的cors控制办法了，精确到单个请求级别。

--------------------

以上三种方法都可以解决问题，最常用的应该是第一种、第二种，控制在自家几个域名范围下足以，一般没必要搞得太细。

这三种配置方式都用了的话，谁生效呢，类似css中样式，就近原则，懂了吧。

所以在开发新项目时，不需要等联调时候，让前端来找你了，我早就解决了跨域问题。

\-----------------------------------------------------------------------------------------------

前戏搞定，现在开始研究第一种方案中，为何继承了WebMvcConfigurer并实现addCorsMapping方法就可以搞定cors

这个问题首先应该从SpringBoot是如何使用SpringMvc的默认配置开始说起：

1、大家都知道，SpringBoot简易化配置的背后是 “自动装配” 在生效，EnableAutoConfiguration 注解带来了自动装配的特性，在这里不深究其源码，最后他是从

protected static final String PATH = "META-INF/"
    			+ "spring-autoconfigure-metadata.properties";

这个文件里获取所有的需要完成自动装配的Configuration类的元数据的，进入这个文件我们发现有1个WebMvc开头的类

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration.xxxx

这个就是引导SpringMvc自动配置的Configuration类了，后面的xxx代表自动装配这个配置项需要满足的条件，包含了Bean的前后序，ConditionalOnClass依赖类等等，一般通过以上这种方式，我们可以反查出某些 boot 默认自动配置的Configuration类。

原理其实很简单，在自动装配的过程中，根据带有@Configurtaion注解的配置类与 “PATH” 中匹配的内容进行比较，再经过筛选后才会决定是否加载配置类及内部的带有@Bean注解Bean实例。

2、接下来分析WebMvcAutoConfiguration是如何解决跨域的设置问题的，看一下部分的源码

@Configuration
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
    		ValidationAutoConfiguration.class })
    public class WebMvcAutoConfiguration {

和我们猜想的一样，是一个带有@Configuration注解的配置类，然后找一下我们关心的Cors在哪。

3、其实这个类中还有一个内部类，发现很多AutoConfiguration自动装配类中的类结构都差不多，内嵌一个Adapter类，并且Adapter类中使用@Import注解 引入了另一个 配置主类，如下所示：

内部类：WebMvcAutoConfigurationAdapter：

// Defined as a nested config to ensure WebMvcConfigurer is not read when not
    	// on the classpath
    	@Configuration
    	@Import(EnableWebMvcConfiguration.class)
    	@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
    	@Order(0)
    	public static class WebMvcAutoConfigurationAdapter
    			implements WebMvcConfigurer, ResourceLoaderAware {

import类：

/**
    	 * Configuration equivalent to {@code @EnableWebMvc}.
    	 */
    	@Configuration
    	public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {

贴一下类的层次结构，可以明显的看到它的继承情况：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70][]  
可以看到 上面标注了一句，与@EnableWebMvc相同。在这里多说一句，@EnableWebMvc可以显示的申明MVC的配置，用来替代boot默认自动装配的Configuration，其实他们两个的实现是一致的，都是DelegatingWebMvcConfiguration。

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(DelegatingWebMvcConfiguration.class)
    public @interface EnableWebMvc {
    }

4、接下来言归正传，看看EnableWebMvcConfiguration中有没有和跨域相关的配置类，经过一番查看，发现如下代码应该与CORS有关：RequestMappingHandlerMapping正是处理Request请求相关的处理类，进入父类的父类WebMvcConfigurationSupport查看

@Bean
    @Primary
    @Override
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
    	// Must be @Primary for MvcUriComponentsBuilder to work
    	return super.requestMappingHandlerMapping();
    }

发现了这段代码：getCorsConfigurations可以明显感觉到这应该和cors的配置相关

@Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
    	RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
    	mapping.setOrder(0);
    	mapping.setInterceptors(getInterceptors());
    	mapping.setContentNegotiationManager(mvcContentNegotiationManager());
    	mapping.setCorsConfigurations(getCorsConfigurations());

我们继续进入这个方法内部一探究竟：

protected final Map<String, CorsConfiguration> getCorsConfigurations() {
    	if (this.corsConfigurations == null) {
    		CorsRegistry registry = new CorsRegistry();
    		addCorsMappings(registry);
    		this.corsConfigurations = registry.getCorsConfigurations();
    	}
    	return this.corsConfigurations;
    }

看到了熟悉的addCorsMappings方法，和解决方案中第一个答案的实现方法一模一样。那他们是怎么发生关系的呢？

5、进入addCorsMappings方法，这次WebMvcConfigurationSupport没有对这个方法进行实现，由一级子类DelegatingWebMvcConfiguration进行了实现，我们进入这个类

@Override
    protected void addCorsMappings(CorsRegistry registry) {
    	this.configurers.addCorsMappings(registry);
    }

发现是this.configures调用了这个方法，往上找到configures属性，一切都恍然大悟了

@Configuration
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    
    	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    
    
    	@Autowired(required = false)
    	public void setConfigurers(List<WebMvcConfigurer> configurers) {
    		if (!CollectionUtils.isEmpty(configurers)) {
    			this.configurers.addWebMvcConfigurers(configurers);
    		}
    	}

WebMvcConfigurerComposite的关键方法：delegates 保存了WebConfigurer实现类的委托

class WebMvcConfigurerComposite implements WebMvcConfigurer {
    
    	private final List<WebMvcConfigurer> delegates = new ArrayList<>();
    
    
    	public void addWebMvcConfigurers(List<WebMvcConfigurer> configurers) {
    		if (!CollectionUtils.isEmpty(configurers)) {
    			this.delegates.addAll(configurers);
    		}
    	}
    
    	@Override
    	public void addCorsMappings(CorsRegistry registry) {
    		for (WebMvcConfigurer delegate : this.delegates) {
    			delegate.addCorsMappings(registry);
    		}
    	}

明显看到，@Autowired注解将所有实现了WebMvcConfigurer接口的类，包括了方案一中自定义的cors实现类自动注入了到了属性configures中。配合我们在第4步中在 new RequestMappingHandlerMapping 的时候一层层调用，最终注入了cors配置

new RequestMappingHandlerMapping  ->  getCorsConfigurations() -> addCorsMappings()

实际项目运行时，会从CorsRegistry中获取cors配置，并在response时使用。

/**
     * Assists with the registration of global, URL pattern based
     * {@link CorsConfiguration} mappings.
     *
     * @author Sebastien Deleuze
     * @author Rossen Stoyanchev
     * @since 4.2
     * @see CorsRegistration
     */
    public class CorsRegistry {
    
    	private final List<CorsRegistration> registrations = new ArrayList<>();
    
    
    	/**
    	 * Enable cross-origin request handling for the specified path pattern.
    	 *
    	 * <p>Exact path mapping URIs (such as {@code "/admin"}) are supported as
    	 * well as Ant-style path patterns (such as {@code "/admin/**"}).
    	 * <p>By default, all origins, all headers, credentials and {@code GET},
    	 * {@code HEAD}, and {@code POST} methods are allowed, and the max age
    	 * is set to 30 minutes.
    	 *
    	 * <p>The following defaults are applied to the {@link CorsRegistration}:
    	 * <ul>
    	 *     <li>Allow all origins.</li>
    	 *     <li>Allow "simple" methods {@code GET}, {@code HEAD} and {@code POST}.</li>
    	 *     <li>Allow all headers.</li>
    	 *     <li>Set max age to 1800 seconds (30 minutes).</li>
    	 * </ul>
    	 */
    	public CorsRegistration addMapping(String pathPattern) {
    		CorsRegistration registration = new CorsRegistration(pathPattern);
    		this.registrations.add(registration);
    		return registration;
    	}
    
    	/**
    	 * Return the registered {@link CorsConfiguration} objects,
    	 * keyed by path pattern.
    	 */
    	protected Map<String, CorsConfiguration> getCorsConfigurations() {
    		Map<String, CorsConfiguration> configs = new LinkedHashMap<>(this.registrations.size());
    		for (CorsRegistration registration : this.registrations) {
    			configs.put(registration.getPathPattern(), registration.getCorsConfiguration());
    		}
    		return configs;
    	}
    
    }

最后，给到几段源码，它们是真正使用CorsRegistry对请求作出处理的实现和过程。再深层次的细节内容大家可以自行阅读源码及DefaultCorsProcessor类，谢谢

//作为RequestMappingHandlerMapping的父类，掌控着cors的请求和响应
    public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport implements HandlerMapping, Ordered {
    
    //所有的corsRegistry最终都会进入这个属性中
    private final UrlBasedCorsConfigurationSource globalCorsConfigSource = new UrlBasedCorsConfigurationSource();
    
    //实际拦截请求进行cors处理的地方，
    	protected HandlerExecutionChain getCorsHandlerExecutionChain(HttpServletRequest request,
    			HandlerExecutionChain chain, @Nullable CorsConfiguration config) {
            //如果是预检请求
    		if (CorsUtils.isPreFlightRequest(request)) {
    			HandlerInterceptor[] interceptors = chain.getInterceptors();
    			chain = new HandlerExecutionChain(new PreFlightHandler(config), interceptors);
    		}
            //正常请求
    		else {
    			chain.addInterceptor(new CorsInterceptor(config));
    		}
    		return chain;
    	}

可以看到，这种方式下，cors是通过 拦截器的模式 进行跨域配置的，所以会造成与其他拦截器加载顺序导致 失效 ，参照：[https://blog.csdn.net/z69183787/article/details/109483337][https_blog.csdn.net_z69183787_article_details_109483337]

[https_segmentfault.com_a_1190000019550329]: https://segmentfault.com/a/1190000019550329
[https_blog.csdn.net_c5113620_article_details_79132968]: https://blog.csdn.net/c5113620/article/details/79132968
[https_segmentfault.com_a_1190000012364985]: https://segmentfault.com/a/1190000012364985?utm_source=Weibo&amp;utm_medium=shareLink&amp;utm_campaign=socialShare
[https_www.jianshu.com_p_470de10b9eec]: https://www.jianshu.com/p/470de10b9eec
[https_blog.csdn.net_z69183787_article_details_109483337]: https://blog.csdn.net/z69183787/article/details/109483337
[https_blog.csdn.net_z69183787_article_details_53102398]: https://blog.csdn.net/z69183787/article/details/53102398
[Spring Boot_Access-Control-Allow-Origin]: https://blog.csdn.net/tiangongkaiwu152368/article/details/81099169
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3o2OTE4Mzc4Nw_size_16_color_FFFFFF_t_70]: /images/20210527/111013aa45e94020b98c1b5ee840f865.png