servletfilter的执行顺序

Servlet的基本运行流程Servlet是Java Web中的一种技术，能够处理来自客户端的请求并生成响应。

它是在Web服务器上运行的Java类，可以与容器进行交互。

下面将详细描述Servlet的基本运行流程的步骤和流程。

1. Servlet的生命周期Servlet的生命周期包括以下三个阶段： - 初始化阶段（Initialization） - 服务阶段（Service） - 销毁阶段（Destroy）1.1 初始化阶段在Servlet类被加载到容器中时，（通常在Web应用程序启动时），容器会实例化Servlet对象，并调用其init()方法来进行初始化。

该方法只会在Servlet生命周期中被调用一次。

1.2 服务阶段一旦Servlet被初始化后，在其生命周期内，任何对Servlet的请求都会被容器处理。

当接收到一个客户端请求时，容器会创建一个新的线程，并调用Servlet的service()方法来处理该请求。

service()方法会根据请求的类型（GET、POST等）来调用相应的方法（如doGet()、doPost()等）进行处理。

1.3 销毁阶段当Web应用程序被关闭或Servlet容器被关闭时，容器会调用Servlet的destroy()方法来清除资源、释放内存和进行最后的操作，以完成Servlet的销毁过程。

2. Servlet运行流程Servlet的运行流程包括以下几个步骤：2.1 客户端发送请求当客户端（如浏览器）向Web服务器发送一个HTTP请求时，请求首先会到达Web容器。

2.2 容器寻找匹配的ServletWeb容器根据请求的URL来确定匹配的Servlet。

容器会维护一个Servlet映射表，将URL与对应的Servlet进行关联。

2.3 容器创建或获取Servlet实例如果Servlet实例不存在，则容器会创建一个新的Servlet实例，并调用其init()方法来进行初始化。

SpringMvcservlet拦截器过滤器关系和区别及执⾏顺序过滤器和拦截器的区别：1、过滤器是基于函数回调，拦截器是基于java的反射机制的。

2、过滤器是servlet规范规定的，只能⽤于web程序中，⽽拦截器是在spring容器中，它不依赖servlet容器。

3、过滤器可以拦截⼏乎所有的请求(包含对静态资源的请求)，⽽拦截器只拦截action请求(不拦截静态资源请求)。

4、滤器不能访问action上下⽂、值栈⾥的对象，拦截器可以访问action上下⽂、值栈⾥的对象。

5、在action的⽣命周期中，过滤器只能在容器初始化时被调⽤⼀次，拦截器可以多次被调⽤，⽽。

6、拦截器可以获取IOC容器中的各个bean，⽽过滤器就不⾏，这点很重要，在拦截器⾥注⼊⼀个service，可以调⽤业务逻辑。

7、拦截器是被包裹在过滤器之中。

过滤器、拦截器、aop 顺序 拦截顺序：filter—>Interceptor—->@Aspect -->Interceptor)过滤器： 依赖于servlet容器。

在实现上基于函数回调，可以对⼏乎所有请求进⾏过滤，但是缺点是⼀个过滤器实例只能在容器初始化时调⽤⼀次。

使⽤过滤器的⽬的是⽤来做⼀些过滤操作，获取我们想要获取的数据，⽐如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的⼀些参数，包括：过滤低俗⽂字、危险字符等。

拦截器： 依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。

在实现上基于Java的反射机制，属于⾯向切⾯编程（AOP）的⼀种运⽤。

由于拦截器是基于web框架的调⽤，因此可以使⽤Spring的依赖注⼊（DI）进⾏⼀些业务操作，同时⼀个拦截器实例在⼀个controller⽣命周期之内可以多次调⽤。

但是缺点是只能对controller请求进⾏拦截，对其他的⼀些⽐如直接访问静态资源的请求则没办法进⾏拦截处理。

SpringBoot中filter的使用详解及原理Spring Boot是基于Spring Framework的快速开发框架，它通过自动配置，简化了Spring的配置过程。

在Spring Boot中使用filter，可以方便地实现对请求和响应的过滤和处理。

本文将详细介绍Spring Boot 中filter的使用方法和原理。

一、使用filter的步骤1. 创建一个实现javax.servlet.Filter接口的类，实现其doFilter方法。

2. 在该类上使用javax.servlet.annotation.WebFilter注解标明该类是一个filter，并指定其拦截的URL模式。

二、filter的原理在Spring Boot中，使用filter的原理是通过Servlet容器来实现的。

当一个请求到达Servlet容器时，Servlet容器会根据配置的过滤器链依次将请求转发给各个filter进行处理，最终再将请求传递给目标Servlet或者Controller处理。

处理完请求后，再按照相反的顺序将响应返回给客户端。

三、filter的执行顺序在Spring Boot中，filter的执行顺序是根据filter的声明顺序决定的。

在WebMvcConfigurer中，可以通过addFilter方法将filter添加到过滤器链中，并且可以根据需要设置filter的顺序。

如果没有配置filter的顺序，默认按照filter类的名称的字母顺序执行。

四、示例代码下面我们以一个简单的登录认证的filter为例，来演示filter的使用方法和原理。

1. 创建LoginFilter类，实现javax.servlet.Filter接口，并重写doFilter方法。

```public class LoginFilter implements Filterpublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException//进行登录认证的逻辑，例如检查是否存在登录凭证等//...//如果认证通过，继续执行后续的过滤器链}``````public class Application extends WebMvcConfigurerAdapterpublic static void main(String[] args)}public void addFilters(FilterRegistrationBean registrationBean)registrationBean.setFilter(new LoginFilter();registrationBean.addUrlPatterns("/api/*");registrationBean.setOrder(1); // 设置filter的顺序}```经过上述配置后，每当有请求以"/api/"开头时，该请求会先经过LoginFilter的doFilter方法进行处理，然后再继续执行后续的过滤器链。

SpringMVC中FilterServletInterceptor执⾏顺序 <servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping>此时初始化时，会寻找⼀个在应⽤程序WEB-INF⽬录下的配置⽂件，命名规则为:servletName-servlet.xml可以利⽤init-param元素更改默认的⽂件名和⽂件路径 <servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/springmvc-context.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping>接下来解读下servlet的配置⽂件中的内容（拦截器、advice？、RequestMappingHandlerAdapter、viewResolver etc) <mvc:annotation-driven /><context:component-scan base-package="com.dianping.lunar.mvc.controller" />。

spring中过滤器（filter）、拦截器（interceptor）和切面（aop）的执行顺序转自：https:///huxiaodong1994/article/details/829918281. 程序执行的顺序是先进过滤器，再进拦截器，最后进切面。

注意：如果拦截器中preHandle方法返回的为false时，则无法进入切面，例子如下。

@RestController @RequestMapping('/user') public class UserController { @GetMapping('/{id:\\d }') @JsonView(erDetailView.class) public User getInfo(@PathVariable String id) { User user = new User(); user.setUsername('tom'); return user; } }编写方法的过滤器：@Componentpublic class TimeFilter implements Filter {/* (non-Javadoc)* @see javax.servlet.Filter#init(javax.servlet.FilterConfig)*/@Overridepublic void init(FilterConfig filterConfig) throws ServletException {System.out.println('time filter init');}/* (non-Javadoc)* @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain) */@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {System.out.println('time filter start');long start = new Date().getTime();chain.doFilter(request, response);System.out.println('time filter:' (new Date().getTime() - start));System.out.println('time filter finish');}/* (non-Javadoc)* @see javax.servlet.Filter#destroy()*/@Overridepublic void destroy() {System.out.println('time filter destroy');}}编写方法的拦截器：@Component public class TimeInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponseresponse, Object handler) throws Exception { System.out.println('preHandle'); System.out.println(((HandlerMethod)handler).getBean().getClass ().getName());System.out.println(((HandlerMethod)handler).getMethod().getN ame()); request.setAttribute('startTime', new Date().getTime()); return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println('postHandle'); Long start = (Long)request.getAttribute('startTime'); System.out.println('time interceptor 耗时:' (new Date().getTime() - start)); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println('afterCompletion'); Long start = (Long) request.getAttribute('startTime'); System.out.println('time interceptor 耗时:' (new Date().getTime() - start)); System.out.println('ex is ' ex); } }编写方法的切面：@Aspect@Componentpublic class TimeAspect {@Before('execution(public * erController.*(..))')public Object handlerControllerMethod() throws Throwable {System.out.println('time aspect start');return new Object();}}运行结果：1、当拦截器中preHandle的方法返回为true时：` time filter start preHandle erController$$EnhancerBySpringCGLIB $$b0bb0dcf getInfo time aspect start postHandle time interceptor 耗时:76 afterCompletion time interceptor 耗时:76 ex is null time filter:92 time filter finish time filter start time filter:46 time filter finish2、当拦截器中preHandle的方法返回为false时：time filter startpreHandleerController$$EnhancerBySpringC GLIB$$b0bb0dcfgetInfotime filter:12time filter finishtime filter starttime filter:23time filter finish2. 当程序有异常抛出时，回先进入切面，然后在进入自定义的ControllerAdvice中。

java-过滤器Filter_多个Filter的执⾏顺序【Filter链】*在⼀个web应⽤中，可以开发编写多个Filter，这些Filter组合起来称为⼀个Filter链。

*web服务器根据Filter在web.xml中的注册顺序，决定先调⽤哪个Filter，当第⼀个Filter的doFilter⽅法被调⽤时，web服务器会创建⼀个代表Filter链的FilterChain对象传递给该⽅法，在doFilter⽅法中，开发⼈员如果调⽤了FilterChain对象的doFilter⽅法，则web服务器会检查FilterChain对象中是否还有filter，如果有，则调⽤第⼆个filter，如果没有，则调⽤⽬标资源。

【⼯程截图】设计了两个Filter和⼀个Servlet，访问Servlet时，查看Filter的执⾏顺序。

【web.xml】<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" <display-name>FilterDemo01</display-name><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><!-- 过滤顺序：谁的写在上⾯，谁先被过滤 --><filter><filter-name>FilterTest01</filter-name><filter-class>com.Higgin.web.filter.FilterTest01</filter-class></filter><filter-mapping><filter-name>FilterTest01</filter-name><url-pattern>/*</url-pattern> <!-- 过滤所有 --></filter-mapping><filter><filter-name>FilterTest02</filter-name><filter-class>com.Higgin.web.filter.FilterTest02</filter-class></filter><filter-mapping><filter-name>FilterTest02</filter-name><url-pattern>/*</url-pattern> <!-- 过滤所有 --></filter-mapping></web-app>【FilterTest01.java】package com.Higgin.web.filter;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;public class FilterTest01 implements Filter{@Overridepublic void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out.println("FilterTest01 执⾏前---");chain.doFilter(request, response);//让⽬标资源执⾏，即：放⾏System.out.println("FilterTest01 执⾏后---");}@Overridepublic void init(FilterConfig arg0) throws ServletException {}@Overridepublic void destroy() {}}【FilterTest02.java】package com.Higgin.web.filter;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;public class FilterTest02 implements Filter{@Overridepublic void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {System.out.println("FilterTest02 执⾏前---");chain.doFilter(request, response); //放⾏System.out.println("FilterTest02 执⾏后---");}@Overridepublic void init(FilterConfig arg0) throws ServletException {}@Overridepublic void destroy() {}}【ServletTest01.java】package com.Higgin.web.servlet;import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;/*** Servlet implementation class ServletTest01*/@WebServlet("/ServletTest01")public class ServletTest01 extends HttpServlet {private static final long serialVersionUID = 1L;public ServletTest01() {super();}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //response.getWriter().write("中国加油！China Come on!");System.out.println("执⾏ServletTest01---");}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request,response);}}【运⾏结果】在浏览器中输⼊：http://localhost:8080/FilterDemo01/ServletTest01查看控制台输出结果⾃⼰可以尝试分别注释FilterTest01和FilterTest02中的chain.doFilter⽅法，⽤Junit查看具体的执⾏过程。

Web过滤器的处理流程通常包括以下几个关键步骤：
1.初始化阶段：当Web容器启动时，过滤器会被创建并初始化。

在
这个阶段，过滤器可以读取配置参数，获取`FilterConfig`对象，并进行一些初始化操作。

2.请求预处理阶段：在请求到达Servlet之前，过滤器可以对请求进
行预处理。

这个环节常用于执行如日志记录、权限验证、字符编码设置等操作。

3.Servlet执行阶段：经过过滤器预处理后，请求会被传递给目标
Servlet进行处理。

如果存在多个过滤器，那么这些过滤器会按照它们在配置文件中的顺序依次执行。

4.响应后处理阶段：在Servlet生成响应之后，过滤器还可以对服务
器的响应进行后处理。

例如，可以对输出的内容进行压缩或者添加额外的头部信息。

5.销毁阶段：在Web容器关闭时，过滤器会被销毁。

在这个阶段，
可以进行资源的清理工作。

需要注意的是，在编写过滤器时，需要实现`javax.servlet.Filter`接口，并重写其中的`doFilter`方法。

该方法接收`ServletRequest`、`ServletResponse`和`FilterChain`三个参数，分别代表请求、响应和过滤器链。

在`doFilter`方法中，可以编写预处理和后处理的逻辑代码。

此外，还需要通过注解`@WebFilter`或者在`web.xml`文件中配置过滤器的映射信息，以指定过滤器应用于哪些URL模式。

filter过滤器原理Filter过滤器是Java Servlet规范中的一个重要组成部分，它主要用于Web应用程序中对请求或响应进行一些处理或修改。

Filter过滤器能够拦截客户端请求和响应，并对其进行一些预处理或后处理，同时不对底层资源进行任何的改变。

在Web应用程序中，客户端的请求会按照一定的顺序被多个过滤器拦截，最后才会到达目标Servlet或JSP页面。

过滤器的拦截顺序是由web.xml文件中的顺序决定的，顺序越靠前的过滤器越先拦截请求。

Filter过滤器的工作过程可以用下面的流程来描述：1、当客户端发起请求时，服务器会根据客户端请求的URL找到相应的Servlet或JSP 页面。

2、在Servlet或JSP页面被执行之前，在过滤器链中的第一个过滤器会被调用。

这个过滤器可以实现一些真正的过滤操作，比如验证用户身份等。

3、当第一个过滤器完成处理后，请求会按照web.xml文件中定义的顺序，依次经过它后面的过滤器。

4、如果过滤器链中有多个过滤器，请求将根据它们的顺序进行处理。

当请求到达最后一个过滤器时，如果没有被任何一个过滤器拦截，则将请求传递给目标Servlet或JSP 页面。

5、在Servlet或JSP页面处理请求并生成响应后，响应会按照相反的顺序经过过滤器链中的过滤器进行处理或修改，最终响应到达客户端。

通过使用Filter过滤器，可以有效的将Web应用程序的功能模块拆分成多个独立的模块，这些模块可以按照一定的顺序调用，扩展或修改Web应用程序的行为。

具体的优点包括：1、实现模块可复用性：在一个应用程序中，多个模块可能会需要进行相同或相似的过滤操作，而使用Filter可以将这些操作独立出来，易于重复使用。

2、抽象控制流：通过使用Filter可以抽象出整个请求和响应的控制流，实现更细粒度的控制。

3、有效的处理URL：通过Filter可以有效的处理URL，实现URL的解析和路由处理。

4、可扩展性：在Web应用程序中，Filter可以很方便的进行增加、删除或修改，从而实现Web应用程序的功能扩展。

web.xml中的listener、filter、servlet加载顺序及其详解在项⽬中总会遇到⼀些关于加载的优先级问题，刚刚就遇到了⼀个问题，由于项⽬中使⽤了quartz任务调度，quartz在web.xml中是使⽤listener进⾏监听的,使得在tomcat启动的时候能马上检查数据库查看那些任务未被按时执⾏，⽽数据库的配置信息在是在web.xml中使⽤servlet配置的，导致tomcat启动后在执⾏quartz任务时报空指针，原因就是servlet中的数据库连接信息未被加载。

⽹上查询了下web.xml中配置的加载优先级：⾸先可以肯定的是，加载顺序与它们在 web.xml ⽂件中的先后顺序⽆关。

即不会因为 filter 写在 listener 的前⾯⽽会先加载 filter。

最终得出的结论是：listener -> filter -> servlet同时还存在着这样⼀种配置节：context-param，它⽤于向 ServletContext 提供键值对，即应⽤程序上下⽂信息。

我们的 listener, filter 等在初始化时会⽤到这些上下⽂中的信息，那么 context-param 配置节是不是应该写在 listener 配置节前呢？实际上 context-param 配置节可写在任意位置，因此真正的加载顺序为：context-param -> listener -> filter -> servlet对于某类配置节⽽⾔，与它们出现的顺序是有关的。

以 filter 为例，web.xml 中当然可以定义多个 filter，与 filter 相关的⼀个配置节是filter-mapping，这⾥⼀定要注意，对于拥有相同 filter-name 的 filter 和 filter-mapping 配置节⽽⾔，filter-mapping 必须出现在 filter 之后，否则当解析到 filter-mapping 时，它所对应的 filter-name 还未定义。

servletfilter的执行顺序Servlet Filter是Java Servlet规范中的一种机制，用于在Web应用程序中对请求和响应进行预处理和后处理。

在Web应用程序中，Filter充当了请求链和响应链上的中间件，可以用于进行各种操作，例如身份验证、请求参数修改、日志记录等。

Servlet Filter的执行顺序取决于它们在web.xml中的注册顺序以及Filter的优先级设置。

1.在web.xml中注册Filter在web.xml配置文件中，可以为每个Filter指定一个或多个url-pattern，来指定它要处理的请求URI。

在注册Filter时，可以通过设置<filter-mapping>元素中的<url-pattern>元素来指定多个Filter的顺序以及它们处理的请求URI。

2. Filter的初始化在Servlet容器启动时，会对所有注册的Filter进行初始化。

Filter的初始化可以通过在Filter的初始化方法init()中完成。

在该方法中，可以对Filter的配置进行初始化，并加载任何需要的资源。

3.过滤器链的执行顺序当有请求到达Web应用程序时，Servlet容器会根据请求的URI匹配相应的Filter，然后按照注册的顺序依次调用它们的doFilter()方法。

Filter的doFilter()方法是Filter实际处理请求和响应的地方。

在doFilter()方法中，Filter可以对请求进行处理，并将请求传递给下一个Filter，或者将请求传递给servlet进行处理。

4. Filter链的结束如果已经到达了Filter链的末尾，或者在Filter链的中途其中一个Filter通过调用filterChain.doFilter()将请求传递给下一个Filter时，Filter链的处理就会结束。

5. Filter的销毁在Servlet容器关闭时，会对所有初始化的Filter进行销毁。

对一类url,或所有url进行业务处理对各种url之类进行匹配，查找，执行相应操作，与action相比较而言，action只能针对某一特定的url进行匹配，进行操作如: <form action = "update.action"> action 对应的url是固定的，对于struts1.x可能一个action只有一个url对于struts2.0，一个action可能有多个url,看它实现的方法数量，不过这些url在提交之前都是已经的，固定的。

而上面四种可以对任意url进行操作，如<url-pattern>*.action</url-pattern>区别：1,servlet 流程是短的，url传来之后，就对其进行处理，之后返回或转向到某一自己指定的页面。

它主要用来在业务处理之前进行控制.2,filter 流程是线性的， url传来之后，检查之后，可保持原来的流程继续向下执行，被下一个filter, servlet接收等，而servlet 处理之后，不会继续向下传递。

filter 功能可用来保持流程继续按照原来的方式进行下去，或者主导流程，而servlet的功能主要用来主导流程。

filter可用来进行字符编码的过滤，检测用户是否登陆的过滤，禁止页面缓存等3, servlet,filter都是针对url之类的，而listener是针对对象的操作的，如session 的创建，session.setAttribute的发生，在这样的事件发生时做一些事情。

可用来进行：Spring整合Struts,为Struts的action注入属性，web应用定时任务的实现，在线人数的统计等4，interceptor 拦截器，类似于filter,不过在struts.xml中配置，不是在web.xml,并且不是针对URL的，而是针对action,当页面提交action时，进行过滤操作，相当于struts1.x提供的plug-in机制，可以看作，前者是struts1.x自带的filter,而interceptor 是struts2 提供的filter.与filter不同点：（１）不在web.xml中配置，而是在struts.xml中完成配置，与action在一起( 2 ) 可由action自己指定用哪个interceptor 来在接收之前做事一，servlet1，在web.xml中配置Servlet<servlet><servlet-name>AutoServlet</servlet-name><servlet-class>com.servlet.AutoServlet</servlet-class></servlet><servlet-mapping><servlet-name>AutoServlet</servlet-name><url-pattern>/AutoServlet</url-pattern></servlet-mapping>2，定义AutoServlet,继承HttpServlet,实现方法doGet, doPost3, 应用：（1）Struts1.x 就是一个Servlet, 它会在doGet方法中读取配置文件struts-config.xml进行action的匹配，进行业务处理（2）验证码生成（也可用action来做）二，filter1, web.xml配置<filter><filter-name>checkUrl</filter-name><filter-class>com.lvjian.filter.CheckUrl</filter-class><init-param><param-name>name</param-name><param-value>asong</param-value>//初始化传参，得到时在filter的init方法中用filterConfig.getInitParameter( "name" )</init-param></filter><filter-mapping><filter-name>checkUrl</filter-name><url-pattern>/*</url-pattern></filter-mapping>2, 继承 javax.servlet.Filter,实现 doFilter(HttpServletRequest request, HttpServletResponse responseFilterChainfilterChain) 等方法HttpServletRequest request = (HttpServletRequest) req;HttpServletResponse response = (HttpServletResponse) res;//获取用户请求的URIString request_uri = request.getRequestURI();//获取web应用程序的上下文路径String contextPath = request.getContextPath();//去除上下文路径，得到剩余部分的路径String uri = request_uri.substring(contextPath.length());//创建会话sessionHttpSession session = request.getSession(true);//保持原有流程不变filterChain.doFilter( servletRequest , servletResponse );3,应用：（1）Struts2.0(2) 进行字符编码的过滤，检测用户是否登陆的过滤等（3）禁止页面缓存，原理就是对各个请求的url令其为空,在doFilter加入：request.setCharacterEncoding("GB2312");//设置编码((HttpServletResponse)response).setHeader("Pragma" ,"No-cache");((HttpServletResponse)response).setHeader("Cache-C ontrol","no-cache");((HttpServletResponse)response).setHeader("Expires ","0");//禁止缓存三，listener1，在web.xml中配置<listener><listener-class>demo.listener.MyContextLoader</listener-class> </listener>//这样服务器就会在启动时创建MyContextLoader的一个实例，并开始监听servlet,session的操作2, 实现常用的listener有：（1） ServletContextListener 监听ServletContext。

七年级下册地理人教版电子书停课不停学!为方便孩子们提前预习,方便广大教师提前备课,下面小编给大家整理了关于七年级下册地理人教版电子书的内容，欢迎阅读，内容仅供参考!七年级下册地理人教版电子书微信搜索关注公众号：5068教学资料查看完整版电子课本可微信搜索公众号【5068教学资料】,关注后对话框回复【7】获取七年级电子课本资源。

七年级地理下册知识点(一)亚洲1.地理位置亚洲位于北半球和东半球，北临北冰洋，南临印度洋，东临太平洋，东北以白令海峡与北美洲为界，东南隔海与大洋洲相望，西南以苏伊士运河与非洲为界，西北以乌拉尔山脉、乌拉尔河、里海、大高加索山脉、黑海和土耳其海峡与欧洲为界。

2.亚洲是世界上面积最大的洲，也是世界上跨纬度最广、东西距离最长的洲。

3.亚洲是世界上面积最大的洲，也是世界上跨纬度最广、东西距离最长的洲。

4.亚洲是世界三大宗教佛教、伊斯兰教、基督教的发源地。

5.地势：亚洲地势起伏很大，中部高，四围低。

6.亚洲之最(1)世界最高的高原：青藏高原(2)世界最高的峰：珠穆朗玛峰(3)世界面积最大的平原：亚马孙平原亚洲面积最大的平原：西西伯利亚平原(4)世界最大的湖泊：里海7.气候：亚洲大陆跨寒、温、热三带。

气候的主要特征是气候类型复杂多样、季风气候典型和大陆性显著。

8.亚洲是世界上人口最多的大洲，其中东亚。

东南亚是人口密集区。

9.亚洲人口最多的国家是中国，第二是印度。

10.新加坡是亚洲人口密度最大的国家。

人口密度最小的国家是蒙古。

(二)中东1.中东战争：阿拉伯国家与以色列的战争;两伊战争：伊朗和伊拉克?2.中东战争：阿拉伯国家与以色列的战争;两伊战争：伊朗和伊拉克?。

3.中东地区气候干燥，主要有热带沙漠气候，地中海气候，温带大陆性气候。

4.中东地区的人们主要信仰伊斯兰教、犹太教和基督教。

(三)欧洲西部1.西欧指欧洲西部濒临大西洋的地区和附近岛屿，包括英国、爱尔兰、荷兰、比利时、卢森堡、法国和摩纳哥。

onceperrequestfilter的执行顺序OncePerRequestFilter是Spring框架中的一个过滤器，它在每个请求处理之前执行一次。

它的执行顺序是在其他过滤器之后，但在Servlet之前。

下面我们来详细了解一下OncePerRequestFilter的执行顺序。

1. 首先，当客户端发起一个请求时，请求会被发送到服务器端。

2. 服务器端接收到请求后，会先经过一系列的过滤器链处理。

这些过滤器包括：SecurityFilter、CharacterEncodingFilter、SessionManagementFilter等。

这些过滤器的作用分别是：安全认证、字符编码转换、会话管理等。

3. OncePerRequestFilter位于这个过滤器链的末端。

当请求经过前面的过滤器处理后，会进入OncePerRequestFilter。

4. OncePerRequestFilter在每次请求处理之前执行一次。

它的主要作用是对请求进行预处理，例如设置一些请求属性、初始化一些数据结构等。

5. OncePerRequestFilter执行完毕后，请求会继续向下传递，进入Servlet的处理阶段。

6. Servlet处理完请求后，会将响应返回给客户端。

7. 最后，服务器端会销毁OncePerRequestFilter所创建的资源，例如释放线程池、关闭数据库连接等。

总结一下，OncePerRequestFilter的执行顺序如下：1. 客户端发起请求；2. 服务器端接收请求，经过一系列过滤器处理；3. 请求进入OncePerRequestFilter；4. OncePerRequestFilter执行预处理操作；5. 请求继续向下传递，进入Servlet处理；6. Servlet处理完请求，返回响应给客户端；7. 销毁OncePerRequestFilter所创建的资源。

需要注意的是，OncePerRequestFilter的执行顺序并不是绝对的。

过滤器（Filter）和拦截器（Interceptor）的执⾏顺序和区别⽬录⾸先建⽴⼀个SpringBoot⼯程，增加⼀个IndexController供测试使⽤。

@Controllerpublic class IndexController {@GetMapping("/hello")@ResponseBodypublic String index(){return "hello";}}过滤器 Filter过滤器（ Filter），是 JavaEE 的标准，依赖于 Servlet 容器，使⽤的时候是配置在 SpringMVC 框架中是配置在web.xml ⽂件中的，可以配置多个，执⾏的顺序是根据配置顺序从上到下。

在 SpringBoot 项⽬中也可以采⽤注解的形式实现。

Servlet中的过滤器Filter是实现了javax.servlet.Filter接⼝的服务器端程序，主要的⽤途是设置字符集、控制权限、控制转向、做⼀些业务逻辑判断等。

其⼯作原理是，只要你在web.xml⽂件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统⼀配置请求编码以及过滤⼀些⾮法参数，垃圾信息，简化操作；同时还可进⾏逻辑判断，如⽤户是否已经登陆、有没有权限访问该页⾯等等⼯作。

它是随你的web应⽤启动⽽启动的，只初始化⼀次，以后就可以拦截相关请求，只有当你的web应⽤停⽌或重新部署的时候才销毁。

Filter可以认为是Servlet的⼀种“加强版”，它主要⽤于对⽤户请求进⾏预处理，也可以对HttpServletResponse进⾏后处理，是个典型的处理链。

Filter也可以对⽤户请求⽣成响应，这⼀点与Servlet相同，但实际上很少会使⽤Filter向⽤户请求⽣成响应。

使⽤Filter完整的流程是：Filter对⽤户请求进⾏预处理，接着将请求交给Servlet进⾏处理并⽣成响应，最后Filter再对服务器响应进⾏后处理。

ServletFilter的顺序问题使⽤Filter可以修改request, response, session, application中的内容，javax.servlet.Filter的doFilter()的signature是这样的:public void doFilter(Request request, ServletResponse response, FilterChain chain) 例如，我们如果想在request中增加⼀点东西，可以request.setAttribute("xx","xx");然后需要记住的是⼀定要记得调⽤chain.doFilter(request, response); 否则的话，后⾯的filter和servlet, jsp将不会得到执⾏。

举例详细点就是：filter1, filter2都在web.xml中定义了，对应的url-mapping都是/*, index.jsp是该应⽤下的⼀个jsp, 那么如果直接访问index.jsp的话，那么⾸先访问的是filter1，然后是filter2（加⼊filter1的定义在filter2之前）, 最后才是index.jsp。

filter1:public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException{request.setAttribute("aaa","aaa");chain.doFilter(request,response);request.setAttribute("bbb","bbb");}filter2:public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException{System.out.println(request.getAttribute("aaa")+" "+request.getAttribute("bbb"));request.setAttribute("ccc","ccc");chain.doFilter(request,response);request.setAttribute("ddd","ddd");}index.jsp:System.out.println(request.getAttribute("aaa")+" "+request.getAttribute("bbb")+" "+request.getAttribute("ccc")+""+request.getAttribute("ddd"));结论：先作filter1中chain.doFilter()前的部分，然后是filter2中chain.doFilter()前的部分，然后是jsp，然后是filter2中chain.doFilter()后的代码部分，然后是filter1中chain.doFilter()后的部分。

servlet执⾏流程和⽣命周期⼀、servlet执⾏流程：⼆、⽣命周期：Servlet的⽣命周期可以分为四个阶段，即装载类及创建实例阶段、初始化阶段、服务阶段和实例销毁阶段。

1、初始化阶段调⽤init()⽅法 2、响应客户请求阶段。

调⽤service()⽅法，由service()⽅法根据提交的⽅式选择执⾏doGet()或者doPost()⽅法 3、终⽌阶段 调⽤destroy()⽅法1、创建servlet实例：在默认情况下Servlet实例是在第⼀个请求到来的时候创建，以后复⽤。

如果有的Servlet需要复杂的操作需要载初始化时完成，⽐如打开⽂件、初始化⽹络连接等，可以通知服务器在启动的时候创建该Servlet的实例。

具体配置如下：<servlet><servlet-name>TimeServlet</servlet-name><servlet-class>com.allanlxf.servlet.basic.TimeServlet</servlet-class><load-on-startup>1</load-on-startup></servlet>创建servlet对象的相关类结构：2、初始化⼀旦Servlet实例被创建，Web服务器会⾃动调⽤init(ServletConfig config)⽅法来初始化该Servlet。

其中⽅法参数config中包含了Servlet 的配置信息，⽐如初始化参数，该对象由服务器创建。

I.如何配置Servlet的初始化参数？在web.xml中该Servlet的定义标记中，⽐如：<servlet><servlet-name>TimeServlet</servlet-name><servlet-class>com.allanlxf.servlet.basic.TimeServlet</servlet-class><init-param><param-name>user</param-name><param-value>username</param-value></init-param><init-param><param-name>blog</param-name><param-value>http://。

ServletFilter过滤器执⾏顺序Servlet中的过滤器相当于守护后台资源的⼀道关卡，我们可以在过滤器中进⾏⾝份校验、权限认证、请求过滤等。

过滤器本⾝并不难，我们只需要知道他的定义⽅法、作⽤范围、执⾏顺序即可。

⽹上对于过滤器执⾏顺序的描述可能会让⼈产⽣误解。

图⽚来源于⽹络客户端请求到达的时候，经过⼀次过滤器。

服务器处理完请求的时候，经过⼀次过滤器。

虽然经过两次过滤器，但不代表同样的代码执⾏了两次。

下⾯做了个简单的测试，看下执⾏结果就应该知道真正的执⾏流程了。

测试环境tomcat9（servlet4.0）jdk1.8新版servlet可以通过注解注册servlet组件以及过滤器，⽆需再到web.xml下注册了。

测试过程测试之间要先知道filterChain（过滤链）是⼲嘛的。

⼀个过滤器处理完后，会把request和response对象通过filterchain传递给下⼀个过滤器，如果没有下⼀个过滤器，则会直接开始执⾏业务代码，单个过滤器定义⼀个过滤器A@WebFilter(value = "/*", filterName="A")public class FilterA implements Filter {@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");System.out.println(format.format(new Date()));System.out.println("A:拦截1");chain.doFilter(request, response);System.out.println(format.format(new Date()));System.out.println("A:拦截2");}@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void destroy() {}}定义⼀个servlet，sleep5秒@WebServlet("/mainUrl")public class MainController extends HttpServlet {private static final long serialVersionUID = 1L;/*** @see HttpServlet#HttpServlet()*/public MainController() {super();// TODO Auto-generated constructor stub}/*** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)*/protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {// TODO Auto-generated method stubtry {Thread.sleep(5000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}/*** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)*/protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {// TODO Auto-generated method stubdoGet(request, response);}}运⾏结果2020-12-01 10:46:50A:拦截12020-12-01 10:46:55A:拦截2执⾏顺序：filterChain之前的代码 ——>业务处理——>filterChain之后的代码。

拦截器和过滤器的执⾏顺序和区别为了⽅便查看，再写⼀遍⽅便⾃⼰⽇后看：过滤器和拦截器的区别： ⼀、过滤器Filter是JavaEE标准，在Servlet的规范中定义的，是Servlet容器⽀持的，是属于Servlet容器的，依赖Servlet容器；拦截器Interceptor是Spring的组件之⼀，是属于Spring框架的，依赖于Spring框架，归Spring管理，配置在Spring的⽂件中，因此能使⽤Spring⾥的任何资源和对象，例如Service对象、数据源、事务管理等，所以可以通过Spring的IOC注⼊⽅式注⼊即可，⽽Filter不可以。

（若⽤配置⽂件⽅式配置，Filter配置在web.xml中，Interceptor配置在Spring MVC的配置⽂件中。

多个过滤器的执⾏顺序跟在web.xml⽂件中定义的先后关系有关。

多个拦截器它们之间的执⾏顺序跟在SpringMVC的配置⽂件中定义的先后顺序有关。

）⼆、过滤器Filter是基于函数回调实现；拦截器是基于java的反射机制实现，属于⾯向切⾯编程（AOP）的⼀种运⽤。

三、拦截器（依赖Spring框架所以）只能对Controller请求进⾏拦截⽽对其他的⼀些⽐如直接访问静态资源的请求则没办法进⾏拦截处理，⽽过滤器则可以对⼏乎所有的请求起作⽤。

四、拦截器（是Spring组件之⼀）所以可以访问action上下⽂、值栈⾥的对象，⽽过滤器不能访问。

五、在action的⽣命周期中，拦截器可以多次被调⽤，⽽过滤器只能在容器初始化是被调⽤⼀次。

拦截器可以获取IOC容器中的各个bean，⽽过滤器就不⾏，这点很重要，在拦截器⾥注⼊⼀个service，可以调⽤业务逻辑过滤器包裹住servlet，servlet包裹住拦截器过滤器Filter@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {System.out.println("before...");chain.doFilter(request, response);System.out.println("after...");}拦截器Interceptor 继承HandlerInterceptor后如下@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("afterCompletion");}过滤器的触发时机是容器后，servlet之前，所以过滤器的doFilter(ServletRequest request, ServletResponse response, FilterChain chain)的⼊参是ServletRequest ，⽽不是httpservletrequest。

Filter的执⾏顺序⼀、过滤器不仅能处理请求还能处理响应⼆、测试Filter的执⾏顺序 2.1.先写⼀个EncodingFilterpackage org.burning.sport.filter;import javax.servlet.*;import java.io.IOException;public class EncodingFilter implements Filter{private String encoding;@Overridepublic void init(FilterConfig filterConfig) throws ServletException {System.out.println("init EncodingFilter.......");encoding = filterConfig.getInitParameter("encoding");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("before EncodingFilter doFilter.....");request.setCharacterEncoding(encoding);chain.doFilter(request, response);System.out.println("after EncodingFilter doFilter......");}@Overridepublic void destroy() {System.out.println("destory EncodingFilter......");}} 2.2.写⼀个LoggerFilterpackage org.burning.sport.filter;import javax.servlet.*;import java.io.IOException;public class LoggerFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {System.out.println("init LoggerFilter....");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { String contextPath = request.getServletContext().getContextPath();System.out.println("LoggerFilter before doFilter.....");chain.doFilter(request, response);System.out.println("LoggerFilter after doFilter");}@Overridepublic void destroy() {System.out.println("destory LoggerFilter....");}} 2.3 写⼀个HelloWorldServletpackage org.burning.sport.filter;import javax.servlet.*;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;public class HelloWorldServlet extends HttpServlet {@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {System.out.println("do service...." + this.getInitParameter("encoding"));super.service(req, resp);}} 2.4 配置web.xml filter的配置顺序跟执⾏顺序有关系<filter><filter-name>myEncodingFilter</filter-name><filter-class>org.burning.sport.filter.EncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>myEncodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><filter><filter-name>myLoggerFilter</filter-name><filter-class>org.burning.sport.filter.LoggerFilter</filter-class></filter><filter-mapping><filter-name>myLoggerFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><servlet><servlet-name>MyHelloworldServlet</servlet-name><servlet-class>org.burning.sport.filter.HelloWorldServlet</servlet-class></servlet><servlet-mapping><servlet-name>MyHelloworldServlet</servlet-name><url-pattern>/helloServlet</url-pattern></servlet-mapping> 2.5 看执⾏结果启动tomcat的时候init EncodingFilter.......init LoggerFilter....-----------------------------------------before EncodingFilter doFilter.....LoggerFilter before doFilter.....do service....nullLoggerFilter after doFilterafter EncodingFilter doFilter......---------------------------------------销毁tomcat的时候destory EncodingFilter......destory LoggerFilter....　 2.6.结论： 容器只会初始化⼀次 filter的执⾏是有先后顺序的，根据在web.xml中配置的先后顺序。