So fügen Sie eine filter-Klasse in den Frühling Starten?

Hier ist ein Beispiel für eine Methode, einschließlich einer benutzerdefinierten filter in eine Spring-Boot-MVC-Anwendung. Werden Sie sicher, dass das Paket in einer Komponente scan:

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 {}

}

InformationsquelleAutor tegatai

Es gibt drei Möglichkeiten, um Ihre filter,

1. Kommentieren Sie Ihren filter mit einer der Feder Stereotypen, wie @Component
2. Registrieren Sie einen @Bean mit Filter Art im Frühjahr @Configuration
3. Registrieren Sie einen @Bean mit FilterRegistrationBean Art im Frühjahr @Configuration

Entweder #1 oder #2 wird tun, wenn Sie möchten, dass Ihre filter, um alle Anforderungen ohne Anpassung, verwenden Sie #3 sonst. Sie brauchen nicht, um anzugeben, component-scan für die #1 zu arbeiten, solange Sie Ihren filter-Klasse im gleichen oder sub-Paket, das Ihre SpringApplication Klasse. Für #3, sowie #2 ist nur erforderlich, wenn Sie möchten, Frühling verwalten Sie Ihre filter-Klasse wie haben es auto-verdrahtete Abhängigkeiten. Es funktioniert gut für mich, um meine neue filter, die braucht keine Abhängigkeit autowiring/Injektion.

Obwohl die Kombination von #2 und #3 funktioniert einwandfrei, ich war überrascht, dass es nicht am Ende mit zwei Filter, die Anwendung zweimal. Meine Vermutung ist, dass der Frühling vereint die zwei Bohnen als ein, wenn es ruft die gleiche Methode zu erstellen, die beide von Ihnen. In Fall, dass Sie wollen, verwenden Sie #3 allein mit authowiring, können Sie AutowireCapableBeanFactory. 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;
    }

InformationsquelleAutor barryku

Hier ist ein Beispiel meiner custom-Filter-Klasse:

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 auf die Spring-boot-Konfiguration, indem Sie auf Configuration-Klasse wie folgt:

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;
    }
}

InformationsquelleAutor DPancs

Wenn Sie Spring Boot + Spring Security, können Sie dies in den security-Konfiguration.

In dem unten angeführten Beispiel, ich bin das hinzufügen eines benutzerdefinierten filter vor der UsernamePasswordAuthenticationFilter (siehe alle Standard-Spring-Security-Filter und deren 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 den filter, Klasse

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);
    }
}

InformationsquelleAutor Andrei Epure

Können Sie @WebFilter javax.- servlet.Anmerkung.WebFilter auf eine Klasse, die javax.- servlet.Filter

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

Dann verwenden Sie @ServletComponentScan registrieren

InformationsquelleAutor Cwrwhaf

Es ist mehr ein Ratschlag als eine Antwort, aber wenn Sie einen Spring MVC in einer Webanwendung die gute Idee ist die Verwendung von Spring HandlerInterceptor statt Filter

Kann es die gleiche Arbeit, aber auch
- Kann die Arbeit mit ModelAndView
- Seine Methoden können aufgerufen werden, die vor und nach der Verarbeitung von Anfragen oder nach Anforderung abgeschlossen.

- Es kann leicht geprüft werden,

1 Implementieren Sie HandlerInterceptor-Schnittstelle, und fügen Sie eine @Component-annotation an deine Klasse

@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 Ihr 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");
    }

}

InformationsquelleAutor Vasily Komarov

Erste, hinzufügen @ServletComponentScan zu Ihrem SpringBootApplication Klasse.

@ServletComponentScan
public class Application {

Zweite, erstellen Sie einen filter, Datei-Filter erweitern oder Drittanbieter-filter-Klasse und hinzufügen von @WebFilter zu dieser Datei wie folgt:

@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{

InformationsquelleAutor oaoit

Sah ich die Antwort von @Wassili Komarov. Ähnlicher Ansatz, aber mit abstrakten HandlerInterceptorAdapter - Klasse 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 );
    }

}

InformationsquelleAutor Shaunak Patel

Filter wie der name andeutet verwendet, um das filtern auf, die entweder die Anforderung an eine Ressource oder auf die Antwort von einer Ressource, oder beides. Spring Boot bietet einige Optionen zum registrieren von benutzerdefinierten Filter in der Spring-Boot-Anwendung. Schauen wir uns die verschiedenen Optionen.

1. Definieren Spring-Boot-Filter und Aufruf, Um

Implementieren Filter-Schnittstelle, um einen neuen filter anzulegen, die im Frühjahr Starten.

@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
 }
}

Lasst uns schnell einen Blick auf einige wichtige Punkte im obigen code

• Der filter registriert von @Komponente annotation.

• Feuer-Filter in der richtigen Reihenfolge–wir nötig, um die @Um annotation.

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

In dem obigen code, CustomFirstFilter wird ausgeführt, bevor die CustomSecondFilter.

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

2. URL-Muster

Wenn das übereinkommen-basierte mapping ist nicht flexibel genug, wir können FilterRegistrationBean für die vollständige Steuerung der Anwendung. Hier, nicht verwenden @Komponente - Anmerkung für die filter Klasse, aber registrieren Sie den filter mit Hilfe eines 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 benutzerdefinierte Filter mit Hilfe 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;
 }
}

InformationsquelleAutor Yogesh