Add HTTP method support to MappedInterceptor

This enhancement enables finer control over interceptor application
based on HTTP methods, aligning with modern Spring 7.x practices.

- Extend MappedInterceptor with include/exclude HTTP methods
- Add constructors for interceptor implementations
- Update InterceptorRegistration with fluent methods
- Keep existing constructors and methods for compatibility
- Update matches() to check HTTP method conditions

See gh-35273

Signed-off-by: SRIRAM9487 <sriram9487tk@gmail.com>

spring-webmvc/src/main/java/org/springframework/web/servlet/config/annotation/InterceptorRegistration.java

@@ -22,6 +22,7 @@ import java.util.List;
 
 import org.jspecify.annotations.Nullable;
 
+import org.springframework.http.HttpMethod;
 import org.springframework.util.AntPathMatcher;
 import org.springframework.util.Assert;
 import org.springframework.util.PathMatcher;
@@ -48,6 +49,10 @@ public class InterceptorRegistration {
 
 	private @Nullable List<String> excludePatterns;
 
+	private @Nullable List<HttpMethod> includeHttpMethods;
+
+	private @Nullable List<HttpMethod> excludeHttpMethods;
+
 	private @Nullable PathMatcher pathMatcher;
 
 	private int order = 0;
@@ -106,6 +111,46 @@ public class InterceptorRegistration {
 		return this;
 	}
 
+	/**
+	 * Add HTTP methods the interceptor should be included for.
+	 * <p>Only requests with these HTTP methods will be intercepted.
+	 * @since 7.0.x
+	 */
+	public InterceptorRegistration includeHttpMethods(HttpMethod... httpMethods) {
+		return includeHttpMethods(Arrays.asList(httpMethods));
+	}
+
+	/**
+	 * List-based variant of {@link #includeHttpMethods(HttpMethod...)}.
+	 * @since 7.0.x
+	 */
+	public InterceptorRegistration includeHttpMethods(List<HttpMethod> httpMethods) {
+		this.includeHttpMethods = (this.includeHttpMethods != null ?
+				this.includeHttpMethods : new ArrayList<>(httpMethods.size()));
+		this.includeHttpMethods.addAll(httpMethods);
+		return this;
+	}
+
+	/**
+	 * Add HTTP methods the interceptor should be excluded from.
+	 * <p>Requests with these HTTP methods will be ignored by the interceptor.
+	 * @since 7.0.x
+	 */
+	public InterceptorRegistration excludeHttpMethods(HttpMethod... httpMethods){
+		return this.excludeHttpMethods(Arrays.asList(httpMethods));
+	}
+
+	/**
+	 * List-based variant of {@link #excludeHttpMethods(HttpMethod...)}.
+	 * @since 7.0.x
+	 */
+	public InterceptorRegistration excludeHttpMethods(List<HttpMethod> httpMethods){
+		this.excludeHttpMethods = (this.excludeHttpMethods != null ?
+				this.excludeHttpMethods : new ArrayList<>(httpMethods.size()));
+		this.excludeHttpMethods.addAll(httpMethods);
+		return this;
+	}
+
 	/**
 	 * Configure the PathMatcher to use to match URL paths with against include
 	 * and exclude patterns.
@@ -143,19 +188,32 @@ public class InterceptorRegistration {
 	}
 
 	/**
-	 * Build the underlying interceptor. If URL patterns are provided, the returned
+	 * Build the underlying interceptor. If URL patterns or HTTP methods are provided, the returned
 	 * type is {@link MappedInterceptor}; otherwise {@link HandlerInterceptor}.
 	 */
 	@SuppressWarnings("removal")
 	protected Object getInterceptor() {
 
-		if (this.includePatterns == null && this.excludePatterns == null) {
+		if (this.includePatterns == null && this.excludePatterns == null && this.includeHttpMethods == null && this.excludeHttpMethods == null) {
 			return this.interceptor;
 		}
 
+		HttpMethod[] includeMethodsArray = (this.includeHttpMethods != null) ?
+				this.includeHttpMethods.toArray(new HttpMethod[0]) : null;
+
+		HttpMethod[] excludeMethodsArray = (this.excludeHttpMethods != null) ?
+				this.excludeHttpMethods.toArray(new HttpMethod[0]) : null;
+
+		String[] includePattersArray = StringUtils.toStringArray(this.includePatterns);
+
+		String[] excludePattersArray = StringUtils.toStringArray(this.excludePatterns);
+
+
 		MappedInterceptor mappedInterceptor = new MappedInterceptor(
-				StringUtils.toStringArray(this.includePatterns),
-				StringUtils.toStringArray(this.excludePatterns),
+				includePattersArray,
+				excludePattersArray,
+				includeMethodsArray,
+				excludeMethodsArray,
 				this.interceptor);
 
 		if (this.pathMatcher != null) {

spring-webmvc/src/main/java/org/springframework/web/servlet/handler/MappedInterceptor.java

@@ -22,6 +22,7 @@ import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import org.jspecify.annotations.Nullable;
 
+import org.springframework.http.HttpMethod;
 import org.springframework.http.server.PathContainer;
 import org.springframework.util.AntPathMatcher;
 import org.springframework.util.ObjectUtils;
@@ -67,6 +68,10 @@ public final class MappedInterceptor implements HandlerInterceptor {
 
 	private final PatternAdapter @Nullable [] excludePatterns;
 
+	private final MethodAdapter @Nullable [] includeHttpMethods;
+
+	private final MethodAdapter @Nullable [] excludeHttpMethods;
+
 	private PathMatcher pathMatcher = defaultPathMatcher;
 
 	private final HandlerInterceptor interceptor;
@@ -78,58 +83,79 @@ public final class MappedInterceptor implements HandlerInterceptor {
 	 * @param includePatterns patterns to which requests must match, or null to
 	 * match all paths
 	 * @param excludePatterns patterns to which requests must not match
+	 * @param includeHttpMethods http methods to which request must match, or null to match all paths
+	 * @param excludeHttpMethods http methods to which request must not match
 	 * @param interceptor the target interceptor
 	 * @param parser a parser to use to pre-parse patterns into {@link PathPattern};
 	 * when not provided, {@link PathPatternParser#defaultInstance} is used.
 	 * @since 5.3
 	 */
-	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns,
+	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns, HttpMethod @Nullable [] includeHttpMethods, HttpMethod @Nullable [] excludeHttpMethods,
 			HandlerInterceptor interceptor, @Nullable PathPatternParser parser) {
 
 		this.includePatterns = PatternAdapter.initPatterns(includePatterns, parser);
 		this.excludePatterns = PatternAdapter.initPatterns(excludePatterns, parser);
+		this.includeHttpMethods = MethodAdapter.initHttpMethods(includeHttpMethods);
+		this.excludeHttpMethods = MethodAdapter.initHttpMethods(excludeHttpMethods);
 		this.interceptor = interceptor;
 	}
 
 
 	/**
 	 * Variant of
-	 * {@link #MappedInterceptor(String[], String[], HandlerInterceptor, PathPatternParser)}
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[], HandlerInterceptor, PathPatternParser)}
 	 * with include patterns only.
 	 */
 	public MappedInterceptor(String @Nullable [] includePatterns, HandlerInterceptor interceptor) {
-		this(includePatterns, null, interceptor);
+		this(includePatterns, null, null, null, interceptor);
 	}
 
 	/**
 	 * Variant of
-	 * {@link #MappedInterceptor(String[], String[], HandlerInterceptor, PathPatternParser)}
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[], HandlerInterceptor, PathPatternParser)}
+	 * with include methods only.
+	 */
+	public MappedInterceptor(HttpMethod @Nullable [] includeHttpMethods, HandlerInterceptor interceptor) {
+		this(null, null, includeHttpMethods, null, interceptor);
+	}
+
+	/**
+	 * Variant of
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[], HandlerInterceptor, PathPatternParser)}
 	 * without a provided parser.
 	 */
-	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns,
+	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns, HttpMethod @Nullable [] includeHttpMethods, HttpMethod @Nullable [] excludeHttpMethods,
 			HandlerInterceptor interceptor) {
 
-		this(includePatterns, excludePatterns, interceptor, null);
+		this(includePatterns, excludePatterns,includeHttpMethods,excludeHttpMethods, interceptor, null);
 	}
 
 	/**
 	 * Variant of
-	 * {@link #MappedInterceptor(String[], String[], HandlerInterceptor, PathPatternParser)}
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[], HandlerInterceptor, PathPatternParser)}
 	 * with a {@link WebRequestInterceptor} as the target.
 	 */
 	public MappedInterceptor(String @Nullable [] includePatterns, WebRequestInterceptor interceptor) {
-		this(includePatterns, null, interceptor);
+		this(includePatterns, null,null,null, interceptor);
+	}
+	/**
+	 * Variant of
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[], HandlerInterceptor, PathPatternParser)}
+	 * with a {@link WebRequestInterceptor} as the target.
+	 */
+	public MappedInterceptor(HttpMethod @Nullable [] includeHttpMethods, WebRequestInterceptor interceptor) {
+		this(null, null,includeHttpMethods ,null, interceptor);
 	}
 
 	/**
 	 * Variant of
-	 * {@link #MappedInterceptor(String[], String[], HandlerInterceptor, PathPatternParser)}
+	 * {@link #MappedInterceptor(String[], String[], HttpMethod[], HttpMethod[] , HandlerInterceptor, PathPatternParser)}
 	 * with a {@link WebRequestInterceptor} as the target.
 	 */
-	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns,
+	public MappedInterceptor(String @Nullable [] includePatterns, String @Nullable [] excludePatterns, HttpMethod @Nullable [] includeHttpMethods, HttpMethod @Nullable [] excludeHttpMethods,
 			WebRequestInterceptor interceptor) {
 
-		this(includePatterns, excludePatterns, new WebRequestHandlerInterceptorAdapter(interceptor));
+		this(includePatterns, excludePatterns,includeHttpMethods,excludeHttpMethods, new WebRequestHandlerInterceptorAdapter(interceptor));
 	}
 
 
@@ -202,6 +228,7 @@ public final class MappedInterceptor implements HandlerInterceptor {
 	 */
 	public boolean matches(HttpServletRequest request) {
 		Object path = ServletRequestPathUtils.getCachedPath(request);
+		HttpMethod method = HttpMethod.valueOf(request.getMethod());
 		if (this.pathMatcher != defaultPathMatcher) {
 			path = path.toString();
 		}
@@ -213,12 +240,45 @@ public final class MappedInterceptor implements HandlerInterceptor {
 				}
 			}
 		}
-		if (ObjectUtils.isEmpty(this.includePatterns)) {
+		if (!ObjectUtils.isEmpty(this.excludeHttpMethods)) {
+			for (MethodAdapter adapter : this.excludeHttpMethods) {
+				if (adapter.match(method)){
+					return false;
+				}
+			}
+		}
+		if (ObjectUtils.isEmpty(this.includePatterns) && ObjectUtils.isEmpty(this.includeHttpMethods)) {
 			return true;
 		}
-		for (PatternAdapter adapter : this.includePatterns) {
-			if (adapter.match(path, isPathContainer, this.pathMatcher)) {
-				return true;
+		if (!ObjectUtils.isEmpty(this.includePatterns) && ObjectUtils.isEmpty(this.includeHttpMethods)) {
+			for (PatternAdapter adapter : this.includePatterns) {
+				if (adapter.match(path, isPathContainer, this.pathMatcher)) {
+					return true;
+				}
+			}
+		}
+		if (!ObjectUtils.isEmpty(this.includeHttpMethods) && ObjectUtils.isEmpty(this.includePatterns)) {
+			for (MethodAdapter adapter : this.includeHttpMethods) {
+				if (adapter.match(method)) {
+					return true;
+				}
+			}
+		}
+		if (!ObjectUtils.isEmpty(this.includePatterns) && !ObjectUtils.isEmpty(this.includeHttpMethods)) {
+			boolean match = false;
+			for (MethodAdapter methodAdapter : this.includeHttpMethods) {
+				if (methodAdapter.match(method)) {
+					match = true;
+					break;
+				}
+			}
+			if (!match) {
+				return false;
+			}
+			for (PatternAdapter pathAdapter : this.includePatterns) {
+				if (pathAdapter.match(path, isPathContainer, pathMatcher)) {
+					return true;
+				}
 			}
 		}
 		return false;
@@ -305,4 +365,40 @@ public final class MappedInterceptor implements HandlerInterceptor {
 		}
 	}
 
+	/**
+	 * Adapts {@link HttpMethod} instances for internal matching purposes.
+	 *
+	 * <p>Encapsulates an {@link HttpMethod} and provides matching functionality.
+	 * Also provides a utility method to initialize arrays of {@code MethodAdapter}
+	 * instances from arrays of {@link HttpMethod}.</p>
+	 *
+	 * @since 7.0.x
+	 */
+	private static class MethodAdapter {
+
+		private final @Nullable HttpMethod httpMethod;
+
+		public MethodAdapter(@Nullable HttpMethod httpMethod) {
+			this.httpMethod = httpMethod;
+		}
+
+		public boolean match(HttpMethod method) {
+			return this.httpMethod == method;
+		}
+
+		public @Nullable HttpMethod  getHttpMethod() {
+			return this.httpMethod;
+		}
+
+		private static MethodAdapter @Nullable [] initHttpMethods(HttpMethod @Nullable [] methods) {
+			if (ObjectUtils.isEmpty(methods)) {
+				return null;
+			}
+			return Arrays.stream(methods)
+					.map(MethodAdapter::new)
+					.toArray(MethodAdapter[]::new);
+		}
+
+	}
+
 }

spring-webmvc/src/test/java/org/springframework/web/servlet/handler/MappedInterceptorTests.java

@@ -26,10 +26,12 @@ import jakarta.servlet.http.HttpServletResponse;
 import org.junit.jupiter.api.Named;
 import org.junit.jupiter.api.Test;
 
+import org.springframework.http.HttpMethod;
 import org.springframework.util.PathMatcher;
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
 import org.springframework.web.testfixture.servlet.MockHttpServletRequest;
+import org.springframework.web.util.ServletRequestPathUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
@@ -50,16 +52,23 @@ class MappedInterceptorTests {
 		return PathPatternsTestUtils.requestArguments();
 	}
 
+	private MockHttpServletRequest requestWithMethod(String method) {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setRequestURI("/some/path");
+		request.setMethod(method);
+		ServletRequestPathUtils.parseAndCache(request);
+		return request;
+	}
 
 	@PathPatternsParameterizedTest
 	void noPatterns(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(null, null, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,null,null, delegate);
 		assertThat(interceptor.matches(requestFactory.apply("/foo"))).isTrue();
 	}
 
 	@PathPatternsParameterizedTest
 	void includePattern(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo/*" }, null, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo/*" }, null,null,null, delegate);
 
 		assertThat(interceptor.matches(requestFactory.apply("/foo/bar"))).isTrue();
 		assertThat(interceptor.matches(requestFactory.apply("/bar/foo"))).isFalse();
@@ -67,13 +76,13 @@ class MappedInterceptorTests {
 
 	@PathPatternsParameterizedTest
 	void includePatternWithMatrixVariables(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo*/*" }, null, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo*/*" },null,null, null, delegate);
 		assertThat(interceptor.matches(requestFactory.apply("/foo;q=1/bar;s=2"))).isTrue();
 	}
 
 	@PathPatternsParameterizedTest
 	void excludePattern(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(null, new String[] { "/admin/**" }, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(null, new String[] { "/admin/**" },null,null, delegate);
 
 		assertThat(interceptor.matches(requestFactory.apply("/foo"))).isTrue();
 		assertThat(interceptor.matches(requestFactory.apply("/admin/foo"))).isFalse();
@@ -82,7 +91,7 @@ class MappedInterceptorTests {
 	@PathPatternsParameterizedTest
 	void includeAndExcludePatterns(Function<String, MockHttpServletRequest> requestFactory) {
 		MappedInterceptor interceptor =
-				new MappedInterceptor(new String[] { "/**" }, new String[] { "/admin/**" }, delegate);
+				new MappedInterceptor(new String[] { "/**" }, new String[] { "/admin/**" },null,null, delegate);
 
 		assertThat(interceptor.matches(requestFactory.apply("/foo"))).isTrue();
 		assertThat(interceptor.matches(requestFactory.apply("/admin/foo"))).isFalse();
@@ -90,7 +99,7 @@ class MappedInterceptorTests {
 
 	@PathPatternsParameterizedTest // gh-26690
 	void includePatternWithFallbackOnPathMatcher(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/path1/**/path2" }, null, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/path1/**/path2" },null,null, null, delegate);
 
 		assertThat(interceptor.matches(requestFactory.apply("/path1/foo/bar/path2"))).isTrue();
 		assertThat(interceptor.matches(requestFactory.apply("/path1/foo/bar/path3"))).isFalse();
@@ -100,18 +109,97 @@ class MappedInterceptorTests {
 	@SuppressWarnings("removal")
 	@PathPatternsParameterizedTest
 	void customPathMatcher(Function<String, MockHttpServletRequest> requestFactory) {
-		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo/[0-9]*" }, null, delegate);
+		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo/[0-9]*" },null,null, null, delegate);
 		interceptor.setPathMatcher(new TestPathMatcher());
 
 		assertThat(interceptor.matches(requestFactory.apply("/foo/123"))).isTrue();
 		assertThat(interceptor.matches(requestFactory.apply("/foo/bar"))).isFalse();
 	}
 
+	@Test
+	void includeMethods(){
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,new HttpMethod[]{HttpMethod.GET},null, delegate);
+		assertThat(interceptor.matches(requestWithMethod("GET"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("HEAD"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("POST"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("PUT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("DELETE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("CONNECT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("OPTIONS"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("TRACE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("PATCH"))).isFalse();
+	}
+
+	@Test
+	void includeMultipleMethods(){
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,new HttpMethod[]{HttpMethod.GET,HttpMethod.POST},null, delegate);
+		assertThat(interceptor.matches(requestWithMethod("GET"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("HEAD"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("POST"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("PUT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("DELETE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("CONNECT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("OPTIONS"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("TRACE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("PATCH"))).isFalse();
+	}
+
+	@Test
+	void excludeMethods(){
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,null,new HttpMethod[]{HttpMethod.GET}, delegate);
+		assertThat(interceptor.matches(requestWithMethod("GET"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("HEAD"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("POST"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("PUT"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("DELETE"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("CONNECT"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("OPTIONS"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("TRACE"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("PATCH"))).isTrue();
+	}
+
+	@Test
+	void excludeMultipleMethods(){
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,null,new HttpMethod[]{HttpMethod.GET,HttpMethod.POST,HttpMethod.OPTIONS}, delegate);
+		assertThat(interceptor.matches(requestWithMethod("GET"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("HEAD"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("POST"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("PUT"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("DELETE"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("CONNECT"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("OPTIONS"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("TRACE"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("PATCH"))).isTrue();
+	}
+
+	@Test
+	void includeMethodsAndExcludeMethods(){
+		MappedInterceptor interceptor = new MappedInterceptor(null, null,new HttpMethod[]{HttpMethod.GET,HttpMethod.POST},new HttpMethod[]{HttpMethod.OPTIONS}, delegate);
+		assertThat(interceptor.matches(requestWithMethod("GET"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("HEAD"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("POST"))).isTrue();
+		assertThat(interceptor.matches(requestWithMethod("PUT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("DELETE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("CONNECT"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("OPTIONS"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("TRACE"))).isFalse();
+		assertThat(interceptor.matches(requestWithMethod("PATCH"))).isFalse();
+	}
+
+	@PathPatternsParameterizedTest
+	void includePatternAndIncludeMethods(Function<String, MockHttpServletRequest> requestFactory) {
+		MappedInterceptor interceptor = new MappedInterceptor(new String[] { "/foo/*" }, null,new HttpMethod[]{HttpMethod.GET},null, delegate);
+
+		assertThat(interceptor.matches(requestFactory.apply("/foo/bar"))).isTrue();
+		assertThat(interceptor.matches(requestFactory.apply("/bar/foo"))).isFalse();
+	}
+
+
 	@Test
 	void preHandle() throws Exception {
 		HandlerInterceptor delegate = mock();
 
-		new MappedInterceptor(null, delegate).preHandle(mock(), mock(), null);
+		new MappedInterceptor(null,null,null,null, delegate).preHandle(mock(), mock(), null);
 
 		then(delegate).should().preHandle(any(HttpServletRequest.class), any(HttpServletResponse.class), any());
 	}
@@ -120,7 +208,7 @@ class MappedInterceptorTests {
 	void postHandle() throws Exception {
 		HandlerInterceptor delegate = mock();
 
-		new MappedInterceptor(null, delegate).postHandle(mock(), mock(), null, mock());
+		new MappedInterceptor(null,null,null,null, delegate).postHandle(mock(), mock(), null, mock());
 
 		then(delegate).should().postHandle(any(), any(), any(), any());
 	}
@@ -129,7 +217,7 @@ class MappedInterceptorTests {
 	void afterCompletion() throws Exception {
 		HandlerInterceptor delegate = mock();
 
-		new MappedInterceptor(null, delegate).afterCompletion(mock(), mock(), null, mock());
+		new MappedInterceptor(null,null,null,null, delegate).afterCompletion(mock(), mock(), null, mock());
 
 		then(delegate).should().afterCompletion(any(), any(), any(), any());
 	}