Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to use SpringBoot interceptor". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn how to use SpringBoot interceptor.

Define interceptor

Interceptor: an interceptor is the ability to intercept a request before an operation is performed, allowing it to be executed further if the request meets the conditions. For example, the Customs is an interceptor that intercepts import and export goods and releases them if they meet the import and export conditions, otherwise they will be intercepted and returned for processing.

There are several ways to define interceptors:

Implement the HandleInterceptor interface

The custom interceptor class implements the HandleInterceptor interface and is annotated as a component using the @ Component annotation.

Public class MySelfInterceptor implements HandlerInterceptor {@ Override public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println ("called before the business processor processes the request"); return true } @ Override public void postHandle (HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println ("execute after the business processor processes the request before generating the view");} @ Override public void afterCompletion (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println ("called after DispatcherServlet has fully processed the request");}}

Depending on the three situations, additional processing of the request can be done in different ways.

In preHandle, permission verification and security control can be carried out.

In postHandle, the returned ModelAndView can be processed, and the view has not yet been rendered.

In afterCompletion, the request has been completed, the page has been rendered, and the data has been returned. At this time, you can do some resource cleaning, or record the call time of the request, and do performance monitoring.

Inherit the HandleInterceptorAdapter class

The custom interceptor class inherits the implementation class HandleInterceptorAdapter of the HandleInterceptor interface and is annotated as a component using the @ Component annotation. It is recommended that you can override some methods as needed.

@ Componentpublic class MyInterceptor extends HandlerInterceptorAdapter {public SingleLoginInterceptor () {super ();} @ Override public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return super.preHandle (request, response, handler);} @ Override public void postHandle (HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {super.postHandle (request, response, handler, modelAndView) @ Override public void afterCompletion (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {super.afterCompletion (request, response, handler, ex);} @ Override public void afterConcurrentHandlingStarted (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {super.afterConcurrentHandlingStarted (request, response, handler);}}

You can see that the bottom layer of the HandlerInterceptorAdapter class implements the HandlerInterceptor interface, with two more methods than

The way to implement the HandlerInterceptor interface is powerful.

These two methods are provided by the org.springframework.web.servlet.AsyncHandlerInterceptor interface implemented by the HandlerInterceptorAdapter class, and the AsyncHandlerInterceptor interface inherits the HandlerInterceptor interface, so the bottom layer of HandlerInterceptorAdapter is the implementation class HandlerInterceptor interface.

Implement the WebRequestInterceptor interface

The custom interceptor class implements the WebRequestInterceptor interface and is annotated as a component using the @ Component annotation.

Componentpublic class MyInterceptor implements WebRequestInterceptor {@ Override public void preHandle (WebRequest webRequest) throws Exception {} @ Override public void postHandle (WebRequest webRequest, ModelMap modelMap) throws Exception {} @ Override public void afterCompletion (WebRequest webRequest, Exception e) throws Exception {}}

The similarities and differences of the two interface implementation methods can realize the differences of intercepting requests in the controller layer.

The input parameter WebRequest of 1.WebRequestInterceptor is packaged with HttpServletRequest and HttpServletResponse, so it is easier to obtain the information in Request through WebRequest.

The preHandle of 2.WebRequestInterceptor does not return a value, indicating that the logic in this method does not affect the execution of subsequent methods, so the implementation of this interface is to obtain the information in Request, or to preset some parameters for subsequent processes to use.

3.HandlerInterceptor is more powerful and basic, and you can reject requests to enter the controller method directly in the preHandle method.

4. Usage scenario: as mentioned in the previous article, if you want to make it easier to get information about HttpServletRequest, use WebRequestInterceptor. Of course, all these HandlerInterceptor can be done, but you need to write more code.

Implement the RequestInterceptor interface

The custom class implements the RequestInterceptor interface, which is a custom interceptor for micro-service Feign calls to pass parameters between micro-services.

@ Configurationpublic class CenterinsRequestInterceptor implements RequestInterceptor {@ Override public void apply (RequestTemplate requestTemplate) {} the difference between @ Configuration and @ Component

The @ Configuration annotation is used instead of @ Component. In fact, @ Configuration is essentially an @ Component, except that all methods marked with @ Bean in the classes described by the former are executed by the CGLIB dynamic proxy, executed on the first call, and then put the execution result into the Spring context. After that, the calls to the method are taken from the Spring context, so they all refer to the same instance. Instead of using @ Component, all methods marked with @ Bean are pure Java calls, each time generating a different instance object. If you want the methods of the @ Bean tag in a class that uses the @ Compnent annotation to generate the same instance, just use the @ AutoWired tag attribute and inject it automatically.

@ Configurationpublic class MyBeanConfig {@ Bean public Country country () {return new Country ();} @ Bean public UserInfo userInfo () {return new UserInfo (country ());}} / / the above code is equivalent to the following code / / to remove the Autowired injection, then the country method is a different instance object. @ Componentpublic class MyBeanConfig {@ Autowired private Country country; @ Bean public Country country () {return new Country ();} @ Bean public UserInfo userInfo () {return new UserInfo (country);}} register the interceptor

The registration interceptor can be implemented directly using annotations in springboot.

Inherit the WebMvcConfigurerAdapter class

1. Create a custom class that inherits the WebMvcConfigurerAdapter class overriding the addInterceptors method.

@ Configurationpublic class WebCofiguration extends WebMvcConfigurerAdapter {public void addInterceptors (InterceptorRegistry registry) {/ / inject a self-defined interceptor to intercept registry.addInterceptor (new MySelfInterceptor ()) .addPathPatterns ("/ *") .intercepdePathPatterns ("/ logout") / / multiple filters can be added. The / * * of addPathPatterns here intercepts all requests. / / excludePathPatterns means to exclude the blocking path of url, that is, not to intercept}}

This class has been abolished since SpringBoot2.0, but can still be used. The following two ways are recommended to replace this approach.

Inherit the WebMvcConfigurationSupport class

two。 Create a custom class that inherits the WebMvcConfigurationSupport class and implements addInterceptors.

@ Configurationpublic class MyInterceptorConfig extends WebMvcConfigurationSupport {@ Override protected void addInterceptors (InterceptorRegistry registry) {registry.addInterceptor (new MyInterceptor ()) .addPathPatterns ("/ *"); super.addInterceptors (registry);}}

This approach results in the default static resources being intercepted, which requires us to manually release the static resources.

In addition to overriding methods, you also need to override addResourceHandlers methods to release static resources

@ Overrideprotected void addResourceHandlers (ResourceHandlerRegistry registry) {registry.addResourceHandler ("/ * *") .addResourceLocations ("classpath:/static/"); super.addResourceHandlers (registry);} implement the WebMvcConfigurer interface

3. Create a custom class to implement the WebMvcConfigurer interface and override the addInterceptors method.

@ Configurationpublic class MyInterceptorConfig implements WebMvcConfigurer {@ Override public void addInterceptors (InterceptorRegistry registry) {/ / implementing WebMvcConfigurer does not cause static resources to be intercepted by registry.addInterceptor (new MyInterceptor ()) .addPathPatterns ("/ *");}}

This method does not intercept static resources

Application scenario

Because of the difference between the two ways:

The method of inheriting the WebMvcConfigurationSupport class is recommended to be used in projects where the front and rear ends are separated. The backend does not need to access static resources (there is no need to let go of static resources). Of course, it can also be used in front and back end without separation. If you need to access static resources, you can override the addResourceHandlers method in the above way.

The way to implement the WebMvcConfigure interface is recommended for projects that are not separated from the front and back ends, because you need to read some images, css, js files, and so on. Of course, you can also use the front and back end to separate the project.

Interceptor execution process single interceptor

The execution process for a single interceptor is explained as follows:

The program first executes the preHandle () method in the interceptor class, and if the method returns true, the program will continue to execute the method in the processor, otherwise the program will not continue to execute. After the business processor (that is, the controller Controller class) processes the request, the postHandle () method is executed, then the response is returned to the client through DispatcherServlet, and the afterCompletion () method is executed after the DispatcherServlet has processed the request.

So the execution flow of a single interceptor:

Prehandle ()-- Handle (i.e., the method in the controller)-- postHandle ()-- afterCompletion ().

Multiple interceptors

In large enterprise projects, multiple interceptors are usually configured to achieve different functions. For example, we customize three interceptors A, B, and C. And register them all in the same interceptor configuration class, as shown in the following figure

@ Configurationpublic class InterceptorConfig implements WebMvcConfigurer {@ Override public void addInterceptors (InterceptorRegistry registry) {registry.addInterceptor (new AInterceptor ()) .addP athPatterns ("/ * *"); registry.addInterceptor (new BInterceptor ()) .addPathPatterns ("/ * *"); registry.addInterceptor (new CInterceptor ()) .addPathPatterns ("/ * *");}}

Their preHandle () methods are executed in the configuration order of the interceptors in the configuration file, while their postHandle () and afterCompletion () methods are executed in reverse order.

So the current order of execution of our three interceptors is as follows:

PreHandleA--preHandleB--preHandleC--Handle--postHandleC--postHandleB--postHandleA--afterCompletionC--afterCompletionB--afterCompletionA

Thank you for reading, the above is the content of "how to use SpringBoot interceptor". After the study of this article, I believe you have a deeper understanding of how to use SpringBoot interceptor, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.