Interceptor interceptor

The interceptor is SpringMVC An object in , Can interceptor pair Controller Request .

There are systematic interceptors in the interceptor framework , You can also customize interceptors , Implement pre-processing of requests .

Implement custom interceptors

1.SpringMVC Middle interceptor

1.  Create a class implementation SpringMVC Framework of the HandlerInterceptor Interface 

   ```java
public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}
   ```



2. Need to be in SpringMVC In the configuration file , Declaration interceptor 

```xml
<mvc:interceptors>
	<mvc:interceptor>
    	<mvc:path="url" />
        <bean class=" Interceptor class fully qualified name "/>
    </mvc:interceptor>
</mvc:interceptors>
```

2.SpringBoot Custom interceptors

First create Interceptor Class implementation HandlerIntercetor Interface

        HandlerInterceptor Interface

 default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }

What we achieve is preHandle.

 /**
     * @param request
     * @param response
     * @param handler   Objects controlled by interceptors 
     * @return boolean
     * true ： The request can be Controller Handle 
     * false： The request was truncated 
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("lanjieqi");
        return true;
    }

Here is the custom interceptor , We will put the custom interceptor into the container

establish config Inherit WebMvcConfigurer Interface

Be careful ： You need to add notes to the class @Configuration If it is not added, the configuration will not be automatically loaded into the container .

WebMvcConfigurer There are many things implemented by interfaces , What we need to realize here is addInterceptors Method .

 @Override
    public void addInterceptors(InterceptorRegistry registry) {
        WebMvcConfigurer.super.addInterceptors(registry);
       
    }

We need to reference the custom interceptor just written .

  LoginInterctor loginInterctor=new LoginInterctor();

 What is written on it can be used normally , however Java It's object-oriented programming , So we should face interface programming CSDN

So you should write

 HandlerInterceptor loginInterctor = new LoginInterctor();

Write what should be blocked , Release what

addPathPatterns Is intercepted

excludePathPatterns Is released

   registry.addInterceptor(loginInterctor)
                .excludePathPatterns( path)
                .addPathPatterns(path1);

  Use the array to write the path that needs to be intercepted and released , Comments can be made later @ConditionalOnProperty To optimize

 String path []={"/test"};
        String path1 []={"/api"};

Finally, we write the configuration class Controller

    @GetMapping("/test")
    @ResponseBody
    public String test() {
        return "test";
    }

    @GetMapping("/api")
    @ResponseBody
    public String api() {
        return "api";
    }