Spring Bootでフィルタクラスを追加する方法

Question

Spring Bootに（Webアプリケーション用の）Filterクラスのアノテーションがあるのではないでしょうか。おそらく@Filterですか？

プロジェクトにカスタムフィルタを追加したいです。

Spring Bootリファレンスガイド でFilterRegistrationBeanについて言及しましたが、使い方がわかりません。

Answer 1

サードパーティのフィルタを設定したい場合はFilterRegistrationBeanを使用できます。例えば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>

これらはあなたの@Configurationファイルの中の2つのBeanになります

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

上記はspring-boot 1.2.3でテストされました

Answer 2

これは、Spring Boot MVCアプリケーションにカスタムフィルタを含める方法の一例です。必ずパッケージをコンポーネントスキャンに含めてください。

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

}

Answer 3

サーブレットフィルタを表すための特別な注釈はありません。あなたはただFilter（またはFilterRegistrationBean）型の@Beanを宣言するだけです。例（すべての応答にカスタムヘッダーを追加する）はBoot自身のものです EndpointWebMvcAutoConfiguration 。

あなたがFilterを宣言するだけなら、それはすべてのリクエストに適用されます。 FilterRegistrationBeanも追加する場合は、適用する個々のサーブレットとURLパターンを追加で指定できます。

注：

Spring Boot 1.4では、FilterRegistrationBeanは非推奨ではなく、単にパッケージをorg.springframework.boot.context.embedded.FilterRegistrationBeanからorg.springframework.boot.web.servlet.FilterRegistrationBeanに移動しました

Answer 4

フィルタを追加する方法は3つあります。

1. フィルタに@ComponentなどのSpringステレオタイプの1つで注釈を付けます
2. SpringでFilter型で@Beanを登録する@Configuration
3. SpringでFilterRegistrationBean型で@Beanを登録する@Configuration

カスタマイズしないですべてのリクエストにフィルタを適用する場合は＃1または＃2のどちらでもかまいません。それ以外の場合は＃3を使用します。フィルタクラスをSpringApplicationクラスと同じパッケージまたはサブパッケージに配置する限り、＃1のコンポーネントスキャンを指定する必要はありません。 ＃3の場合、＃2と一緒に使用するのは、Springがあなたのフィルタクラスを自動配線された依存関係のように管理したい場合にのみ必要です。依存関係の自動配線/インジェクションを必要としない私のフィルタを新しくしても問題ありません。

＃2と＃3を組み合わせても問題はありませんが、2つのフィルタが2回適用されることにならないことに驚きました。私が思うに、Springは同じメソッドを呼び出して両方のBeanを作成するときに、2つのBeanを1つのBeanとして結合します。もしあなたがauthowiringと一緒に＃3を単独で使いたいのであれば、AutowireCapableBeanFactoryを使えます。以下はその一例です。

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

Answer 5

更新日：2017-12-16：

Spring Boot 1.5.8で簡単にこれを行うには2つの方法があります。RELEASE、XMLは不要です。

最初の方法：特殊なURLパターンがない場合は、次のように@Componentを使用できます。（完全なコードと詳細はこちらです https ：//www.surasint.com/spring-boot-filter/ ）

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

2つ目の方法：URLパターンを使用する場合は、@ WebFilterを次のように使用します。（完全なコードと詳細はこちらです https：/ /www.surasint.com/spring-boot-filter-urlpattern/ ）

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

しかし、@ SpringBootApplicationクラスに@ServletComponentScanアノテーションを追加する必要もあります。

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

@ComponentはSpringのアノテーションですが、@ WebFilterはそうではありません。 @WebFilterはサーブレット3のアノテーションです。

どちらの方法でも、pom.xmlに基本的なSpring Bootの依存関係が必要なだけです（明示的なTomcat埋め込みジャスパーは不要です）。

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

警告：最初の方法は、Spring BootのコントローラがJSPファイルに戻った場合、リクエストはフィルタを2回通過することです。

その一方で、2番目の方法では、リクエストはフィルタを1回だけ通過します。

2番目の方法は、サーブレット仕様（ https://docs.Oracle.com/cd/E19879-01/819-3669/6n5sg7b0b/index）のデフォルトの動作により近いため、この方法をお勧めします。 html ）

あなたはより多くのテストログをここで見ることができます https://www.surasint.com/spring-boot-webfilter-instead-of-component/

Answer 6

これが私のカスタムFilterクラスの例です。

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

そして、私は次のようにそれをConfigurationクラスに追加することによってSpringのブート設定に追加しました：

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

Answer 7

Springのドキュメントから、

埋め込みサーブレットコンテナ - サーブレット、フィルタ、またはリスナをアプリケーションに追加します

サーブレット、フィルタ、またはサーブレット*リスナを追加するには、@ Bean定義を指定します。

例えば：

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

この@Bean設定を@Configurationクラスに追加すると、フィルタは起動時に登録されます。

また、クラスパススキャンを使用してサーブレット、フィルタ、およびリスナを追加することもできます。

@WebServlet、@ WebFilter、および@WebListenerアノテーション付きクラスは、@ServletComponentScanで@Configurationクラスにアノテーションを付け、登録するコンポーネントを含むパッケージを指定することによって、埋め込みサーブレットコンテナに自動的に登録できます。デフォルトでは、@ServletComponentScanは注釈付きクラスのパッケージからスキャンします。

Answer 8

Spring Boot + Spring Securityを使用している場合は、セキュリティ設定でそれを実行できます。

以下の例では、UsernamePasswordAuthenticationFilterの前にカスタムフィルターを追加しています（ すべてのデフォルトのSpring Securityフィルターとその順序 を参照）。

@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired FilterDependency filterDependency;

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

そしてフィルタクラス

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

Answer 9

@WebFilterアノテーションを使うと、次のようにすることができます。

@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

    }

}

Answer 10

回答よりもアドバイスですが、WebアプリケーションでSpring MVCを使用している場合は、Filterの代わりにSpring HandlerInterceptorを使用することをお勧めします。

それは同じ仕事をすることができますがまたまた - ModelAndViewとはたらくことができます - そのメソッドは要求処理の前後、または要求完了の後に呼ばれることができます。
- 簡単にテストできます

1 HandlerInterceptorインタフェースを実装し、クラスに@Componentアノテーションを追加します

@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インターセプタを設定する

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

}

Answer 11

Javax.servlet.Filterを実装しているクラスで@WebFilter javax.servlet.annotation.WebFilterを使用できます。

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

それから@ServletComponentScanを使って登録する

Answer 12

私はここでたくさんの答えを見ました、しかし私はそれらのどれも試しませんでした。次のコードのようにフィルタを作成しました。

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

    }
}

そして残りのSpring Bootアプリケーションをそのまま残しました。

Answer 13

Springを使用してフィルターを登録する には、おおよそ4つの異なるオプションがあります。

まず、実装するFilterまたは拡張するHttpFilterSpring Beanを作成できます。

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

次に、拡張するSpring Beanを作成できます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);
    }
}

または、FilterRegistrationBeanクラスを使用できます。

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

最後に、@ WebFilterアノテーションと@ 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);
    }
}

Answer 14

@WebFilterを使ってフィルタを作成してFilterを実装することもできます。

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

Answer 15

皆さんご存じのとおり、Spring Bootは、最小限の構成と適切なセットアップを備えたWebAppまたはStandaloneAppを開発するための素晴らしい方法です。

これが、Spring BootアプリケーションでWebフィルタ開発を達成した方法です。

私のSpringBootApp仕様： -

Spring Bootのバージョン：2.0.4.RELEASE
Javaバージョン：8.0
サーブレット仕様：サーブレット3.0（必須および重要）

Servlet仕様3.0に準拠して、次のようにWebフィルタを宣言しました。

これは、web.xmlベースの定義に代わるものとしてフィルタを定義するためのプログラム的な方法です。

「@Webfilter」アノテーションはデプロイ中にコンテナによって処理され、それが見つかったFilterクラスは設定に従って作成され、URLパターンjavax.servlet.Servletsおよびjavax.servlet.DispatcherTypesに適用されます。

Web.xmlを完全に回避し、「展開可能な」WebAppを実現するには、以下の手順を実行します。 -

Spring Boot Applicationを "Traditional WAR"としてデプロイするには、アプリケーションクラスはSpringBootServletInitializerを拡張する必要があります。

注::SpringBootServletInitializerは、Servlet 3.0以降の仕様を参照するweb.xmlの「プログラムによる実装」であり、WebApplicationInitializerの実装が必要です。

したがって、SpringBootApplicationは、（SpringBootServletInitializerを拡張した後の）Applicationクラスをスキャンするために "web.xml"を必要としません。
- @WebFilter、
- @WebListenerと
- @WebServlet.

アノテーション@ServletComponentScan

このアノテーションは、@ WebFilter、@ WebListener、および@ WebServletでアノテートされたWebコンポーネントのベースパッケージをスキャンすることを可能にします。

埋め込みコンテナは@WebServlet、@ WebFilter、および@WebListenerアノテーションをサポートしていないという事実により、Spring Bootは埋め込みコンテナに大きく依存して、この新しいアノテーション@ServletComponentScanを導入して、これら3つのアノテーションを使用する依存jarをサポートします。

スキャンは、埋め込みサーブレットコンテナを使用している場合にのみ実行されます。

以下は私のSpring Bootのアプリケーションクラスの定義です： -

カスタムサーブレットイニシャライザ： -

ここで、私は、Class：SpringBootServletInitializerを拡張するカスタムクラス "ServletInitializer"を定義しました。

先に説明したように、SpringBootServletInitializerはアノテーションをスキャンする責任があります -
- @WebFilter、
- @WebListenerと
- @WebServlet.

したがって、Spring Boot Application Classは

• クラスを拡張するか：SpringBootServletInitializerまたは
• クラスを拡張するカスタムクラス：SpringBootServletInitializer

Answer 16

名前が示すとおりにフィルタリングし、リソースへの要求またはリソースからの応答のいずれか、あるいはその両方に対してフィルタリングを実行するために使用します。 Spring Bootには、Spring Bootアプリケーションにカスタムフィルタを登録するためのいくつかのオプションがあります。さまざまなオプションを見てみましょう。

1。 Spring Bootのフィルタと呼び出し順序を定義する

Spring Bootで新しいフィルタを作成するためのフィルタインタフェースを実装する。

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

上記のコードの重要な点を簡単に見てみましょう。

• @ Componentアノテーションで登録されたフィルタ。

• 正しい順序でフィルタを起動するには、@ Orderアノテーションを使用する必要がありました。

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

上記のコードでは、CustomFirstFilterはCustomSecondFilterの前に実行されます。

数字が小さいほど、優先順位が高くなります。

2。 URLパターン

規約に基づくマッピングが十分に柔軟でない場合は、FilterRegistrationBeanを使用して、アプリケーションここで、フィルタクラスに@ Componentアノテーションを使用せず、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() {

 }
}

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

Answer 17

@Vasily Komarovが答えを見ました。同様のアプローチですが、HandlerInterceptorの代わりにabstractHandlerInterceptorAdapterクラスを使用します。

これは一例です...

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

}

Answer 18

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

}

あなたはフィルタを実装する必要があり、@ WebFilter（urlPatterns = "/ *"）のアノテーションを付ける必要があります。

そしてApplicationクラスまたはConfigurationクラスで@ServletComponentScanを追加する必要があります。これによってあなたのフィルタが登録されます。

Answer 19

このフィルターは、クロスオリジンアクセスを許可するのにも役立ちます

@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

    }

}

Answer 20

まず、SpringBootApplicationクラスに@ServletComponentScanを追加します。

@ServletComponentScan
public class Application {

次に、Filterまたはサードパーティのフィルタクラスを拡張したフィルタファイルを作成し、このファイルに@WebFilterを次のように追加します。

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

Answer 21

2つの主なものが必要です。-メインクラスに@ServletComponentScanを追加します-その中にfilterという名前のパッケージを追加して、次のFilterクラスを作成できます。

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