it-swarm.com.de

Wie füge ich eine Filterklasse in Spring Boot hinzu?

Ich frage mich, ob es eine Anmerkung für eine Filter-Klasse (für Webanwendungen) in Spring Boot gibt. Vielleicht @Filter

Ich möchte meinem Projekt einen benutzerdefinierten Filter hinzufügen.

Das Spring Boot-Referenzhandbuch erwähnte über FilterRegistrationBean, aber ich bin nicht sicher, wie man es benutzt.

176
janetsmith

Wenn Sie einen Drittanbieter-Filter einrichten möchten, können Sie FilterRegistrationBean..__ verwenden. Beispielsweise das Äquivalent von web.xml

<filter>
     <filter-name>SomeFilter</filter-name>
        <filter-class>com.somecompany.SomeFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SomeFilter</filter-name>
    <url-pattern>/url/*</url-pattern>
    <init-param>
       <param-name>paramName</param-name>
       <param-value>paramValue</param-value>
    </init-param>
</filter-mapping>

Dies sind die beiden Beans in Ihrer @Configuration-Datei

@Bean
public FilterRegistrationBean someFilterRegistration() {

    FilterRegistrationBean registration = new FilterRegistrationBean();
    registration.setFilter(someFilter());
    registration.addUrlPatterns("/url/*");
    registration.addInitParameter("paramName", "paramValue");
    registration.setName("someFilter");
    registration.setOrder(1);
    return registration;
} 

public Filter someFilter() {
    return new SomeFilter();
}

Das obige wurde mit Springboot 1.2.3 getestet

128
Haim Raman

Hier ist ein Beispiel für eine Methode zum Einfügen eines benutzerdefinierten Filters in eine Spring Boot-MVC-Anwendung. Stellen Sie sicher, dass das Paket in einen Komponentenscan aufgenommen wird:

package com.dearheart.gtsc.filters;

import Java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Component;

@Component
public class XClacksOverhead implements Filter {

  public static final String X_CLACKS_OVERHEAD = "X-Clacks-Overhead";

  @Override
  public void doFilter(ServletRequest req, ServletResponse res,
      FilterChain chain) throws IOException, ServletException {

    HttpServletResponse response = (HttpServletResponse) res;
    response.setHeader(X_CLACKS_OVERHEAD, "GNU Terry Pratchett");
    chain.doFilter(req, res);
  }

  @Override
  public void destroy() {}

  @Override
  public void init(FilterConfig arg0) throws ServletException {}

}
106
tegatai

Es gibt keine spezielle Anmerkung, um einen Servlet-Filter zu bezeichnen. Sie müssen nur einen @Bean vom Typ Filter (oder FilterRegistrationBean) angeben. Ein Beispiel (Hinzufügen eines benutzerdefinierten Headers zu allen Antworten) befindet sich in Boots eigenem EndpointWebMvcAutoConfiguration ;

Wenn Sie nur eine Filter angeben, wird sie auf alle Anfragen angewendet. Wenn Sie auch eine FilterRegistrationBean hinzufügen, können Sie zusätzlich einzelne Servlets und URL-Muster angeben, die angewendet werden sollen.

Hinweis:

Seit Spring Boot 1.4 ist FilterRegistrationBean nicht veraltet und es werden lediglich Pakete von org.springframework.boot.context.embedded.FilterRegistrationBean nach org.springframework.boot.web.servlet.FilterRegistrationBean verschoben.

69
Dave Syer

Es gibt drei Möglichkeiten, Ihren Filter hinzuzufügen:

  1. Kommentieren Sie Ihren Filter mit einem der Spring-Stereotypen wie @Component 
  2. Registrieren Sie einen @Bean mit Filter in Spring @Configuration
  3. Registrieren Sie einen @Bean mit FilterRegistrationBean in Spring @Configuration

Wenn Sie möchten, dass Ihr Filter auf alle Anforderungen ohne Anpassung angewendet wird, können Sie entweder # 1 oder # 2 verwenden. Andernfalls verwenden Sie # 3. Sie müssen keinen Komponentenscan für # 1 angeben, um zu funktionieren, solange Sie Ihre Filterklasse im selben oder Unterpaket Ihrer SpringApplication-Klasse platzieren. Für # 3 ist die Verwendung zusammen mit # 2 nur erforderlich, wenn Sie möchten, dass Spring Ihre Filterklasse verwaltet, z. B. um automatisch abhängige Abhängigkeiten zu haben. Es funktioniert gut für mich, um meinen Filter neu zu installieren, der keine Abhängigkeit von automatischer Verdrängung/Injektion benötigt. 

Obwohl die Kombination von # 2 und # 3 gut funktioniert, war ich überrascht, dass nicht zwei Filter doppelt angewendet werden. Meine Vermutung ist, dass Spring die beiden Beans als eine kombiniert, wenn dieselbe Methode aufgerufen wird, um beide zu erstellen. Falls Sie # 3 alleine mit authowiring verwenden möchten, können Sie AutowireCapableBeanFactory verwenden. Das folgende ist ein Beispiel, 

private @Autowired AutowireCapableBeanFactory beanFactory;

    @Bean
    public FilterRegistrationBean myFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        Filter myFilter = new MyFilter();
        beanFactory.autowireBean(myFilter);
        registration.setFilter(myFilter);
        registration.addUrlPatterns("/myfilterpath/*");
        return registration;
    }
59
barryku

UPDATE: 2017-12-16:

Es gibt zwei einfache Möglichkeiten, dies in Spring boot 1.5.8.RELEASE zu tun, ohne dass XML erforderlich ist.

Erster Weg: Wenn Sie kein räumliches URL-Muster haben, können Sie @Component wie folgt verwenden: (Den vollständigen Code und Details finden Sie hier https://www.surasint.com/ Spring-Boot-Filter/ )

@Component
public class ExampleFilter implements Filter{
   ...
}

Zweiter Weg: Wenn Sie URL-Muster verwenden möchten, können Sie @WebFilter wie folgt verwenden: (Den vollständigen Code und Details finden Sie hier https://www.surasint.com/spring- boot-filter-urlpattern/ )

@WebFilter(urlPatterns = "/api/count")
public class ExampleFilter implements Filter{
 ...
}

Sie müssen jedoch @ServletComponentScan-Anmerkung in Ihrer @SpringBootApplication-Klasse hinzufügen:

@ServletComponentScan
@SpringBootApplication
public class MyApplication extends SpringBootServletInitializer {
...
}

Beachten Sie, dass @Component die Anmerkung von Spring ist, @WebFilter jedoch nicht. @WebFiler ist die Servlet 3-Anmerkung.

Auf beiden Wegen benötigen Sie nur eine grundlegende Spring-Boot-Abhängigkeit in pom.xml (keine expliziten Tomcat-eingebetteten Jaspis erforderlich).

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.Apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.Apache.org/POM/4.0.0 http://maven.Apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
    </parent>

    <groupId>com.surasint.example</groupId>
    <artifactId>spring-boot-04</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

WARNUNG: Die erste Möglichkeit, wenn der Controller im Spring Boot zu einer JSP-Datei zurückkehrt, wird der Filter zweimal durchlaufen. 

Auf die zweite Art passiert die Anforderung den Filter nur einmal.

Ich bevorzuge den zweiten Weg, weil er dem Standardverhalten in der Servlet-Spezifikation ähnlicher ist ( https://docs.Oracle.com/cd/E19879-01/819-3669/6n5sg7b0b/index.html )

Weitere Testprotokolle finden Sie hier https://www.surasint.com/spring-boot-webfilter-instead-of-component/

18

Hier ist ein Beispiel meiner benutzerdefinierten Filterklasse:

package com.dawson.controller.filter;

import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import Java.io.IOException;


@Component
public class DawsonApiFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        if (req.getHeader("x-dawson-nonce") == null || req.getHeader("x-dawson-signature") == null) {
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            httpResponse.setContentType("application/json");
            httpResponse.sendError(HttpServletResponse.SC_BAD_REQUEST, "Required headers not specified in the request");
            return;
        }
        chain.doFilter(request, response);
    }
}

Und ich habe es der Spring-Boot-Konfiguration hinzugefügt, indem ich es wie folgt zur Configuration-Klasse hinzufügte:

package com.dawson.configuration;

import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
import com.dawson.controller.filter.DawsonApiFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

@SpringBootApplication
public class ApplicationConfiguration {
    @Bean
    public FilterRegistrationBean dawsonApiFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new DawsonApiFilter());
// In case you want the filter to apply to specific URL patterns only
        registration.addUrlPatterns("/dawson/*");
        return registration;
    }
}
17
DPancs

Von den Frühlingsdokumenten

Eingebettete Servlet-Container - Hinzufügen von Servlets, Filtern oder Listener zu einer Anwendung

Um ein Servlet, Filter oder Servlet * Listener hinzuzufügen, geben Sie ein @Bean .__ ein. Definition dafür.

Z.B:

@Bean
public Filter compressFilter() {
    CompressingFilter compressFilter = new CompressingFilter();
    return compressFilter;
}

Fügen Sie diese @Bean config Ihrer @Configuration-Klasse hinzu, und der Filter wird beim Start registriert.

Sie können auch Servlets, Filter und Listener mithilfe von Classpath-Scanning hinzufügen.

Annotierte Klassen von @WebServlet, @WebFilter und @WebListener können .__ sein. wird automatisch mit einem eingebetteten Servlet-Container von .__ registriert. Annotieren einer @Configuration-Klasse mit @ServletComponentScan und Angeben der Pakete, die die gewünschten Komponenten enthalten registrieren. Standardmäßig scannt @ServletComponentScan aus dem Paket der kommentierten Klasse.

14
Lucky

Wenn Sie Spring Boot + Spring Security verwenden, können Sie dies in der Sicherheitskonfiguration tun.

Im folgenden Beispiel füge ich vor dem UsernamePasswordAuthenticationFilter einen benutzerdefinierten Filter hinzu (siehe alle Spring Security-Standardfilter und ihre Reihenfolge ).

@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired FilterDependency filterDependency;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(
                new MyFilter(filterDependency),
                UsernamePasswordAuthenticationFilter.class);
    }
}

Und die Filterklasse

class MyFilter extends OncePerRequestFilter  {
    private final FilterDependency filterDependency;

    public MyFilter(FilterDependency filterDependency) {
        this.filterDependency = filterDependency;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
        HttpServletResponse response,
        FilterChain filterChain)
        throws ServletException, IOException {
       // filter
       filterChain.doFilter(request, response);
    }
}
8
Andrei Epure

Mit der @WebFilter-Annotation kann dies wie folgt durchgeführt werden:

@WebFilter(urlPatterns = {"/*" })
public class AuthenticationFilter implements Filter{

    private static Logger logger = Logger.getLogger(AuthenticationFilter.class);

    @Override
    public void destroy() {
        // TODO Auto-generated method stub

    }

    @Override
    public void doFilter(ServletRequest arg0, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

         logger.info("checking client id in filter");
        HttpServletRequest request = (HttpServletRequest) arg0;
        String clientId = request.getHeader("clientId");
        if (StringUtils.isNotEmpty(clientId)) {
            chain.doFilter(request, response);
        } else {
            logger.error("client id missing.");
        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
        // TODO Auto-generated method stub

    }

}
5
KayV

Dies ist mehr ein Rat als eine Antwort, aber wenn Sie in Ihrer Webanwendung ein Spring-MVC verwenden, sollten Sie anstelle von Filter Spring HandlerInterceptor verwenden

Es kann den gleichen Job machen, aber auch - Kann mit ModelAndView arbeiten - Ihre Methoden können vor und nach der Anforderungsverarbeitung oder nach Abschluss der Anforderung aufgerufen werden.
- Es kann leicht getestet werden

1 Implementieren Sie die HandlerInterceptor-Schnittstelle und fügen Sie Ihrer Klasse eine @Component-Annotation hinzu

@Component
public class SecurityInterceptor implements HandlerInterceptor {

    private static Logger log = LoggerFactory.getLogger(SecurityInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        request.getSession(true);
        if(isLoggedIn(request))
            return true;

        response.getWriter().write("{\"loggedIn\":false}");
        return false;
    }

    private boolean isLoggedIn(HttpServletRequest request) {
        try {
            UserSession userSession = (UserSession) request.getSession(true).getAttribute("userSession");
            return userSession != null && userSession.isLoggedIn();
        } catch(IllegalStateException ex) {
            return false;
        }
    }

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

    }

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

    }
}

2 Konfigurieren Sie Ihren Interceptor

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private HandlerInterceptor securityInterceptor;

    @Autowired
    public void setSecurityInterceptor(HandlerInterceptor securityInterceptor) {
        this.securityInterceptor = securityInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(securityInterceptor).addPathPatterns("/**").excludePathPatterns("/login", "/logout");
    }

}
2
Vasily Komarov

Sie können @WebFilter javax.servlet.annotation.WebFilter für eine Klasse verwenden, die javax.servlet.Filter implementiert

@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {}

Dann verwenden Sie @ServletComponentScan, um sich zu registrieren

2
Cwrwhaf

Ich habe hier viele Antworten gesehen, aber ich habe keine davon probiert. Ich habe den Filter gerade wie im folgenden Code erstellt. 

import org.springframework.context.annotation.Configuration;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import Java.io.IOException;

@WebFilter(urlPatterns = "/Admin")
@Configuration
public class AdminFilter implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse  servletResponse, FilterChain filterChain) throws IOException, ServletException      {
    System.out.println("happened");

    }

    @Override
    public void destroy() {

    }
}

Und die verbleibende Spring Boot-Anwendung blieb unverändert.

2
Shaaban Ebrahim

Wir haben ungefähr vier verschiedene Möglichkeiten, um einen Filter mit Spring zu registrieren .

Erstens können wir ein Spring Bean erstellen, das Filter implementiert oder HttpFilter erweitert:

@Component
public class MyFilter extends HttpFilter {

    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
        // Implementation details...

        chain.doFilter(request, response);
    }
}

Zweitens können wir ein Spring Bean erzeugen, das GenericFilterBean erweitert:

@Component
public class MyFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
  throws IOException, ServletException {
    //Implementation details...

        chain.doFilter(currentRequest, servletResponse);
    }
}

Alternativ können wir die FilterRegistrationBean Klasse verwenden:

@Configuration
public class FilterConfiguration {

    private final MyFilter myFilter;

    @Autowired
    public FilterConfiguration(MyFilter myFilter) {
        this.myFilter = myFilter;
    }

    @Bean
    public FilterRegistrationBean<MyFilter> myFilterRegistration() {
        FilterRegistrationBean<DateLoggingFilter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setFilter(myFilter);
        filterRegistrationBean.setUrlPatterns(Collections.singletonList("/*"));
        filterRegistrationBean.setDispatcherTypes(DispatcherType.REQUEST);
        filterRegistrationBean.setOrder(Ordered.LOWEST_PRECEDENCE - 1);
        return filterRegistrationBean;
    }
}

Und zuletzt können wir die Annotation @ WebFilter mit @ ServletComponentScan verwenden:

@WebFilter(urlPatterns = "/*", dispatcherTypes = {DispatcherType.REQUEST})
public class MyFilter extends HttpFilter {

    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
  throws IOException, ServletException {
        // Implementation details...

        chain.doFilter(request, response);
    }
}
1
isaolmez

Wie Sie alle wissen, ist Spring Boot eine wunderbare Möglichkeit, eine WebApp oder StandaloneApp mit minimalem Konfigurationsaufwand und einer gewissenhaften Einrichtung zu entwickeln.

Auf diese Weise habe ich eine Webfilter-Entwicklung in der Spring Boot-Anwendung erreicht

Meine SpringBootApp-Spezifikationen: -

Spring Boot Version: 2.0.4.RELEASE
Java Version: 8.0
Servlet-Spezifikation: Servlet 3.0 (obligatorisch und wichtig)

Ich habe meinen Webfilter folgendermaßen deklariert, wobei ich die Servlet-Spezifikationen 3.0 eingehalten habe

 enter image description here  Dies ist die programmatische Methode zum Definieren eines Filters als Ersatz für web.xml-basierte Definitionen.

Die Annotation "@Webfilter" wird vom Container während der Bereitstellung verarbeitet. Die Filterklasse, in der sie gefunden wird, wird gemäß der Konfiguration erstellt und auf die URL-Muster javax.servlet.Servlets und javax.servlet.DispatcherTypes angewendet.

Um Web.xml vollständig zu vermeiden und eine "Deployable" WebApp zu erreichen:

Um die Spring Boot-Anwendung als "traditionelles WAR" bereitzustellen, sollte die Anwendungsklasse SpringBootServletInitializer erweitern.

HINWEIS :: SpringBootServletInitializer ist eine "programmatische Implementierung" von web.xml unter Bezugnahme auf Servlet 3.0+-Spezifikationen, für die eine Implementierung von WebApplicationInitializer erforderlich ist.

SpringBootApplication erfordert daher nicht "web.xml", da die Anwendungsklasse (nach der Erweiterung von SpringBootServletInitializer) nach "web.xml" sucht
- @WebFilter,
- @WebListener und
- @WebServlet.

Anmerkung @ServletComponentScan

Mit dieser Annotation können Basispakete nach den mit @WebFilter, @WebListener und @WebServlet annotierten Webkomponenten durchsucht werden.

Da eingebettete Container die Annotationen @WebServlet, @WebFilter und @WebListener nicht unterstützen, hat Spring Boot diese neue Annotation @ServletComponentScan eingeführt, um einige abhängige Jars zu unterstützen, die diese 3 Annotationen verwenden.

Das Scannen wird nur bei Verwendung eines eingebetteten Servlet-Containers durchgeführt.

Das Folgende ist meine Spring Boot-Anwendungsklassendefinition: -

 enter image description here 

Benutzerdefinierter Servlet-Initialisierer: -

Hier: Ich habe eine benutzerdefinierte Klasse: "ServletInitializer" definiert, die die Klasse: SpringBootServletInitializer erweitert.

Wie bereits erläutert, ist SpringBootServletInitializer für das Scannen von Anmerkungen verantwortlich:
- @WebFilter,
- @WebListener und
- @WebServlet.

Und daher sollte die Spring Boot Application Class

  • Erweitern Sie entweder die Klasse: SpringBootServletInitializer ODER
  • extend Benutzerdefinierte Klasse, die die Klasse SpringBootServletInitializer erweitert

 enter image description here 

0
Philip Dilip

Filter, wie der Name vermuten lässt, werden verwendet, um entweder die Anforderung an eine Ressource oder die Antwort von einer Ressource oder beides zu filtern. Spring Boot bietet einige Optionen zum Registrieren benutzerdefinierter Filter in der Spring Boot-Anwendung. Schauen wir uns die verschiedenen Optionen an.

1. Spring Boot Filter und Invocation Order definieren

Implementieren Sie die Filter-Schnittstelle, um einen neuen Filter in Spring Boot zu erstellen.

@Configuration
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CustomFilter implements Filter {

 private static final Logger LOGGER = LoggerFactory.getLogger(CustomFilter.class);

 @Override
 public void init(FilterConfig filterConfig) throws ServletException {
  LOGGER.info("########## Initiating Custom filter ##########");
 }

 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

  HttpServletRequest request = (HttpServletRequest) servletRequest;
  HttpServletResponse response = (HttpServletResponse) servletResponse;

  LOGGER.info("Logging Request  {} : {}", request.getMethod(), request.getRequestURI());

  //call next filter in the filter chain
  filterChain.doFilter(request, response);

  LOGGER.info("Logging Response :{}", response.getContentType());
 }

 @Override
 public void destroy() {
  // TODO: 7/4/18
 }
}

Sehen wir uns kurz einige wichtige Punkte im obigen Code an

  • Der von @Component annotation registrierte Filter.
  • Um Filter in der richtigen Reihenfolge auszulösen, mussten wir die Annotation @Order verwenden.

    @Component
    @Order(1)
    public class CustomFirstFilter implements Filter {
    
    }
    @Component
    @Order(2)
    public class CustomSecondFilter implements Filter {
    
    }
    

Im obigen Code wird CustomFirstFilter vor dem CustomSecondFilter ausgeführt.

Je niedriger die Zahl, desto höher die Priorität

2. URL-Muster

Wenn das auf Konventionen basierende Mapping nicht flexibel genug ist, können wir FilterRegistrationBean für die vollständige Steuerung der Anwendung verwenden. Verwenden Sie hier nicht @Component annotation für die Filterklasse, sondern registrieren Sie den Filter mit einem FilterRegistrationBean .

 public class CustomURLFilter implements Filter {

 private static final Logger LOGGER = LoggerFactory.getLogger(CustomURLFilter.class);

 @Override
 public void init(FilterConfig filterConfig) throws ServletException {
  LOGGER.info("########## Initiating CustomURLFilter filter ##########");
 }

 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

  HttpServletRequest request = (HttpServletRequest) servletRequest;
  HttpServletResponse response = (HttpServletResponse) servletResponse;

  LOGGER.info("This Filter is only called when request is mapped for /customer resource");

  //call next filter in the filter chain
  filterChain.doFilter(request, response);
 }

 @Override
 public void destroy() {

 }
}

Registrieren Sie den benutzerdefinierten Filter mit FilterRegistrationBean .

@Configuration
public class AppConfig {

 @Bean
 public FilterRegistrationBean < CustomURLFilter > filterRegistrationBean() {
  FilterRegistrationBean < CustomURLFilter > registrationBean = new FilterRegistrationBean();
  CustomURLFilter customURLFilter = new CustomURLFilter();

  registrationBean.setFilter(customURLFilter);
  registrationBean.addUrlPatterns("/greeting/*");
  registrationBean.setOrder(2); //set precedence
  return registrationBean;
 }
}
0
Yogesh

Ich habe Antwort von @Vasily Komarov gesehen. Ein ähnlicher Ansatz, aber die Verwendung von abstract HandlerInterceptorAdapter class anstelle von HandlerInterceptor .

Hier ist ein Beispiel...

@Component
public class CustomInterceptor extends HandlerInterceptorAdapter {
   @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
    }
}

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private CustomInterceptor customInterceptor ;

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

}
0
Shaunak Patel
@WebFilter(urlPatterns="/*")
public class XSSFilter implements Filter {

    private static final org.Apache.log4j.Logger LOGGER = LogManager.getLogger(XSSFilter.class);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        LOGGER.info("Initiating XSSFilter... ");

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpRequestWrapper requestWrapper = new HttpRequestWrapper(req);
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {
        LOGGER.info("Destroying XSSFilter... ");
    }

}

Sie müssen Filter implementieren und müssen mit @WebFilter (urlPatterns = "/ *") kommentiert werden.

In der Klasse Application oder Configuration müssen Sie @ServletComponentScan Hinzufügen. Dadurch wird Ihr Filter registriert.

0
Rahul Anand

Dieser Filter hilft Ihnen auch dabei, den Zugriff über mehrere Origin-Standorte zuzulassen

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class SimpleCORSFilter implements Filter {

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

            HttpServletResponse response = (HttpServletResponse) res;
            HttpServletRequest request = (HttpServletRequest) req;
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
            response.setHeader("Access-Control-Max-Age", "20000");
            response.setHeader("Access-Control-Allow-Headers", "x-requested-with, authorization, Content-Type, Authorization, credential, X-XSRF-TOKEN");

            if("OPTIONS".equalsIgnoreCase(request.getMethod())) {
                response.setStatus(HttpServletResponse.SC_OK);
            } else {
                chain.doFilter(req, res);
            }
    }


    public void destroy() {}

    @Override
    public void init(FilterConfig arg0) throws ServletException {
        // TODO Auto-generated method stub

    }

}
0
Ghulam Murtaza

Fügen Sie zunächst @ServletComponentScan zu Ihrer SpringBootApplication-Klasse hinzu.

@ServletComponentScan
public class Application {

Zweitens erstellen Sie eine Filterdatei, die den Filter oder die Filterklasse eines Drittanbieters erweitert, und fügen Sie @WebFilter zu dieser Datei wie folgt hinzu:

@Order(1) //optional
@WebFilter(filterName = "XXXFilter", urlPatterns = "/*",
    dispatcherTypes = {DispatcherType.REQUEST, DispatcherType.FORWARD},
    initParams = {@WebInitParam(name = "confPath", value = "classpath:/xxx.xml")})
public class XXXFilter extends Filter{
0
oaoit

Sie benötigen zwei wichtige Dinge: - Fügen Sie Ihrer Hauptklasse @ServletComponentScan hinzu - Sie können ein Paket mit dem Namen filter hinzufügen, indem Sie eine Filter -Klasse erstellen, die Folgendes enthält:

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RequestFilter implements Filter {

 // whatever field you have

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) {
    HttpServletResponse response = (HttpServletResponse) res;
    HttpServletRequest request = (HttpServletRequest) req;

 // whatever implementation you want

        try {
            chain.doFilter(req, res);
        } catch(Exception e) {
            e.printStackTrace();
        }

}

public void init(FilterConfig filterConfig) {}

public void destroy() {}
}
0
Slimane Deb

sie können auch einen Filter erstellen, indem Sie @WebFilter verwenden und den Filter implementieren.

 @Configuration
        public class AppInConfig 
        {
        @Bean
      @Order(1)
      public FilterRegistrationBean aiFilterRegistration() {
            FilterRegistrationBean registration = new FilterRegistrationBean();
            registration.setFilter(new TrackingFilter());
            registration.addUrlPatterns("/**");
            registration.setOrder(1);
            return registration;
        } 
    @Bean(name = "TrackingFilter")
        public Filter TrackingFilter() {
            return new TrackingFilter();
        }   
    }
0
Muni