Spring Boot interceptor configuration

Keywords: Java Spring Spring Boot

catalogue

  • preface

  • Spring Boot version

  • What is an interceptor?

  • How to customize an interceptor?

  • How to make it work in Spring Boot?

  • Take a chestnut

    • thinking

    • According to what judgment, this interface has been requested?

    • Where is this specific information stored?

    • How?

  • summary

preface

The last article talked about the basic content of WEB development of Spring Boot. I believe readers have a preliminary understanding and know how to write an interface.

Today's article introduces how to customize and configure interceptors in Spring Boot.

Spring Boot version

The version of Spring Boot based on this article is 2.3.4.RELEASE.

What is an interceptor?

The Interceptor in Spring MVC is similar to the Filter in Servlet. It is mainly used to intercept user requests and process them accordingly. For example, through the Interceptor, you can verify permissions, log request information, judge whether users log in, etc.

How to customize an interceptor?

Customizing an interceptor is very simple. You only need to implement the HandlerInterceptor interface. The interface has three methods that can be implemented, as follows:

  1. preHandle() method: this method will be executed before the controller method, and its return value indicates whether it knows how to write an interface. Interrupt subsequent operations. When the return value is true, it means to continue downward execution; When the return value is false, all subsequent operations will be interrupted (including calling the next interceptor and method execution in the controller class).

  2. postHandle() method: this method will be executed after the controller method is called and before the view is parsed. You can use this method to make further modifications to the model and view in the request domain.

  3. afterCompletion() method: this method will be executed after the entire request is completed, that is, after the view rendering is completed. This method can be used to clean up resources and record log information.

How to make it work in Spring Boot?

In fact, it is very simple to take effect in Spring Boot. You only need to define a configuration class, implement the WebMvcConfigurer interface, and implement the addInterceptors() method. The code is shown as follows:

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private XXX xxx;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //Non intercepted uri
        final String[] commonExclude = {}};
        registry.addInterceptor(xxx).excludePathPatterns(commonExclude);
    }
}

Take a chestnut

In the development, we may often encounter repeated requests within a few seconds due to repeated clicks of users in a short time. It may be that various problems, such as network and transaction isolation, lead to data duplication and other problems within these seconds. Therefore, we must avoid such repeated request operations in daily development, Let's simply deal with this problem with interceptors today.

thinking

Judge the specified interface (such as the interface marked with an annotation) before interface execution. If it has been requested once within the specified time (such as 5 seconds), the repeatedly submitted information will be returned to the caller.

According to what judgment, this interface has been requested?

The conditions may be different according to the project architecture, such as IP address, user unique ID, request parameter, request URI, etc.

Where is this specific information stored?

Because it is in a short time or even in an instant, and the timing failure must be guaranteed, it must not exist in the transactional database. Therefore, among the commonly used databases, only Redis is more appropriate.

How?

The first step is to customize an annotation, which can be marked on a class or method, as follows:

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatSubmit {
    /**
     * The default expiration time is 5 seconds
     */
    long seconds() default 5;
}

The second step is to create an interceptor and inject it into the IOC container. The implementation idea is very simple. Judge whether the @ RepeatSubmit annotation is marked on the controller class or method. If so, intercept the judgment. Otherwise, skip. The code is as follows:

/**
 * Interceptor for repeated requests
 * @Component: This annotation injects it into the IOC container
 */
@Component
public class RepeatSubmitInterceptor implements HandlerInterceptor {

    /**
     * Redis API for
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * preHandler Method, executed before the controller method
     * 
     * The judgment condition only uses uri. In actual development, a unique identification condition is combined according to the actual situation.
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod){
            //Only the annotation @ RepeatSubmit is intercepted
            HandlerMethod method=(HandlerMethod)handler;
            //@ RepeatSubmit marked on method
            RepeatSubmit repeatSubmitByMethod = AnnotationUtils.findAnnotation(method.getMethod(),RepeatSubmit.class);
            //@ RepeatSubmit marked on the controller class
            RepeatSubmit repeatSubmitByCls = AnnotationUtils.findAnnotation(method.getMethod().getDeclaringClass(), RepeatSubmit.class);
            //There is no restriction on repeated submission. Skip directly
            if (Objects.isNull(repeatSubmitByMethod)&&Objects.isNull(repeatSubmitByCls))
                return true;

            //  todo:   The combination judgment condition is just a demonstration. In the actual project, the conditions are combined according to the architecture
            //Requested URI
            String uri = request.getRequestURI();

            //Returns false if it exists and true if it does not exist
            Boolean ifAbsent = stringRedisTemplate.opsForValue().setIfAbsent(uri, "", Objects.nonNull(repeatSubmitByMethod)?repeatSubmitByMethod.seconds():repeatSubmitByCls.seconds(), TimeUnit.SECONDS);

            //If it exists, it indicates that the request has been made. An exception is thrown directly, and the global exception is processed to return the specified information
            if (ifAbsent!=null&&!ifAbsent)
                throw new RepeatSubmitException();
        }
        return true;
    }
}

Step 3: configure the interceptor in Spring Boot. The code is as follows:

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private RepeatSubmitInterceptor repeatSubmitInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //Non intercepted uri
        final String[] commonExclude = {"/error", "/files/**"};
        registry.addInterceptor(repeatSubmitInterceptor).excludePathPatterns(commonExclude);
    }
}

OK, the interceptor has been configured. You only need to mark @ RepeatSubmit on the interface to be intercepted, as follows:

@RestController
@RequestMapping("/user")
//Marked with @ RepeatSubmit annotation, all interfaces need to be intercepted
@RepeatSubmit
public class LoginController {

    @RequestMapping("/login")
    public String login(){
        return "login success";
    }
}

At this point, request this URI:http://localhost:8080/springboot-demo/user/login can only be requested once in 5 seconds.

Note: the timeout time marked on the method will overwrite the time on the class, because the following code:

Boolean ifAbsent = stringRedisTemplate.opsForValue().setIfAbsent(uri, "", Objects.nonNull(repeatSubmitByMethod)?repeatSubmitByMethod.seconds():repeatSubmitByCls.seconds(), TimeUnit.SECONDS);

The expiration time of this code first takes the value configured in repeatSubmitByMethod. If it is null, it takes the value configured in repeatSubmitByCls.

summary

So far, the content of the interceptor has been introduced. In fact, the configuration is very simple and there is no important content.

Posted by blear on Fri, 12 Nov 2021 01:08:24 -0800