Comment ajouter une classe de filtre dans Spring Boot?
Je me demande s’il existe une annotation pour une classe Filter (pour les applications Web) dans Spring Boot? Peut-être @Filter?
Je souhaite ajouter un filtre personnalisé à mon projet.
Le Guide de référence du démarrage de printemps mentionné à propos de FilterRegistrationBean, mais je ne sais pas comment l'utiliser.
Si vous souhaitez configurer un filtre tiers, vous pouvez utiliser FilterRegistrationBean. Par exemple, l'équivalent 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>
Ce seront les deux haricots dans votre fichier @Configuration
@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();
}
Ce qui précède a été testé avec Spring-Boot 1.2.3
Voici un exemple de méthode permettant d'inclure un filtre personnalisé dans une application Spring Boot MVC. Veillez à inclure le package dans une analyse de composant:
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 {}
}
Il n'y a pas d'annotation spéciale pour désigner un filtre de servlet. Vous venez de déclarer un @Bean de type Filter (ou FilterRegistrationBean). Un exemple (ajout d'un en-tête personnalisé à toutes les réponses) figure dans le propre fichier EndpointWebMvcAutoConfiguration de Boot;
Si vous ne déclarez qu'une Filter, elle sera appliquée à toutes les demandes. Si vous ajoutez également une FilterRegistrationBean, vous pouvez également spécifier des modèles de servlets et d'URL individuels à appliquer.
Remarque:
À partir de Spring Boot 1.4, FilterRegistrationBean n'est pas obsolète et a simplement déplacé les packages de org.springframework.boot.context.embedded.FilterRegistrationBean à org.springframework.boot.web.servlet.FilterRegistrationBean
Il y a trois façons d'ajouter votre filtre,
- Annotez votre filtre avec l'un des stéréotypes Spring tels que
@Component - Enregistrez un
@BeanavecFilteret entrez Spring@Configuration - Enregistrez un
@BeanavecFilterRegistrationBeanet entrez Spring@Configuration
N ° 1 ou N ° 2 suffiront si vous souhaitez que votre filtre s'applique à toutes les demandes sans personnalisation, utilisez N ° 3 sinon. Vous n'avez pas besoin de spécifier l'analyse de composant pour # 1 pour fonctionner tant que vous placez votre classe de filtre dans le même package ou sous-package de votre classe SpringApplication. Pour # 3, utiliser avec # 2 n'est nécessaire que si vous souhaitez que Spring gère votre classe de filtre, par exemple si vous le faites avec des dépendances câblées automatiquement. Cela fonctionne très bien pour moi de changer mon filtre qui ne nécessite aucune autowiring/injection de dépendance.
Bien que la combinaison des n ° 2 et n ° 3 fonctionne bien, j'ai été surprise de constater que deux filtres ne s'appliquent pas deux fois. Je suppose que Spring combine les deux beans en un seul lorsqu'il appelle la même méthode pour créer les deux. Si vous souhaitez utiliser le n ° 3 seul avec l'authowiring, vous pouvez AutowireCapableBeanFactory. Ce qui suit est un exemple,
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;
}
MISE À JOUR: 2017-12-16:
Il existe 2 façons simples de faire cela dans Spring boot 1.5.8.RELEASE, pas besoin de xml.
Première manière: Si vous n’avez pas de motif d’URL spécifique, vous pouvez utiliser @Component comme ceci: (Le code complet et les détails se trouvent ici https://www.surasint.com/ filtre de démarrage à ressort/ )
@Component
public class ExampleFilter implements Filter{
...
}
Deuxième manière: Si vous voulez utiliser des modèles d'URL, vous pouvez utiliser @WebFilter comme ceci: (Le code complet et les détails sont ici https://www.surasint.com/spring- boot-filter-urlpattern/ )
@WebFilter(urlPatterns = "/api/count")
public class ExampleFilter implements Filter{
...
}
Mais vous devez également ajouter une annotation @ServletComponentScan dans votre classe @SpringBootApplication:
@ServletComponentScan
@SpringBootApplication
public class MyApplication extends SpringBootServletInitializer {
...
}
Notez que @Component est l'annotation de Spring, mais @WebFilter ne l'est pas. @WebFiler est l'annotation Servlet 3.
Dans les deux cas, vous avez simplement besoin de la dépendance de base du démarrage printanier dans pom.xml (pas besoin de jasper Tomcat intégré explicite).
<?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>
WARNING: Dans un premier temps, si le contrôleur au démarrage du ressort revient à un fichier jsp, la demande transmettra le filtre deux fois.
Dans le second cas, la requête ne passera le filtre qu’une fois.
Je préfère la deuxième façon, car elle ressemble davantage au comportement par défaut dans la spécification Servlet ( https://docs.Oracle.com/cd/E19879-01/819-3669/6n5sg7b0b/index.html )
Vous pouvez voir plus de journal de test ici https://www.surasint.com/spring-boot-webfilter-instead-of-component/
Voici un exemple de ma classe de filtre personnalisée:
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);
}
}
Et je l'ai ajouté à la configuration de démarrage Spring en l'ajoutant à la classe de configuration comme suit:
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;
}
}
À partir des documents de printemps,
Conteneurs de servlets intégrés - Ajouter un servlet, un filtre ou un écouteur à une application
Pour ajouter un servlet, un filtre ou un écouteur Servlet *, fournissez un @Bean définition pour cela.
Par exemple:
@Bean
public Filter compressFilter() {
CompressingFilter compressFilter = new CompressingFilter();
return compressFilter;
}
Ajoutez cette configuration @Bean à votre classe @Configuration et le filtre sera enregistré au démarrage.
Vous pouvez également ajouter des servlets, des filtres et des écouteurs à l’aide du balayage des chemins de classes.
Les classes annotées @WebServlet, @WebFilter et @WebListener peuvent être automatiquement enregistré avec un conteneur de servlets intégré par annoter une classe @Configuration avec @ServletComponentScan et en spécifiant le (s) package (s) contenant les composants que vous souhaitez registre. Par défaut, @ServletComponentScan analysera à partir du package de la classe annotée.
Si vous utilisez Spring Boot + Spring Security, vous pouvez le faire dans la configuration de la sécurité.
Dans l'exemple ci-dessous, j'ajoute un filtre personnalisé avant UsernamePasswordAuthenticationFilter (voir tous les filtres Spring Security par défaut et leur ordre ).
@EnableWebSecurity
class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired FilterDependency filterDependency;
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.addFilterBefore(
new MyFilter(filterDependency),
UsernamePasswordAuthenticationFilter.class);
}
}
Et la classe de filtre
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);
}
}
En utilisant l'annotation @WebFilter, cela peut être fait comme suit:
@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
}
}
C'est plus un conseil que une réponse, mais si vous utilisez un Spring MVC dans votre application Web, la bonne idée est d'utiliser Spring HandlerInterceptor au lieu de Filter
Il peut faire le même travail, mais aussi - Peut fonctionner avec ModelAndView - Ses méthodes peuvent être appelées avant et après le traitement de la demande ou après son exécution.
- Il peut être facilement testé
1 Implémentez l'interface HandlerInterceptor et ajoutez une annotation @Component à votre 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 Configurez votre intercepteur
@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");
}
}
Vous pouvez utiliser @WebFilter javax.servlet.annotation.WebFilter sur une classe qui implémente javax.servlet.Filter.
@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {}
Puis utilisez @ServletComponentScan pour vous inscrire
J'ai vu beaucoup de réponses ici mais je n'ai essayé aucune d'entre elles. Je viens de créer le filtre comme dans le code suivant.
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() {
}
}
Et laissé le reste de l'application Spring Boot telle qu'elle était.
Nous avons environ quatre options différentes à enregistrer un filtre en utilisant Spring .
Tout d'abord, nous pouvons créer un bean Spring mettant en œuvre un filtre ou une extension 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);
}
}
Deuxièmement, nous pouvons créer un bean Spring qui s'étend 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);
}
}
Alternativement, nous pouvons utiliser la classe 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;
}
}
Enfin, nous pouvons utiliser l'annotation @ WebFilter avec @ 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);
}
}
Comme vous le savez tous, Spring Boot est un moyen formidable de développer une application Web ou autonome avec une configuration minimale et une configuration appropriée.
Voici comment j'ai réalisé un développement de filtre Web dans une application Spring Boot
Mes spécifications SpringBootApp: -
Version Spring Boot: 2.0.4.RELEASE
Version Java: 8.0
Spécification du servlet: Servlet 3.0 (obligatoire et important)
J'ai déclaré mon filtre Web de la manière suivante, conformément aux spécifications Servlet 3.0.
Ceci est la méthode programmatique pour définir un filtre en remplacement des définitions basées sur web.xml.
L'annotation "@Webfilter" sera traitée par le conteneur lors du déploiement, la classe Filter dans laquelle il se trouve sera créée selon la configuration et appliquée aux modèles d'URL, javax.servlet.Servlets et javax.servlet.DispatcherTypes.
Pour éviter complètement Web.xml et pour obtenir une WebApp "déployable": -
Pour déployer une application de démarrage Spring en tant que "WAR traditionnel", la classe d'application doit étendre SpringBootServletInitializer.
NOTE :: SpringBootServletInitializer est une "implémentation programmatique" de web.xml avec une référence aux spécifications Servlet 3.0+, qui nécessite une implémentation de WebApplicationInitializer.
SpringBootApplication ne nécessite donc pas "web.xml" car sa classe Application (après l'extension de SpringBootServletInitializer) recherche
- @WebFilter,
- @WebListener et
- @WebServlet.
Annotation @ServletComponentScan
Cette annotation active l'analyse des packages de base pour les composants Web annotés avec @WebFilter, @WebListener et @WebServlet.
Etant donné que les conteneurs incorporés ne prennent pas en charge les annotations @WebServlet, @WebFilter et @WebListener, Spring Boot, s'appuyant largement sur les conteneurs incorporés, a introduit cette nouvelle annotation @ServletComponentScan pour prendre en charge certains fichiers jar dépendants utilisant ces 3 annotations.
L'analyse est effectuée uniquement lors de l'utilisation d'un conteneur Servlet intégré.
Voici ma définition de classe d'application de démarrage de printemps: -
Initialiseur de servlet personnalisé: -
Ici: j'ai défini une classe personnalisée: "ServletInitializer" qui étend la classe: SpringBootServletInitializer.
Comme expliqué précédemment, SpringBootServletInitializer est chargé de l'analyse des annotations: -
- @WebFilter,
- @WebListener et
- @WebServlet.
Et par conséquent, la classe d’application Spring Boot devrait
- Étendez la classe: SpringBootServletInitializer OR
- extend Custom class qui étend la classe: SpringBootServletInitializer
Les filtres comme leur nom l'indique, permettent de filtrer la demande adressée à une ressource ou la réponse d'une ressource, ou les deux. Spring Boot fournit peu d'options pour enregistrer des filtres personnalisés dans l'application Spring Boot. Examinons les différentes options.
1. Définir l'ordre d'invocation du filtre d'amorçage du ressort
Implémentez l'interface de filtre pour créer un nouveau filtre dans 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
}
}
Voyons rapidement quelques points importants dans le code ci-dessus
- Le filtre enregistré par @Component annotation.
Pour déclencher les filtres dans le bon ordre, nous devions utiliser l'annotation @Order .
@Component @Order(1) public class CustomFirstFilter implements Filter { } @Component @Order(2) public class CustomSecondFilter implements Filter { }
Dans le code ci-dessus, CustomFirstFilter sera exécuté avant le CustomSecondFilter.
Plus le nombre est bas, plus la préséance est élevée
2. Modèle d'URL
Si le mappage basé sur les conventions n'est pas assez flexible, nous pouvons utiliser FilterRegistrationBean pour le contrôle complet de l'application. Ici, n’utilisez pas @Component annotation pour la classe de filtre, mais enregistrez le filtre en utilisant un 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() {
}
}
Enregistrez le filtre personnalisé avec 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;
}
}
J'ai vu la réponse de @Vasily Komarov. Approche similaire, mais en utilisant la classe abstraite HandlerInterceptorAdapter au lieu d'utiliser HandlerInterceptor.
Voici un exemple...
@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 );
}
}
@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... ");
}
}
Vous devez implémenter le filtre et être annoté avec @WebFilter (urlPatterns = "/ *")
Et dans la classe Application ou Configuration, vous devez ajouter @ServletComponentScan Ainsi, votre filtre sera enregistré.
Ce filtre vous aidera également à autoriser l’accès croisé à l’origine.
@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
}
}
Tout d'abord, ajoutez @ServletComponentScan à votre classe SpringBootApplication.
@ServletComponentScan
public class Application {
Deuxièmement, créez un fichier de filtre prolongeant un filtre ou une classe de filtre tierce et ajoutez @WebFilter à ce fichier comme suit:
@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{
Vous avez besoin de 2 choses principales: - Ajoutez @ServletComponentScan à votre classe principale - vous pouvez ajouter un paquet nommé filter à l'intérieur pour créer une classe Filter qui présente les caractéristiques suivantes:
@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() {}
}
vous pouvez également créer un filtre en utilisant @WebFilter et implémenter le filtre, cela ira.
@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();
}
}