跨域-告别CORS烦恼

跨域-告别CORS烦恼

1-参考网址

• Cors办理跨域哀求题目
  
• SpringBoot3跨域方案详解
  

---

2-思绪整理

1-核心题目

• 1）什么是跨域-为什么要搞一个跨域
  
• 2）简单哀求/非简单哀求
  
• 3）理论上怎样办理跨域题目
  
• 4）Java怎样办理跨域题目
  

2-个人思索

• 1）为什么有CORS跨域->最简单的表明：前端和后端最好是摆设在同一个服务器上，前后端之间利用内网IP举行访问，克制后端的API接口被其他网站访问（同源计谋）
  
• 2）但我们为什么没有如许做->多种缘故原由：①前后端分离架构 ②后端多实例容灾 ③等等其他元素 ->前后端分析引发征象：前端必须利用IP大概域名举行访问后端
  
• 3）又引发运维上的题目->后端的IP大概域名会变，但是前端又不能总是更换后端IP大概域名->一劳永逸的办理方案：后端直接全部放开API的接口调用
  
• 4）域名不校验岂不是要翻天->办理方案：①前后端鉴权利用API-KEY大概其他鉴权步调 ②公有云的防御服务
  
• 5）那为什么我当地开发可以访问许多网站的API接口->由于开发职员没有留意这些情况，大概网站本身就是对外提供API访问的网站
  

3-脑洞打开

• 1）开发侧-如果我做静态个人网站，我怎样举行跨域限定（防止网站被恶意攻击）
  
• 2）开发侧-如果我做SDK服务型网站，我怎样举行跨域限定（防止网站被恶意攻击）
  
• 3）爬虫侧-如和克制网站的API接口被爬取，怎样界说本身的robots.txt
  

---

4-个人思索-修正版

你的明白总体上是精确的，但有一些地方可以进一步美满和修正：
1-个人思索

• 为什么有CORS跨域
  
  
  
  • 最简单的表明
    ：前端和后端最好是摆设在同一个服务器上，前后端之间利用内网IP举行访问，克制后端的API接口被其他网站访问（同源计谋）。这个说法根本精确，但同源计谋不光是为了克制后端API被其他网站访问，更是为了掩护用户的数据安全，防止恶意网站通过用户欣赏器偷取敏感信息。
    
  • 同源计谋：欣赏器的同源计谋限定了一个文档或脚本从一个源访问另一个源的资源，除非满意同源条件（协议、域名、端口都雷同）。这是欣赏器提供的一种安全机制，用于防止恶意网站读取其他网站的敏感数据。
    
  
  
• 但我们为什么没有如许做
  
  
  
  • 多种缘故原由：
    
    
    
    • 前后端分离架构：今世Web开发中，前后端分离架构很常见，前端负责展示和交互，后端负责数据处理惩罚和业务逻辑，两者通常摆设在差别的服务器上。
      
    • 后端多实例容灾：为了进步体系的可用性和可靠性，后端大概有多个实例摆设在差别的服务器或数据中心，前端须要访问差别的后端实例。
      
    • 其他元素：比如微服务架构，差别的服务大概摆设在差别的服务器上，前端须要调用多个服务的API。
      
    
    
  • 前后端分析引发征象：前端必须利用IP大概域名举行访问后端。这个说法不完全正确，前端可以通过多种方式访问后端，比如通过域名、IP、负载均衡器等。
    
  
  
• 又引发运维上的题目
  
  
  
  • 后端的IP大概域名会变：确实，在实际运维中，后端的IP大概域名大概会由于各种缘故原由发生厘革，比如服务器迁移、负载均衡器调解等。
    
  • 但是前端又不能总是更换后端IP大概域名：这个说法精确，频仍更换前端设置不实际，也不方便。
    
  • 一劳永逸的办理方案：后端直接全部放开API的接口调用。这个办理方案不安全，不能简单地全部放开，否则会导致安全风险，比如跨站哀求伪造（CSRF）攻击、恶意爬虫等。
    
  
  
• 域名不校验岂不是要翻天
  
  
  
  • 办理方案：
    
    
    
    • 前后端鉴权利用API-KEY大概其他鉴步调权：精确，通过API-KEY、OAuth、JWT等方式举行鉴权，可以确保只有授权的哀求才气访问后端API。
      
    • 公有云的防御服务：精确，公有云平台提供了一系列的安全服务，比如防火墙、DDoS防护、WAF（Web应用防火墙）等，可以有效防止恶意攻击。
      
    
    
  
  
• 那为什么我当地开发可以访问许多网站的API接口
  
  
  
  • 由于开发职员没有留意这些情况：这个说法不完全正确，许多网站的API是对外提供服务的，答应其他网站或开发者调用但，通常会有一些限定，比如须要注册、申请API密钥等。
    
  • 大概网站本身就是对外提供API访问的网站：精确，比如一些开放平台，如微博、微信等，它们的API就是对外提供服务的，供开发者集成到本身的应用中。
    
  
  

2-脑洞打开

• 开发侧-如果我做静态个人网站，我怎样举行跨域限定（防止网站被恶意攻击）
  
  
  
  • 跨域限定：可以通过设置CORS（跨域资源共享）计谋来限定哪些网站可以访问你的API。比方，在服务器设置中，只答应特定的域名访问你的API。
    
  • 防止恶意攻击：除了CORS，还可以接纳其他安全步调，比如利用防火墙、限定哀求频率、利用验证码等。
    
  
  
• 开发侧-如果我做SDK服务型网站，我怎样举行跨域限定（防止网站被恶意攻击）
  
  
  
  • 跨域限定：同样可以通过CORS计谋来限定访问，还可以要求调用方提供API密钥或其他身份验证信息。
    
  • 防止恶意攻击：可以对哀求举行署名验证，确保哀求的正当性；还可以对哀求举行限流，防止恶意爬虫或攻击导致服务器过载。
    
  
  
• 爬虫侧-如和克制网站的API接口被爬取，怎样界说本身的robots.txt
  
  
  
  • 克制被爬取：可以通过技能本领，比如限定哀求频率、验证哀求泉源、利用验证码等，来防止恶意爬虫。
    
  • 界说robots.txt：robots.txt文件是网站根目次下的一个文本文件，用于告诉搜刮引擎和其他爬虫哪些页面可以爬取，哪些不可以爬取。比方：
    1. User-agent: *
    2. Disallow: /api/ #  禁止爬虫访问API接口
    3. Allow: /public/  # 允许爬虫访问公开的资源

    复制代码
    但要留意，robots.txt只是一种君子协议，恶意爬虫大概会忽略它，以是还须要其他安全步调来掩护API接口。
    
  
  

---

3-知识整理

1-什么是跨域

一、同源计谋简介

同源计谋（same origin policy）是欣赏器的一个安全功能，差别源的客户端脚本在没有明确授权的情况下，不能读写对方资源。同源计谋是欣赏器安全的基石。
什么是源

源（origin）就是协议、域名和端标语。比方：http://www.baidu.com:80这个URL。
什么是同源

若所在内里的协议、域名和端标语均雷同则属于同源。
是否是同源的判断

比方判断下面的URL是否与 http://www.a.com/test/index.html 同源

• http://www.a.com/dir/page.html 同源
  
• http://www.child.a.com/test/index.html 差别源，域名不雷同
  
• https://www.a.com/test/index.html 差别源，协议不雷同
  
• http://www.a.com:8080/test/index.html 差别源，端标语不雷同
  

哪些操纵不受同源计谋限定

• 页面中的链接，重定向以及表单提交是不会受到同源计谋限定的；
  
• 跨域资源的引入是可以的。但是JS不能读写加载的内容。如嵌入到页面中的<script src="..."></script>，<img>，<link>，<iframe>等。
  

跨域

受前面所讲的欣赏器同源计谋的影响，不是同源的脚本不能操纵其他源下面的对象。想要操纵另一个源下的对象就须要跨域。 在同源计谋的限定下，非同源的网站之间不能发送 AJAX 哀求。
怎样跨域

• 降域
  可以通过设置 document.domain='a.com'，欣赏器就会以为它们都是同一个源。想要实现以上恣意两个页面之间的通讯，两个页面必须都设置document.domain='a.com' 。
  
• JSONP跨域
  
• CORS 跨域
  

二、CORS 简介

为相识决欣赏器同源题目，W3C 提出了跨源资源共享，即 CORS(Cross-Origin Resource Sharing)。
CORS 做到了如下两点：

• 不粉碎即有规则
  
• 服务器实现了 CORS 接口，就可以跨源通讯
  

基于这两点，CORS 将哀求分为两类：简单哀求和非简单哀求。
1、简单哀求

在CORS出现前，发送HTTP哀求时在头信息中不能包罗任何自界说字段，且 HTTP 头信息不凌驾以下几个字段：

• Accept
  
• Accept-Language
  
• Content-Language
  
• Last-Event-ID
  
• Content-Type 只限于 [application/x-www-form-urlencoded 、multipart/form-data、text/plain ] 范例
  

一个简单的哀求例子：

1. GET /test HTTP/1.1
2.         Accept: */*
3.         Accept-Encoding: gzip, deflate, sdch, br
4.         Origin: http://www.examples.com
5.         Host: www.examples.com

复制代码

对于简单哀求，CORS的计谋是哀求时在哀求头中增长一个Origin字段，服务器收到哀求后，根据该字段判断是否答应该哀求访问。

• 如果答应，则在 HTTP 头信息中添加 Access-Control-Allow-Origin 字段，并返回精确的效果 ；
  
• 如果不答应，则不在 HTTP 头信息中添加 Access-Control-Allow-Origin 字段 。
  

除了上面提到的 Access-Control-Allow-Origin ，尚有几个字段用于形貌 CORS 返回效果 ：

• Access-Control-Allow-Credentials： 可选，用户是否可以发送、处理惩罚 cookie；
  
• Access-Control-Expose-Headers：可选，可以让用户拿到的字段。有几个字段无论设置与否都可以拿到的，包罗：Cache-Control、Content-Language、Content-Type
  、Expires、Last-Modified、Pragma 。
  

2、非简单哀求

对于非简单哀求的跨源哀求，欣赏器会在真实哀求发出前，增长一次OPTION哀求，称为预检哀求（preflight request）。预检哀求将真实哀求的信息，包罗哀求方法、自界说头字段、源信息添加到 HTTP
头信息字段中，扣问服务器是否答应如许的操纵。
比方一个DELETE哀求：

1. OPTIONS /test HTTP/1.1
2.         Origin: http://www.examples.com
3.         Access-Control-Request-Method: DELETE
4.         Access-Control-Request-Headers: X-Custom-Header
5.         Host: www.examples.com

复制代码

与 CORS 干系的字段有：

• 哀求利用的 HTTP 方法 Access-Control-Request-Method ；
  
• 哀求中包罗的自界说头字段 Access-Control-Request-Headers 。
  

服务器收到哀求时，须要分别对 Origin、Access-Control-Request-Method、Access-Control-Request-Headers 举行验证，验证通事后，会在返回 HTTP 头信息中添加 ：

1. Access-Control-Allow-Origin: http://www.examples.com
2. Access-Control-Allow-Methods: GET, POST, PUT, DELETE
3. Access-Control-Allow-Headers: X-Custom-Header
4. Access-Control-Allow-Credentials: true
5. Access-Control-Max-Age: 1728000

复制代码

他们的寄义分别是：

• Access-Control-Allow-Methods: 真实哀求答应的方法
  
• Access-Control-Allow-Headers: 服务器答应利用的字段
  
• Access-Control-Allow-Credentials: 是否答应用户发送、处理惩罚 cookie
  
• Access-Control-Max-Age: 预检哀求的有效期，单元为秒。有效期内，不会重复发送预检哀求
  

当预检哀求通事后，欣赏器会发送真实哀求到服务器。这就实现了跨源哀求。
三、Spring Boot 设置 CORS

1、利用@CrossOrigin 注解实现

如果想要对某一接口设置 CORS，可以在方法上添加 @CrossOrigin 注解 ：

1. @CrossOrigin(origins = {"http://localhost:9000", "null"})
2. @RequestMapping(value = "/test", method = RequestMethod.GET)
3. public String greetings(){
4.      return"{"project":"just a test"}";
5. }

复制代码

如果想对一系列接口添加 CORS 设置，可以在类上添加注解，对该类声明全部接口都有效：

2. @CrossOrigin(origins = {"http://localhost:9000", "null"})
3. @RestController
4. @SpringBootApplication
5. public class SpringBootCorsTestApplication {
6. }

复制代码

如果想添加全局设置，则须要添加一个设置类 ：

2. @Configuration
3. public class WebMvcConfig implements WebMvcConfigurer {
4.     @Override
5.     public void addCorsMappings(CorsRegistry registry) {
6.         registry.addMapping("/**")
7.                 .allowedOrigins("*")
8.                 .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
9.                 .maxAge(3600)
10.                 .allowCredentials(true);
11.     }
12. }

复制代码

别的，还可以通过添加 Filter 的方式，设置 CORS 规则，并手动指定对哪些接口有效。

1. @Bean
2. public FilterRegistrationBean corsFilter(){
3.         UrlBasedCorsConfigurationSource source=new UrlBasedCorsConfigurationSource();
4.         CorsConfiguration config=new CorsConfiguration();
5.         config.setAllowCredentials(true);
6.         config.addAllowedOrigin("http://localhost:9000");
7.         config.addAllowedOrigin("null");
8.         config.addAllowedHeader("*");
9.         config.addAllowedMethod("*");
10.         source.registerCorsConfiguration("/**",config); // CORS 配置对所有接口都有效
11.         FilterRegistrationBean bean=new FilterRegistrationBean(new CorsFilter(source));
12.         bean.setOrder(0);
13.         return bean;
14.         }

复制代码

2、原理分析

无论是通过哪种方式设置 CORS，实在都是在构造 CorsConfiguration。一个 CORS 设置用一个 CorsConfiguration类来表现，它的界说如下：

1. public class CorsConfiguration {
2.     private List<String> allowedOrigins;
3.     private List<String> allowedMethods;
4.     private List<String> allowedHeaders;
5.     private List<String> exposedHeaders;
6.     private Boolean allowCredentials;
7.     private Long maxAge;
8. }

复制代码

Spring 中对 CORS 规则的校验，都是通过委托给 DefaultCorsProcessor 实现的。
DefaultCorsProcessor 处理惩罚过程如下：

• 判断依据是 Header 中是否包罗 Origin。如果包罗则阐明为 CORS哀求，转到 2；否则，阐明不是 CORS 哀求，不作任那边理惩罚。
  
• 判断 response 的 Header 是否已经包罗 Access-Control-Allow-Origin，如果包罗，证实已经被处理惩罚过了, 转到 3，否则不再处理惩罚。
  
• 判断是否同源，如果是则转交给负责该哀求的类处理惩罚。
  
• 是否设置了 CORS 规则，如果没有设置，且是预检哀求，则拒绝该哀求，如果没有设置，且不是预检哀求，则交给负责该哀求的类处理惩罚。如果设置了，则对该哀求举行校验。
  

校验就是根据 CorsConfiguration 这个类的设置举行判断：

• 判断 origin 是否正当
  
• 判断 method 是否正当
  
• 判断 header是否正当
  
• 如果全部正当，则在 response header中添加相应的字段，并交给负责该哀求的类处理惩罚，如果不正当，则拒绝该哀求。
  

---

2-Java怎样设置CORS

在Spring Boot
3中，办理跨域哀求（CORS，Cross-Origin
Resource Sharing）的题目紧张有以下几种方式：
1. 利用@CrossOrigin注解

你可以直接在Controller类大概详细的哀求处理惩罚方法上利用@CrossOrigin注解来答应跨域哀求。

2. @RestController
3. @RequestMapping("/user")
4. @CrossOrigin(origins = "*")
5. public class UserController {
7. }

复制代码

在这个例子中，@CrossOrigin
注解被添加到了控制器类上，表现这个控制器下的全部方法都答应来自http://example.com的GET和POST哀求。你也可以将注解添加到特定的方法上，以对该方法应用CORS设置。
2. 全局设置CORS

如果你盼望全局设置CORS，而不是在每个Controller或方法上单独设置，你可以创建一个设置类来实现WebMvcConfigurer接口，并重写addCorsMappings方法。

1. import org.springframework.context.annotation.Configuration;
2. import org.springframework.web.servlet.config.annotation.CorsRegistry;
3. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
5. @Configuration
6. public class CorsConfig implements WebMvcConfigurer {
8.     @Override
9.     public void addCorsMappings(CorsRegistry registry) {
11.         registry.addMapping("/**")
12.                 .allowedOrigins("*")
13.                 .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")
14.                 .allowedHeaders("*")
15.                 .allowCredentials(true)
16.                 .maxAge(168000);
18.     }
19. }

复制代码

在这个设置中，addMapping("/**")表现对全部的路径都应用CORS设置。allowedOrigins("*")
表现答应全部泉源的访问，这在生产情况中大概不是最佳实践，通常你会指定详细的域名。allowedMethods界说了答应的HTTP方法，allowedHeaders
界说了答应的HTTP头部，allowCredentials(true)表现是否答应携带根据（cookies, HTTP认证及客户端SSL证实等），maxAge则用于设置预检哀求的有效期。
3. 利用Filter实现CORS

你也可以通过实现Filter接口来自界说CORS处理惩罚逻辑。

1. import javax.servlet.*;
2. import javax.servlet.http.HttpServletResponse;
3. import java.io.IOException;
5. public class SimpleCorsFilter implements Filter {
7.     @Override
8.     public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
9.             throws IOException, ServletException {
11.         HttpServletResponse response = (HttpServletResponse) res;
12.         response.setHeader("Access-Control-Allow-Origin", "http://example.com");
13.         response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
14.         response.setHeader("Access-Control-Max-Age", "3600");
15.         response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
16.         chain.doFilter(req, res);
18.     }
20.     @Override
21.     public void init(FilterConfig filterConfig) {
22.     }
24.     @Override
25.     public void destroy() {
26.     }
28. }

复制代码

然后须要在设置类中注册这个Filter。

1. import org.springframework.boot.web.servlet.FilterRegistrationBean;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
5. @Configuration
6. public class FilterConfig {
8.     @Bean
9.     public FilterRegistrationBean<SimpleCorsFilter> corsFilter() {
11.         FilterRegistrationBean<SimpleCorsFilter> registrationBean = new FilterRegistrationBean<>();
12.         registrationBean.setFilter(new SimpleCorsFilter());
13.         registrationBean.addUrlPatterns("/*");
14.         return registrationBean;
15.     }
17. }

复制代码

4. 利用拦截器（Interceptor）

如果须要更复杂的CORS逻辑，你可以创建一个拦截器来处理惩罚CORS哀求。拦截器答应你在哀求处理惩罚之前或之后添加逻辑。

1. import org.springframework.web.servlet.HandlerInterceptor;
3. import javax.servlet.http.HttpServletRequest;
4. import javax.servlet.http.HttpServletResponse;
6. public class CorsInterceptor implements HandlerInterceptor {
8.     @Override
9.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
11.         response.setHeader("Access-Control-Allow-Origin", "http://example.com");
12.         response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
13.         response.setHeader("Access-Control-Allow-Headers", "*");
14.         return true;
15.     }
16. }

复制代码

然后，你须要在设置类中注册这个拦截器：

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
4. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
6. @Configuration
7. public class WebConfig implements WebMvcConfigurer {
9.     @Autowired
10.     private CorsInterceptor corsInterceptor;
12.     @Override
13.     public void addInterceptors(InterceptorRegistry registry) {
15.         registry.addInterceptor(corsInterceptor).addPathPatterns("/**");
17.     }
19. }

复制代码

• 当设置allowedHeaders("*")时，实际上欣赏器会发送实际哀求头而不是*。出于安全思量，最好明确指定答应的头部。
  
• 在生产情况中，确保不要过于宽松地设置CORS，只答应须要的源和方法。
  
• 如果你的应用摆设在署理服务器反面（如Nginx或Apache），大概还须要在署理服务器上设置CORS。
  

5.相应体（Response Body）来设置CORS

固然这种方式不如前面提到的几种方法直接和常用，但在某些特别场景下，你大概须要手动控制相应头来实现跨域。
详细实现时，你可以在Controller的方法中，通过HttpServletResponse对象来设置Access-Control-Allow-Origin等CORS干系的HTTP头。

1. import javax.servlet.http.HttpServletResponse;
3. import org.springframework.web.bind.annotation.GetMapping;
4. import org.springframework.web.bind.annotation.RestController;
6. @RestController
7. public class MyController {
9.     @GetMapping("/data")
10.     public String getData(HttpServletResponse response) {
12.         response.setHeader("Access-Control-Allow-Origin", "http://example.com");
13.         response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
14.         response.setHeader("Access-Control-Allow-Headers", "*");
15.         response.setHeader("Access-Control-Max-Age", "3600");
16.         return "Data";
18.     }
20. }

复制代码

须要留意的是，手动设置相应头的方式相对繁琐，且容易遗漏某些须要的头信息，导致CORS设置不完备。因此，在实际开发中，保举利用前面提到的方法，它们更为直接且易于管理。
别的，如果你正在利用Spring Security，还须要确保Spring Security的设置不会制止跨域哀求的处理惩罚。在某些情况下，你大概须要在Spring Security的设置中答应特定的CORS哀求。
6.通过自界说ResponseBodyAdvice

ResponseBodyAdvice是Spring MVC提供的一个接口，答应你在Controller方法返反相应体之前对其举行修改。固然它本身不是专为CORS筹划的，但你可以利用它在返反相应之前添加CORS干系的HTTP头。
下面是一个简单的示例，展示了怎样通过实现ResponseBodyAdvice接口来添加CORS头：

1. import org.springframework.core.MethodParameter;
2. import org.springframework.http.MediaType;
3. import org.springframework.http.server.ServerHttpRequest;
4. import org.springframework.http.server.ServerHttpResponse;
5. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
7. import java.lang.reflect.Type;
9. public class CorsResponseBodyAdvice implements ResponseBodyAdvice<Object> {
11.     @Override
12.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
14.         return true;
16.     }
18.     @Override
19.     public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
20.                                   Class<? extends HttpMessageConverter<?>> selectedConverterType,
21.                                   ServerHttpRequest request, ServerHttpResponse response) {
23.         response.getHeaders().set("Access-Control-Allow-Origin", "http://example.com");
24.         response.getHeaders().set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
25.         response.getHeaders().set("Access-Control-Allow-Headers", "*");
26.         return body;
28.     }
29. }

复制代码

然后，你须要在Spring Boot的设置中注册这个ResponseBodyAdvice：

1. import org.springframework.context.annotation.Configuration;
2. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
4. @Configuration
5. public class WebConfig implements WebMvcConfigurer {
7.     @Override
8.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
10.         converters.forEach(converter -> {
12.             if (converter instanceof MappingJackson2HttpMessageConverter) {
13.                 ((MappingJackson2HttpMessageConverter) converter).setResponseBodyAdvice(new CorsResponseBodyAdvice());
15.             }
16.         });
17.     }
19. }

复制代码

这种方法的优点在于它可以全局地应用于全部Controller的相应，而无需在每个Controller或方法上单独设置。然而，它同样也有一些范围性，比如你大概须要手动处理惩罚一些CORS的细节，而且这种方式不如利用Spring提供的CORS支持那么直接和机动。
在选择办理方案时，应该根据项目标详细需求和团队的偏好来衡量各种方法的优缺点。如果项目中有大量的Controller须要处理惩罚跨域哀求，而且盼望有一个同一且全局的办理方案，那么利用WebMvcConfigurer或CorsFilter
大概是更好的选择。如果只须要在特定的Controller或方法上处理惩罚跨域哀求，那么利用@CrossOrigin注解大概更为简单直接。

---