wake-up-neo.com

Spring Boot Hinzufügen von HTTP-Request-Interceptors

Was ist der richtige Weg, um HttpRequest-Interceptors in der Spring-Boot-Anwendung hinzuzufügen? Ich möchte Anforderungen und Antworten für jede http-Anforderung protokollieren.

Die Springboot-Dokumentation behandelt dieses Thema überhaupt nicht. ( http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/ )

Ich habe einige Web-Beispiele gefunden, wie man dasselbe mit älteren Versionen von spring macht, aber diese funktionieren mit applicationcontext.xml. Bitte helfen Sie.

85
riship89

Da Sie Spring Boot verwenden, sollten Sie sich nach Möglichkeit auf die automatische Konfiguration von Spring verlassen. Um eine zusätzliche benutzerdefinierte Konfiguration wie Ihre Interceptors hinzuzufügen, geben Sie einfach eine Konfiguration oder Bean von WebMvcConfigurerAdapter an.

Hier ist ein Beispiel für eine Konfigurationsklasse:

@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {

  @Autowired 
  HandlerInterceptor yourInjectedInterceptor;

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(...)
    ...
    registry.addInterceptor(getYourInterceptor()); 
    registry.addInterceptor(yourInjectedInterceptor);
    // next two should be avoid -- tightly coupled and not very testable
    registry.addInterceptor(new YourInterceptor());
    registry.addInterceptor(new HandlerInterceptor() {
        ...
    });
  }
}

[~ # ~] note [~ # ~] Kommentieren Sie dies nicht mit @EnableWebMvc, wenn Sie Spring Boots-Autokonfiguration beibehalten möchten für mvc .

135
ikumen

WebMvcConfigurerAdapter wird mit Spring 5 veraltet sein. Ab Javadoc :

@deprecated from 5.0 {@link WebMvcConfigurer} verfügt über Standardmethoden (ermöglicht durch eine Java 8 Baseline)) und kann direkt implementiert werden, ohne dass dieser Adapter erforderlich ist

Wie oben erwähnt, müssen Sie WebMvcConfigurer implementieren und die addInterceptors -Methode überschreiben.

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyCustomInterceptor());
    }
}
63
sedooe

Gehen Sie wie folgt vor, um einer Spring-Boot-Anwendung einen Interceptor hinzuzufügen

  1. Erstellen Sie eine Interceptor-Klasse

    public class MyCustomInterceptor implements HandlerInterceptor{
    
        //unimplemented methods comes here. Define the following method so that it     
        //will handle the request before it is passed to the controller.
    
        @Override
        public boolean preHandle(HttpServletRequest request,HttpServletResponse  response){
        //your custom logic here.
            return true;
        }
    }
    
  2. Definieren Sie eine Konfigurationsklasse

    @Configuration
    public class MyConfig extends WebMvcConfigurerAdapter{
        @Override
        public void addInterceptors(InterceptorRegistry registry){
            registry.addInterceptor(new MyCustomInterceptor()).addPathPatterns("/**");
        }
    }
    
  3. Das ist es. Jetzt durchlaufen alle Ihre Anforderungen die unter der preHandle () -Methode von MyCustomInterceptor definierte Logik.

24
sunitha

Ich hatte das gleiche Problem, dass WebMvcConfigurerAdapter veraltet war. Als ich nach Beispielen suchte, fand ich kaum implementierten Code. Hier ist ein Stück Arbeitscode.

erstellen Sie eine Klasse, die HandlerInterceptorAdapter erweitert

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import me.rajnarayanan.datatest.DataTestApplication;
@Component
public class EmployeeInterceptor extends HandlerInterceptorAdapter {
    private static final Logger logger = LoggerFactory.getLogger(DataTestApplication.class);
    @Override
    public boolean preHandle(HttpServletRequest request, 
            HttpServletResponse response, Object handler) throws Exception {

            String x = request.getMethod();
            logger.info(x + "intercepted");
        return true;
    }

}

implementieren Sie dann die WebMvcConfigurer-Schnittstelle

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import me.rajnarayanan.datatest.interceptor.EmployeeInterceptor;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Autowired
    EmployeeInterceptor employeeInterceptor ;

    @Override
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(employeeInterceptor).addPathPatterns("/employee");
    }
}
9
user2532195

Sie können auch die Open-Source-SpringSandwich-Bibliothek verwenden, mit der Sie direkt in Ihren Spring Boot-Controllern Anmerkungen zu den anzuwendenden Interceptors hinzufügen können, ähnlich wie Sie Ihre URL-Routen mit Anmerkungen versehen.

Auf diese Weise können keine Tippfehler auftreten - die Methoden- und Klassenanmerkungen von SpringSandwich überstehen problemlos das Refactoring und machen deutlich, was wo angewendet wird. (Offenlegung: Ich bin der Autor).

http://springsandwich.com/

7
Magnus

Da für alle Antworten auf diese Frage der lange veraltete abstrakte WebMvcConfigurer-Adapter anstelle des WebMvcInterface (wie bereits von @sebdooe erwähnt) verwendet wird, ist hier ein funktionierendes Minimalbeispiel für eine SpringBoot (2.1.4) -Anwendung mit einem Interceptor:

Minimal.Java:

@SpringBootApplication
public class Minimal
{
    public static void main(String[] args)
    {
        SpringApplication.run(Minimal.class, args);
    }
}

MinimalController.Java:

@RestController
@RequestMapping("/")
public class Controller
{
    @GetMapping("/")
    @ResponseBody
    public ResponseEntity<String> getMinimal()
    {
        System.out.println("MINIMAL: GETMINIMAL()");

        return new ResponseEntity<String>("returnstring", HttpStatus.OK);
    }
}

Config.Java:

@Configuration
public class Config implements WebMvcConfigurer
{
    //@Autowired
    //MinimalInterceptor minimalInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry)
    {
        registry.addInterceptor(new MinimalInterceptor());
    }
}

MinimalInterceptor.Java:

public class MinimalInterceptor extends HandlerInterceptorAdapter
{
    @Override
    public boolean preHandle(HttpServletRequest requestServlet, HttpServletResponse responseServlet, Object handler) throws Exception
    {
        System.out.println("MINIMAL: INTERCEPTOR PREHANDLE CALLED");

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception
    {
        System.out.println("MINIMAL: INTERCEPTOR POSTHANDLE CALLED");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception
    {
        System.out.println("MINIMAL: INTERCEPTOR AFTERCOMPLETION CALLED");
    }
}

funktioniert wie angekündigt

Die Ausgabe gibt Ihnen etwas wie:

> Task :Minimal.main()

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.4.RELEASE)

2019-04-29 11:53:47.560  INFO 4593 --- [           main] io.minimal.Minimal                       : Starting Minimal on y with PID 4593 (/x/y/z/spring-minimal/build/classes/Java/main started by x in /x/y/z/spring-minimal)
2019-04-29 11:53:47.563  INFO 4593 --- [           main] io.minimal.Minimal                       : No active profile set, falling back to default profiles: default
2019-04-29 11:53:48.745  INFO 4593 --- [           main] o.s.b.w.embedded.Tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2019-04-29 11:53:48.780  INFO 4593 --- [           main] o.Apache.catalina.core.StandardService   : Starting service [Tomcat]
2019-04-29 11:53:48.781  INFO 4593 --- [           main] org.Apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.17]
2019-04-29 11:53:48.892  INFO 4593 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2019-04-29 11:53:48.893  INFO 4593 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1269 ms
2019-04-29 11:53:49.130  INFO 4593 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2019-04-29 11:53:49.375  INFO 4593 --- [           main] o.s.b.w.embedded.Tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2019-04-29 11:53:49.380  INFO 4593 --- [           main] io.minimal.Minimal                       : Started Minimal in 2.525 seconds (JVM running for 2.9)
2019-04-29 11:54:01.267  INFO 4593 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2019-04-29 11:54:01.267  INFO 4593 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2019-04-29 11:54:01.286  INFO 4593 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 19 ms
MINIMAL: INTERCEPTOR PREHANDLE CALLED
MINIMAL: GETMINIMAL()
MINIMAL: INTERCEPTOR POSTHANDLE CALLED
MINIMAL: INTERCEPTOR AFTERCOMPLETION CALLED
6
Xenonite