我可以在 servlet 过滤器中确定 HttpServletRequest 是否映射到特定的 Spring 控制器类

Question

我正在开发一个应用程序，该应用程序使用OncePerRequestFilter 使用传入的 Web 请求执行一些自定义的类似日志的行为。此行为同时使用HttpServletRequest 和HttpServletResponse。此外，过滤器同时使用ContentCachingRequestWrapper 和ContentCachingResponseWrapper 来访问请求/响应正文。

我们决定只在调用特定 Spring 控制器的方法时才执行此行为，因为我们不想为其他控制器/执行器端点/等执行此操作。有没有办法判断传入的请求是否会（或曾经）映射到控制器？

public class ExampleFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        // Can I tell here whether this will be mapping to an endpoint in
        // ExampleController or NestedExampleController?

        ContentCachingRequestWrapper requestToUse = new ContentCachingRequestWrapper(request);
        ContentCachingResponseWrapper responseToUse = new ContentCachingResponseWrapper(response);

        try {
            filterChain.doFilter(requestToUse, responseToUse);

            // Can I tell here whether this was mapped to an endpoint in
            // ExampleController or OtherExampleController?
        } finally {
            responseToUse.copyBodyToResponse(); // Write the cached body back to the real response
        }
    }
}

@RestController
@RequestMapping("/example")
public class ExampleController {
  @GetMapping("/{id}")
  public Example retrieveExample() {
    return getValue(); // Retrieve the value
  }

  // ...
}

@RestController
@RequestMapping("/example/{id}/nested")
public class NestedExampleController {
  @GetMapping("/{nestedId}")
  public NestedExample retrieveNestedExample() {
    return getValue(); // Retrieve the value
  }

  // ...
}

我已经对 Spring MVC/Boot 内部进行了一些研究，但我不确定是否有一种方法可以轻松地做到这一点。作为替代方案，我可以进行一些手动 URL 模式匹配，这可能不一定与控制器中的方法完全匹配，但可能会让我足够接近以成为可接受的解决方案。

总结一下：网络过滤器中有没有办法判断传入的请求是映射到控制器（在执行过滤器链之前）还是映射到控制器（在执行过滤器链之后）？

Answer 1

你想要的基本上是一个cross-cutting concern，它针对你的应用程序的特定部分——在本例中是日志记录。

这是面向方面编程最常见的用例之一，Spring 使用 AspectJ 风格的切入点对此提供了内置支持。

你需要：

1. 在配置类的 Spring 配置中启用 AOP，如下所示：

@Configuration
@EnableAspectJAutoProxy
public class AopConfiguration {
}

1. 定义一个方面，例如如下：

@Aspect
public class LoggingAspect {

    Logger log = ...; // define logger

    // Matches all executions in com.example.ExampleController,
    // with any return value, using any parameters   
    @Pointcut("execution(* com.example.ExampleController.*(..))")
    public void controllerExecutionPointcut() {}

    @Around("controllerExecutionPointcut()")
    public Object aroundTargetControllerInvocation(ProceedingJoinPoint pjp) {
    
        log.debug("About to invoke method: {}", pjp.getSignature().getName());
        
        try {
            return pjp.proceed(); 
        } catch (Throwable t) {
            // note that getArgs() returns an Object[],
            // so you may want to map it to a more readable format
            log.debug("Encountered exception while invoking method with args {}", pjp.getArgs());
            throw t;
        }
        
        log.debug("Sucessfully finished invocation");
    }
}

参见例如this 指南以了解有关切入点表达式的更多信息。

另一个常见的用例是为您的方法调用计时，尽管使用 @Timed 的 Micrometer（和 Spring 的 Micrometer 适配器）可能会更好。

您可能还希望通读reference documentation，它提供了大量有关 Spring 中 AOP 工作原理的信息。

注意：与几乎所有其他 Spring 代理机制一样，来自目标对象内的调用不会被代理，即 this.otherControllerMethod() 不会被拦截上述建议。同样，private 方法也不能被拦截。有关详细信息，请参阅参考文档的 5.4.3 部分。

最后一点，如果性能非常重要，您应该查看 AspectJ 编译时或加载时编织，它消除了 Spring 的代理机制引入的一些开销（这是 Spring AOP 在引擎盖）。在您的情况下，这很可能不是必需的，但请记住这一点。

---

编辑评论：

谢谢！这种方法的一个警告是它不能让我访问 HttpServletRequest 或 HttpServletResponse，这是我正在使用的东西。如果这不是我需要的东西，我可以看到这会有所帮助。我发现我在我的问题中没有明确说明这个要求，所以我会相应地更新。

确实，不幸的是，这种方法无法直接实现。如果你真的需要这个请求，那么@DarrenForsythe 提到的HandlerInterceptor 方法是另一种可能。如果您只想记录日志，我看不出您绝对需要该请求的理由 - 除非您希望提取特定的标头并记录它们。

在这种情况下，IMO，您最初尝试的 OncePerRequestFilter 会好得多，因为您可以控制对哪些请求应用过滤器（使用 shouldNotFilter(HttpServletRequest request) 并在 URL 上进行匹配）。

Answer 2

经过一些额外的探索和反复试验，我发现控制器可以通过RequestMappingHandlerMapping bean 访问。当请求可以由控制器处理时，这会将请求映射到HandlerMethod，用于控制器的请求处理方法。

public class ExampleFilter extends OncePerRequestFilter {
    private RequestMappingHandlerMapping requestMappingHandlerMapping;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        Object handler = getHandlerBean(request);
        boolean isHandledController = handler instanceof ExampleController
                || handler instanceof NestedEampleController;

        if (!isHandledController) {
            filterChain.doFilter(request, response);
            return;
        }

        // ...
    }

    private Object getHandlerBean(HttpServletRequest request) {
        try {
            HandlerExecutionChain handlerChain = requestMappingHandlerMapping.getHandler(request);
            if (handlerChain != null) {
                Object handler = handlerChain.getHandler();
                if (handler instanceof HandlerMethod) {
                    return ((HandlerMethod) handler).getBean();
                }
            }
            return null;
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    protected void initFilterBean() {
        WebApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        requestMappingHandlerMapping = appContext.getBean(RequestMappingHandlerMapping.class);
    }
}

为了更加彻底和真正模仿 Spring 的处理程序逻辑，可以使用/模仿 DispatcherServlet 逻辑，而不是直接引用 RequestMappingHandlerMapping。这将咨询所有处理程序，而不仅仅是RequestMappingHandlerMapping。

public class ExampleFilter extends OncePerRequestFilter {
    private DispatcherServlet dispatcherServlet;

    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {
        Object handler = getHandlerBean(request);
        boolean isHandledController = handler instanceof ExampleController
                || handler instanceof NestedEampleController;

        if (!isHandledController) {
            filterChain.doFilter(request, response);
            return;
        }

        // ...
    }

    private Object getHandlerBean(HttpServletRequest request) {
        try {
            HandlerExecutionChain handlerChain = getHandler(request);
            if (handlerChain != null) {
                Object handler = handlerChain.getHandler();
                if (handler instanceof HandlerMethod) {
                    return ((HandlerMethod) handler).getBean();
                }
            }
            return null;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Duplicates the protected "getHandler" method logic from DispatcherServlet.
     */
    private HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        List<HandlerMapping> handlerMappings = dispatcherServlet.getHandlerMappings();
        if (handlerMappings != null) {
            for (HandlerMapping mapping : handlerMappings) {
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
    }

    @Override
    protected void initFilterBean() {
        WebApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        dispatcherServlet = appContext.getBean(DispatcherServlet.class);
    }
}

我不确定是否有更惯用的方法，而且它确实感觉像是跳过了一些圈子并过多地挖掘了 Spring 的内部结构。但它似乎确实有效，至少在 spring-web 5.2.7.RELEASE 上。