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 {

    @Override
    public void init() {
        System.out.println("servlet init...");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("Get Method");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("Post Method");
    }

    @Override
    public 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”)。
@Web​Servlet(“/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<>();

    @Override
    public 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默认为false
    if (!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 now
                    SecurityUtil.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 {
	...
	@Override
	public void init(ServletConfig config) throws ServletException {
	    this.config = config; // 绑定配置对象
	    this.init(); // 调用真正的Servlet类init方法
	}
	...
}

@WebServlet("/my")
public class MyServlet extends HttpServlet {
	... 
	/**
	* 最终调用了MyServlet的init方法，完成初始化
	*/
    @Override
    public 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 logic
	            doGet(req, resp);
	        } else {
	            long ifModifiedSince;
	            try {
	                ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
	            } catch (IllegalArgumentException iae) {
	                // Invalid date header - proceed as if none was set
	                ifModifiedSince = -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 less
	                maybeSetLastModified(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 {
	... 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().write("Get Method");
    }

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

    @Override
    public void init(FilterConfig filterConfig) {
        System.out.println("filter init...");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("在这个方法里面完成权限认证、信息加密等操作");
        chain.doFilter(request, response); // 执行下一个过滤器doFilter方法。如果在执行此句之前就return返回，则请求到此结束。
    }

    @Override
    public void destroy() {
        System.out.println("filter destroy...");
    }
}

Filter拦截器使用起来十分简单，只要我们自定义的过滤器类实现Filter接口，覆盖其中的init、doFilter、destroy方法即可。
使用上来说，过滤器的实现可以说是有手就行了。但是其中的具体实现逻辑，比如说Filter是在什么时候起作用的？为什么可以不断的层级调用？等等问题。作为Java工程师来说，在工作中运用如此频繁的组件，是时候应该详细了解一番了。

Filter的执行流程

详细的说，Filter的执行流程主要分为两个部分：

• 初始化部分：对于定义好的Filter过滤器（例如上面自定义的MyFilter），会首先创建过滤器对象，并保存到过容器中，并调用其init方法进行初始化。

  执行部分：当匹配到相应的请求路径时，首先会对该请求进行拦截，执行doFilter中的逻辑，若不通过则该请求则到此为止，不会继续往下执行（此时通常会进行重定向或者转发到其他地方进行处理）；若通过则继续执行下一个拦截器的doFilter方法，直到指定的过滤器都执行完doFilter后，便执行Servlet中的业务逻辑。

1. 初始化部分
   首先来了解下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);
}