Tomcat 源码解析一容器加载-大寂灭指(下)

接着 Tomcat 源码解析一容器加载-大寂灭指(中) 继续 。

  之前有一个方法configureContext()有一行代码（下面加粗代码）没有分析完，这里接着继续分析 。

public void configureContext(Context context) {
    ...
    // 遍历所有的servlet,创建wrapper
    for (ServletDef servlet : servlets.values()) {
        Wrapper wrapper = context.createWrapper();
        // Description is ignored
        // Display name is ignored
        // Icons are ignored

        // jsp-file gets passed to the JSP Servlet as an init-param

        if (servlet.getLoadOnStartup() != null) {
            wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue());
        }
        if (servlet.getEnabled() != null) {
            wrapper.setEnabled(servlet.getEnabled().booleanValue());
        }
        wrapper.setName(servlet.getServletName());
        Map params = servlet.getParameterMap();
        for (Entry entry : params.entrySet()) {
            wrapper.addInitParameter(entry.getKey(), entry.getValue());
        }
        wrapper.setRunAs(servlet.getRunAs());
        Set roleRefs = servlet.getSecurityRoleRefs();
        for (SecurityRoleRef roleRef : roleRefs) {
            wrapper.addSecurityReference(
                    roleRef.getName(), roleRef.getLink());
        }
        wrapper.setServletClass(servlet.getServletClass());
        MultipartDef multipartdef = servlet.getMultipartDef();
        if (multipartdef != null) {
            if (multipartdef.getMaxFileSize() != null &&
                    multipartdef.getMaxRequestSize()!= null &&
                    multipartdef.getFileSizeThreshold() != null) {
                wrapper.setMultipartConfigElement(new MultipartConfigElement(
                        multipartdef.getLocation(),
                        Long.parseLong(multipartdef.getMaxFileSize()),
                        Long.parseLong(multipartdef.getMaxRequestSize()),
                        Integer.parseInt(
                                multipartdef.getFileSizeThreshold())));
            } else {
                wrapper.setMultipartConfigElement(new MultipartConfigElement(
                        multipartdef.getLocation()));
            }
        }
        if (servlet.getAsyncSupported() != null) {
            wrapper.setAsyncSupported(
                    servlet.getAsyncSupported().booleanValue());
        }
        wrapper.setOverridable(servlet.isOverridable());
        // 把wrapper添加到context中去
        context.addChild(wrapper);
    }
    
	// 把mapping关系添加到context中去
	for (Entry entry : servletMappings.entrySet()) {
	    context.addServletMapping(entry.getKey(), entry.getValue());
	}

}

  看StandardContext的addChild()具体实现。

public void addChild(Container child) {

    Wrapper oldJspServlet = null;

	// StandardContext下的child只能是Wrapper ,否则抛出异常 
    if (!(child instanceof Wrapper)) {
        throw new IllegalArgumentException
            (sm.getString("standardContext.notWrapper"));
    }

    boolean isJspServlet = "jsp".equals(child.getName());
    if (isJspServlet) {
    	// 在一个StandardContext中只允许有一个名字为jsp的child
        oldJspServlet = (Wrapper) findChild("jsp");
        if (oldJspServlet != null) {
        	// 将旧的名字为jsp的child移除掉 
            removeChild(oldJspServlet);
        }
    }

    super.addChild(child);

    if (isJspServlet && oldJspServlet != null) {
    	// 如果存在两个名字为jsp的child 
    	// 将两者的映射合并，都指向jsp 
        String[] jspMappings = oldJspServlet.findMappings();
        for (int i=0; jspMappings!=null && iaddServletMapping(jspMappings[i], child.getName());
        }
    }
}      

  其他的很多代码就略过了，一般StandardWrapper也没有监听器，因此直接到StandardWrapper的startInternal()方法 。

protected synchronized void startInternal() throws LifecycleException {
    if (this.getObjectName() != null) {
        Notification notification = new Notification("j2ee.state.starting",
                                                    this.getObjectName(),
                                                    sequenceNumber++);
        broadcaster.sendNotification(notification);
    }
    super.startInternal();
    // 此servlet将变为可用的日期和时间（从纪元开始以毫秒为单位），
    // 如果servlet可用，则为零。如果该值等于Long。MAX_VALUE，此servlet的不可用性被认为是永久性的。
    setAvailable(0L);

    if (this.getObjectName() != null) {
        Notification notification =
            new Notification("j2ee.state.running", this.getObjectName(),
                            sequenceNumber++);
        broadcaster.sendNotification(notification);
    }
}

  在StandardWrapper的startInternal()方法中也并没有多少事情，只是发送一下广播事件，设置available为可用。当然接着调用父类的super.startInternal();方法。

protected synchronized void startInternal() throws LifecycleException {
	...
    // Start the Valves in our pipeline (including the basic), if any
    if (pipeline instanceof Lifecycle) {
        ((Lifecycle) pipeline).start();
    }

    // 这个时候会触发START_EVENT事件，会进行deployApps
    setState(LifecycleState.STARTING);

}

  而父类则是ContainerBase类，StandardWrapper中当然也存在管道，因此会启动StandardPipeline，而StandardPipeline默认是没有实现监听器的，StandardPipeline同样继承了LifecycleBase， 因此不会处理StandardPipeline启动过程中生命周期监听器事件，那就直接进入StandardPipeline的startInternal()方法吧。

protected synchronized void startInternal() throws LifecycleException {
    // Start the Valves in our pipeline (including the basic), if any
    Valve current = first;
    if (current == null) {
        current = basic;
    }
    while (current != null) {
        if (current instanceof Lifecycle)
            ((Lifecycle) current).start();
        current = current.getNext();
    }
    setState(LifecycleState.STARTING);
}

  此时大家可能比较迷惑，basic是哪里初始化值的，请看 StandardWrapper的构造方法 。

public StandardWrapper() {

    super();
    // 【注意】StandardWrapper 类的构造函数将一个StandardWrapperValue 作为它的基本阀门
    // 本章关注的是一个servlet 被调用的时候发生的细节，因此我们需要自习看StandardWrapper 和StandardWrapperValue 类，在学习它们
    // 之前，我们需要首先关注下，javax.servlet.SignleThreaadModel ，理解该接口对于理解一个包装器是如何工作的非常重要 。
    swValve=new StandardWrapperValve();
    pipeline.setBasic(swValve);  //
    // 广播
    broadcaster = new NotificationBroadcasterSupport();

}

  在StandardWrapper的构造方法中，初始化basic的值为StandardWrapperValve，到这里StandardWrapper被添加到StandardContext操作已经完成了。

添加映射

  将StandardWrapper添加到StandardContext主要是提供服务，根据前端的url请求，tomcat最终将请求转发到不同的StandardWrapper中，StandardWrapper最后又调用我们开发的Servlet，因此光将Wrapper添加到Context还不行，还需要将映射也添加到Context中，当接收到请求时，才能找到相应的Servlet 。
  在分析方法之前先来看一下servletMappings的数据。

public void addServletMapping(String pattern, String name) {
    addServletMapping(pattern, name, false);
}


public void addServletMapping(String pattern, String name,
                              boolean jspWildCard) {
    // Validate the proposed mapping
    //
    if (findChild(name) == null)
        throw new IllegalArgumentException
            (sm.getString("standardContext.servletMap.name", name));
    // 如果urlPattern以 *. 或 / 开头，则返回原urlPattern
    // 如果urlPattern不为空，但不以 / 开头，则帮urlPattern加上前缀 /  
    String decodedPattern = adjustURLPattern(RequestUtil.URLDecode(pattern));
    // 1. 如果url中有\n ,\r 或为null，则验证不通过
    // 2. 以*.开头并且还有/ 的url验证不通过，如*.xxx/ 
    // 3. 以/ 开头，并且还有*. 的url 验证不通过 如，/xxx*. 
    if (!validateURLPattern(decodedPattern))
        throw new IllegalArgumentException
            (sm.getString("standardContext.servletMap.pattern", decodedPattern));

    // Add this mapping to our registered set
    // 如果对某个servlet重复配置了urlPattern，那么将被覆盖
    synchronized (servletMappingsLock) {
        String name2 = servletMappings.get(decodedPattern);
        if (name2 != null) {
            // Don't allow more than one servlet on the same pattern
            Wrapper wrapper = (Wrapper) findChild(name2);
            wrapper.removeMapping(decodedPattern);
            mapper.removeWrapper(decodedPattern);
        }
        servletMappings.put(decodedPattern, name);
    }
    Wrapper wrapper = (Wrapper) findChild(name);
    // 将pattern添加到StandardWrapper的mappings属性中
    wrapper.addMapping(decodedPattern);

    // Update context mapper
    // 在Mapper中添加映射关系
    mapper.addWrapper(decodedPattern, wrapper, jspWildCard,
            resourceOnlyServlets.contains(name));

    fireContainerEvent("addServletMapping", decodedPattern);

}

  接下来看向mapper添加映射关系 。

public void addWrapper(String path, Object wrapper, boolean jspWildCard,
        boolean resourceOnly) {
    addWrapper(context, path, wrapper, jspWildCard, resourceOnly);
}

protected void addWrapper(ContextVersion context, String path,
        Object wrapper, boolean jspWildCard, boolean resourceOnly) {
    synchronized (context) {
        if (path.endsWith("/*")) {  // 比如/test/*
            // Wildcard wrapper 通配符Wrapper
            String name = path.substring(0, path.length() - 2);
            // 这里的两个Wrapper都表示Servlet包装器，不同的是，一个是只用来记录映射关系，一个是真正的StandardWrapper
            Wrapper newWrapper = new Wrapper(name, wrapper, jspWildCard,
                    resourceOnly);

            // 如果在老的wildcardWrappers中不存在相同name的，则把新的通配符wrapper插入到数组中
            Wrapper[] oldWrappers = context.wildcardWrappers;
            Wrapper[] newWrappers =
                new Wrapper[oldWrappers.length + 1];
            if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                context.wildcardWrappers = newWrappers;
                int slashCount = slashCount(newWrapper.name);   // 一个url被"/"切分为几个部分
                // 记录当前Context中url按"/"切分后长度最大的长度
                if (slashCount > context.nesting) {
                    context.nesting = slashCount;
                }
            }
        } else if (path.startsWith("*.")) { // 比如*.jsp
            // Extension wrapper  扩展匹配
            String name = path.substring(2);
            Wrapper newWrapper = new Wrapper(name, wrapper, jspWildCard,
                    resourceOnly);
            Wrapper[] oldWrappers = context.extensionWrappers;
            Wrapper[] newWrappers =
                new Wrapper[oldWrappers.length + 1];
            if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                context.extensionWrappers = newWrappers;
            }
        } else if (path.equals("/")) {
            // Default wrapper
            Wrapper newWrapper = new Wrapper("", wrapper, jspWildCard,
                    resourceOnly);
            context.defaultWrapper = newWrapper;
        } else {
            // Exact wrapper   精确匹配
            final String name;
            if (path.length() == 0) {
                // Special case for the Context Root mapping which is
                // treated as an exact match
                // 我们可以在web.xml中配置一个mapping关系是，url-pattern设置为空，那么就表示可以通过应用跟路径来访问
                name = "/";
            } else {
                name = path;
            }
            Wrapper newWrapper = new Wrapper(name, wrapper, jspWildCard,
                    resourceOnly);
            Wrapper[] oldWrappers = context.exactWrappers;
            Wrapper[] newWrappers =
                new Wrapper[oldWrappers.length + 1];
            if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                context.exactWrappers = newWrappers;
            }
        }
    }
}

private static final boolean insertMap
    (MapElement[] oldMap, MapElement[] newMap, MapElement newElement) {
    int pos = find(oldMap, newElement.name);    // 先在oldMap中找是否存在newElement
    if ((pos != -1) && (newElement.name.equals(oldMap[pos].name))) {
        // 如果存在则不插入了
        return false;
    }
    // 从oldMap的第0个位置开始，复制pos + 1个元素到newMap中，newMap中从第0个位置开始
    System.arraycopy(oldMap, 0, newMap, 0, pos + 1);
    newMap[pos + 1] = newElement; // 修改newMap中的pos+1位置的元素为新元素
    // 从oldMap的第pos+1个位置开始，复制oldMap剩下的元素到newMap中
    System.arraycopy
        (oldMap, pos + 1, newMap, pos + 2, oldMap.length - pos - 1);
    return true;
}

  看上去addWrapper代码那么多，其实也就分三种情况，以url 以xxx/结尾，以.xxx开头，否则就是精确匹配了，关于添加映射就分析到这里了。

TldConfig的configure_start事件

  之前只分析过ContextConfig的configure_start事件，但StandardContext还有一个监听器TldConfig，也注册了configure_start事件，接下来分析它。

public void execute() {
    long t1=System.currentTimeMillis();

    /*
     * Priority order of URIs required by spec is:
     * 1. J2EE platform taglibs - Tomcat doesn't provide these
     * 2. web.xml entries
     * 3. JARS in WEB-INF/lib & TLDs under WEB-INF (equal priority)
     * 4. Additional entries from the container
     *
     * Keep processing order in sync with o.a.j.compiler.TldLocationsCache
     */

    // Stage 2 - web.xml entries
    tldScanWebXml();

    // Stage 3a - TLDs under WEB-INF (not lib or classes)
    tldScanResourcePaths("/WEB-INF/");

    // Stages 3b & 4
    JarScanner jarScanner = context.getJarScanner();

    TldJarScannerCallback tldCallBack = new TldJarScannerCallback();
    // 扫描StandardContext 项目目录下的所有WEB-INF/lib下的jar包
    jarScanner.scan(context.getServletContext(), context.getLoader().getClassLoader(),
            tldCallBack, noTldJars);
    if(tldCallBack.scanFoundNoTLDs()){
        log.info(sm.getString("tldConfig.noTldSummary"));
    }
    // Now add all the listeners we found to the listeners for this context
    String list[] = getTldListeners();

    if( log.isDebugEnabled() )
        log.debug(sm.getString("tldConfig.addListeners",
                Integer.valueOf(list.length)));

    for( int i=0; i// 将taglib的监听器类添加到StandardContext的applicationListeners属性中
        context.addApplicationListener(
                new ApplicationListener(list[i], true));
    }

    long t2=System.currentTimeMillis();
    if( context instanceof StandardContext ) {
        ((StandardContext)context).setTldScanTime(t2-t1);
    }

}

1. 在web.xml中声明TLD文件的路径。

private void tldScanWebXml() {
    if (log.isTraceEnabled()) {
        log.trace(sm.getString("tldConfig.webxmlStart"));
    }

	// 默认情况下 JspConfigDescripto是ApplicationJspConfigDescriptor
    Collection descriptors =
        context.getJspConfigDescriptor().getTaglibs();

    for (TaglibDescriptor descriptor : descriptors) {
        String resourcePath = descriptor.getTaglibLocation();
        // Note: Whilst the Servlet 2.4 DTD implies that the location must
        // be a context-relative path starting with '/', JSP.7.3.6.1 states
        // explicitly how paths that do not start with '/' should be
        // handled.
        if (!resourcePath.startsWith("/")) {
            resourcePath = "/WEB-INF/" + resourcePath;
        }
        if (taglibUris.contains(descriptor.getTaglibURI())) {
            log.warn(sm.getString("tldConfig.webxmlSkip", resourcePath,
                    descriptor.getTaglibURI()));
        } else {
            if (log.isTraceEnabled()) {
                log.trace(sm.getString("tldConfig.webxmlAdd", resourcePath,
                        descriptor.getTaglibURI()));
            }
            InputStream stream = null;
            try {
                stream = context.getServletContext().getResourceAsStream(
                        resourcePath);
                if (stream != null) {
                    XmlErrorHandler handler = tldScanStream(stream);
                    handler.logFindings(log, resourcePath);
                    taglibUris.add(descriptor.getTaglibURI());
                    webxmlTaglibUris.add(descriptor.getTaglibURI());
                } else {
                    log.warn(sm.getString("tldConfig.webxmlFailPathDoesNotExist", resourcePath,
                            descriptor.getTaglibURI()));
                }
            } catch (IOException ioe) {
                log.warn(sm.getString("tldConfig.webxmlFail", resourcePath,
                        descriptor.getTaglibURI()), ioe);
            } finally {
                if (stream != null) {
                    try {
                        stream.close();
                    } catch (Throwable t) {
                        ExceptionUtils.handleThrowable(t);
                    }
                }
            }
        }
    }
}

  先来看一个例子再来理解这段代码 。

1. 配置MyTaglib.tld

    学习如何使用 Tag 接口
    1.0
    
    tools
    
    /learnTag



    
    
        基于 Tag 接口的自定义标签
        
        showTime
        
        com.luban.MyTaglib
        
        empty
    

2. 创建MyTaglib类

public class MyTaglib implements Tag {
 
    private PageContext pageContext;
    private Tag parent;
 
    public MyTaglib() {
        super();
    }
 
    @Override
    public void setPageContext(PageContext pageContext) {
        this.pageContext = pageContext;
    }
 
    @Override
    public void setParent(Tag tag) {
        this.parent = tag;
    }
 
    @Override
    public Tag getParent() {
        return this.parent;
    }
 
    @Override
    public int doStartTag() throws JspException {
        //返回 SKIP_BODY，表示不计算标签体
        return SKIP_BODY;
    }
 
    @Override
    public int doEndTag() throws JspException {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern("yyyy-MM-dd HH:mm:ss");
            Date date = new Date();// 获取当前时间
            pageContext.getOut().write(sdf.format(date));
        } catch (IOException e) {
            throw new JspTagException(e.getMessage());
        }
        return EVAL_PAGE;
    }
    
    @Override
    public void release() {
 
    }
}

3. 在web.xml中添加taglib标签 ，但要区分一下，如果是Servlet2.4之前的版本，在web.xml中不需要加标签

    
        
        
            
            /learnTag
            
            /WEB-INF/MyTaglib.tld
        
    
    

4. 添加MyTaglib.jsp文件

<%@ page contentType="text/html; charset=GBK" language="java" errorPage="" %>
<%@ page import="java.util.*" %>
<%@ taglib prefix="tools" uri="/learnTag" %>

  有了这个例子后，再来看tldScanWebXml()源码 。

private XmlErrorHandler tldScanStream(InputStream resourceStream)
        throws IOException {

    InputSource source = new InputSource(resourceStream);

    XmlErrorHandler result = new XmlErrorHandler();

    synchronized (tldDigester) {
        try {
            tldDigester.setErrorHandler(result);
            tldDigester.push(this);
            tldDigester.parse(source);
        } catch (SAXException s) {
            // Hack - makes exception handling simpler
            throw new IOException(s);
        } finally {
            tldDigester.reset();
        }
        return result;
    }
}

  在解析/WEB-INF/MyTaglib.tld文件时， 将this 也就是TldConfig添加到tldDigester中。 而在TldRuleSet中，使用了TaglibUriRule规则。

当解析到下的 标签时，会将uri的body内容添加到TldConfig的taglibUris中 。

  接下来看tldScanResourcePaths()方法的实现。

private void tldScanResourcePaths(String startPath) {

    if (log.isTraceEnabled()) {
        log.trace(sm.getString("tldConfig.webinfScan", startPath));
    }
    
    ServletContext ctxt = context.getServletContext();

    Set dirList = ctxt.getResourcePaths(startPath);
    if (dirList != null) {
        Iterator it = dirList.iterator();
        while (it.hasNext()) {
        	// 如果路径以/WEB-INF/lib/或/WEB-INF/classes/ 开头，
        	// 并且不以.tld结构，则忽略掉
            String path = it.next();
            if (!path.endsWith(".tld")
                    && (path.startsWith("/WEB-INF/lib/")
                            || path.startsWith("/WEB-INF/classes/"))) {
                continue;
            }
            // 如果文件路径以.tld结尾，但文件名以/WEB-INF/tags/开头
            // 并且文件名不是implicit.tld ，则忽略掉，也就是说默认情况下
            //  /WEB-INF/tags/目录下，只会扫描implicit.tld文件 ，当然其他目录
            // 下，只要以.tld文件结尾，还是会扫描解析的
            if (path.endsWith(".tld")) {
                if (path.startsWith("/WEB-INF/tags/") &&
                        !path.endsWith("implicit.tld")) {
                    continue;
                }
                InputStream stream = ctxt.getResourceAsStream(path);
                try {
                    XmlErrorHandler handler = tldScanStream(stream);
                    handler.logFindings(log, path);
                } catch (IOException ioe) {
                    log.warn(sm.getString("tldConfig.webinfFail", path),
                            ioe);
                } finally {
                    if (stream != null) {
                        try {
                            stream.close();
                        } catch (Throwable t) {
                            ExceptionUtils.handleThrowable(t);
                        }
                    }
                }
            } else {
            	// 递归搜索
                tldScanResourcePaths(path);
            }
        }
    }
}

  看了tldScanResourcePaths()方法后，我们得出一个结论，如果非WEB-INF/tags目录下的文件，即使不配置在web.xml中，也会被扫描解析 。

例1 ，注释掉web.xml中MyTaglib.tld配置

例2 配置MyTaglib.tld

  在web.xml配置taglib配置后， 虽然tldScanResourcePaths()方法依然没有扫描到/WEB-INF/tags/MyTaglib.tld文件，但配置有效，因为在tldScanWebXml()方法中已经处理过了。

  接下来看扫描StandardContext项目下的WEB-INF/lib下的所有jar包，并将扫描到的包通过TldJarScannerCallback类来处理。

private class TldJarScannerCallback implements JarScannerCallback {
    boolean tldFound = true;

    @Override
    public void scan(JarURLConnection urlConn) throws IOException {
        tldFound = tldScanJar(urlConn);
    }

    @Override
    public void scan(File file) {
        File metaInf = new File(file, "META-INF");
        if (metaInf.isDirectory()) {
            tldFound = tldScanDir(metaInf);
        }
    }

    private boolean scanFoundNoTLDs() {
        return !tldFound;
    }
}

  无论是URLConnection还是File类型，最终都由tldScanDir()方法来处理。

private boolean tldScanDir(File start) {
    boolean isFound = false;

    if (log.isTraceEnabled()) {
        log.trace(sm.getString("tldConfig.dirScan", start.getAbsolutePath()));
    }

    File[] fileList = start.listFiles();
    if (fileList != null) {
        for (int i = 0; i < fileList.length; i++) {
            // Scan recursively
            if (fileList[i].isDirectory()) {
            	// 如果是目录，则递归查找
                tldScanDir(fileList[i]);
            } else if (fileList[i].getAbsolutePath().endsWith(".tld")) {
                InputStream stream = null;
                isFound = true;
                try {
                    stream = new FileInputStream(fileList[i]);
                    XmlErrorHandler handler = tldScanStream(stream);
                    handler.logFindings(log, fileList[i].getAbsolutePath());
                } catch (IOException ioe) {
                    log.warn(sm.getString("tldConfig.dirFail",
                            fileList[i].getAbsolutePath()),
                            ioe);
                } finally {
                    if (stream != null) {
                        try {
                            stream.close();
                        } catch (Throwable t) {
                            ExceptionUtils.handleThrowable(t);
                        }
                    }
                }
            }
        }
    }
    if(!isFound){
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("tldConfig.noTldInDir", start.getAbsolutePath()));
        }
    }
    return isFound;
}

  其实上面方法就是扫描jar包下所有META-INF下的.tld文件 。
  接下来看getTldListeners()方法 。

public String[] getTldListeners() {
    String result[]=new String[listeners.size()];
    listeners.toArray(result);
    return result;
}

  获取applicationListener监听器。

  从上述源码中推出listener-class的使用。

  添加类MyTaglibListener

public class MyTaglibListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("====MyTaglibListener======");
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

  查看启动结果

  到这里已经对TldConfig的configure_start事件分析完了。继续分析StandardContext中的其他方法 。

欢迎页的设置

  向mapper中添加欢迎页。

  而欢迎页默认来源于catalina.base/conf/web.xml

private void mergeParameters() {
    Map mergedParams = new HashMap();

    String names[] = findParameters();
    for (int i = 0; i < names.length; i++) {
        mergedParams.put(names[i], findParameter(names[i]));
    }

    ApplicationParameter params[] = findApplicationParameters();
    for (int i = 0; i < params.length; i++) {
        if (params[i].getOverride()) {
            if (mergedParams.get(params[i].getName()) == null) {
                mergedParams.put(params[i].getName(),
                        params[i].getValue());
            }
        } else {
            mergedParams.put(params[i].getName(), params[i].getValue());
        }
    }

    ServletContext sc = getServletContext();
    for (Map.Entry entry : mergedParams.entrySet()) {
        sc.setInitParameter(entry.getKey(), entry.getValue());
    }
}

public String[] findParameters() {
    List parameterNames = new ArrayList(parameters.size());
    parameterNames.addAll(parameters.keySet());
    return parameterNames.toArray(new String[parameterNames.size()]);
}



public ApplicationParameter[] findApplicationParameters() {
    synchronized (applicationParametersLock) {
        return (applicationParameters);
    }
}

  mergeParameters()方法本身业务不难， 但是要清楚parameters和applicationParameters是从哪里来的。 先来看parameters属性的由来 。

  在catalina.base/webapps/servelet-test-1.0/WEB-INF/web.xml中配置context-param标签即可。

   aaa
   bbb

  接下来看applicationParameters参数是从哪里配置的。 有两个地方可以配置。

  接下来看执行mergeParameters()方法合并的效果。当然啦源于 applicationParameters 我们可以在context.xml文件中添加初始化参数，以实现所在Web 应用中的复用而不必每个Web 应用复制配置，当然在Web应用确实允许Tomcat 紧耦合的情况下，我们才推荐使用该方式进行配置，否则会导致Web 应用
适应性非常差。

  接下来看startInternal()的另外一段代码

for (Map.Entry>> entry :
    initializers.entrySet()) {
    try {
        // Context容器启动时就会分别调用每个ServletContainerInitializer的onStartup()方法，将感兴趣的类作为参数传入
        entry.getKey().onStartup(entry.getValue(), getServletContext());
    } catch (ServletException e) {
        log.error(sm.getString("standardContext.sciFail"), e);
        ok = false;
        break;
    }
}

  首先关于initializers属性值从哪里添加的。回顾之前的代码。之前在分析webConfig()方法中有一行这样的代码 。

public void addServletContainerInitializer(
         ServletContainerInitializer sci, Set> classes) {
     initializers.put(sci, classes);
}

  现在已经对ServletContainerInitializer原理分析完了。

实例管理器-InstanceManager

  Context容器中包含了一个实例管理器，它主要的作用是实现对Context容器中监听器过滤器及Servlet等实例管理，其中包括根据监听器Class对其进行实例化，对它们的Class的注解进行解析并处理， 对它们的Class实例化的访问权限的限制，销毁前统一的调用preDestory方法等。

  实例管理器的实现其实很简单，其中就使用了一些反射机制实例化出对象的，但这里面需要注意的地方是InstanceManager包含了两个类加载器， 一个是属于Tomcat容器内部的类加载器，而另外一个是Web应用的类加载器，Tomcat容器类加载器是Web就任类加载器的父类加载器， 且Tomcat容器类加载器在Tomcat整个生命周期中都存在，而Web应用加载器则不同，它可能在重启后则丢弃，最终被GC回收。

  所以，由不同的类加载器的类也会有不同的生命周期，于是，实例管理器中的loadClass方法中会有类似如下判断 。

protected Class loadClass(String className, ClassLoader classLoader ) throws ClassNotFundException{
  if ( className.startWith(“org.apache.catalina”)){
    return containerClassLoader.loadClass(className);
  } else {
    return webClassLoader.loadClass(className);
  }
}

  接下来看StandardContext的实例管理器的初始化 。

if (ok ) {
    if (getInstanceManager() == null) {
        javax.naming.Context context = null;
        if (isUseNaming() && getNamingContextListener() != null) {
            context = getNamingContextListener().getEnvContext();
        }
        Map> injectionMap = buildInjectionMap(
                getIgnoreAnnotations() ? new NamingResources(): getNamingResources());
        setInstanceManager(new DefaultInstanceManager(context,
                injectionMap, this, this.getClass().getClassLoader()));
        getServletContext().setAttribute(
                InstanceManager.class.getName(), getInstanceManager());
    }
}

  接起来看实例管理器的应用 。

public boolean listenerStart() {
    if (log.isDebugEnabled())
        log.debug("Configuring application event listeners");

    // Instantiate the required listeners
    ApplicationListener listeners[] = applicationListeners;
    Object results[] = new Object[listeners.length];
    boolean ok = true;
    for (int i = 0; i < results.length; i++) {
        if (getLogger().isDebugEnabled())
            getLogger().debug(" Configuring event listener class '" +
                listeners[i] + "'");
        try {
            ApplicationListener listener = listeners[i];
            results[i] = getInstanceManager().newInstance(
                    listener.getClassName());
            if (listener.isPluggabilityBlocked()) {
                noPluggabilityListeners.add(results[i]);
            }
        } catch (Throwable t) {
            t = ExceptionUtils.unwrapInvocationTargetException(t);
            ExceptionUtils.handleThrowable(t);
            getLogger().error
                (sm.getString("standardContext.applicationListener",
                              listeners[i].getClassName()), t);
            ok = false;
        }
    }
    if (!ok) {
        getLogger().error(sm.getString("standardContext.applicationSkipped"));
        return (false);
    }

    // Sort listeners in two arrays
    ArrayList