StandardWrapper容器
Context容器包含一个或者多个Wrapper实例，每个Wrapper实例表示一个具体的servlet定义。
方法调用序列
具体过程
(1)连接器创建request和response对象
(2)连接器调用StandardContext实例的invoke()方法
(3)接着，StandardContext实例的invoke方法调用其管道对象的invoke方法。StandardContext中管道对象的基础阀是StandContextValve类的实例，因此，StandardContext的管道对象会调用StandardContextValve实例的invoke方法。
(4)StandardContextValve实例的invoke方法获取相应的Wrapper实例处理HTTP请求，调用Wrapper实例的invoke的方法。
(5)StandardWrapper类是Wrapper接口的标准实现，StandardWrapper实例的invoke方法会调用其管道对象的invoke方法。
(6)StandardWrapper流水线的基本阀门时StandardWrapperValve。因此StandardWrapperValve的invoke方法会被调用。StandardWrapperValve的invoke方法会调用包装器的allocate方法获得一个servlet的实例。
(7)当一个servlet需要被加载的时候，方法allocate调用方法load来加载一个servlet。
(8)方法load会调用servlet的init方法。
(9)StandardWrapperValve调用servlet实例的service方法。
1. StandardWrapper对象主要任务加载servlet类，并进行实例。但是StandardWrapper并不调用servlet的service方法。StandardWrapperValve对象通过调用allocate()方法从StandardWrapper实例中获取servlet实例。在获取得了servlet实例后，StandardWrapperValve实例就会调用servlet实例的service方法。
粗略流程如下：
分配Servlet实例
StandardWrapperValve实例的invoke方法调用Wrapper实例的allocate方法获取请求的servlet的一个实例，因此StandardWrapper类的实现allocate方法。
StandardWrapperValve#invoke
public final void invoke(Request request, Response response) throws IOException, ServletException { //...省略 // Allocate a servlet instance to process this request try { if (!unavailable) { servlet = wrapper.allocate(); } } catch (UnavailableException e) { //...省略
StandardWrapper#allocate
/** * Stack containing the STM instances. */ protected Stack<Servlet> instancePool = null; public Servlet allocate() throws ServletException { // If we are currently unloading this servlet, throw an exception if (unloading) throw new ServletException (sm.getString("standardWrapper.unloading", getName())); boolean newInstance = false; // 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 { if (log.isDebugEnabled()) log.debug("Allocating non-STM instance"); instance = loadServlet();//加载servlet实例 if (!singleThreadModel) { // For non-STM, increment here to prevent a race // condition with unload. Bug 43683, test case // #3 newInstance = true; //分配计数 countAllocated.incrementAndGet(); } } catch (ServletException e) { throw e; } catch (Throwable e) { ExceptionUtils.handleThrowable(e); throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } } } if (!instanceInitialized) { initServlet(instance);//初始化servlet->servlet.init() } if (singleThreadModel) { if (newInstance) { // Have to do this outside of the sync above to prevent a // possible deadlock synchronized (instancePool) { instancePool.push(instance); nInstances++; } } } else { if (log.isTraceEnabled()) log.trace(" Returning non-STM instance"); // For new instances, count will have been incremented at the // time of creation if (!newInstance) { countAllocated.incrementAndGet(); } return (instance); } } synchronized (instancePool) { while (countAllocated.get() >= 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) { ExceptionUtils.handleThrowable(e); throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } else { try { instancePool.wait(); } catch (InterruptedException e) { // Ignore } } } if (log.isTraceEnabled()) log.trace(" Returning allocated STM instance"); countAllocated.incrementAndGet(); return instancePool.pop();//弹出栈顶servlet } }
加载Servlet
在StandardWrapper#loadServlet()方法，先检查是否已经加载过servlet
if (!singleThreadModel && (instance != null)) return instance;
StandardContext获取实例管理器,并通过实例管理器获取servlet实例
InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();
servlet = (Servlet) instanceManager.newInstance(servletClass);
初始化servlet，并触发容器加载监听事件。
initServlet(servlet); fireContainerEvent("load", this);
最后，返回servlet
return servlet;
2.ServletConfig类
在servlet调用init方法，要传入ServletConfig参数，ServletConfig参数的来源，由于StandardWrapper不仅实现了Wrapper接口，还实现了javax.servlet.ServletConfig接口，在ServletConfig接口中的方法如下：
public interface ServletConfig { public String getServletName();//返回servlet名字 public ServletContext getServletContext();//返回servlet容器 public String getInitParameter(String name);//返回初始化参数 public Enumeration<String> getInitParameterNames(); }
StandardWrapper类并不是将自身传递给servlet#init方法，它会在一个StandardWrapperFacade实例中包装自生，将其大部分的公共方法对servlet程序员隐藏。
/** * The facade associated with this wrapper. */ protected StandardWrapperFacade facade = new StandardWrapperFacade(this);
在StandardWrapper中方法实现
public ServletContext getServletContext() { if (parent == null) return (null); else if (!(parent instanceof Context)) return (null); else return (((Context) parent).getServletContext()); } protected HashMap<String, String> parameters = new HashMap<String, String>(); /** * Return the name of this servlet. */ @Override public String getServletName() { return (getName()); } public String getInitParameter(String name) { return (findInitParameter(name)); } /** * Return the set of initialization parameter names defined for this * servlet. If none are defined, an empty Enumeration is returned. */ @Override public Enumeration<String> getInitParameterNames() { try { parametersLock.readLock().lock(); return Collections.enumeration(parameters.keySet()); } finally { parametersLock.readLock().unlock(); } } //初始化参数 public void addInitParameter(String name, String value) { try { parametersLock.writeLock().lock(); parameters.put(name, value); } finally { parametersLock.writeLock().unlock(); } fireContainerEvent("addInitParameter", name); }
3.Servlet容器的父子关系。
Wrapper实例代表一个servlet实例，因此Wrapper实例不在有子容器，不应该在调用其addChild方法，否则抛出IllegalStateException异常。下面是addChild方法。
public void addChild(Container child) { throw new IllegalStateException (sm.getString("standardWrapper.notChild")); }
Wrapper的父容器只能是Context类的实现，若是在调用Wrapper实例的setParent方法时，传入了一个非Context类型的容器，则会抛出IllegalStateException异常。
public void setParent(Container container) { if ((container != null) && !(container instanceof Context)) throw new IllegalArgumentException (sm.getString("standardWrapper.notContext")); if (container instanceof StandardContext) { swallowOutput = ((StandardContext)container).getSwallowOutput(); unloadDelay = ((StandardContext)container).getUnloadDelay(); } super.setParent(container); }
4.StandardWrapperFacade类
StandardWrapper实例会调用它所载入的servlet类的实例的init()方法。init()方法需要一个javax.servlet.ServletConfig实例，而StandardWrapper类本身实现了javax.servlet.ServletConfig接口，所以，理论上StandardWrapper对象可以将自己传入init()方法。但是StandardWrapper需要将其大部分公共方法对servlet程序员隐藏起来。为了实现在这个目的，StandWrapper类将自身包装成StandardWrapperFacade类的一个实例。关系如下。
(1)在StandardWrapper类中，将自身包装成StandardWrapperFacade。
/** * The facade associated with this wrapper. */ protected StandardWrapperFacade facade = new StandardWrapperFacade(this);
(2)StandardWrapperFacade中的构造方法。
public StandardWrapperFacade(StandardWrapper config) { super(); this.config = config; } //通过包装类型调用方法 public String getInitParameter(String name) { return config.getInitParameter(name); } public ServletContext getServletContext() { if (context == null) { context = config.getServletContext(); if ((context != null) && (context instanceof ApplicationContext)) context = ((ApplicationContext) context).getFacade(); } return (context); } public String getServletName() { return config.getServletName(); }
这里采用装饰模式。
5.StandardWrapperValve类
StandardWrapperValve是StandardWrapper中的基础阀门，主要完成2个操作。
(1)执行与该servlet实例关联的全部过滤器，
(2)调用servlet实例的service方法。
在StandardWrapperValve中invoke方法执行的步骤。
(1)调用StandardWrapper实例的allocate方法获取该StandardWrapper实例所表示的servlet的实例；
(2)调用私有方法createFilterChain，创建过滤器链；
(3)调用过滤链的doFilter方法，其中包括调用servlet实例的service方法；
(4)释放过滤链；
(5)调用Wrapper实例的deallocate方法；
(6)若该servlet类再也不会用到，将会调用Wrapper实例的unload方法。
6.ApplicationFilterChain类
ApplicationFilterChain类实现了FilterChain接口，StandardWrapperValve类的invoke方法会创建ApplicationFilterChain类的一个实例，并调用其doFilter方法，doFilter方法会调用第一个过滤器的doFilter方法。直到最后一个过滤器，则会调用被请求的servlet类的service方法。
总结：
通过StandWrapper的学习，大致的了解了Servlet的从加载，初始化，service方法，到卸载的整个流程。另外还有就是单例模式，监听事件，装饰模式的设计思想的了解。