01.JavaWeb三大组件指的是:Servlet、Filter、Listener,三者提供不同的功能
这三个在springmvc 运用很多
Servlet
01.Servlet接口:
public interface Servlet {/*** 初始化方法* 实例化servlet之后,该方法仅调用一次 * init方法必须执行完成,servlet才能接收任何请求*/public void init(ServletConfig config) throws ServletException;/*** 获取Servlet的初始化和启动参数对象*/public ServletConfig getServletConfig();/*** 处理request请求*/public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;/*** 返回有关servlet的信息,例如作者,版本和版权*/public String getServletInfo();/*** 销毁方法*/public void destroy();
}
02.Servlet相关体系
ServletConfig接口:用来定义一个在初始化期间将配置信息(Servlet名、初始化参数等)传递给Servlet的Servlet配置对象。它的主要实现子类是StandardWrapperFacade类。
GenericServlet抽象类:用于包装Servlet接口,其中提供了很多Servlet接口的默认实现,这样我们实现Servlet的时候,就不必实现Servlet接口的所有方法,只重写核心方法即可。
HttpServlet抽象类:听这个类的名字就大概能够知道,HttpServlet类是专门用于处理http请求的Servlet类。它继承了GenericServlet类,其中有很多http请求专用的处理方法(例如:doGet、doPost、doPut等等方法)
03.Servlet使用例子
@WebServlet("/my")
public class MyServlet extends HttpServlet {@Overridepublic void init() {System.out.println("servlet init...");}@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {resp.getWriter().write("Get Method");}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {resp.getWriter().write("Post Method");}@Overridepublic void destroy() {System.out.println("servlet destroy...");}
}
以上代码就是一个基础的Servlet代码,使用起来十分简单。我们只要继承HttpServlet,然后覆盖其init、destroy、doGet、doPost(还有其他的doXXX方法,后面源码分析会讲到)即可。
从使用层面上来看,实现一个Servlet真的没什么难度,但是我们关注不是如何使用,而是其中的实现原理。
@WebServlet的使用:
Servlet 中,web.xml 扮演的角色十分的重要,它可以将所有的 Servlet 的配置集中进行管理,但是若项目中 Servelt 数量较多时,web.xml 的配置会变得十分的冗长。这种情况下,注解(Annotation)就是一种更好的选择。
@WebServlet 注解的属性: 一部分
使用 @WebServlet 注解
@WebServlet 属于类级别的注解,标注在继承了 HttpServlet 的类之上。常用的写法是将 Servlet 的相对请求路径(即 value)直接写在注解内,
@WebServlet(urlPatterns = “/MyServlet”)。
@WebServlet(“/MyServlet”) 省略了 urlPatterns 属性名
04.Servlet执行流程
配置信息初始化阶段:当服务器启动后,首先会读取web.xml配置文件或者注解配置的相关Servlet信息,然后创建对应的对象,为之后Servlet初始化做准备。
Servlet初始化阶段:当请求访问达到,Servlet首先调用init方法进行初始化。
Servlet执行阶段:当Servlet初始化完成后,就会调用service方法进行业务处理。
05.Servlet源码分析
基于以上对Servlet的了解,那么现在开始进入Servlet的源码分析。
1.配置信息初始化阶段:
首先来了解下配置信息初始化阶段,就拿上面自定义的MyServlet类来作为例子讲解(为了讲解源码时候排除不必要的干扰,此后的源码解析内容只针对关键部分代码进行讲解)。
当我们定义好MyServlet类后,便启动Tomcat服务器。
通过调试可以发现配置信息初始化的入口是ContextConfig类的configureContext方法:这个就是启动Tomcat后,初始化Servlet配置信息的入口方法。如果你有足够的好奇心的话,肯定会对这个方法有不少的疑问。
private void configureContext(WebXml webxml) {... // 省略干扰代码// 从web.xml配置文件或注解配置信息中获取配置的Servlet,并将其封装成ServletDef对象(这个ServletDef是个什么?)for (ServletDef servlet : webxml.getServlets().values()) { Wrapper wrapper = context.createWrapper(); // 从context容器中创建wrapper对象(这个context是个什么?warpper呢?)... wrapper.setName(servlet.getServletName()); // 为wrapper设置Servlet名称Map<String,String> params = servlet.getParameterMap();for (Entry<String, String> entry : params.entrySet()) {wrapper.addInitParameter(entry.getKey(), entry.getValue()); // 为wrapper添加初始化参数}...wrapper.setServletClass(servlet.getServletClass()); // 为wrapper设置Servlet类限定名...
}
ServletDef :
通过查看ServletDef类的方法和属性,以及官方解释,可以得知:这个ServletDef类其实就是用来封装Servlet相关配置信息的,我称其为Servlet定义对象。
/*** 来看下官方解释:* Web应用程序的Servlet定义的表示形式,如在部署描述符的<servlet>元素* 例如以下Servlet配置:* <servlet>* <servlet-name>MyServlet</servlet-name>* <servlet-class>com.servlet.MyServlet</servlet-class>* </servlet>* * 说白了,其实这个ServletDef就是将我们配置的Servlet信息封装成了一个对象* 其中,它还有两个重要属性:servletName、servletClass
*/
public class ServletDef implements Serializable {...private String servletName = null; // Servlet名,必须唯一。表示<servlet-name>标签中的内容private String servletClass = null; // Servlet类全限定名。表示<servlet-class>标签中的内容...
}
context:(tomcat相关容器)
这个context对象,其实代表的是容器,它是StandardContext类的实例化对象。这个通过调试就可以知道,在此不解释太多。
wrapper:(tomcat相关容器)
对于warpper对象来说,它是通过调用 context.createWrapper() 方法而来的。它是StandardWrapper类的实例化对象。单看方法名调用就可以大概猜测到,它是在容器中生成并返回的,因此我们来看下StandarContext类的createWrapper方法:
/**
* 从这个方法的关键代码来看,其实这个wrapper对象是通过反射的方式创建的
* 而且它是StandarWrapper类的实例对象
*/
public Wrapper createWrapper() {Wrapper wrapper = null;if (wrapperClass != null) {try {wrapper = (Wrapper) wrapperClass.getConstructor().newInstance();} catch (Throwable t) {ExceptionUtils.handleThrowable(t);log.error("createWrapper", t);return null;}} else {wrapper = new StandardWrapper();}... return wrapper;
}
用到了变量wrapperClass :
private Class<?> wrapperClass = null;
为了全面了解这个wrapper对象,我们继续往下看StandarWrapper类:
/**
* 看下官方解释:
* Wrapper接口的标准实现,表示单个servlet定义。不允许使用任何子容器,并且父容器必须是上下文
*/
public class StandardWrapper extends ContainerBase implements ServletConfig, Wrapper, NotificationEmitter {//构造函数public StandardWrapper() {super();swValve=new StandardWrapperValve();//阀门,这个和tomcat的管道阀门模型有关pipeline.setBasic(swValve);broadcaster = new NotificationBroadcasterSupport();}}
先不说StandardWrapper类其他细节,通过官方的解释,我们可以知道它其实是Wrapper接口的实现子类。那么为了搞清楚这个StandardWrapper类的具体目的,我们再来看下这个Wrapper接口:
/**
* 结合官方的注释,以及其中定义的各种抽象方法,可以知道:
* Wrapper的实现类负责管理其基础servlet类的servlet生命周期,包括在适当的时间调用init()和destroy()等等
*/
public interface Wrapper extends Container {... // 其中的抽象方法都是针对于Servlet设置/获取相关信息,在此不一一列举
}
到这里可以明白StandardWrapper类其实是用于管理Servlet生命周期的,从创建到销毁。那么基于这个理论,我们再来看看它其中的重要属性和方法:
public class StandardWrapper extends ContainerBase implements ServletConfig, Wrapper, NotificationEmitter {// 真正的Servlet对象,默认为空protected volatile Servlet instance = null;... // Servlet类的全限定名,默认为空protected String servletClass = null;// Servlet类的参数集合protected HashMap<String, String> parameters = new HashMap<>();@Overridepublic void setServletClass(String servletClass) { // 设置Servlet类全限定名String oldServletClass = this.servletClass;this.servletClass = servletClass;support.firePropertyChange("servletClass", oldServletClass,this.servletClass);if (Constants.JSP_SERVLET_CLASS.equals(servletClass)) {isJspServlet = true;}}...// 设置Servlet名(name属性并不是在当前类中定义的)public void setServletName(String name) {setName(name);}//设置Servlet参数,这里是符合Wrapper包装的Servlet的参数public void addInitParameter(String name, String value) {parametersLock.writeLock().lock();try {parameters.put(name, value);} finally {parametersLock.writeLock().unlock();}fireContainerEvent("addInitParameter", name);}
}
到此, Servlet配置信息初始化阶段的源码解析就结束了。在这个阶段做的事情并不多,主要就是创建wrapper对象,并为其设置相应的Servlet配置信息,为之后的阶段做准备。
为了加深理解,送出下图:
2. Servlet初始化阶段
当Tomcat服务器启动后,Servlet相关的配置信息已经初始化好了。那么当我们在网页上通过网址访问后端Servlet时,此时就会进入Servlet的第二个阶段——Servlet初始化。
通过调试,可以知道Servlet初始化的入口是StandardWrapperValve类的invoke方法:
public final void invoke(Request request, Response response) throws IOException, ServletException {...Servlet servlet = null;StandardWrapper wrapper = (StandardWrapper) getContainer();... // 分配一个Servlet实例来处理request请求try {if (!unavailable) {servlet = wrapper.allocate();}}// 在之后的操作中会使用到上面分配到的servlet对象对过滤链进行初始化// 因为在请求到达Servlet之前,会经过一系列的过滤器校验过滤// 但本文只是对Servlet进行源码解析,对于Filter过滤器的源码不做太多解释...
}
allocate方法:
public Servlet allocate() throws ServletException {...// 如果不是单线程模式,则每次分配都返回同一个Servlet对象(复用Servlet)// singleThreadModel默认为falseif (!singleThreadModel) {// 此处的instance就是配置信息初始化阶段的时候说的真正Servlet对象// 而instance初始化时候,默认为空。说明第一次请求访问对应的Servlet时候,需要创建instance// instanceInitialized属性表示instance是否已初始化if (instance == null || !instanceInitialized) { synchronized (this) { // 初始化servlet属于同步操作if (instance == null) {try {if (log.isDebugEnabled()) { // 日志相关log.debug("Allocating non-STM instance");}instance = loadServlet(); // 加载Servlet(重点关注)newInstance = true; // newInstance表示当前instance是否是此次访问新建的if (!singleThreadModel) { // 不是单线程模式,则记录已分配Servlet次数加1(用于多线程计数)countAllocated.incrementAndGet();}} catch (ServletException e) {throw e;} catch (Throwable e) {ExceptionUtils.handleThrowable(e);throw new ServletException(sm.getString("standardWrapper.allocate"), e);}}if (!instanceInitialized) { // 加载获取到的Servlet对象仍未初始化initServlet(instance); // 初始化已加载的Servlet对象}}}if (singleThreadModel) {...} else {if (log.isTraceEnabled()) { // 日志相关log.trace(" Returning non-STM instance");}if (!newInstance) { // instance不是此次访问新建的,说明instance已创建countAllocated.incrementAndGet(); // 记录分配Servlet对象次数加1}return instance; // 返回分配的Servlet对象}}...
}
可以看到,返回的instance对象是由loadServlet方法加载而来:
public synchronized Servlet loadServlet() throws ServletException {if (!singleThreadModel && (instance != null)) // 如果instance已存在则直接返回(复用)return instance;...Servlet servlet;try {long t1=System.currentTimeMillis();if (servletClass == null) { // servletClass为空,说明Servlet类限定名设置失败,抛出异常(servletClass属性是由配置信息初始阶段时设置的,忘了回头看)unavailable(null);throw new ServletException(sm.getString("standardWrapper.notClass", getName()));}InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();try {servlet = (Servlet) instanceManager.newInstance(servletClass); // 根据Servlet类全限定名通过反射创建Servlet实例对象}... initServlet(servlet); // 初始化Servlet实例对象...} ...return servlet; // 最后返回已创建并初始化好的Servlet对象
}
对Servlet实例对象进行初始化,实际上就是调用其init方法:
private synchronized void initServlet(Servlet servlet) throws ServletException {if (instanceInitialized && !singleThreadModel) // 如果此Servlet已初始化过,则直接返回(同时说明,init方法实例化Servlet后只执行一次)return;try {if(Globals.IS_SECURITY_ENABLED) {boolean success = false;try {Object[] args = new Object[] { facade };SecurityUtil.doAsPrivilege("init", servlet, classType, args);success = true;} finally {if (!success) {// destroy() will not be called, thus clear the reference nowSecurityUtil.remove(servlet);}}} else {servlet.init(facade); // 调用Servlet的init方法,并传入facade属性(facade属性是什么?),进行初始化}instanceInitialized = true; // 标识该Servlet已经初始化过了} catch (UnavailableException f) {unavailable(f);throw f;} catch (ServletException f) {throw f;} catch (Throwable f) {ExceptionUtils.handleThrowable(f);getServletContext().log("StandardWrapper.Throwable", f );throw new ServletException(sm.getString("standardWrapper.initException", getName()), f);}
}
到此,可能很多人都以为执行到了 servlet.init(facade) 方法就结束了,认为下一步直接就执行了我们自定义的MyServlet类的init方法。但其实并不是,回头看看MyServlet类的init方法有传入参数吗?
并没有,因此代码执行到这里还没有结束!为了解决疑惑,我们需要继续往下看:
public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable {...@Overridepublic void init(ServletConfig config) throws ServletException {this.config = config; // 绑定配置对象this.init(); // 调用真正的Servlet类init方法}...
}@WebServlet("/my")
public class MyServlet extends HttpServlet {... /*** 最终调用了MyServlet的init方法,完成初始化*/@Overridepublic void init() {System.out.println("servlet init...");}...
}
通过调试我们可以看到,其实是先调用了GenericServlet类的init方法,而在方法最后再调用Servlet的init方法,完成初始化。
GenericServlet类在前面已经说过了,它为Servlet接口中的方法提供了默认实现。而它的init方法也只是为当前Servlet绑定了配置对象而已。
此时,可能会有人提问了。调用GenericServlet类的init方法中传入的facade参数是什么?其实通过它的init方法的接收参数命名,我们可以猜测facade其实是ServletConfig对象,也就是封装了Servlet配置信息的对象。
为了验证我们的猜测,来看看StandardWrapper类的facade属性:
// 原来是StandardWrapperFacade类的实例对象
protected final StandardWrapperFacade facade = new StandardWrapperFacade(this);/**
* 通过查看StandardWrapperFacade类,发现它实现了ServletConfig接口
* 观察其中的属性和方法,可以将StandardWrapperFacade看做是获取Servlet配置相关信息的类
*/
public final class StandardWrapperFacade implements ServletConfig {private final ServletConfig config; .../*** 将传入的StandardWrapper类的实例对象,绑定到本类中的config属性*/public StandardWrapperFacade(StandardWrapper config) {super();this.config = config;}... // 其他方法都是针对于config属性进行获取操作
}
Servlet执行阶段
Servlet的执行阶段,我们要了解的是当请求访问到达后端时候,服务器中它是如何判断这个请求,并准确的调用到响应的doXXX方法。
但针对于Servlet执行阶段的过程中,并不只是仅仅涉及到Servlet,其中还与Filter过滤器有很大的关系。为了更好理解这个阶段,在这里先提前说下Servlet的执行阶段的流程:
1.当启动Tomcat服务器时,服务器除了会封装Servlet相关配置信息之外,其实还会封装Filter过滤器的相关配置信息,以及对Filter过滤器进行创建并初始化。
2.当Tomcat服务器完全启动后,由前端发送request请求,此时服务器检测到有请求到达,此时会加载对应的Servlet实例对象(如果是初次访问,则创建),然后通过请求路径、请求类型、Servlet名三个条件对已存在的过滤器进行匹配筛选,然后将匹配筛选成功的过滤器组成过滤器链。
3.当过滤器链完成后,首先从链头开始调用每个过滤器的doFilter方法进行请求校验(我们自己实现的),一直到链中的所有过滤器doFilter方法都调用完毕,且都通过后,最后才会轮到对应的Servlet处理请求。
从以上分析的流程可知,在真正执行Servlet业务操作前,还需经过层层Filter过滤器的过滤。因此,如果想要完全理解Servlet的执行过程的话,需要先去了解JavaWeb三大组件——Filter过滤器源码解析。
在本文的话,就直接跳过执行Filter的过程,从调用Servlet方法入口着手:
/**
* 从以下代码可以得知,调用Servlet方法入口其实是:ApplicationFilterChain类的internalDoFilter方法
* 正印证了前面说的流程:需要执行过滤器链中的过滤器方法,最后才执行Servlet方法
*/
public final class ApplicationFilterChain implements FilterChain {...private void internalDoFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {... // 前面的代码都是执行过滤器的,此处无须关注// 当链中的过滤器都执行完了,才会执行以下代码try {...if ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse) && Globals.IS_SECURITY_ENABLED ) {final ServletRequest req = request;final ServletResponse res = response;Principal principal = ((HttpServletRequest) req).getUserPrincipal();Object[] args = new Object[]{req, res};SecurityUtil.doAsPrivilege("service", servlet, classTypeUsedInService, args, principal);} else {servlet.service(request, response); // 调用Servlet的service方法(重点关注)}} ...}...
}
此时的调用 servlet.service(request, response) 的这个servlet其实就是MyServlet类的实例对象,它早在创建过滤器链的时候被设置进来。
因此,此处是直接调用MyServlet类中的service方法,而MyServlet类又是继承HttpServlet抽象类:
public abstract class HttpServlet extends GenericServlet {.../*** 最后调用的是HttpServlet类的service方法*/public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {HttpServletRequest request;HttpServletResponse response;// 对传入的请求和响应对象进行类型强转,强转失败则抛出异常// 因为继承的是HttpServlet类,它是专门处理http请求的Servlet类,所以需要确保传入的请求和响应也是属于http范围内的try {request = (HttpServletRequest) req;response = (HttpServletResponse) res;} catch (ClassCastException e) {throw new ServletException("non-HTTP request or response");}service(request, response);}/*** 根据传入的request请求的类型进行匹配,执行子类中相应的重写方法(例如MyServlet的doGet、doPost方法)*/ protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {String method = req.getMethod(); // 获取request请求的类型if (method.equals(METHOD_GET)) { // GET类型long lastModified = getLastModified(req);if (lastModified == -1) {// servlet doesn't support if-modified-since, no reason// to go through further expensive logicdoGet(req, resp);} else {long ifModifiedSince;try {ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);} catch (IllegalArgumentException iae) {// Invalid date header - proceed as if none was setifModifiedSince = -1;}if (ifModifiedSince < (lastModified / 1000 * 1000)) {// If the servlet mod time is later, call doGet()// Round down to the nearest second for a proper compare// A ifModifiedSince of -1 will always be lessmaybeSetLastModified(resp, lastModified);doGet(req, resp);} else {resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);}}} else if (method.equals(METHOD_HEAD)) { // HEAD类型long lastModified = getLastModified(req);maybeSetLastModified(resp, lastModified);doHead(req, resp);} else if (method.equals(METHOD_POST)) { // POST类型doPost(req, resp);} else if (method.equals(METHOD_PUT)) { // PUT类型doPut(req, resp);} else if (method.equals(METHOD_DELETE)) { // DELETE类型doDelete(req, resp);} else if (method.equals(METHOD_OPTIONS)) { // OPTIONS类型doOptions(req,resp);} else if (method.equals(METHOD_TRACE)) { // TRACE类型doTrace(req,resp);} else { // 若以上类型都不匹配,则向前端输出异常信息String errMsg = lStrings.getString("http.method_not_implemented");Object[] errArgs = new Object[1];errArgs[0] = method;errMsg = MessageFormat.format(errMsg, errArgs);resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);}}...
}
最终根据request请求的类型匹配调用相应的方法(最常用的就是doGet、doPost):
@WebServlet("/my")
public class MyServlet extends HttpServlet {... @Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {resp.getWriter().write("Get Method");}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {resp.getWriter().write("Post Method");}...
}
到此,Servlet执行阶段源码分析结束。主要是创建过滤器链,并执行链中过滤器过滤方法,所有过滤方法通过后,最后执行Servlet的service方法,其中再根据request请求的类型匹配对应执行方法:
Filter:
Filter是过滤器的核心接口,其中定义了初始化方法、拦截请求后的要做的具体任务方法、销毁方法。
public interface Filter {//初始化方法,整个生命周期中只执行一次。//在init方法成功(失败如抛异常等)执行完前,不能提供过滤服务。//参数FilterConfig用于获取初始化参数public void init(FilterConfig filterConfig) throws ServletException;//执行过滤任务的方法,参数FilterChain表示过滤器链,doFilter方法中只有执行chain.doFilter()后才能调用下一个过滤器的doFilter方法//才能将请求交经下一个Filter或Servlet执行public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;//销毁方法,当移出服务时由web容器调用。整个生命周期中destroy方法只会执行一次//destroy方法可用于释放持有的资源,如内存、文件句柄等public void destroy();
}
拦截器使用例子
@WebFilter(urlPatterns = "/my")
public class MyFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) {System.out.println("filter init...");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {System.out.println("在这个方法里面完成权限认证、信息加密等操作");chain.doFilter(request, response); // 执行下一个过滤器doFilter方法。如果在执行此句之前就return返回,则请求到此结束。}@Overridepublic void destroy() {System.out.println("filter destroy...");}
}
Filter拦截器使用起来十分简单,只要我们自定义的过滤器类实现Filter接口,覆盖其中的init、doFilter、destroy方法即可。
使用上来说,过滤器的实现可以说是有手就行了。但是其中的具体实现逻辑,比如说Filter是在什么时候起作用的?为什么可以不断的层级调用?等等问题。作为Java工程师来说,在工作中运用如此频繁的组件,是时候应该详细了解一番了。
Filter的执行流程
详细的说,Filter的执行流程主要分为两个部分:
-
初始化部分:对于定义好的Filter过滤器(例如上面自定义的MyFilter),会首先创建过滤器对象,并保存到过容器中,并调用其init方法进行初始化。
执行部分:当匹配到相应的请求路径时,首先会对该请求进行拦截,执行doFilter中的逻辑,若不通过则该请求则到此为止,不会继续往下执行(此时通常会进行重定向或者转发到其他地方进行处理);若通过则继续执行下一个拦截器的doFilter方法,直到指定的过滤器都执行完doFilter后,便执行Servlet中的业务逻辑。
- 初始化部分
首先来了解下Filter的初始化流程,就拿上面自定义的MyFilter类来作为例子讲解(为了讲解源码时候排除不必要的干扰,此后的源码解析内容只针对关键部分代码进行讲解)。
当我们定义好MyFilter类后,便开启Tomcat服务器,开始启动程序。
通过调试发现初始化Filter的入口是:StandardContext类的startInternal方法
@Override
protected synchronized void startInternal() throws LifecycleException {... // 省略不必要代码fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); // 读取web.xml配置文件或者注解配置信息,创建并添加Filter... if (ok) {if (!filterStart()) { // 初始化Filter。若初始化成功则继续往下执行;若初始化失败则抛出异常,终止程序log.error(sm.getString("standardContext.filterFail"));ok = false;}}...
}
可以看到,原来filterStart方法才是真正初始化Filter的方法。
那么在看filterStart方法源码之前,我们先来了解下一些相关的重点属性(有助于之后的源码阅读):
// filterConfigs是一个HashMap,以键值对的形式保存数据(key :value = 过滤器名 :过滤器配置信息对象)
private HashMap<String, ApplicationFilterConfig> filterConfigs = new HashMap<>();
// filterDefs同时也是一个HashMap,其中保存的数据是(过滤器名 :过滤器定义对象)
private HashMap<String, FilterDef> filterDefs = new HashMap<>();
看下其中的FilterDef、ApplicationFilterConfig这两个类,再进一步了解上面的两个属性:
FilterDef:
/**
* 来看下官方解释:
* Web应用程序的过滤器定义的表示形式,如部署描述符中<filter>元素中的所示。
* 例如:
* <filter>
* <filter-name>MyFilter</filter-name>
* <filter-class>com.filter.MyFilter</filter-class>
* </filter>
*
* 说白了,这个FilterDef其实就是封装了配置信息中<filter>标签当中的元素
* 其中就有三个重点属性:filterName、filterClass、filter
*/
public class FilterDef implements Serializable {...private String filterName = null; // 过滤器名,对应的是<filter-name>中的内容private String filterClass = null; // 过滤器全限定类名,对应的是<filter-class>中的内容(用于反射创建过滤器对象)private transient Filter filter = null; // 真正的过滤器对象(如:MyFilter实例对象)...
}
ApplicationFilterConfig:
/**
* ApplicationFilterConfig类主要用于保存自定义Filter的一些配置信息,例如过滤器名、初始化参数、过滤器定义对象等等
*/
public final class ApplicationFilterConfig implements FilterConfig, Serializable {.../*** 构造方法*/ApplicationFilterConfig(Context context, FilterDef filterDef)throws ClassCastException, ClassNotFoundException, IllegalAccessException,InstantiationException, ServletException, InvocationTargetException, NamingException,IllegalArgumentException, NoSuchMethodException, SecurityException {super();this.context = context; this.filterDef = filterDef; // 由此可知,ApplicationFilterConfig类中其实定义了过滤器定义对象// 初始化真正的过滤器对象if (filterDef.getFilter() == null) {getFilter();} else {this.filter = filterDef.getFilter();getInstanceManager().newInstance(filter);initFilter();}}...
}
了解完上面的属性,我们再来研究filterStart方法到底做了什么:
public boolean filterStart() {if (getLogger().isDebugEnabled()) { // 日志相关getLogger().debug("Starting filters");}boolean ok = true;synchronized (filterConfigs) { // 初始化过滤器属于同步操作filterConfigs.clear(); // 在初始化前,先清空for (Entry<String,FilterDef> entry : filterDefs.entrySet()) { // 循环遍历过滤器定义对象集合(filterDefs初始化在哪?)String name = entry.getKey(); // 获取过滤器名if (getLogger().isDebugEnabled()) { // 日志相关getLogger().debug(" Starting filter '" + name + "'");}try {ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(this, entry.getValue()); // 创建过滤器配置对象filterConfigs.put(name, filterConfig); // 添加配置对象} catch (Throwable t) {t = ExceptionUtils.unwrapInvocationTargetException(t);ExceptionUtils.handleThrowable(t);getLogger().error(sm.getString("standardContext.filterStart", name), t);ok = false;}}}return ok;
}
此处,如果细心的朋友就会发现,filterStart方法中直接就拿filterDefs进行循环遍历获取过滤器名了。但是filterDefs是在哪里进行添加元素的呢?
回想一下,我们发现初始化过滤器的入口是StandardContext类中的startInternal方法,而在其中执行真正过滤器初始化方法前,还有一步:
fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null); // 读取web.xml配置文件或者注解配置信息,创建并添加FilterDef过滤器定义对象// 通过调试代码,可以找到其实是调用了ContextConfig类中configureContext方法,以下部分是该方法中的关键代码
for (FilterDef filter : webxml.getFilters().values()) { // 循环配置信息中的过滤器定义对象if (filter.getAsyncSupported() == null) {filter.setAsyncSupported("false");}context.addFilterDef(filter); // 将过滤器定义对象添加到容器中
}/**
* 最后发现fireLifecycleEvent方法最终调用的是StandardContext类中的addFilterDef方法
* 而参数filterDef正是容器context经过解析web.xml文件或者注解配置后创建的过滤器定义对象
* 但此时filterDef中的真正过滤器对象filter还未初始化,因此才会有之后的初始化过滤器方法
*/
public void addFilterDef(FilterDef filterDef) {synchronized (filterDefs) { // 同步添加过滤器定义对象filterDefs.put(filterDef.getFilterName(), filterDef); }fireContainerEvent("addFilterDef", filterDef);
}
明白了filterDefs的初始化,我们再回到filterStart方法,而此时执行到创建ApplicationFilterConfig过滤器配置对象:
/**
* 没错,就是调用这个构造方法创建的filterConfig
**/
ApplicationFilterConfig(Context context, FilterDef filterDef)throws ClassCastException, ClassNotFoundException, IllegalAccessException,InstantiationException, ServletException, InvocationTargetException, NamingException,IllegalArgumentException, NoSuchMethodException, SecurityException {super();this.context = context;this.filterDef = filterDef;// 现在重点来关注以下部分的代码// 从过滤器定义对象中获取真正的过滤器对象(正常来说,应该都是空。因为从之前filterDefs的添加元素逻辑来看,添加的过滤器定义对象中的过滤器对象都是空的)if (filterDef.getFilter() == null) { // 过滤器对象为空getFilter(); // 获取并初始化过滤器(此处没有进行接收结果,说明此处只是进行初始化)} else {this.filter = filterDef.getFilter(); // 绑定过滤器对象getInstanceManager().newInstance(filter);initFilter(); // 调用过滤器的init方法,初始化过滤器}
}
获取并初始化过滤器
Filter getFilter() throws ClassCastException, ClassNotFoundException, IllegalAccessException,InstantiationException, ServletException, InvocationTargetException, NamingException,IllegalArgumentException, NoSuchMethodException, SecurityException {if (this.filter != null) // 若ApplicationFilterConfig类中已存在过滤器对象,则直接返回return (this.filter);// 通过反射的方式创建过滤器对象,并绑定到配置对象的filter上String filterClass = filterDef.getFilterClass(); this.filter = (Filter) getInstanceManager().newInstance(filterClass);initFilter(); // 调用过滤器对象的init方法,初始化过滤器return (this.filter);
}