第十七课： StandardWrapper

课前复习：

       不知道大家是否还有印象，就是在 6 、 7 节课说的 4 种 container, 粗略的从大到小来说就是 engine,host,context , 和 wrapper 。当时写的时候很纠结，因为后面有详细介绍这 4 个的计划，所以前面写的可能不是很详尽。

       让我们回忆一下，当一个请求到来的时候，发生了什么。比如什么创建 Request 这里就不说了，之后 connector 会调用与之关联的容器的 invoke 方法，之后那就肯定会调用 pipeline 的 invoke ，之后一顿 invoke valve 。好，那让我们回想一下之前写过的 context 和 wrapper ，总结一个比较详细的执行过程。

1.        Connector 创建 req 和 resp

2.        调用 StandardContext 的 invoke ，调用 xxxPipeline 的 invoke 方法

3.        Pipeline 调用了 wrapper 的 invoke 方法

4.        Wrapper 调用 valve 的 invoke 方法

5.        valve 调用了 servlet 的 allocate （这里在以前的课程中讲过）

6.        allocate 方法调用 servlet 的 load 方法 ( 当 servlet 需要加载的时候 )

7.        init 方法，之后就是 servlet 处理了。

关于 SingleThreadModel

       这个 SingleThreadModel 在 servlet2.4 以上版本就已经移除了，因为这个东西只能给你的 servlet 的 service 保证同一时刻只有一个进程在访问，给人一种假象的安全。而且只是给 service 方法给予同步，这显然是不能完全解决多线程访问的问题的。其实说这个是为了给下面的 StandardWrapper 做铺垫。因为我们都知道 StrandardWrapper 是负责加载它所代表的 servlet 并 allocate 一个对象的实例。之后交给 valve 来调用 servlet 的 service 方法。这个 allocate 在使用 和 不使用 SingleThreadModel 的时候是不同的。好的，我们接下来就说这个 StandardWrapper 。

StandardWrapper

       这个之前介绍过了，我们这次主要介绍的是 allocate 方法， 我们看下面这一段源码可以发现，当没有实现 SingleThreadModel 的时候， allocate 总是返回第一次时候产生的 servlet 实例。而如果实现 SingleThreadModel 接口，那么就开始控制分配的数量，当分配的大于 nInstance 时候，就 load 一个 servlet 实例，当然这个 load 实在 maxInstance 控制之内的。

       代码如下。

 

          public Servlet allocate() throws ServletException {

        if (debug >= 1)
            log("Allocating an instance");

        // If we are currently unloading this servlet, throw an exception
        if (unloading)
            throw new ServletException
              (sm.getString("standardWrapper.unloading", getName()));

        // If not SingleThreadedModel, return the same instance every time
        if (!singleThreadModel) {

            // Load and initialize our instance if necessary
            if (instance == null) {
                synchronized (this) {
                    if (instance == null) {
                        try {
                            instance = loadServlet();
                        } catch (ServletException e) {
                            throw e;
                        } catch (Throwable e) {
                            throw new ServletException
                                (sm.getString("standardWrapper.allocate"), e);
                        }
                    }
                }
            }

            if (!singleThreadModel) {
                if (debug >= 2)
                    log("  Returning non-STM instance");
                countAllocated++;
                return (instance);
            }

        }

        synchronized (instancePool) {

            while (countAllocated >= nInstances) {
                // Allocate a new instance if possible, or else wait
                if (nInstances < maxInstances) {
                    try {
                        instancePool.push(loadServlet());
                        nInstances++;
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        throw new ServletException
                            (sm.getString("standardWrapper.allocate"), e);
                    }
                } else {
                    try {
                        instancePool.wait();
                    } catch (InterruptedException e) {
                        ;
                    }
                }
            }
            if (debug >= 2)
                log("  Returning allocated STM instance");
            countAllocated++;
            return (Servlet) instancePool.pop();

        }

    }
    

 

Load

       这个没什么多说的，以前说过了，我们知道 wrapper 接口有一个 load 方法，其实他和 Allocate 里的一样，都是调用的 LoadServlet 方法。我们来看看它的源码。

    先看看这一段。

 

              // 这里是说如果不是第一次访问了，并且不是singleThreadModel
    	//就直接返回  Servlet实例
        if (!singleThreadModel && (instance != null))
            return instance;

	if ((actualClass == null) && (jspFile != null)) {
                Wrapper jspWrapper = (Wrapper)
                    ((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
                if (jspWrapper != null) {
                    actualClass = jspWrapper.getServletClass();
                    // Merge init parameters
                    String paramNames[] = jspWrapper.findInitParameters();
                    for (int i = 0; i < paramNames.length; i++) {
                        if (parameters.get(paramNames[i]) == null) {
                            parameters.put
                                (paramNames[i], 
                            jspWrapper.findInitParameter(paramNames[i]));
                        }
                    }
                }
}

    

     这是Tomcat4 的方法，以后的版本就没有了。都是直接loadservletclass。之后就是Loader了，回忆一下我们当时讲的，是自定义的一个classLoader，需要注意的是，container提供一个特殊的servlet，可以访问container的内部内容，名称以org.apache.catalina.起始。之后就是加载servlet，之后就是权限验证，没啥说的。在之后就是在init()的前后fire事件。之后用instanceof来确定是否是实现了singleThreadModel的，如果是就放入pool(如果pool为空就创建一个新的)中。剩下就是Return了。