JavaWeb三大组件之一——Servlet源码解析（剖析底层代码，需要耐心看完）

最新推荐文章于 2024-05-01 19:17:00 发布

MrFC

最新推荐文章于 2024-05-01 19:17:00 发布

阅读量2.4k

点赞数 8

分类专栏： Servlet 文章标签： java servlet

本文链接：https://blog.csdn.net/weixin_41083377/article/details/115333897

版权

Servlet 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

什么是Servlet？

Servlet的全称是Server Applet。通俗来说，它是一个请求处理器，它可以接受来自前端或者其他服务器端的请求。作为Java工程师，我们通常是将其用在后端处理前端请求，执行相应业务操作。
而在目前市场的常用的主流框架，如Spring、SpringMvc、SpringBoot等等，这些Java应用开发框架中都不见Servlet的踪影，难道Servlet已经没落了吗？当然不是，这些所谓的主流框架，在底层用的其实还是Servlet，只是这些框架已经把Servlet封装隐藏起来了。
因此，如果要了解JavaWeb相关框架，那么Servlet就是必不可少的一关。

初步了解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();
}

Servlet相关体系

在这里插入图片描述

对于Servlet接口就不再重复介绍了

ServletConfig接口：用来定义一个在初始化期间将配置信息（Servlet名、初始化参数等）传递给Servlet的Servlet配置对象。它的主要实现子类是StandardWrapperFacade类。
GenericServlet抽象类：用于包装Servlet接口，其中提供了很多Servlet接口的默认实现，这样我们实现Servlet的时候，就不必实现Servlet接口的所有方法，只重写核心方法即可。
HttpServlet抽象类：听这个类的名字就大概能够知道，HttpServlet类是专门用于处理http请求的Servlet类。它继承了GenericServlet类，其中有很多http请求专用的处理方法（例如：doGet、doPost、doPut等等方法）

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真的没什么难度，但是我们关注不是如何使用，而是其中的实现原理。

Servlet执行流程

配置信息初始化阶段：当服务器启动后，首先会读取web.xml配置文件或者注解配置的相关Servlet信息，然后创建对应的对象，为之后Servlet初始化做准备。
Servlet初始化阶段：当请求访问达到，Servlet首先调用init方法进行初始化。
Servlet执行阶段：当Servlet初始化完成后，就会调用service方法进行业务处理。

Servlet源码分析

基于以上对Servlet的了解，那么现在开始进入Servlet的源码分析。

1. 配置信息初始化阶段：

首先来了解下配置信息初始化阶段，就拿上面自定义的MyServlet类来作为例子讲解（为了讲解源码时候排除不必要的干扰，此后的源码解析内容只针对关键部分代码进行讲解）。

当我们定义好MyServlet类后，便启动Tomcat服务器。
通过调试可以发现配置信息初始化的入口是ContextConfig类的configureContext方法：

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类限定名
        ... 
}

这个就是启动Tomcat后，初始化Servlet配置信息的入口方法。如果你有足够的好奇心的话，肯定会对这个方法有不少的疑问。
那么接下来，让我一步步解析：

ServletDef：

/**
 * 来看下官方解释：
 * 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>标签中的内容
	... 
}

通过查看ServletDef类的方法和属性，以及官方解释，可以得知：这个ServletDef类其实就是用来封装Servlet相关配置信息的，我称其为Servlet定义对象。

context：

这个context对象，其实代表的是容器，它是StandardContext类的实例化对象。这个通过调试就可以知道，在此不解释太多。

wrapper：

对于warpper对象来说，它是通过调用 context.createWrapper() 方法而来的。单看方法名调用就可以大概猜测到，它是在容器中生成并返回的，因此我们来看下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;
}

为了全面了解这个wrapper对象，我们继续往下看StandarWrapper类：

/**
* 看下官方解释：
* Wrapper接口的标准实现，表示单个servlet定义。不允许使用任何子容器，并且父容器必须是上下文
*/
public class StandardWrapper extends ContainerBase implements ServletConfig, Wrapper, NotificationEmitter {
	...
}

先不说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;
    @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配置信息，为之后的阶段做准备。

为了加深理解，送出下图：
在这里插入图片描述

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过滤器的源码不做太多解释
    ... 
}

通过上面的关键代码，可以了解到Servlet对象是通过wrapper对象进行分配的。
为此，来看下StandardWrapper类的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对象；或者创建Servlet对象，以及调用其init方法进行初始化，并返回Servlet对象：
在这里插入图片描述

3. Servlet执行阶段

Servlet的执行阶段，我们要了解的是当请求访问到达后端时候，服务器中它是如何判断这个请求，并准确的调用到响应的doXXX方法。

但针对于Servlet执行阶段的过程中，并不只是仅仅涉及到Servlet，其中还与Filter过滤器有很大的关系。为了更好理解这个阶段，在这里先提前说下Servlet的执行阶段的流程：

当启动Tomcat服务器时，服务器除了会封装Servlet相关配置信息之外，其实还会封装Filter过滤器的相关配置信息，以及对Filter过滤器进行创建并初始化。
当Tomcat服务器完全启动后，由前端发送request请求，此时服务器检测到有请求到达，此时会加载对应的Servlet实例对象（如果是初次访问，则创建），然后通过请求路径、请求类型、Servlet名三个条件对已存在的过滤器进行匹配筛选，然后将匹配筛选成功的过滤器组成过滤器链。
当过滤器链完成后，首先从链头开始调用每个过滤器的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请求的类型匹配对应执行方法：
在这里插入图片描述

如果你能够理解本文分析的源码逻辑，那相信你对Servlet的理解又会提升一层。但其实完全理解本文并不足够，因为在最后部分，本文还介绍了Filter过滤器。而作为JavaWeb三大组件之二：Servlet和Filter有着密不可分的联系，因此在理解本文的基础上，在这里再次强烈推荐阅读我的另外一篇博文：JavaWeb三大组件——Filter过滤器源码解析

MrFC

关注

8
点赞
踩
27

收藏

觉得还不错? 一键收藏
1
评论
JavaWeb三大组件之一——Servlet源码解析（剖析底层代码，需要耐心看完）

什么是Servlet？Servlet的全程是Server Applet。通俗来说，它是一个请求处理器，它可以接受来自前端或者其他服务器端的请求。作为Java工程师，我们通常是将其用在后端处理前端请求，执行相应业务操作。而在目前市场的常用的主流框架，如Spring、SpringMvc、SpringBoot等等，这些Java应用开发框架中都不见Servlet的踪影，难道Servlet已经没落了吗？当然不是，这些所谓的主流框架，在底层用的其实还是Servlet，只是这些框架已经把Servlet封装隐藏起来了。
复制链接

扫一扫