CORS跨域资源共享(二)：详解Spring MVC对CORS支持的相关类和API【享学Spring MVC】

梦里梦外; 2024-04-19 16:23 43阅读 0赞

#### 每篇一句 ####

> 重构一时爽，一直重构一直爽。但出了问题火葬场

#### 前言 ####

[上篇文章][Link 1]通过我模拟的跨域请求实例和结果分析，相信小伙伴们都已经`80%`的掌握了`CORS`到底是怎么一回事以及如何使用它。由于Java语言中的web框架几乎都是使用的`Spring MVC`，因此本文将聚焦于`Spring MVC`对`CORS`的支持，深度分析下它对CORS支持的相关API，这也方便下一章节的灵活使用以及流程原理分析。

#### Spring MVC与CORS ####

`Spring MVC`一直到`4.2`版本“才”开始内置对`CORS`支持，至于为何到这个版本`Spring`官方才对此提供支持，我这里需要结合时间轴来给大家解释一下。  
上文我有说到了`CORS`它属于`W3C`的标准。我们知道任何一个规范的形成都是**非常漫长**的。`W3C`对web标准的制定分为如下7个阶段（从上到下有序）：

1.  WD（Working Draft 工作草案）：不稳定也不完整
2.  CR（Candidate Recommendation 候选推荐标准）：所有的已知`issues`都被解决了
3.  PR（Proposed Recommendation 提案推荐标准）：在浏览器做各种测试，此部分不会再有实质性的改动
4.  PER（Proposed Edited Recommendation 已修订的提案推荐标准）：
5.  **`REC`（Recommendation 推荐标准，通常称之为 standard，即事实标准）：几乎不会再变动任何东西**
6.  RET（Retired 退役的)：最后这两个是建立在`REC`基础上变来，成熟的技术一般都不会有后面这两个
7.  NOTE（Group Note 工作组说明）：

关于这7步，从[这里][Link 2] 可以看倒`CORS`的WD从`2009-03-17`开始，`2014-01-16`进入的`REC`阶段，可谓正式毕业。而`Spring4.2`是在`2015-06`发布给与的全面支持，从时间轴上看`Spring`的响应速度还是把握得不错的（毕竟`CORS`经历过一段时间市场的考验`Spring`才敢全面纳入进来支持嘛~）

> Tips：在`Spring4.2`之前，官方没有提供内置的支持，所以那时都是自己使用Filter/拦截器来处理。它的唯一缺点就是可能没那么灵活和优雅，后续官方提供标注支持后能力更强更为灵活了（底层原理都一样）

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

## Spring MVC中CORS相关类及API说明 ##

所有涉及到和`CORS`相关的类、注解、代码片段都是`Spring4.2`后才有的，请保持一定的版本意识。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5nc2hpeGlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
从截图里可以看出`spring-web`包提供的专门用于处理`CORS`的相关的类，下面有必要进行逐个分析

### CorsConfiguration ###

它代表一个`cors`配置，记录着各种配置项。它还提供了检查给定请求的实际来源、http方法和头的方法供以调用。用人话说：**它就是具体封装跨域配置信息的pojo**。  
默认情况下**新创建**的`CorsConfiguration`它是不允许任何跨域请求的，需要你手动去配置，或者调用`applyPermitDefaultValues()`开启`GET、POST、Head`的支持~

> 几乎所有场景，创建完`CorsConfiguration`最后都调用了`applyPermitDefaultValues()`方法。也就是说你不干预的情况下，一个`CorsConfiguration`配置一般都是支持`GET、POST、Head`的

// @since 4.2
    public class CorsConfiguration { 
    	
    	// public的通配符：代表所有的源、方法、headers...
    	// 若你需要使用通配符，可以使用此静态常量
    	public static final String ALL = "*";
    
    	private static final List<HttpMethod> DEFAULT_METHODS = Collections.unmodifiableList(Arrays.asList(HttpMethod.GET, HttpMethod.HEAD));
    	// 默认许可所有方法
    	private static final List<String> DEFAULT_PERMIT_ALL = Collections.unmodifiableList(Arrays.asList(ALL));
    	// 默认许可这三个方法
    	private static final List<String> DEFAULT_PERMIT_METHODS = Collections.unmodifiableList(Arrays.asList(HttpMethod.GET.name(), HttpMethod.HEAD.name(), HttpMethod.POST.name()));
    
    	// ==========把这些属性对应上文讲述的响应头们对应，和W3C标注都是对应上的=========
    	@Nullable
    	private List<String> allowedOrigins;
    	@Nullable
    	private List<String> allowedMethods;
    	@Nullable
    	private List<HttpMethod> resolvedMethods = DEFAULT_METHODS;
    	@Nullable
    	private List<String> allowedHeaders;
    	@Nullable
    	private List<String> allowedHeaders;
    	@Nullable
    	private List<String> exposedHeaders;
    	@Nullable
    	private Boolean allowCredentials;
    	@Nullable
    	private Long maxAge;
    
    	... // 省略所有构造函数以及所有的get/set方法
    
    
    	// 使用此方法将初始化模型翻转为以允许get、head和post请求的所有跨源请求的打开默认值开始
    	// 注意：此方法不会覆盖前面set进去的值，所以建议此方法可以作为兜底调用。实际上Spring内部也是用它兜底的
    	public CorsConfiguration applyPermitDefaultValues() { 
    		if (this.allowedOrigins == null) { 
    			this.allowedOrigins = DEFAULT_PERMIT_ALL;
    		}
    		if (this.allowedMethods == null) { 
    			this.allowedMethods = DEFAULT_PERMIT_METHODS;
    			this.resolvedMethods = DEFAULT_PERMIT_METHODS.stream().map(HttpMethod::resolve).collect(Collectors.toList());
    		}
    		if (this.allowedHeaders == null) { 
    			this.allowedHeaders = DEFAULT_PERMIT_ALL;
    		}
    		if (this.maxAge == null) { 
    			this.maxAge = 1800L;
    		}
    		return this;
    	}
    
    	public CorsConfiguration combine(@Nullable CorsConfiguration other) {  ... }
    
    	// 根据配置的允许来源检查请求的来源
    	// 返回值并不是bool值，而是字符串--> 返回可用的origin。若是null表示请求的origin不被支持
    	@Nullable
    	public String checkOrigin(@Nullable String requestOrigin) {  ... }
    	// 检查预检请求的Access-Control-Request-Method这个请求头
    	public List<HttpMethod> checkHttpMethod(@Nullable HttpMethod requestMethod) {  ... }
    	// 检查预检请求的Access-Control-Request-Headers
    	@Nullable
    	public List<String> checkHeaders(@Nullable List<String> requestHeaders) { 
    }

这个POJO的配置，是`servlet`传统web以及`reactive web`所共用的，它提供有校验的基本方法。它的属性、校验原则和W3C的CORS标准所对应。

### CorsConfigurationSource ###

它表示一个源，该接口主要是为请求提供一个`CorsConfiguration`。

public interface CorsConfigurationSource { 
    
    	// 找到此request的一个CORS配置
    	@Nullable
    	CorsConfiguration getCorsConfiguration(HttpServletRequest request);
    }

此接口方法的调用处有三个地方：

*  AbstractHandlerMapping.getHandler()/getCorsConfiguration()
 *  CorsFilter.doFilterInternal()
 *  HandlerMappingIntrospector.getCorsConfiguration()

因为它可以根据`request`返回一个CORS配置。可以把这个接口理解为：存储request与跨域配置信息的容器。它的继承树如下：  
![在这里插入图片描述][20190922161333596.png]  
首先需要说的便是cors包下的`UrlBasedCorsConfigurationSource`

#### `UrlBasedCorsConfigurationSource` ####

它位于`org.springframework.web.cors`包：它里面存储着`path patterns`和`CorsConfiguration`的键值对。

// @since 4.2
    public class UrlBasedCorsConfigurationSource implements CorsConfigurationSource { 
    	
    	// 请务必注意：这里使用的是LinkedHashMap
    	private final Map<String, CorsConfiguration> corsConfigurations = new LinkedHashMap<>();
    	private PathMatcher pathMatcher = new AntPathMatcher();
    	private UrlPathHelper urlPathHelper = new UrlPathHelper();
    	
    	... // 生路所有的get/set方法
    
    	// 这里的path匹配用到的是AntPathMatcher.match()，默认是按照ant风格进行匹配的
    	@Override
    	@Nullable
    	public CorsConfiguration getCorsConfiguration(HttpServletRequest request) { 
    		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
    		for (Map.Entry<String, CorsConfiguration> entry : this.corsConfigurations.entrySet()) { 
    			if (this.pathMatcher.match(entry.getKey(), lookupPath)) { 
    				return entry.getValue();
    			}
    		}
    		return null;
    	}
    }

本类它是作为`AbstractHandlerMapping`（`RequestMappingHandlerMapping`）的默认跨域资源配置的管理类

##### HandlerMappingIntrospector #####

`HandlerMapping`内省器。它是一个帮助类用于从`HandlerMapping`里获取信息，这些信息用于服务特定的请求。`@EnableWebMvc`默认会把它放进容器里，开发者可以`@Autowired`拿来使用（框架内部木有使用）

> 这个类比较重要，`Spring Cloud Netflix Zuul`巧用它实现了一些功能~

// @since 4.3.1
    public class HandlerMappingIntrospector implements CorsConfigurationSource, ApplicationContextAware, InitializingBean { 
    	@Nullable
    	private ApplicationContext applicationContext;
    	@Nullable
    	private List<HandlerMapping> handlerMappings;
    	
    	... // 生路一些构造函数、set方法
    	
    	// 1、Map<String, HandlerMapping> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, HandlerMapping.class, true, false)
    	// 2、如果第一步获取到了Beans，sort()排序一下
    	// 3、若没找到，回退到`DispatcherServlet.properties`这个配置文件里去找
    	@Override
    	public void afterPropertiesSet() { 
    		if (this.handlerMappings == null) { 
    			Assert.notNull(this.applicationContext, "No ApplicationContext");
    			this.handlerMappings = initHandlerMappings(this.applicationContext);
    		}
    	}
    
    	// 从这些HandlerMapping找到MatchableHandlerMapping
    	// 若一个都木有，此方法抛出异常
    	@Nullable
    	public MatchableHandlerMapping getMatchableHandlerMapping(HttpServletRequest request) throws Exception {  ... }
    
    
    	@Override
    	@Nullable
    	public CorsConfiguration getCorsConfiguration(HttpServletRequest request) { 
    		Assert.notNull(this.handlerMappings, "Handler mappings not initialized");
    		HttpServletRequest wrapper = new RequestAttributeChangeIgnoringWrapper(request);
    		for (HandlerMapping handlerMapping : this.handlerMappings) { 
    			HandlerExecutionChain handler = null;
    			try { 
    				handler = handlerMapping.getHandler(wrapper);
    			} catch (Exception ex) { 
    				// Ignore
    			}
    			if (handler == null) { 
    				continue;
    			}
    
    			// 拿到作用在此Handler上的所有的拦截器们：HandlerInterceptor
    			// 若有拦截器实现了CorsConfigurationSource接口，那就返回此拦截器上的CORS配置源
    			if (handler.getInterceptors() != null) { 
    				for (HandlerInterceptor interceptor : handler.getInterceptors()) { 
    					if (interceptor instanceof CorsConfigurationSource) { 
    						return ((CorsConfigurationSource) interceptor).getCorsConfiguration(wrapper);
    					}
    				}
    			}
    			// 若这个Handle本身（注意：并不是所有的handler都是一个方法，也可能是个类，所以也有可能是会实现接口的）
    			// 就是个CorsConfigurationSource 那就以它的为准
    			if (handler.getHandler() instanceof CorsConfigurationSource) { 
    				return ((CorsConfigurationSource) handler.getHandler()).getCorsConfiguration(wrapper);
    			}
    		}
    		return null;
    	}
    }

这个自省器最重要的功能就是初始化的时候把所有的`HandlerMapping`都拿到了。**这个处理逻辑和`DispatcherServlet.initHandlerMappings`是一样的，为何不提取成公用的呢？？？**

它另外一个功能便是获取`HttpServletRequest`对应的`CORS`配置信息：

1.  从作用在此`Handler`的拦截器`HandlerInterceptor`上获取
2.  若拦截器里木有，那就从`Handler`本身获取（若实现了`CorsConfigurationSource`接口）
3.  都没有就返回null

##### CorsInterceptor #####

`Cors`拦截器。它最终会被放到处理器链`HandlerExecutionChain`里，用于拦截处理（最后一个拦截）。

private class CorsInterceptor extends HandlerInterceptorAdapter implements CorsConfigurationSource { 
    		@Nullable
    		private final CorsConfiguration config;
    
    		//拦截操作 最终是委托给了`CorsProcessor`，也就是DefaultCorsProcessor去完成处理的
    		@Override
    		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
    			return corsProcessor.processRequest(this.config, request, response);
    		}
    		@Override
    		@Nullable
    		public CorsConfiguration getCorsConfiguration(HttpServletRequest request) { 
    			return this.config;
    		}
    	}

该拦截器是`AbstractHandlerMapping`的私有内部类，它会在每次`getHandler()`的时候放进去专门作用域当前跨域的请求，具体的流程在下个章节里有讲述。

##### PreFlightHandler #####

这个和上面的`CorsInterceptor`互斥，它最终也是委托给`corsProcessor`来处理请求，只是它是**专门用于处理预检请求的**。详见`CORS`请求处理流程部分。

### CorsProcessor（重要） ###

它便是`CORS`真正处理器：用于接收请求和一个配置，然后更新Response：比如接受/拒绝

public interface CorsProcessor { 
    
    	// 根据所给的`CorsConfiguration`来处理请求
    	boolean processRequest(@Nullable CorsConfiguration configuration, HttpServletRequest request, HttpServletResponse response) throws IOException;
    }

它的唯一实现类是`DefaultCorsProcessor`

##### DefaultCorsProcessor #####

它遵循的是W3C标准实现的。`Spring MVC`中对`CORS`规则的校验，**都是**通过委托给 `DefaultCorsProcessor`实现的

// @since 4.2
    public class DefaultCorsProcessor implements CorsProcessor { 
    
    	@Override
    	@SuppressWarnings("resource")
    	public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request, HttpServletResponse response) throws IOException { 
    		
    		// 若不是跨域请求，不处理
    		// 这个判断极其简单：请求中是否有Origin请求头。有这个头就是跨域请求
    		if (!CorsUtils.isCorsRequest(request)) { 
    			return true;
    		}
    
    		// response.getHeaders().getAccessControlAllowOrigin() != null
    		// 若响应头里已经设置好了Access-Control-Allow-Origin这个响应头，此处理器也不管了
    		ServletServerHttpResponse serverResponse = new ServletServerHttpResponse(response);
    		if (responseHasCors(serverResponse)) { 
    			logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
    			return true;
    		}
    
    		// 即使你有Origin请求头，但是是同源的请求，那也不处理
    		ServletServerHttpRequest serverRequest = new ServletServerHttpRequest(request);
    		if (WebUtils.isSameOrigin(serverRequest)) { 
    			logger.trace("Skip: request is from same origin");
    			return true;
    		}
    
    		// 是否是预检请求，判断标准如下：
    		// 是跨域请求 && 是`OPTIONS`请求 && 有Access-Control-Request-Method这个请求头
    		boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    
    		// 若config == null，分两种case：
    		// 是预检请求but木有给config，那就拒绝：给出状态码403
    		// response.setStatusCode(HttpStatus.FORBIDDEN)
    		// response.getBody().write("Invalid CORS request".getBytes(StandardCharsets.UTF_8));
    		if (config == null) { 
    			if (preFlightRequest) { 
    				rejectRequest(serverResponse);
    				return false; // 告诉后面的处理器不用再处理了
    			} else {  // 虽然没给config，但不是预检请求（是真是请求，返回true）
    				return true;
    			}
    		}
    
    		// 真正的跨域处理逻辑~~~~
    		// 它的处理逻辑比较简单，立即了W3C规范理解它起来非常简单，本文略
    		// checkOrigin/checkMethods/checkHeaders等等方法最终都是委托给CorsConfiguration去做的
    		return handleInternal(serverRequest, serverResponse, config, preFlightRequest);
    	}
    	...
    }

使用框架来处理跨域的好处便是：兼容性很强且灵活。它的处理过程如下：

1.  若不是跨域请求，不处理（注意是`return true`后面拦截器还得执行呢）。若是跨域请求继续处理。（是否是跨域请求就看请求头是否有`Origin`这个头）
2.  判断`response`是否有`Access-Control-Allow-Origin`这个响应头，若有说明已经被处理过，那本处理器就不再处理了
3.  判断是否是同源：即使有Origin请求头，但若是同源的也不处理
4.  是否配置了`CORS`规则，若没有配置：  
    1. 若是预检请求，**直接决绝403，return false**  
    2. 若不是预检请求，则本处理器不处理
5.  正常处理`CORS`请求，大致是如下步骤：  
    1. 判断 origin 是否合法  
    2. 判断 method 是否合法  
    3. 判断 header是否合法  
    4. 若其中有一项不合法，直接决绝掉403并`return false`。都合法的话：就在`response`设置上一些头信息~~~

### CorsFilter ###

`Spring4.2`之前一般自己去实现一个这样的`Filter`来处理，`4.2`之后框架提供了内置支持。

> Reactive的叫`org.springframework.web.cors.reactive.CorsWebFilter`

// @since 4.2
    public class CorsFilter extends OncePerRequestFilter { 
    
    	private final CorsConfigurationSource configSource;
    	// 默认使用的DefaultCorsProcessor，当然你也可以自己指定
    	private CorsProcessor processor = new DefaultCorsProcessor();
    
    	@Override
    	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { 
    		// 只处理跨域请求
    		if (CorsUtils.isCorsRequest(request)) { 
    			// Spring这里有个bug：因为它并不能保证configSource肯定被初始化了
    			CorsConfiguration corsConfiguration = this.configSource.getCorsConfiguration(request);
    			if (corsConfiguration != null) { 
    				boolean isValid = this.processor.processRequest(corsConfiguration, request, response);
    
    	
    				// 若处理后返回false，或者该请求本身就是个Options请求，那后面的Filter也不要处理了~~~~~
    				if (!isValid || CorsUtils.isPreFlightRequest(request)) { 
    					return;
    				}
    			}
    		}
    
    		filterChain.doFilter(request, response);
    	}
    }

它的工作完全委托给`CorsProcessor`去处理的。此`Filter`可以与`DelegatingFilterProxy`一起使用，以帮助初始化且可以使用Spring容器内的Bean。注意`CorsFilter`在框架内部默认是木有配置的，若有需要请自行配置~

> `CorsFilter`属于jar包内的过滤器，在没有web.xml环境下如何配置呢？详见下个章节的示例

### `@CrossOrigin` ###

`Spring MVC`提供了此注解来帮助你解决CORS跨域问题，比你使用`Filter`更加的方便，且能实现更加精细化的控制（一般可以和`CorsFilter`一起来使用，效果更佳）。  
`Spring Web MVC`和`Spring WebFlux`在`RequestMappingHandlerMapping`里都是支持此注解的，该注解配置参数的原理可参考`CorsConfiguration`

// @since 4.2 可使用在类上和方法上
    @Target({  ElementType.METHOD, ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface CrossOrigin { 
    
    	// 下面4个属性在5.0后都被此方法所代替 因为此方法默认会被执行
    	/** @deprecated as of Spring 5.0, in favor of {@link CorsConfiguration#applyPermitDefaultValues} */
    	@Deprecated
    	String[] DEFAULT_ORIGINS = {  "*" };
    	@Deprecated
    	String[] DEFAULT_ALLOWED_HEADERS = {  "*" };
    	@Deprecated
    	boolean DEFAULT_ALLOW_CREDENTIALS = false;
    	@Deprecated
    	long DEFAULT_MAX_AGE = 1800;
    
    	// 若需要通配，可写*
    	@AliasFor("origins")
    	String[] value() default { };
    	@AliasFor("value")
    	String[] origins() default { };
    
    	String[] allowedHeaders() default { };
    	String[] exposedHeaders() default { };
    	RequestMethod[] methods() default { };
    	String allowCredentials() default "";
    	long maxAge() default -1; // 负值意味着不生效 By default this is set to {@code 1800} seconds (30 minutes)
    }

此注解可以标注在`Controller`上和方法上，若都有标注将会有combine的效果。

### CorsRegistry / CorsRegistration ###

这两个类是`Spring MVC`提供出来便于进行global全局配偶的，它是基于`URL pattern`配置的。

public class CorsRegistry { 
    	// 保存着全局的配置，每个CorsRegistration就是URL pattern和CorsConfiguration配置
    	private final List<CorsRegistration> registrations = new ArrayList<>();
    
    	// 像上面List添加一个全局配置（和pathPattern绑定）
    	// 它使用的是new CorsRegistration(pathPattern)
    	// 可见使用配置是默认配置：new CorsConfiguration().applyPermitDefaultValues()
    	// 当然它CorsRegistration return给你了，你还可以改（配置）的~~~~
    	public CorsRegistration addMapping(String pathPattern) { 
    		CorsRegistration registration = new CorsRegistration(pathPattern);
    		this.registrations.add(registration);
    		return registration;
    	}
    
    	// 这个就比较简单了：把当前List专程Map。key就是PathPattern~~~~
    	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;
    	}
    }

对于`CorsRegistration`这个类，它就是持有`pathPattern`和`CorsConfiguration config`两个属性，它特特点是提供了`allowedMethods/allowedHeaders...`等方法，提供钩子方便我们对`CorsConfiguration`进行配置，源码很简单略。

> 这两个类虽然简单，但是在`@EnableWebMvc`里扩展配置时使用得较多，参见下个章节对`WebMvcConfigurer`扩展使用和配置

#### 相关阅读 ####

[CORS跨域资源共享(一)：模拟跨域请求以及结果分析，理解同源策略【享学Spring MVC】][Link 1]  
[CORS跨域资源共享(二)：详解Spring MVC对CORS支持的相关类和API【享学Spring MVC】][CORS_Spring MVC_CORS_API_Spring MVC]  
[CORS跨域资源共享(三)：@CrossOrigin/CorsFilter处理跨域请求示例，原理分析【享学Spring MVC】][CORS_CrossOrigin_CorsFilter_Spring MVC]

#### 总结 ####

本文内容主要介绍`Spring MVC`它对`CORS`支持的那些类，为我们生产是灵活的使用`Spring MVC`解决`CORS`问题提供理论基础。下个章节也是本系列的最后一个章节，将具体介绍`Spring MVC`中对`CORS`的实践。

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

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[Link 1]: https://fangshixiang.blog.csdn.net/article/details/100999550
[Link 2]: https://www.w3.org/TR/cors/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5nc2hpeGlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9bfb586c6a0b40fda113493f8e8a260e.png
[20190922161333596.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0b9ac555b8bd4ac3ae0d6680f5b1f29b.png
[CORS_Spring MVC_CORS_API_Spring MVC]: https://fangshixiang.blog.csdn.net/article/details/101036506
[CORS_CrossOrigin_CorsFilter_Spring MVC]: https://fangshixiang.blog.csdn.net/article/details/101170214
[BAT]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3ee838930f88427786a4ecc946fd134d.gif