Spring中的路径匹配器AntPathMatcher详解

更新时间：2023年09月25日 10:01:58 作者：骑个小蜗牛

这篇文章主要介绍了Spring中的路径匹配器AntPathMatcher详解,Spring的PathMatcher路径匹配器接口,用于支持带通配符的资源路径匹配,本文提供了部分实现代码,需要的朋友可以参考下

PathMatcher接口

Spring的PathMatcher路径匹配器接口，用于支持带通配符的资源路径匹配。

使用场景

PathMatcher接口在Spring的许多场景下使用，比如：

PathMatchingResourcePatternResolver：资源扫描，启动时扫描并加载资源
AbstractUrlHandlerMapping：请求路径映射到 Controller
WebContentInterceptor：拦截器拦截路径分析

接口方法

方法	描述
boolean isPattern(String path)	判断路径是否是模式
boolean match(String pattern, String path)	判断路径是否完全匹配
boolean matchStart(String pattern, String path)	判断路径是否前缀匹配前缀匹配的意思：路径能与模式的前面部分匹配，但模式可能还有后面多余部分例如：/test能前缀匹配/test/{id}（但模式还有多余的/{id}部分未匹配）
String extractPathWithinPattern(String pattern, String path)	得到模式匹配的部分值该方法只返回路径的实际模式匹配部分例如：myroot/*.html 匹配 myroot/myfile.html 路径，结果为 myfile.html
Map<String, String> extractUriTemplateVariables(String pattern, String path)	提取路径中的路径参数值
Comparator<String> getPatternComparator(String path)	得到一个排序比较器，用于对匹配到的所有路径进行排序
String combine(String pattern1, String pattern2)	合并两个模式

AntPathMatcher类

AntPathMatcher是Spring为PathMatcher接口提供的默认实现，支持Ant风格的路径匹配。

匹配规则

AntPathMatcher支持的匹配规则：

规则	描述
?	匹配一个字符
*	在一个路径段中匹配零个、一个或多个字符
**	匹配零个或多个路径段，直到路径结束
{id}	匹配一个路径段，并将该路径段的值作为变量id的变量值
{id:[a-z]+}	匹配一个满足正则（[a-z]+）路径段，并将该路径段的值作为变量id的变量值

举例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        // ?
        System.out.println(matcher.match("/test/a?c", "/test/abc"));// true
        // *
        System.out.println(matcher.match("/test/*", "/test/"));// true
        System.out.println(matcher.match("/test/*", "/test/aa"));// true
        System.out.println(matcher.match("/test/*.html", "/test/aa"));// false
        // **
        System.out.println(matcher.match("/test/**", "/test/"));// true
        System.out.println(matcher.match("/test/**", "/test/aa"));// true
        System.out.println(matcher.match("/test/**", "/test/aa/bb"));// true
        // {id}
        System.out.println(matcher.match("/test/{id}", "/test/111"));// true
        System.out.println(matcher.match("/test/a{id}", "/test/a111"));// true
        System.out.println(matcher.match("/test/{id}/aa", "/test/111/aa"));// true
        System.out.println(matcher.match("/test/{id}-{name}/aa", "/test/111-haha/aa"));// true
        // {id:[a-z]+}
        System.out.println(matcher.match("/test/{id:[a-z]+}", "/test/111"));// false
        System.out.println(matcher.match("/test/{id:[a-z]+}", "/test/abc"));// true
        System.out.println(matcher.match("/test/{id:\\w+}", "/test/1a_"));// true
        System.out.println(matcher.match("/test/{id:\\w+}", "/test/--"));// false
    }

一些不匹配情况原因：

模式	路径	原因
/user/aaa/	/user/aaa	结束符不一致
/user/*/	/user/aaa	结束符不一致

实际在Spring项目中使用的时候，你会发现：就算实际请求的结束符为 / ，但还是能匹配成功。这又是为什么呢？

两个关键属性：

useSuffixPatternMatch：设置是否使用后缀模式匹配，如“/user”是否匹配/user.*，默认是这种模式下，实际请求.后面加任何后缀，都会匹配到。如：实际请求“/user.html”能匹配上“/user”。
useTrailingSlashMatch：设置是否使用后缀路径模式匹配，如“/user”是否匹配“/user/”，默认是这种模式下，实际请求加、后缀，都会匹配到。如：实际请求“/user/”能匹配上“/user”。

关键源码：

PatternsRequestCondition类的getMatchingPattern方法

private String getMatchingPattern(String pattern, String lookupPath) {
		// 模式与路径相等，直接返回模式
		if (pattern.equals(lookupPath)) {
			return pattern;
		}
		// 如果使用后缀模式匹配，返回的模式会拼接上合适的后缀，如.html
		if (this.useSuffixPatternMatch) {
			if (!this.fileExtensions.isEmpty() && lookupPath.indexOf('.') != -1) {
				for (String extension : this.fileExtensions) {
					if (this.pathMatcher.match(pattern + extension, lookupPath)) {
						return pattern + extension;
					}
				}
			}
			else {
				boolean hasSuffix = pattern.indexOf('.') != -1;
				if (!hasSuffix && this.pathMatcher.match(pattern + ".*", lookupPath)) {
					return pattern + ".*";
				}
			}
		}
		if (this.pathMatcher.match(pattern, lookupPath)) {
			return pattern;
		}
		// 如果使用后缀路径模式匹配，返回的模式会拼接上/
		if (this.useTrailingSlashMatch) {
			if (!pattern.endsWith("/") && this.pathMatcher.match(pattern + "/", lookupPath)) {
				return pattern + "/";
			}
		}
		return null;
	}

因此，getMatchingPattern方法返回的模式再与请求路径进行模式匹配当然能匹配上了。

主要方法

1. isPattern

判断路径是否是模式。

只要路径中拥有 * 、 ? 、 {} ，则就是模式。

public boolean isPattern(@Nullable String path) {
    if (path == null) {
        return false;
    }
    boolean uriVar = false;
    for (int i = 0; i < path.length(); i++) {
        char c = path.charAt(i);
        if (c == '*' || c == '?') {
            return true;
        }
        if (c == '{') {
            uriVar = true;
            continue;
        }
        if (c == '}' && uriVar) {
            return true;
        }
    }
    return false;
}

示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.isPattern("/test/{id}"));// true
    }

2. match

判断路径是否完全匹配

public boolean match(String pattern, String path) {
    return doMatch(pattern, path, true, null);
}

示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.match("/test/*", "/test/111"));// true
        System.out.println(matcher.match("/test/**", "/test/111/222"));// true
        System.out.println(matcher.match("/test/{id}", "/test/111"));// true
        System.out.println(matcher.match("/test/{id}/aa", "/test/111/aa"));// true
        System.out.println(matcher.match("/test/{id}-{name}/aa", "/test/111-haha/aa"));// true
        System.out.println(matcher.match("/test/{id}-{name}/aa", "/test/111-/aa"));// true
    }

3. matchStart

判断路径是否前缀匹配

前缀匹配的意思：路径能与模式的前面部分匹配，但模式可能还有后面多余部分（可以理解为模式是否是以路径开头）

public boolean matchStart(String pattern, String path) {
    return doMatch(pattern, path, false, null);
}

示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.matchStart("/test/*", "/test"));// true
        System.out.println(matcher.matchStart("/test/aa/*", "/test"));// true
        System.out.println(matcher.matchStart("/test/{id}", "/test"));// true
        System.out.println(matcher.matchStart("/test/{id}-{name}/aa", "/test"));// true
        System.out.println(matcher.matchStart("/test/{id}", "/test/111/222"));// false
    }

4. extractPathWithinPattern

得到模式匹配的映射部分。找出通过*或者?匹配上的那一段路径及其后续路径。

示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.extractPathWithinPattern("/test/*", "/test"));//
        System.out.println(matcher.extractPathWithinPattern("/test/*", "/test/aa"));// aa
        System.out.println(matcher.extractPathWithinPattern("/test/**", "/test/aa/bb"));// aa/bb
        System.out.println(matcher.extractPathWithinPattern("/test/a?c/aa", "/test/abc/aa"));// abc/aa
        System.out.println(matcher.extractPathWithinPattern("/test/aa?c/aa/cc", "/test/abc/aa"));// abc/aa
    }

5. extractUriTemplateVariables

路径必须完全匹配（否则抛出异常），并提取路径中的路径参数值。

示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.extractPathWithinPattern("/test/*", "/test"));//
        System.out.println(matcher.extractPathWithinPattern("/test/*", "/test/aa"));// aa
        System.out.println(matcher.extractPathWithinPattern("/test/**", "/test/aa/bb"));// aa/bb
        System.out.println(matcher.extractPathWithinPattern("/test/a?c/aa", "/test/abc/aa"));// abc/aa
        System.out.println(matcher.extractPathWithinPattern("/test/aa?c/aa/cc", "/test/abc/aa"));// abc/aa
    }

6. getPatternComparator

得到一个排序比较器。

public Comparator<String> getPatternComparator(String path) {
		return new AntPatternComparator(path);
	}

7. combine

合并两个模式。示例：

    public static void main(String[] args) {
        AntPathMatcher matcher = new AntPathMatcher();
        System.out.println(matcher.combine("/test/*", "/test/aa"));// /test/aa
        System.out.println(matcher.combine("/test/*", "/test/aa/bb"));// /test/test/aa/bb
        System.out.println(matcher.combine("/test/**", "/test/aa"));// /test/aa
        System.out.println(matcher.combine("/test/{id}", "/test/aa"));// /test/{id}/test/aa
    }

到此这篇关于Spring中的路径匹配器AntPathMatcher详解的文章就介绍到这了,更多相关AntPathMatcher详解内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java微信公众平台开发（7）公众平台测试帐号的申请
这篇文章主要为大家详细介绍了Java微信公众平台开发第七步，微信公众平台测试帐号的申请，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-04-04
Java时区转换及Date类实现原理解析
这篇文章主要介绍了Java时区转换及Date类实现原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2019-11-11
Java序列化机制详解
Java 序列化机制是一种将对象转换为字节流的过程,以便在网络上传输或保存到文件中,并能在需要时将字节流还原为对象,这一机制通过实现 java.io.Serializable 接口来实现,同时涉及到一些关键概念和注意事项,需要的朋友可以参考下
2023-12-12
Springboot+netty实现Web聊天室
这篇文章主要介绍了利用springboot+netty实现一个简单Web聊天室,文中有非常详细的代码示例,对正在学习Java的小伙伴们有非常好的帮助,需要的朋友可以参考下
2021-12-12
Java LinkedList集合功能实例解析
这篇文章主要介绍了Java LinkedList集合功能实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-04-04
SpringBoot基于knife4j生成接口文档方式
Knife4j介绍一个基于Swagger的JavaAPI文档生成工具,提供美观界面和高级功能,本文详细介绍了在SpringBoot项目中集成Knife4j的方法,包括导入依赖、创建Swagger配置和WebMvcConfiguration配置类等
2026-05-05
Java中Date时区的转换代码示例
这篇文章主要给大家介绍了关于Java中Date时区转换的相关资料,当在不同的时区使用相同程序,时间的值只会为当地时间,这样就会造成时间混乱,需要的朋友可以参考下
2023-07-07
java项目中classpath的理解
这篇文章介绍了java项目中classpath的理解，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-12-12
MyBatis-Plus通过version机制实现乐观锁的思路
version机制的核心思想就是，假设发生并发冲突的几率很低，只有当更新数据的时候采取检查是否有冲突，而判断是否有冲突的依据就是version的值是否被改变了，这篇文章主要介绍了MyBatis-Plus通过version机制实现乐观锁的思路,需要的朋友可以参考下
2021-09-09
关于Logback+MyBatis日志输出问题的一些思考
这篇文章主要介绍了关于Logback+MyBatis日志输出问题的一些思考,具有很好的参考价值,希望对大家有所帮助,
2023-09-09