1919import java .util .ArrayList ;
2020import java .util .Arrays ;
2121import java .util .List ;
22+ import java .util .Set ;
23+ import java .util .stream .Collectors ;
2224
25+ import org .eclipse .jetty .http .HttpMethod ;
2326import org .jspecify .annotations .Nullable ;
24-
2527import org .springframework .util .AntPathMatcher ;
2628import org .springframework .util .Assert ;
2729import org .springframework .util .PathMatcher ;
2830import org .springframework .util .StringUtils ;
2931import org .springframework .web .servlet .HandlerInterceptor ;
3032import org .springframework .web .servlet .handler .MappedInterceptor ;
33+ import org .springframework .web .servlet .handler .MethodInterceptor ;
3134import org .springframework .web .util .ServletRequestPathUtils ;
3235import org .springframework .web .util .UrlPathHelper ;
3336import org .springframework .web .util .pattern .PathPattern ;
@@ -50,8 +53,9 @@ public class InterceptorRegistration {
5053
5154 private @ Nullable PathMatcher pathMatcher ;
5255
53- private int order = 0 ;
56+ private @ Nullable Set < String > allowedMethods ;
5457
58+ private int order = 0 ;
5559
5660 /**
5761 * Create an {@link InterceptorRegistration} instance.
@@ -61,10 +65,10 @@ public InterceptorRegistration(HandlerInterceptor interceptor) {
6165 this .interceptor = interceptor ;
6266 }
6367
64-
6568 /**
6669 * Add patterns for URLs the interceptor should be included in.
67- * <p>For pattern syntax see {@link PathPattern} when parsed patterns
70+ * <p>
71+ * For pattern syntax see {@link PathPattern} when parsed patterns
6872 * are {@link PathMatchConfigurer#setPatternParser enabled} or
6973 * {@link AntPathMatcher} otherwise. The syntax is largely the same with
7074 * {@link PathPattern} more tailored for web usage and more efficient.
@@ -75,18 +79,19 @@ public InterceptorRegistration addPathPatterns(String... patterns) {
7579
7680 /**
7781 * List-based variant of {@link #addPathPatterns(String...)}.
82+ *
7883 * @since 5.0.3
7984 */
8085 public InterceptorRegistration addPathPatterns (List <String > patterns ) {
81- this .includePatterns = (this .includePatterns != null ?
82- this .includePatterns : new ArrayList <>(patterns .size ()));
86+ this .includePatterns = (this .includePatterns != null ? this .includePatterns : new ArrayList <>(patterns .size ()));
8387 this .includePatterns .addAll (patterns );
8488 return this ;
8589 }
8690
8791 /**
8892 * Add patterns for URLs the interceptor should be excluded from.
89- * <p>For pattern syntax see {@link PathPattern} when parsed patterns
93+ * <p>
94+ * For pattern syntax see {@link PathPattern} when parsed patterns
9095 * are {@link PathMatchConfigurer#setPatternParser enabled} or
9196 * {@link AntPathMatcher} otherwise. The syntax is largely the same with
9297 * {@link PathPattern} more tailored for web usage and more efficient.
@@ -97,28 +102,34 @@ public InterceptorRegistration excludePathPatterns(String... patterns) {
97102
98103 /**
99104 * List-based variant of {@link #excludePathPatterns(String...)}.
105+ *
100106 * @since 5.0.3
101107 */
102108 public InterceptorRegistration excludePathPatterns (List <String > patterns ) {
103- this .excludePatterns = (this .excludePatterns != null ?
104- this .excludePatterns : new ArrayList <>(patterns .size ()));
109+ this .excludePatterns = (this .excludePatterns != null ? this .excludePatterns : new ArrayList <>(patterns .size ()));
105110 this .excludePatterns .addAll (patterns );
106111 return this ;
107112 }
108113
109114 /**
110115 * Configure the PathMatcher to use to match URL paths with against include
111116 * and exclude patterns.
112- * <p>This is an advanced property that should be used only when a
117+ * <p>
118+ * This is an advanced property that should be used only when a
113119 * customized {@link AntPathMatcher} or a custom PathMatcher is required.
114- * <p>By default this is {@link AntPathMatcher}.
115- * <p><strong>Note:</strong> Setting {@code PathMatcher} enforces use of
120+ * <p>
121+ * By default this is {@link AntPathMatcher}.
122+ * <p>
123+ * <strong>Note:</strong> Setting {@code PathMatcher} enforces use of
116124 * String pattern matching even when a
117125 * {@link ServletRequestPathUtils#parseAndCache parsed} {@code RequestPath}
118126 * is available.
119- * @deprecated use of {@link PathMatcher} and {@link UrlPathHelper} is deprecated
120- * for use at runtime in web modules in favor of parsed patterns with
121- * {@link PathPatternParser}.
127+ *
128+ * @deprecated use of {@link PathMatcher} and {@link UrlPathHelper} is
129+ * deprecated
130+ * for use at runtime in web modules in favor of parsed patterns
131+ * with
132+ * {@link PathPatternParser}.
122133 */
123134 @ Deprecated (since = "7.0" , forRemoval = true )
124135 public InterceptorRegistration pathMatcher (PathMatcher pathMatcher ) {
@@ -128,9 +139,10 @@ public InterceptorRegistration pathMatcher(PathMatcher pathMatcher) {
128139
129140 /**
130141 * Specify an order position to be used. Default is 0.
142+ *
131143 * @since 4.3.23
132144 */
133- public InterceptorRegistration order (int order ){
145+ public InterceptorRegistration order (int order ) {
134146 this .order = order ;
135147 return this ;
136148 }
@@ -143,20 +155,42 @@ protected int getOrder() {
143155 }
144156
145157 /**
146- * Build the underlying interceptor. If URL patterns are provided, the returned
147- * type is {@link MappedInterceptor}; otherwise {@link HandlerInterceptor}.
158+ * Build and return the configured interceptor instance.
159+ *
160+ * <p>
161+ * If no include or exclude path patterns are configured, this method returns
162+ * the
163+ * original {@link HandlerInterceptor} (or a decorated one if method filtering
164+ * is applied).
165+ * If path patterns are provided, a {@link MappedInterceptor} is returned with
166+ * the patterns and optional {@link PathMatcher} applied.
167+ *
168+ * <p>
169+ * If {@link #allowedMethods(HttpMethod...)} is used, the interceptor is wrapped
170+ * with a {@link MethodInterceptor} that restricts its invocation based on HTTP
171+ * method.
172+ *
173+ * @return a {@link HandlerInterceptor} or {@link MappedInterceptor} instance
174+ * depending
175+ * on path and method configuration
148176 */
149177 @ SuppressWarnings ("removal" )
150178 protected Object getInterceptor () {
151179
180+ HandlerInterceptor methodInterceptor = this .interceptor ;
181+
182+ if (allowedMethods != null ) {
183+ methodInterceptor = new MethodInterceptor (methodInterceptor , allowedMethods );
184+ }
185+
152186 if (this .includePatterns == null && this .excludePatterns == null ) {
153- return this . interceptor ;
187+ return methodInterceptor ;
154188 }
155189
156190 MappedInterceptor mappedInterceptor = new MappedInterceptor (
157191 StringUtils .toStringArray (this .includePatterns ),
158192 StringUtils .toStringArray (this .excludePatterns ),
159- this . interceptor );
193+ methodInterceptor );
160194
161195 if (this .pathMatcher != null ) {
162196 mappedInterceptor .setPathMatcher (this .pathMatcher );
@@ -165,4 +199,39 @@ protected Object getInterceptor() {
165199 return mappedInterceptor ;
166200 }
167201
202+ /**
203+ * Specify the HTTP methods that the interceptor should be invoked for.
204+ *
205+ * <p>
206+ * When this method is called, the underlying {@link HandlerInterceptor} will be
207+ * wrapped in a {@link MethodInterceptor}, which conditionally delegates based
208+ * on
209+ * the HTTP method of the request.
210+ *
211+ * <p>
212+ * This allows interceptors to be configured declaratively, e.g., to run only
213+ * for {@code POST}, {@code PUT}, etc., without requiring manual method checks
214+ * in the interceptor implementation.
215+ *
216+ * <p>
217+ * Must specify at least one method; an {@link IllegalArgumentException} will be
218+ * thrown otherwise.
219+ *
220+ * <pre class="code">
221+ * registry.addInterceptor(new AuditInterceptor())
222+ * .addPathPatterns("/api/**")
223+ * .allowedMethods(HttpMethod.POST, HttpMethod.PUT);
224+ * </pre>
225+ *
226+ * @param methods one or more HTTP methods to allow
227+ * @return this registration for chained calls
228+ * @throws IllegalArgumentException if no methods are specified
229+ */
230+ public InterceptorRegistration allowedMethods (HttpMethod ... methods ) {
231+ Assert .isTrue (methods .length > 0 , "At least one HTTP method must be specified" );
232+ this .allowedMethods = Arrays .stream (methods )
233+ .map (HttpMethod ::name )
234+ .collect (Collectors .toSet ());
235+ return this ;
236+ }
168237}
0 commit comments