Spring MVC RequestMappingInfo路由条件匹配

前言

我们已经知道,被@RequestMapping标注的方法会被解析为 HandlerMethod,它也是 Spring MVC 中最常用的 Handler 类型。现在的问题是,HTTP 请求是如何路由到对应的 HandlerMethod?你可能脱口而出:根据请求的 Url 匹配啊!的确,Url 匹配是最简单一种规则,但事实上 Spring MVC 的功能之丰富超乎你想象。

比如,你可以在两个方法上定义相同的请求路径,根据请求参数的不同路由到不同的方法上处理:

@GetMapping(path = "api", params = "id")
public Object apiV1(@RequestParam("id") String id) {
    return "apiV1:" + id;
}

@GetMapping(path = "api", params = "name")
public Object apiV2(@RequestParam("name") String name) {
    return "apiV2:" + name;
}

除此之外,你还可以根据请求方法、请求头、Content-Type、Accept、甚至自定义更复杂的路由规则。Spring MVC 处理这套路由机制是很复杂的,来看下是怎么实现的吧。

RequestCondition

首先我们重新认识一下@RequestMapping注解,先了解它支持配置哪些路由条件。

public @interface RequestMapping {
  String[] path() default {};
  RequestMethod[] method() default {};
  String[] params() default {};
  String[] headers() default {};
  String[] consumes() default {};
  String[] produces() default {};
}
  • path:请求的路径数组,可以使用 Ant 模式匹配
  • method:请求的方法数组
  • params:请求的参数数组,可以指定键或键值
  • headers:请求头数组,可以指定键或键值
  • consumes:指定只接收哪些媒体类型参数的请求,匹配 Content-Type 请求头,例如:application/json
  • produces:指定返回的媒体类型,匹配 Accept 请求头,例如:text/html

这里举一个典型示例:

@RequestMapping(
        path = "get/{userId}",
        method = {RequestMethod.GET},
        headers = {"token"},
        params = {"name"},
        consumes = {"application/json"},
        produces = {"text/html"}
)
public Object getUser(@PathVariable("userId") String userId,
                      @RequestParam("name") String name) {

    return null;
}

在这个示例中,请求的 Url 必须匹配"get/{userId}“、请求方法必须是 GET、请求头必须携带 token、必须有一个 name 参数、Content-Type 必须是"application/json”、Accept 必须包含"text/html",满足以上所有条件请求才会路由到该方法。

因为要匹配的条件特别多,Spring MVC 专门为此抽象了一个接口:RequestCondition,它代表 HTTP 请求要匹配的条件。

public interface RequestCondition<T> {
  T combine(T other);
  
  T getMatchingCondition(HttpServletRequest request);
   
  int compareTo(T other, HttpServletRequest request);
}
  • combine:条件合并,例如合并方法和类上的@RequestMapping注解
  • getMatchingCondition:获得匹配的条件,例如有多个 path,返回匹配上的 path,返回 null 表示不匹配
  • compareTo:条件比较,匹配到多个候选项时选出一个最佳项

RequestCondition 有很多实现类,@RequestMapping里的每一项规则都对应一个具体的实现类:

如图所示,请求路径匹配对应 PathPatternsRequestCondition、请求方法条件匹配对应 RequestMethodsRequestCondition、请求头条件匹配对应 HeadersRequestCondition 等等。CompositeRequestCondition 组合了多个 RequestCondition,本身不具备条件匹配的能力,委托给内部的 requestConditions。

所有的实现类就不一一分析了,我们看几个常用的。

RequestMethodsRequestCondition

RequestMethodsRequestCondition 是请求方法条件类,内部用一个 Set 记录支持的请求方法,通过构造函数传入:

private RequestMethodsRequestCondition(Set<RequestMethod> methods) {
	this.methods = methods;
}

匹配规则也很简单,就是看 methods 是否包含了:

private RequestMethodsRequestCondition matchRequestMethod(String httpMethodValue) {
	RequestMethod requestMethod;
	try {
		requestMethod = RequestMethod.valueOf(httpMethodValue);
		if (getMethods().contains(requestMethod)) {
			return requestMethodConditionCache.get(httpMethodValue);
		}
		if (requestMethod.equals(RequestMethod.HEAD) && getMethods().contains(RequestMethod.GET)) {
			return requestMethodConditionCache.get(HttpMethod.GET.name());
		}
	}
	catch (IllegalArgumentException ex) {
		// Custom request method
	}
	return null;
}

HeadersRequestCondition

HeadersRequestCondition 是请求头条件类,支持多种匹配方式:

  • key:请求头必须有 key
  • !key:请求头必须没有 key
  • key=value:请求头必须有 key、且值必须是 value

配置通过构造函数传入,因为匹配的复杂性,Spring MVC 会把配置的字符串解析成表达式 HeaderExpression。

public HeadersRequestCondition(String... headers) {
	// 解析表达式
	this.expressions = parseExpressions(headers);
}

解析过程并不复杂,内部用三个变量记录键值、以及是否取反:

AbstractNameValueExpression(String expression) {
	int separator = expression.indexOf('=');
	if (separator == -1) {
		this.isNegated = expression.startsWith("!");
		this.name = (this.isNegated ? expression.substring(1) : expression);
		this.value = null;
	}
	else {
		this.isNegated = (separator > 0) && (expression.charAt(separator - 1) == '!');
		this.name = (this.isNegated ? expression.substring(0, separator - 1) : expression.substring(0, separator));
		this.value = parseValue(expression.substring(separator + 1));
	}
}

匹配的过程也不复杂,挨个和所有 HeaderExpression 匹配,必须所有都匹配通过才行:

public HeadersRequestCondition getMatchingCondition(HttpServletRequest request) {
	if (CorsUtils.isPreFlightRequest(request)) {
		return PRE_FLIGHT_MATCH;
	}
	for (HeaderExpression expression : this.expressions) {
		if (!expression.match(request)) {
			return null;
		}
	}
	return this;
}

RequestMappingInfo

在 RequestCondition 众多实现类中,有一个最为关键,也是我们要重点分析的——RequestMappingInfo,它可以看作是@RequestMapping的封装类。
它聚合了@RequestMapping注解的所有条件对象,内部用七个变量来表示,匹配时必须所有的条件都匹配通过才算,任一条件不匹配都会导致失败。

public final class RequestMappingInfo implements RequestCondition<RequestMappingInfo> {
  // 请求路径条件 path = {"/api"}
  private final PathPatternsRequestCondition pathPatternsCondition;
  // 方法条件 method = {RequestMethod.GET, RequestMethod.POST}
  private final RequestMethodsRequestCondition methodsCondition;
  // 参数条件 params = {"name"}
  private final ParamsRequestCondition paramsCondition;
  // 请求头条件 headers = {"token"}
  private final HeadersRequestCondition headersCondition;
  // 请求头Content-Type条件 consumes = {"application/json"}
  private final ConsumesRequestCondition consumesCondition;
  // 请求头Accept条件 produces = {"text/html"}
  private final ProducesRequestCondition producesCondition;
  // 自定义条件
  private final RequestConditionHolder customConditionHolder;
}

它是如何被构建的呢???
AbstractHandlerMethodMapping 属性填充完毕后,会自动检测容器内所有 ControllerBean,然后解析 Bean 上所有被 @RequestMapping 标注的方法,源码在 RequestMappingHandlerMapping#getMappingForMethod 。

  • 先解析方法上的注解,构建 RequestMappingInfo 实例
  • 再解析类上的注解,构建 RequestMappingInfo 实例
  • 最后将二者合并
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
	// 基于方法构建RequestMappingInfo
	RequestMappingInfo info = createRequestMappingInfo(method);
	if (info != null) {
		// 基于类构建RequestMappingInfo
		RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
		if (typeInfo != null) {
			// 二者合并 比如类上path=/user 方法上path=/get/{id} 匹配的完整路径:/user/get/{id}
			info = typeInfo.combine(info);
		}
		String prefix = getPathPrefix(handlerType);
		if (prefix != null) {
			info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
		}
	}
	return info;
}

RequestMappingInfo 实例化采用建造者模式,通过内部类 DefaultBuilder 完成实例化,没什么复杂的,就是读取注解属性完成实例化:

protected RequestMappingInfo createRequestMappingInfo(
		RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {

	RequestMappingInfo.Builder builder = RequestMappingInfo
			.paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
			.methods(requestMapping.method())
			.params(requestMapping.params())
			.headers(requestMapping.headers())
			.consumes(requestMapping.consumes())
			.produces(requestMapping.produces())
			.mappingName(requestMapping.name());
	if (customCondition != null) {
		builder.customCondition(customCondition);
	}
	return builder.options(this.config).build();
}

@RequestMapping注解上的配置,就对应了 RequestMappingInfo 内部的七个变量。
最后,我们看一下 RequestMappingInfo 的匹配过程吧。其实非常简单,就是按顺序依次匹配内部的七个条件对象,全部匹配通过才算通过。

public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
	RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
	if (methods == null) {
		return null;
	}
	ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
	if (params == null) {
		return null;
	}
	HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
	if (headers == null) {
		return null;
	}
	ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
	if (consumes == null) {
		return null;
	}
	ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
	if (produces == null) {
		return null;
	}
	PathPatternsRequestCondition pathPatterns = null;
	if (this.pathPatternsCondition != null) {
		pathPatterns = this.pathPatternsCondition.getMatchingCondition(request);
		if (pathPatterns == null) {
			return null;
		}
	}
	PatternsRequestCondition patterns = null;
	if (this.patternsCondition != null) {
		patterns = this.patternsCondition.getMatchingCondition(request);
		if (patterns == null) {
			return null;
		}
	}
	RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
	if (custom == null) {
		return null;
	}
	return new RequestMappingInfo(this.name, pathPatterns, patterns,
			methods, params, headers, consumes, produces, custom, this.options);
}

尾巴

Spring MVC 把 HTTP 请求路由到 HandlerMethod 是一个极其复杂的过程,要匹配的条件项之多,为此专门抽象出了 RequestCondition 接口,代表请求要匹配的条件。@RequestMapping注解的每一项配置都对应一个 RequestCondition 实现类,每个实现类只负责自己的条件匹配逻辑。
最后,为了聚合这些条件,Spring MVC 还提供了 RequestMappingInfo 子类,内部用七个变量记录注解配置的条件对象,方便一次性完成匹配。有了 RequestMappingInfo 对象,Spring MVC 就能轻松把请求路由到 HandlerMethod。

你可能感兴趣的:(Spring,MVC,spring,mvc,java)