public interface HandlerInterceptor {    /**     * Intercept the execution of a handler. Called after HandlerMapping determined     * an appropriate handler object, but before HandlerAdapter invokes the handler.     * <p>DispatcherServlet processes a handler in an execution chain, consisting     * of any number of interceptors, with the handler itself at the end.     * With this method, each interceptor can decide to abort the execution chain,     * typically sending a HTTP error or writing a custom response.     * @param request current HTTP request     * @param response current HTTP response     * @param handler chosen handler to execute, for type and/or instance evaluation     * @return {@code true} if the execution chain should proceed with the     * next interceptor or the handler itself. Else, DispatcherServlet assumes     * that this interceptor has already dealt with the response itself.     * @throws Exception in case of errors     */    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)        throws Exception;    /**     * Intercept the execution of a handler. Called after HandlerAdapter actually     * invoked the handler, but before the DispatcherServlet renders the view.     * Can expose additional model objects to the view via the given ModelAndView.     * <p>DispatcherServlet processes a handler in an execution chain, consisting     * of any number of interceptors, with the handler itself at the end.     * With this method, each interceptor can post-process an execution,     * getting applied in inverse order of the execution chain.     * @param request current HTTP request     * @param response current HTTP response     * @param handler handler (or {@link HandlerMethod}) that started async     * execution, for type and/or instance examination     * @param modelAndView the {@code ModelAndView} that the handler returned     * (can also be {@code null})     * @throws Exception in case of errors     */    void postHandle(            HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)            throws Exception;    /**     * Callback after completion of request processing, that is, after rendering     * the view. Will be called on any outcome of handler execution, thus allows     * for proper resource cleanup.     * <p>Note: Will only be called if this interceptor‘s {@code preHandle}     * method has successfully completed and returned {@code true}!     * <p>As with the {@code postHandle} method, the method will be invoked on each     * interceptor in the chain in reverse order, so the first interceptor will be     * the last to be invoked.     * @param request current HTTP request     * @param response current HTTP response     * @param handler handler (or {@link HandlerMethod}) that started async     * execution, for type and/or instance examination     * @param ex exception thrown on handler execution, if any     * @throws Exception in case of errors     */    void afterCompletion(            HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)            throws Exception;}