Spring Boot'a filtre sınıfı nasıl eklenir?

Acaba, FilterSpring Boot'da bir sınıf (web uygulamaları için) için herhangi bir not varsa ? Belki @Filter?

Projeme özel bir filtre eklemek istiyorum.

Spring Boot Başvuru Kılavuzu bahsetti FilterRegistrationBean, ancak nasıl kullanılacağından emin değilim.

Üçüncü taraf bir filtre ayarlamak istiyorsanız kullanabilirsiniz FilterRegistrationBean. Örneğin web.xml eşdeğeri

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

Bunlar @Configurationdosyanızdaki iki fasulye olacak

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

Yukarıdaki yay önyükleme 1.2.3 ile test edildi

Burada, Spring Boot MVC uygulamasına özel bir filtre eklemek için bir yöntem örneği. Paketi bir bileşen taramasına dahil ettiğinizden emin olun:

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

}

Sunucu uygulaması filtresini belirtmek için özel bir açıklama yoktur. Sadece bir @Beantür Filter(veya FilterRegistrationBean) beyan edersiniz . Bir örnek (tüm yanıtlara özel bir başlık eklemek) Boot'un kendi EndpointWebMvcAutoConfiguration'ındadır ;

Sadece beyan ederseniz Filter, tüm taleplere uygulanacaktır. Ayrıca bir eklerseniz FilterRegistrationBean, uygulanacak ayrı ayrı sunucu uygulamaları ve URL kalıpları da belirtebilirsiniz.

Not:

Bahar Boot 1.4 itibariyle FilterRegistrationBeankaldırılmış değildir ve sadece paketleri taşındı org.springframework.boot.context.embedded.FilterRegistrationBeaniçinorg.springframework.boot.web.servlet.FilterRegistrationBean

Filtrenizi eklemenin üç yolu vardır,

1. Filtrenize, Spring stereotiplerinden biri gibi açıklama ekleyin @Component
2. İlkbaharda bir tür @Beanile kaydolunFilter@Configuration
3. İlkbaharda bir tür @Beanile kaydolunFilterRegistrationBean@Configuration

Filtrenizin özelleştirme olmadan tüm isteklere uygulanmasını istiyorsanız # 1 veya # 2 yapılır, aksi takdirde # 3 kullanın. Filtre sınıfınızı sınıfınızla aynı veya alt pakete yerleştirdiğiniz sürece, # 1 için bileşen taraması belirtmeniz gerekmez SpringApplication. # 3 için # 2 ile birlikte kullanmak, yalnızca Spring'in otomatik sınıf bağımlılıkları gibi filtre sınıfınızı yönetmesini istediğinizde gereklidir. Herhangi bir bağımlılık otomatik kablolama / enjeksiyon gerektirmeyen yeni filtrem için benim için iyi çalışıyor.

# 2 ve # 3'ü birleştirmek iyi çalışıyor olsa da, iki filtre uygulayan iki filtre ile sonuçlanmamasına şaşırdım. Tahminimce Spring, her ikisini de oluşturmak için aynı yöntemi çağırdığında iki fasulyeyi bir araya getiriyor. Authowiring ile yalnızca # 3 kullanmak istiyorsanız, bunu yapabilirsiniz AutowireCapableBeanFactory. Aşağıdaki bir örnektir,

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

GÜNCELLEME: 2017-12-16:

Bunu Spring Boot 1.5.8'de yapmanın 2 basit yolu vardır.

İlk yol: Herhangi bir boşluk URL kalıbınız yoksa, @Component'i şu şekilde kullanabilirsiniz: (Tam kod ve ayrıntılar burada https://www.surasint.com/spring-boot-filter/ )

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

İkinci yol: URL kalıplarını kullanmak istiyorsanız, @WebFilter'i şu şekilde kullanabilirsiniz: (Tam kod ve ayrıntılar burada https://www.surasint.com/spring-boot-filter-urlpattern/ )

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

Ancak @SpringBootApplication sınıfınıza @ServletComponentScan ek açıklaması da eklemeniz gerekir:

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

@Component öğesinin Spring ek açıklaması olduğunu, ancak @WFFilter olmadığını unutmayın. @ WebFilter, Servlet 3 ek açıklamasıdır.

Her iki şekilde de, pom.xml'de temel Spring Boot bağımlılığına ihtiyacınız var (açık tomcat gömülü jasper'a gerek yok)

    <?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>

UYARI: İlk yol, Spring Boot'daki Denetleyici bir JSP dosyasına dönerse, istek filtreyi iki kez geçirir.

İkinci şekilde, istek filtreyi yalnızca bir kez geçirir.

İkinci yolu tercih ediyorum çünkü Servlet belirtimindeki varsayılan davranışa daha çok benziyor ( https://docs.oracle.com/cd/E19879-01/819-3669/6n5sg7b0b/index.html )

Daha fazla test günlüğü burada görebilirsiniz https://www.surasint.com/spring-boot-webfilter-instead-of-component/

İşte benim özel Filter sınıfına bir örnek:

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

Ve aşağıdaki gibi Configuration sınıfına ekleyerek Spring önyükleme yapılandırmasına ekledim:

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

Bahar dokümanlarından,

Gömülü sunucu uygulaması kapları - Bir uygulamaya Sunucu Uygulaması, Filtre veya Dinleyici ekleme

Sunucu Uygulaması , Filtre veya Sunucu Uygulaması * Dinleyicisi eklemek için @Bean tanımını girin.

Örneğin:

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

Bu @Beanyapılandırmayı @Configurationsınıfınıza ekleyin , başlangıçta filtre kaydedilir.

Ayrıca sınıf yolu taramayı kullanarak Sunucu, Filtre ve Dinleyici ekleyebilirsiniz,

@WebServlet, @WebFilter ve @WLListener açıklamalı sınıfları, @SfigletComponentScan ile bir @Configuration sınıfına açıklama ekleyerek ve kaydetmek istediğiniz bileşenleri içeren paketleri belirterek katıştırılmış sunucu uygulaması kapsayıcısına otomatik olarak kaydedilebilir. Varsayılan olarak, @ServletComponentScan ek açıklamalı sınıfın paketinden tarar.

Spring Boot + Spring Security kullanıyorsanız bunu güvenlik yapılandırmasında yapabilirsiniz.

Aşağıdaki örnekte, UsernamePasswordAuthenticationFilter'dan önce özel bir filtre ekliyorum ( varsayılan tüm Spring Security filtrelerine ve sıralarına bakın ).

@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired FilterDependency filterDependency;

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

Ve filtre sınıfı

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

@WebFilter ek açıklamasını kullanarak şu şekilde yapılabilir:

@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

    }

}

Spring'i kullanarak bir filtre kaydetmek için kabaca dört farklı seçeneğimiz var .

İlk olarak, Filtre uygulayan veya HttpFilter'ı genişleten bir Spring bean oluşturabiliriz :

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

İkinci olarak, GenericFilterBean'ı genişleten bir Spring bean oluşturabiliriz :

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

Alternatif olarak, FilterRegistrationBean sınıfını kullanabiliriz :

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

Son olarak @WebFilter ek açıklamasını @ServletComponentScan ile kullanabiliriz :

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

Cevaptan çok bir tavsiye, ancak web uygulamanızda bir Spring MVC kullanıyorsanız, Filtre yerine Spring HandlerInterceptor kullanmak iyi bir fikirdir.

Aynı işi yapabilir, ama aynı zamanda - ModelAndView ile çalışabilir - Yöntemleri, istek işlemeden önce ve sonra veya istek tamamlandıktan sonra çağrılabilir.
- Kolayca test edilebilir

1 HandlerInterceptor arabirimini uygulayın ve sınıfınıza @Component ek açıklaması ekleyin

@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 Durdurucunuzu yapılandırın

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

}

Bu filtre aynı zamanda çapraz menşe erişimine izin vermenize yardımcı olacaktır

@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

    }

}

Javax.servlet.Filter uygulayan bir sınıfta @WebFilter javax.servlet.annotation.WebFilter kullanabilirsiniz.

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

Sonra kaydolmak için @ServletComponentScan kullanın

Burada pek çok cevap gördüm ama hiçbirini denemedim. Aşağıdaki kodda olduğu gibi filtreyi yeni oluşturdum.

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() {

    }
}

Ve geri kalan Spring Boot uygulamasını olduğu gibi bıraktı.

Sen 2 ana şeye ihtiyacı: - Add @ServletComponentScan, Ana Sınıfı için - Eğer bir oluşturmak içine filtre adında bir paket ekleyebilir Filteraşağıdaki sahiptir Class:

@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() {}
}

Ayrıca @WebFilter kullanarak bir filtre yapabilir ve Filtre uygular.

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

Ad olarak filtreler, bir kaynağa yapılan istekte veya bir kaynaktan gelen yanıtta veya her ikisinde de filtreleme gerçekleştirmek için kullanılmasını önerir. Spring Boot, Spring Boot uygulamasında özel filtreleri kaydetmek için birkaç seçenek sunar. Farklı seçeneklere bakalım.

1. Yay Önyükleme Filtresi ve Çağrı Sırasını Tanımlama

Spring Boot'da yeni bir filtre oluşturmak için Filtre arabirimini uygulayın.

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

Yukarıdaki koddaki bazı önemli noktalara hızlıca bakalım

• @Bileşen ek açıklamasıyla kaydedilen filtre .

• Filtreleri doğru sırada ateşlemek için @Order ek açıklamasını kullanmamız gerekiyordu .

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

Yukarıdaki kodda, CustomFirstFilter, CustomSecondFilter öğesinden önce çalışır.

Sayı ne kadar düşükse, öncelik de o kadar yüksek olur

2. URL Modeli

Kural tabanlı eşleme yeterince esnek değilse, uygulamanın tam kontrolü için FilterRegistrationBean'ı kullanabiliriz . Burada, filtre sınıfı için @Component ek açıklamasını kullanmayın , ancak bir FilterRegistrationBean kullanarak filtreyi kaydedin .

 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() {

 }
}

FilterRegistrationBean kullanarak özel Filtreyi kaydedin .

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

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

    }

Filtre uygulamanız ve @WebFilter ile açıklamanız gerekir (urlPatterns = "/ *")

Ve Uygulama veya Yapılandırma sınıfında @ServletComponentScan eklemeniz gerekir. Bu şekilde filtreniz kaydedilecektir.

Adım 1: Filtre arabirimini uygulayarak bir filtre bileşeni oluşturun.

@Component
public class PerformanceFilter implements Filter {

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

            ......
            ......
    }

}

Adım 2: FilterRegistrationBean kullanarak bu filtreyi uri modellerine ayarlayın.

@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<PerformanceFilter> perfFilter() {
        FilterRegistrationBean<PerformanceFilter> registration = new FilterRegistrationBean<>();
        registration.setFilter(new PerformanceFilter());
        registration.addUrlPatterns("/*");
        return registration;
    }
}

Tam başvuru için bu bağlantıya başvurabilirsiniz .

İlk olarak, @ServletComponentScanSpringBootApplication sınıfınıza ekleyin .

@ServletComponentScan
public class Application {

İkinci olarak, Filtre veya üçüncü taraf filtre sınıfını genişleten bir filtre dosyası oluşturun ve @WebFilterbu dosyaya şu şekilde ekleyin :

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

@Vasily Komarov'un cevabını gördüm. Benzer yaklaşım, ancak kullanmak yerine soyut HandlerInterceptorAdapter sınıfını kullanma HandlerInterceptor .

İşte bir örnek...

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

}

Hepinizin bildiği gibi, Spring Boot minimum yapılandırma ve düşünülmüş Kurulum ile bir WebApp veya StandaloneApp geliştirmenin harika bir yoludur.

Spring Boot uygulamasında Web Filtresi Geliştirme yöntemini bu şekilde elde ettim.

My SpringBootApp Özellikleri: -

Spring Boot sürümü: 2.0.4.RELEASE
Java Sürümü: 8.0 Sunucu Uygulaması
Özellikler: Servlet 3.0 (Zorunlu ve Önemli)

Web Filtremi Servlet Özellikler 3.0'a bağlı kalarak aşağıdaki şekilde beyan ettim

Bu, bir Filtreyi web.xml tabanlı tanımların yerine tanımlamanın Programlı yoludur.

"@Webfilter" ek açıklaması dağıtım sırasında kapsayıcı tarafından işlenecek, içinde bulunduğu Filtre sınıfı yapılandırmaya göre oluşturulacak ve javax.servlet.Servlets ve javax.servlet.DispatcherTypes URL kalıplarına uygulanacaktır.

Web.xml'den tamamen kaçınmak ve "Konuşlandırılabilir" WebApp'a ulaşmak için: -

Spring Boot Uygulamasını "Geleneksel SAVAŞ" olarak dağıtmak için, uygulama sınıfı SpringBootServletInitializer öğesini genişletmelidir.

NOT :: SpringBootServletInitializer, WebApplicationInitializer uygulamasının uygulanmasını gerektiren Servlet 3.0+ belirtimlerine başvuru ile web.xml dosyasının "Programlı Uygulamasıdır".

Bu nedenle, SpringBootApplication Uygulama sınıfı olarak "web.xml" gerektirmez (
SpringBootServletInitializer genişletildikten sonra) - @WebFilter,
- @WebListener ve
- @WebServlet için tarama yapar.

Ek Açıklama @ServletComponentScan

Bu açıklama, @WebFilter, @WebListener ve @WebServlet ile açıklamalı web bileşenleri için temel paketlerin taranmasını sağlar.

Gömülü kapların @WebServlet, @WebFilter ve @WebListener ek açıklamalarını desteklememesi nedeniyle, gömülü kaplara büyük ölçüde dayanan Spring Boot, bu 3 ek açıklamayı kullanan bazı bağımlı kavanozları desteklemek için bu yeni ek açıklamayı @ServletComponentScan tanıttı.

Tarama yalnızca yerleşik bir Servlet kabı kullanılırken gerçekleştirilir.

Benim bahar çizme uygulama sınıfı tanımı aşağıdadır: -

Özel Sunucu Uygulaması Başlatıcı: -

Burada: Sınıf: SpringBootServletInitializer genişleten bir özel sınıf: "ServletInitializer" tanımladım.

Daha önce açıklandığı gibi,
SpringBootServletInitializer ek açıklamaları taramaktan sorumludur: - - @WebFilter,
- @WebListener ve
- @WebServlet.

Ve böylece Bahar Önyükleme Uygulama Sınıfı

• Sınıfı genişletin: SpringBootServletInitializer OR
• genişletme Sınıfı genişleten Özel sınıf: SpringBootServletInitializer

Filtreler çoğunlukla Lemme log4j2 için açıkladığı projede kullandığınız logger'a göre değişir logger dosyalarında kullanılır:

<Filters>
                <!-- It prevents error -->
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                <!-- It prevents debug -->
                <ThresholdFilter level="debug" onMatch="DENY" onMismatch="NEUTRAL" />
                <!-- It allows all levels except debug/trace -->
                <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY" /> 
            </Filters>

Filtreler verileri kısıtlamak için kullanılır ve akıştaki veri seviyelerini kısıtlamak için eşik filtresi daha da kullandım. Daha fazla referans için log4j2 - Log4J Seviye seviyesine bakınız: ALL> TRACE> DEBUG> INFO> WARN> ERROR> FATAL> OFF