SpringBoot注册Servlet、Filter、Listener、Interceptor四大组件

SpringBoot中注册四大组件

文章目录

SpringBoot中注册四大组件
1. Servlet注册
- 1. 基于配置类方式使用Servlet使用Servlet方式
- 2. 基于纯注解方式配置Servlet
2. Filter(过滤器)注册
- 1. 以配置类方式注册Filter
- 2. 以纯注解方式注册Filter
- 3. 以注解的方式注册Filter执行顺序不生效问题
3. Listener(监听器)注册
- 1. `@Component`注解
- 2. `@EventListener`注册监听
- 3. 主启动配置监听
4. Interceptor(拦截器)注册
5. 执行顺序

SpringBoot版本：2.2.5 GA 版

GA=General Availability，字面意思是一般或正常可用性。

代表的是官方正式发布的版本，推荐可广泛使用的版本，国外有的软件用GA来表示RELEASE版本。 RELEASE表示正式发布版
<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.5.RELEASE</version><relativePath/> </parent>

1. Servlet注册

有两种使用方式

1.基于配置类方式使用Servlet

2.基于纯注解方式使用Servlet

1. 基于配置类方式使用Servlet使用Servlet方式

自定义一个MyServlet类，让其继承HttpServlet类

在配置类中使用ServletRegistrationBean类注册自定义MyServlet类

设置相关属性并访问

MyServlet

package com.yuan.demo.servlet;import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;public class MyServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doPost(req, resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {String requestURI = req.getRequestURI();System.out.println("requestURI" + requestURI);System.out.println("req.getRequestURL()" + req.getRequestURL());resp.getWriter().write("Hello,Servlet!!!");}
}

配置类

package com.yuan.demo.config;import com.yuan.demo.filter.MyFilter;
import com.yuan.demo.listener.MyListener;
import com.yuan.demo.servlet.MyServlet;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/**** 注册自定义的Servlet*/
@Configuration
public class RegisterServerConfig {/*** 注册自定义Servlet* @return*/@Beanpublic ServletRegistrationBean myServlet(){ServletRegistrationBean<MyServlet> registrationBean = new ServletRegistrationBean<>(new MyServlet());registrationBean.addUrlMappings("/hello","/myServlet");return registrationBean;}/**** 注册自定义Filter* @return*/@Beanpublic FilterRegistrationBean myFilter(){FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();filterRegistrationBean.setFilter(new MyFilter());//设置自定义拦截器filterRegistrationBean.addUrlPatterns("/hello","/myServlet");//设置要拦截的请求return filterRegistrationBean;}/*** 注册自定义Listener* @return*/@Beanpublic ServletListenerRegistrationBean myListener(){ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());return registrationBean;}
}

2. 基于纯注解方式配置Servlet

写一个继承HttpServlet的类,并在其上面加上**@WebServlet**注解
在SpringBoot的主启动类上加上**@ServletComponentScan**注解

MyServletOne.java

package com.yuan.servlet;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;@WebServlet(value = {"/aa","/bb"}) //配置请求路径，其他参数看源码
public class MyServletOne extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doPost(req, resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {System.out.println("req.getRequestURI()====>"+req.getRequestURI());resp.getWriter().write("Hello,MyServletOne!!!");}
}

SpringBoot主启动如下：

package com.yuan;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;@ServletComponentScan
@SpringBootApplication
public class MyServletApplication {public static void main(String[] args) {SpringApplication.run(MyServletApplication.class,args);}
}

打开浏览器输入http://localhost:8080/aa，输出结果如下：

Hello,MyServletOne!!!

2. Filter(过滤器)注册

1. 以配置类方式注册Filter

自定义一个Filter类(如:MyFilter.java)让其实现Filter接口并实现相关方法
在配置类中注册 FilterRegistrationBean，设置过滤的URL等
编写测试案例进行过滤器测试

2. 以纯注解方式注册Filter

在在定义的Filter类中加入**@WebFilter**注解，并设置filterName及过滤的URL
在主启动类上加入 @ServletComponentScan注解
启动服务器进行测试

3. 以注解的方式注册Filter执行顺序不生效问题

问题描述，使用**@WebFilter方式注入filter后，用@Order**注解指定filter的执行顺序则不起作用
原因分析：

阅读源码发现：重点在ServletComponentHandler 处理带有注解WebFilter的类；handle方法中处理的attributes是@WebFilter的属性，因为@WebFilter本身是没有Order属性，所以构建的Filter将是默认的Order值，而上面源码可得知，类名可决定注册Filter的顺序（即Filter过滤顺序，因为此处只能注册默认的Order值）

解决方法：

1. 以自定义的Filter名称(属性filterName=“myFilter”)来改变其执行顺序
1. 使用配置类的方式，直接对象.setOrder(2)来改变其顺序，order值越小优先级越高

//根据MyFilter会在MyFilterOne执行后再执行
@WebFilter(filterName = "bmyFilter",urlPatterns = {"/*","/one/*"})
public class MyFilter implements Filter {.......
}
//MyFilterOne会被先执行
@WebFilter(filterName = "amyFilter",urlPatterns = {"/*","/one/*"})
public class MyFilterOne implements Filter {...}

注：SpringBoot自带初始化的Filter

Spring Boot 自带的4中Filter，主要为了了解其过滤顺序，且与自定义Filter的执行顺序。（由Order值从小到大的顺序），由Filter类名来实现自定义Filter顺序，因Order为默认值，所以自带的4种Filter都会比自定义的Filter先执行。

 org.springframework.boot.web.servlet.FilterRegistrationBean 258 - Mapping filter: 'characterEncodingFilter' to: [/*]org.springframework.boot.web.servlet.FilterRegistrationBean 258 - Mapping filter: 'hiddenHttpMethodFilter' to: [/*]org.springframework.boot.web.servlet.FilterRegistrationBean 258 - Mapping filter: 'httpPutFormContentFilter' to: [/*]org.springframework.boot.web.servlet.FilterRegistrationBean 258 - Mapping filter: 'requestContextFilter' to: [/*]

CharacterEncodingFilter :编码过滤器

/** Copyright 2012-2019 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package org.springframework.boot.web.servlet.filter;import org.springframework.core.Ordered;
import org.springframework.web.filter.CharacterEncodingFilter;/*** {@link CharacterEncodingFilter} that also implements {@link Ordered}.** @author Phillip Webb* @since 2.0.0*/
public class OrderedCharacterEncodingFilter extends CharacterEncodingFilter implements OrderedFilter {private int order = Ordered.HIGHEST_PRECEDENCE; //HIGHEST_PRECEDENCE = -2147483648;@Overridepublic int getOrder() {return this.order;}/*** Set the order for this filter.* @param order the order to set*/public void setOrder(int order) {this.order = order;}
}

HiddenHttpMethodFilter :处理隐藏的PUT,DELETE等请求方法

/** Copyright 2012-2019 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package org.springframework.boot.web.reactive.filter;import org.springframework.core.Ordered;
import org.springframework.web.filter.reactive.HiddenHttpMethodFilter;/*** {@link HiddenHttpMethodFilter} that also implements {@link Ordered}.** @author Artsiom Yudovin* @since 2.0.5*/
public class OrderedHiddenHttpMethodFilter extends HiddenHttpMethodFilter implements OrderedWebFilter {/*** The default order is high to ensure the filter is applied before Spring Security.*/public static final int DEFAULT_ORDER = REQUEST_WRAPPER_FILTER_MAX_ORDER - 10000;private int order = DEFAULT_ORDER;@Overridepublic int getOrder() {return this.order;}/*** Set the order for this filter.* @param order the order to set*/public void setOrder(int order) {this.order = order;}}

HttpPutFormContentFilter :处理PUT表单请求

/** Copyright 2002-2018 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package org.springframework.web.filter;import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;/*** {@link javax.servlet.Filter} that makes form encoded data available through* the {@code ServletRequest.getParameter*()} family of methods during HTTP PUT* or PATCH requests.** <p>The Servlet spec requires form data to be available for HTTP POST but* not for HTTP PUT or PATCH requests. This filter intercepts HTTP PUT and PATCH* requests where content type is {@code 'application/x-www-form-urlencoded'},* reads form encoded content from the body of the request, and wraps the ServletRequest* in order to make the form data available as request parameters just like* it is for HTTP POST requests.** @author Rossen Stoyanchev* @since 3.1* @deprecated as of 5.1 in favor of {@link FormContentFilter} which is the same* but also handles DELETE.*/
@Deprecated
public class HttpPutFormContentFilter extends OncePerRequestFilter {private FormHttpMessageConverter formConverter = new AllEncompassingFormHttpMessageConverter();/*** Set the converter to use for parsing form content.* <p>By default this is an instance of {@link AllEncompassingFormHttpMessageConverter}.*/public void setFormConverter(FormHttpMessageConverter converter) {Assert.notNull(converter, "FormHttpMessageConverter is required.");this.formConverter = converter;}public FormHttpMessageConverter getFormConverter() {return this.formConverter;}/*** The default character set to use for reading form data.* This is a shortcut for:<br>* {@code getFormConverter.setCharset(charset)}.*/public void setCharset(Charset charset) {this.formConverter.setCharset(charset);}@Overrideprotected void doFilterInternal(final HttpServletRequest request, HttpServletResponse response,FilterChain filterChain) throws ServletException, IOException {if (("PUT".equals(request.getMethod()) || "PATCH".equals(request.getMethod())) && isFormContentType(request)) {HttpInputMessage inputMessage = new ServletServerHttpRequest(request) {@Overridepublic InputStream getBody() throws IOException {return request.getInputStream();}};MultiValueMap<String, String> formParameters = this.formConverter.read(null, inputMessage);if (!formParameters.isEmpty()) {HttpServletRequest wrapper = new HttpPutFormContentRequestWrapper(request, formParameters);filterChain.doFilter(wrapper, response);return;}}filterChain.doFilter(request, response);}private boolean isFormContentType(HttpServletRequest request) {String contentType = request.getContentType();if (contentType != null) {try {MediaType mediaType = MediaType.parseMediaType(contentType);return (MediaType.APPLICATION_FORM_URLENCODED.includes(mediaType));}catch (IllegalArgumentException ex) {return false;}}else {return false;}}private static class HttpPutFormContentRequestWrapper extends HttpServletRequestWrapper {private MultiValueMap<String, String> formParameters;public HttpPutFormContentRequestWrapper(HttpServletRequest request, MultiValueMap<String, String> parameters) {super(request);this.formParameters = parameters;}@Override@Nullablepublic String getParameter(String name) {String queryStringValue = super.getParameter(name);String formValue = this.formParameters.getFirst(name);return (queryStringValue != null ? queryStringValue : formValue);}@Overridepublic Map<String, String[]> getParameterMap() {Map<String, String[]> result = new LinkedHashMap<>();Enumeration<String> names = getParameterNames();while (names.hasMoreElements()) {String name = names.nextElement();result.put(name, getParameterValues(name));}return result;}@Overridepublic Enumeration<String> getParameterNames() {Set<String> names = new LinkedHashSet<>();names.addAll(Collections.list(super.getParameterNames()));names.addAll(this.formParameters.keySet());return Collections.enumeration(names);}@Override@Nullablepublic String[] getParameterValues(String name) {String[] parameterValues = super.getParameterValues(name);List<String> formParam = this.formParameters.get(name);if (formParam == null) {return parameterValues;}if (parameterValues == null || getQueryString() == null) {return StringUtils.toStringArray(formParam);}else {List<String> result = new ArrayList<>(parameterValues.length + formParam.size());result.addAll(Arrays.asList(parameterValues));result.addAll(formParam);return StringUtils.toStringArray(result);}}}}

RequestContextFilter :设置请求的上下文环境

/** Copyright 2002-2015 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package org.springframework.web.filter;import java.io.IOException;import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;/*** Servlet Filter that exposes the request to the current thread,* through both {@link org.springframework.context.i18n.LocaleContextHolder} and* {@link RequestContextHolder}. To be registered as filter in {@code web.xml}.** <p>Alternatively, Spring's {@link org.springframework.web.context.request.RequestContextListener}* and Spring's {@link org.springframework.web.servlet.DispatcherServlet} also expose* the same request context to the current thread.** <p>This filter is mainly for use with third-party servlets, e.g. the JSF FacesServlet.* Within Spring's own web support, DispatcherServlet's processing is perfectly sufficient.** @author Juergen Hoeller* @author Rod Johnson* @author Rossen Stoyanchev* @since 2.0* @see org.springframework.context.i18n.LocaleContextHolder* @see org.springframework.web.context.request.RequestContextHolder* @see org.springframework.web.context.request.RequestContextListener* @see org.springframework.web.servlet.DispatcherServlet*/
public class RequestContextFilter extends OncePerRequestFilter {private boolean threadContextInheritable = false;/*** Set whether to expose the LocaleContext and RequestAttributes as inheritable* for child threads (using an {@link java.lang.InheritableThreadLocal}).* <p>Default is "false", to avoid side effects on spawned background threads.* Switch this to "true" to enable inheritance for custom child threads which* are spawned during request processing and only used for this request* (that is, ending after their initial task, without reuse of the thread).* <p><b>WARNING:</b> Do not use inheritance for child threads if you are* accessing a thread pool which is configured to potentially add new threads* on demand (e.g. a JDK {@link java.util.concurrent.ThreadPoolExecutor}),* since this will expose the inherited context to such a pooled thread.*/public void setThreadContextInheritable(boolean threadContextInheritable) {this.threadContextInheritable = threadContextInheritable;}/*** Returns "false" so that the filter may set up the request context in each* asynchronously dispatched thread.*/@Overrideprotected boolean shouldNotFilterAsyncDispatch() {return false;}/*** Returns "false" so that the filter may set up the request context in an* error dispatch.*/@Overrideprotected boolean shouldNotFilterErrorDispatch() {return false;}@Overrideprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)throws ServletException, IOException {ServletRequestAttributes attributes = new ServletRequestAttributes(request, response);initContextHolders(request, attributes);try {filterChain.doFilter(request, response);}finally {resetContextHolders();if (logger.isTraceEnabled()) {logger.trace("Cleared thread-bound request context: " + request);}attributes.requestCompleted();}}private void initContextHolders(HttpServletRequest request, ServletRequestAttributes requestAttributes) {LocaleContextHolder.setLocale(request.getLocale(), this.threadContextInheritable);RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);if (logger.isTraceEnabled()) {logger.trace("Bound request context to thread: " + request);}}private void resetContextHolders() {LocaleContextHolder.resetLocaleContext();RequestContextHolder.resetRequestAttributes();}
}

3. Listener(监听器)注册

1. `@Component`注解

编写自定义监听类如RegListenerTwo实现ApplicationListener接口
在自定义监听类上面标注 @Component注解

package com.yuan.regcomponent;import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;@Component
public class RegListenerTwo implements ApplicationListener {@Overridepublic void onApplicationEvent(ApplicationEvent event) {System.out.println("RegListenerTwo====执行了");}
}

2. `@EventListener`注册监听

编写自定义监听类如RegListenerTwo实现ApplicationListener接口
在自定义监听类上面标注 @Component注解
在自定义类中编写一个监听方法，并在方法上标注@EventListener注解

package com.yuan.regcomponent;import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;@Component
public class RegListenerThree {@EventListenerpublic void onApplicationEvent(ApplicationEvent event) {System.out.println("RegListenerThree====执行了");}
}

3. 主启动配置监听

编写自定义监听类如RegListenerOne实现ApplicationListener接口
在主启动类上面标注@ServletComponentScan
将自定义的监听类加入到SpringApplication的监听中

编写监听类

package com.yuan.regcomponent;import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;public class RegListenerOne implements ApplicationListener {@Overridepublic void onApplicationEvent(ApplicationEvent event) {System.out.println("RegListenerOne====执行了");}
}

直接启动类开启注解并添加自定义监听

package com.yuan;import com.yuan.regcomponent.RegListenerOne;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;@SpringBootApplication
@ServletComponentScan
public class YuanBootDiskfileApplication {public static void main(String[] args) {//SpringApplication.run(YuanBootDiskfileApplication.class, args);SpringApplication springApplication = new SpringApplication(YuanBootDiskfileApplication.class);springApplication.addListeners(new RegListenerOne());//添加自定义监听类springApplication.run(args);}}

4. Interceptor(拦截器)注册

自定义拦截器

package com.yuan.demo.interceptor;import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;/*** 自定义拦截器*/
public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("MyInterceptor拦截器。。。。处理前");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {StringBuffer requestURL = request.getRequestURL();System.out.println("MyInterceptor拦截器拦截了请求："+requestURL);}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("MyInterceptor拦截器。。。。处理后");}
}

注册拦截器

package com.yuan.demo.config;import com.yuan.demo.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {InterceptorRegistration interceptor = registry.addInterceptor(new MyInterceptor());interceptor.addPathPatterns("/hello","/test");//拦截的urlinterceptor.excludePathPatterns("/login");//排除拦截的urlinterceptor.order(1);//拦截顺序}
}