Como adicionar uma classe de filtro na Primavera de inicialização?

Não há uma anotação especial para denotar um filtro de servlet. Você acabou de declarar uma @Beando tipo Filter(ou FilterRegistrationBean). Um exemplo (adicionando um cabeçalho personalizado para todas as respostas) é no próprio Boot EndpointWebMvcAutoConfiguration ;

Se você só declarar Filterserá aplicado a todas as solicitações. Se você também adicionar um FilterRegistrationBeanvocê também poderá especificar servlets individuais e padrões de URL para aplicar.

Nota:

Na Primavera de inicialização 1.4, FilterRegistrationBeannão é obsoleto e simplesmente mudou pacotes a partir org.springframework.boot.context.embedded.FilterRegistrationBeandeorg.springframework.boot.web.servlet.FilterRegistrationBean

Aqui está um exemplo de um método de inclusão de um filtro personalizado em um aplicativo Primavera Bota MVC. Certifique-se de incluir o pacote em uma varredura de componente:

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

}

Se você quiser configurar um terceiro filtro que você pode usar FilterRegistrationBean. Por exemplo, o equivalente de 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>

Estes serão os dois feijões em seu @Configurationarquivo

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

O texto acima foi testado com mola de arranque 1.2.3

Existem três maneiras de adicionar o filtro,

1. Anotar o filtro com um dos estereótipos da Primavera, como @Component
2. Registar-se um @Beancom o Filtertipo de mola@Configuration
3. Registar-se um @Beancom o FilterRegistrationBeantipo de mola@Configuration

Ou # 1 ou # 2 vai fazer se você quiser que o seu filtro se aplica a todas as solicitações sem personalização, uso # 3 de outra forma. Você não precisa especificar varredura componente para # 1 a trabalhar enquanto você coloca sua classe de filtro no mesmo ou sub-pacote de sua SpringApplicationclasse. Para # 3, usar junto com # 2 só é necessário quando você quer Primavera para gerir a sua classe de filtro, como tê-lo auto dependências fio. Ele funciona muito bem para mim novo meu filtro que não precisa de qualquer dependência autowiring / injeção.

Embora combinando # 2 e # 3 obras excelentes, fiquei surpreso que ele não acabar com dois filtros de aplicação duas vezes. Meu palpite é que a Primavera combina os dois grãos como um quando ele chama o mesmo método para criar os dois. No caso de você querer usar # 3 sozinho com authowiring, você pode AutowireCapableBeanFactory. O seguinte é um exemplo,

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

De docs Primavera,

contêineres de servlet embutidos - Adicionar um Servlet, filtro ou ouvinte a uma aplicação

Para adicionar um Servlet, Filter, ou Servlet * Listener fornecer uma @Bean definição para ele.

Por exemplo:

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

Adicione esta @Beanconfiguração para a sua @Configurationclasse e filtrar será registrado na inicialização.

Além disso, você pode adicionar Servlets, filtros e ouvintes usando digitalização classpath,

@WebServlet, @WebFilter, e as classes @WebListener anotado podem ser registrados automaticamente com um servlet container embutido anotando uma classe @Configuration com @ServletComponentScan e especificando o pacote (s) contendo os componentes que você deseja registrar. Por padrão, @ServletComponentScan fará a varredura do pacote da classe anotada.

Aqui está um exemplo de minha classe Filtro personalizado:

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

E eu acrescentou que para a configuração de inicialização Primavera, acrescentando que a configuração da classe da seguinte forma:

package com.lyrahealth.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;
    }
}

Se você usar o Spring Bota + Spring Security, você pode fazer isso na configuração de segurança.

No exemplo abaixo, eu estou adicionando um filtro personalizado antes da UsernamePasswordAuthenticationFilter (ver todos os filtros de Primavera de segurança padrão e sua ordem ).

@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired FilterDependency filterDependency;

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

E a classe de filtro

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

Você pode usar @WebFilter javax.servlet.annotation.WebFilter em uma classe que implementa javax.servlet.Filter

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

Em seguida, use @ServletComponentScan a registar

Usando a anotação @WebFilter, isso pode ser feito da seguinte forma:

@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

    }

}

Filtros são utilizados principalmente em arquivos logger isso varia de acordo com o logger está usando no projeto Lemme explicar para log4j2:

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

Os filtros são usados ​​para restringir os dados e I usado filtro limiar adicional para restringir os níveis de dados no fluxo de I mencionados os níveis que podem ser restringidas por lá. Para o seu mais refrence ver a ordem nível de log4j2 - Níveis Log4J: ALL> TRACE> DEBUG> INFO> WARN> ERRO> FATAL> OFF

UPDATE: 2017/12/16:

Existem 2 maneiras simples de fazer isso na Primavera 1.5.8.RELEASE boot, não precisa xml.

Primeira maneira: Se você não tem qualquer padrão url spacific, você pode usar @Component assim. Código completo e detalhes aqui https://www.surasint.com/spring-boot-filter/

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

A segunda maneira: Se você quiser usar padrão de URL, você pode usar @WebFilter assim. Código completo e detalhes aqui https://www.surasint.com/spring-boot-filter-urlpattern/

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

Mas você precisa adicionar essa anotação @ServletComponentScan em sua Primavera de inicialização Classe Aplicação.

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

Note-se que @Component é anotação do Spring, mas @WebFilter não é. @WebFiler é servlet 3 anotação.

Ambas as formas, você só precisa de dependência de inicialização primavera básica em pom.xml (sem jasper necessidade tomcat explícita incorporado)

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

ATENÇÃO: A primeira forma, se o Controlador na Primavera de retorno de inicialização para um arquivo JSP, a solicitação passará o filtro duas vezes.

Enquanto, na segunda maneira, o pedido vai passar o filtro apenas uma vez.

Estou preferem a segunda maneira porque é mais semelhante ao comportamento na especificação servlet padrão ( https://docs.oracle.com/cd/E19879-01/819-3669/6n5sg7b0b/index.html )

Você vê veja mais log de teste aqui https://www.surasint.com/spring-boot-webfilter-instead-of-component/

você também pode fazer um filtro usando @WebFilter e implementa filtro, ele vai fazer.

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

Primeiro, adicione @ServletComponentScana sua classe SpringBootApplication.

@ServletComponentScan
public class Application {

Em segundo lugar, criar um arquivo de filtro estendendo filtro ou filtro de terceiros classe e adicionar @WebFiltera este arquivo como este:

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

Eu vi um monte de respostas aqui, mas eu não tentar qualquer um deles. Acabei de criar o filtro como no código a seguir.

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

    }
}

E com folhas a aplicação Primavera Bota permanecendo como era.

É mais um conselho de responder, mas se você estiver usando um Spring MVC em sua aplicação web a boa idéia é usar Primavera HandlerInterceptor vez de Filtro

Ele pode fazer o mesmo trabalho, mas também - Pode trabalhar com ModelAndView - Seus métodos pode ser chamado antes e após o processamento do pedido, ou depois do pedido de conclusão.
- Ele pode ser facilmente testado

1 Implementar interface de HandlerInterceptor e adicionar uma anotação @Component a sua classe

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

}

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

}

Você precisa implementar filtro e precisam ser anotado com @WebFilter (urlpatterns = "/ *")

E em aplicação ou classe de configuração que você precisa adicionar @ServletComponentScan por isso, seu filtro vai ficar registrado.

Vi resposta por @Vasily Komarov. Abordagem semelhante, mas utilizando abstrato HandlerInterceptorAdapter classe em vez de usar HandlerInterceptor .

Aqui está um exemplo...

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

}

Como todos sabem, Primavera de inicialização é uma ótima maneira de desenvolver um WebApp ou StandaloneApp com configuração mínima e Configuração opinativo.

Isto é como eu ter conseguido um Desenvolvimento Web Filter no aplicativo Primavera Bota

Meus SpringBootApp Especificações: -

Versão da mola de arranque: 2.0.4.RELEASE
Java Versão: 8,0
Servlet Specification: Servlet 3.0 (Obrigatório e importante)

Eu declarei meu Web Filter da seguinte forma, aderindo ao Servlet Especificações 3,0

Esta é a maneira programática de definir um filtro como um substituto para web.xml definições baseadas.

"@Webfilter" anotação serão processados ​​pelo recipiente durante a implantação, a classe de filtro em que se encontra vai ser criada de acordo com a configuração e aplicado ao URL padrões, javax.servlet.Servlets e javax.servlet.DispatcherTypes.

Para evitar Web.xml completamente e para alcançar WebApp "Deployable": -

Para implantar Primavera aplicativo de inicialização como "tradicional guerra", a classe de aplicativo deve estender SpringBootServletInitializer.

NOTA :: SpringBootServletInitializer é uma "implementação programática" do web.xml com referência às especificações Servlet 3.0 ou superior, o que requer uma implementação de WebApplicationInitializer.

Assim, SpringBootApplication não requer "web.xml" como a sua classe Application (depois de estender SpringBootServletInitializer) varre para
- @WebFilter,
- @WebListener e
- @WebServlet.

@ServletComponentScan anotação

Esta anotação permite pacotes básicos de digitalização para os componentes web anotados com @WebFilter, @WebListener e @WebServlet.

Devido ao fato de que os recipientes incorporados não suportam anotações @WebListener @WebServlet, @WebFilter e, Primavera Bota, confiando muito em contentores embarcados, introduziu esta nova anotação @ServletComponentScan para apoiar alguns frascos dependentes que usam essas 3 anotações.

A digitalização é executado apenas quando se utiliza um recipiente servlet incorporado.

A seguir é a minha Primavera de inicialização de aplicativos de Definição de Classe: -

Personalizado Servlet Initializer: -

Aqui: Eu tenho definido uma classe personalizada: "ServletInitializer" que se estende Classe: SpringBootServletInitializer.

Como explicado anteriormente, SpringBootServletInitializer é responsável por anotações de digitalização: -
- @WebFilter,
- @WebListener e
- @WebServlet.

E, portanto, a aplicação de classe Primavera de inicialização deve

• Quer estender a classe: SpringBootServletInitializer OR
• estender classe customizada que se estende a classe: SpringBootServletInitializer

Filtros como o nome sugere usado para executar a filtragem em ambos o pedido para um recurso ou na resposta de um recurso, ou ambos. Primavera Bota fornece algumas opções para registrar filtros personalizados no aplicativo de inicialização Primavera. Vamos olhar para as diferentes opções.

1. Definir Filtro Primavera Boot and Order Invocation

Implementar a interface de filtro para criar um novo filtro na Primavera de inicialização.

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

Vamos dar uma olhada rápida em alguns pontos importantes no código acima

• O filtro registrado pelo @Component anotação.

• Para disparar filtros no direito fim-precisávamos usar o @Order anotação.

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

No código acima, CustomFirstFilter será executado antes do CustomSecondFilter.

Quanto menor o número, maior é a prioridade

Padrão 2. URL

Se o mapeamento baseado em convenção não é suficientemente flexível, podemos usar FilterRegistrationBean para o controle total da aplicação. Aqui, não use @Component anotação para a classe filtro, mas registrar o filtro usando um 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() {

 }
}

Registrar o filtro personalizado usando 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;
 }
}

Este filtro também irá ajudá-lo para permitir o acesso de origem cruzada

@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

    }

}

Temos cerca de quatro opções diferentes para registrar um filtro usando Spring .

Em primeiro lugar, podemos criar um bean Spring implementação de filtro ou estender HTTPFilter :

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

Em segundo lugar, podemos criar um bean Spring estendendo GenericFilterBean :

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

Alternativamente, podemos usar o FilterRegistrationBean classe:

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

E por último, podemos usar o @WebFilter anotação com @ServletComponentScan :

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

Você precisa de 2 coisas principais: - Adicione @ServletComponentScanà sua classe principal - você pode adicionar um pacote chamado filtro dentro dele você cria uma Filterclasse que tem o seguinte:

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

Passo 1: Criar um componente de filtro através da implementação da interface Filter.

@Component
public class PerformanceFilter implements Filter {

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

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

}

Passo 2: Defina este filtro para os padrões de URI usando FilterRegistrationBean.

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

Você pode consultar esta ligação para aplicação completa.