7、注册

回到StandardService的start方法，我们已经分析了engine及其子容器的启动，现在我们继续往下看看其他组件的启动

protected void org.apache.catalina.core.StandardService.startInternal() throws LifecycleException {

        if(log.isInfoEnabled())
            log.info(sm.getString("standardService.start.name", this.name));
        setState(LifecycleState.STARTING);

        // Start our defined Container first
        if (engine != null) {
            synchronized (engine) {
                engine.start();
            }
        }
        //线程池的启动
        synchronized (executors) {
            for (Executor executor: executors) {
                executor.start();
            }
        }
        //映射监听的启动
        mapperListener.start();

        // Start our defined Connectors second
        //连接的启动
        synchronized (connectorsLock) {
            for (Connector connector: connectors) {
                try {
                    // If it has already failed, don't try and start it
                    if (connector.getState() != LifecycleState.FAILED) {
                        connector.start();
                    }
                } catch (Exception e) {
                    log.error(sm.getString(
                            "standardService.connector.startFailed",
                            connector), e);
                }
            }
        }
    }

在研究其他组件的启动时，我们别漏了Engine还有一个后台的线程操作（也是每个容器都有的操作），这个操作主要是为了进行资源的监控，如果发生变化就进行
reload，也就是context的重启

protected void org.apache.catalina.core.ContainerBase.threadStart() {

        if (thread != null)
            return;
        if (backgroundProcessorDelay <= 0)
            return;

        threadDone = false;
        String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
        //容器后台操作进程
        thread = new Thread(new ContainerBackgroundProcessor(), threadName);
        thread.setDaemon(true);
        thread.start();

    }

在ContainerBase的backgroundProcess方法中会触发一个periodic事件，这个事件被HostConfig捕获

 protected void check() {
        //判断是否是自动部署
        if (host.getAutoDeploy()) {
            // Check for resources modification to trigger redeployment
            //获取所有部署的应用
            DeployedApplication[] apps =
                deployed.values().toArray(new DeployedApplication[0]);
            //检查资源是否被更改
            for (int i = 0; i < apps.length; i++) {
                if (!isServiced(apps[i].name))
                    checkResources(apps[i], false);
            }

            // Check for old versions of applications that can now be undeployed
            //检查不被重新部署的老版本
            if (host.getUndeployOldVersions()) {
                checkUndeploy();
            }

            // Hotdeploy applications
            //热部署
            deployApps();
        }
    }

检查资源是否发生变更

//app：维护这某个context需要进行监控的资源，skipFileModificationResolutionCheck：是否跳过资源修改时间分辨率的检查
protected synchronized void org.apache.catalina.startup.HostConfig.checkResources(DeployedApplication app,
            boolean skipFileModificationResolutionCheck) {
        //获取需要需要重新部署的资源
        String[] resources =
            app.redeployResources.keySet().toArray(new String[0]);
        // Offset the current time by the resolution of File.lastModified()
        //计算当前时间与FILE_MODIFICATION_RESOLUTION_MS（1000ms）的差值，也就是提前1000ms
        //这主要是因为File的lastModified()方法的分辨率是1s，所以在1s内发生的更改，其时间会直接加一秒
        //所以这里会进行偏移
        long currentTimeWithResolutionOffset =
                System.currentTimeMillis() - FILE_MODIFICATION_RESOLUTION_MS;
        for (int i = 0; i < resources.length; i++) {
            File resource = new File(resources[i]);
            if (log.isDebugEnabled())
                log.debug("Checking context[" + app.name +
                        "] redeploy resource " + resource);
            //获取发布应用时文件的修改时间
            long lastModified =
                    app.redeployResources.get(resources[i]).longValue();
            //如果资源存在或者这个资源不存在，但是修改时间是零（比如那些可能一开始不存在，但是后面可能会动态加进来的资源）
            if (resource.exists() || lastModified == 0) {
                // 如果上次修改时间不相等，假设某个资源在部署的时间为12:00:00，然后在12:00:01之内做了更改
                //那么这个资源的修改时间变更为12:00:01，但是此时真实时间还未到12:00:01，那么这里不就丢失了更新吗？？？
                //直到当前时间超过12:00:01时会发生更新。那么存储到重部署资源map的时间是12:00:01，表示一个过去时间（要不然直接部署就成了未来时间了）
                //其实这里没有看懂？？？
                if (resource.lastModified() != lastModified && (!host.getAutoDeploy() ||
                        resource.lastModified() < currentTimeWithResolutionOffset ||
                        skipFileModificationResolutionCheck)) {
                    //如果资源是一个目录
                    if (resource.isDirectory()) {
                        // No action required for modified directory
                        //重新设置修改时间
                        app.redeployResources.put(resources[i],
                                Long.valueOf(resource.lastModified()));
                    //当前资源是否有描述文件，比如context.xml，并且是否是war包
                    } else if (app.hasDescriptor &&
                            resource.getName().toLowerCase(
                                    Locale.ENGLISH).endsWith(".war")) {
                        // 找到对应的context对象
                        Context context = (Context) host.findChild(app.name);
                        String docBase = context.getDocBase();
                        if (!docBase.toLowerCase(Locale.ENGLISH).endsWith(".war")) {
                            // This is an expanded directory
                            File docBaseFile = new File(docBase);
                            if (!docBaseFile.isAbsolute()) {
                                docBaseFile = new File(host.getAppBaseFile(),
                                        docBase);
                            }
                            //重新启动
                            reload(app, docBaseFile, resource.getAbsolutePath());
                        } else {
                            //重新启动
                            reload(app, null, null);
                        }
                        // Update times
                        //更新资源修改时间
                        app.redeployResources.put(resources[i],
                                Long.valueOf(resource.lastModified()));
                        app.timestamp = System.currentTimeMillis();
                        boolean unpackWAR = unpackWARs;
                        if (unpackWAR && context instanceof StandardContext) {
                            unpackWAR = ((StandardContext) context).getUnpackWAR();
                        }
                        //如果需要解压，那么当然需要监控解压后的资源，以docBase作为非绝对路径的前缀
                        if (unpackWAR) {
                            addWatchedResources(app, context.getDocBase(), context);
                        } else {
                            //如果不需要解压，那么没有docBase，直接监控context.xml配置的资源，因为没有docBase
                            //只能都当前绝对路径使用，可能找不到再下次检查部署时找不到文件（会被undeploy）
                            addWatchedResources(app, null, context);
                        }
                        return;
                    } else {
                        // Everything else triggers a redeploy
                        // (just need to undeploy here, deploy will follow)
                        //取消部署，将从host中移除context，并且移除部署的App，资源监控对象
                        undeploy(app);
                        //删除资源
                        deleteRedeployResources(app, resources, i, false);
                        return;
                    }
                }
            } else {
                // There is a chance the the resource was only missing
                // temporarily eg renamed during a text editor save
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e1) {
                    // Ignore
                }
                // Recheck the resource to see if it was really deleted
                if (resource.exists()) {
                    continue;
                }
                // Undeploy application
                //取消部署，并且删除对应context的资源
                undeploy(app);
                deleteRedeployResources(app, resources, i, true);
                return;
            }
        }
        resources = app.reloadResources.keySet().toArray(new String[0]);
        boolean update = false;
        for (int i = 0; i < resources.length; i++) {
            File resource = new File(resources[i]);
            if (log.isDebugEnabled()) {
                log.debug("Checking context[" + app.name + "] reload resource " + resource);
            }
            long lastModified = app.reloadResources.get(resources[i]).longValue();
            // File.lastModified() has a resolution of 1s (1000ms). The last
            // modified time has to be more than 1000ms ago to ensure that
            // modifications that take place in the same second are not
            // missed. See Bug 57765.
            if ((resource.lastModified() != lastModified &&
                    (!host.getAutoDeploy() ||
                            resource.lastModified() < currentTimeWithResolutionOffset ||
                            skipFileModificationResolutionCheck)) ||
                    update) {
                if (!update) {
                    // Reload application
                    //重新部署
                    reload(app, null, null);
                    update = true;
                }
                // Update times. More than one file may have been updated. We
                // don't want to trigger a series of reloads.
                //更新监控
                app.reloadResources.put(resources[i],
                        Long.valueOf(resource.lastModified()));
            }
            app.timestamp = System.currentTimeMillis();
        }
    }

从上面我们看到，tomcat使用一个单独的后台线程去监控资源，如果发生变更，那么就进行重新部署，资源不完整的context会被下掉。

//app：发布的应用，用于维护会导致重新部署的资源修改时间，fileToRemove：docBase，用于删除，newDocBase就是那个被修改了的资源绝对路径
 private void org.apache.catalina.startup.HostConfig.reload(DeployedApplication app, File fileToRemove, String newDocBase) {
        if(log.isInfoEnabled())
            log.info(sm.getString("hostConfig.reload", app.name));
        //查找对应的context
        Context context = (Context) host.findChild(app.name);
        if (context.getState().isAvailable()) {
            if (fileToRemove != null && newDocBase != null) {
                //设置监听器，用于监听after_stop事件，然后删除资源
                context.addLifecycleListener(
                        new ExpandedDirectoryRemovalListener(fileToRemove, newDocBase));
            }
            // Reload catches and logs exceptions
            context.reload();
        } else {
            // If the context was not started (for example an error
            // in web.xml) we'll still get to try to start
            if (fileToRemove != null && newDocBase != null) {
                ExpandWar.delete(fileToRemove);
                context.setDocBase(newDocBase);
            }
            try {
                //启动
                context.start();
            } catch (Exception e) {
                log.warn(sm.getString
                         ("hostConfig.context.restart", app.name), e);
            }
        }
    }

context的reload，reload首先需要将自己标记为暂停中，然后停止，然后删除资源，启动，标记为可用。

public synchronized void org.apache.catalina.core.StandardContext.reload() {

        // Validate our current component state
        if (!getState().isAvailable())
            throw new IllegalStateException
                (sm.getString("standardContext.notStarted", getName()));

        if(log.isInfoEnabled())
            log.info(sm.getString("standardContext.reloadingStarted",
                    getName()));

        // Stop accepting requests temporarily.
        //标记为暂停
        setPaused(true);

        try {
            //停止，修改状态，触发before_stop，stoping等事件，对应ContextConfig生命周期监听器来说，主要是将context中维护的filter，servlet
            //listener，监控资源，JNDI，session等等进行关闭，session的话还会进行钝化。
            stop();
        } catch (LifecycleException e) {
            log.error(
                sm.getString("standardContext.stoppingContext", getName()), e);
        }

        try {
            //启动，这部分逻辑就是StandardContext的启动，不再赘述
            start();
        } catch (LifecycleException e) {
            log.error(
                sm.getString("standardContext.startingContext", getName()), e);
        }
        //修改暂停标记为false，表示已经启动
        setPaused(false);

        if(log.isInfoEnabled())
            log.info(sm.getString("standardContext.reloadingCompleted",
                    getName()));

    }

线程池的启动，tomcat的线程池实现是StandardThreadExecutor，我们直接看到它的startInternal方法，其父类的start方法就不再看了，和其他组件基本一样的操作，因为它们继承的基类都是一样

protected void org.apache.catalina.core.StandardThreadExecutor.startInternal() throws LifecycleException {
        //创建队列，这个队列继承自JDK的LinkedBlockingQueue并发队列
        taskqueue = new TaskQueue(maxQueueSize);
        //线程工厂，namePrefix固定前缀tomcat-exec-，daemon默认为true，getThreadPriority()默认为5
        TaskThreadFactory tf = new TaskThreadFactory(namePrefix,daemon,getThreadPriority());
        //创建线程池，getMinSpareThreads()默认为25，getMaxThreads()默认200，maxIdleTime默认60000毫秒，
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);
        //threadRenewalDelay默认1000毫秒，表示两个线程之间隔着1秒的时间进行启动（为了避免所有线程同时启动）
        executor.setThreadRenewalDelay(threadRenewalDelay);
        //是否重新启动所有的核心线程
        if (prestartminSpareThreads) {
            executor.prestartAllCoreThreads();
        }
        //给任务队列设置线程池
        taskqueue.setParent(executor);
        //给这个线程池设置状态并触发生命周期事件
        setState(LifecycleState.STARTING);
    }

mapperListener.start()

MapperListener属于ContainerListener和LifecycleListener，关联Mapper

 public void org.apache.catalina.mapper.MapperListener.startInternal() throws LifecycleException {
        //设置状态starting
        setState(LifecycleState.STARTING);
        //获取Engine容器
        Engine engine = service.getContainer();
        if (engine == null) {
            return;
        }
        //查找默认的Host，一般就是localhost，如果找到就设置到Mapper中
        findDefaultHost();

        //给子容器添加MapperListener
        //(*1*)
        addListeners(engine);
        
        //获取子容器
        Container[] conHosts = engine.findChildren();
        for (Container conHost : conHosts) {
            Host host = (Host) conHost;
            if (!LifecycleState.NEW.equals(host.getState())) {
                // Registering the host will register the context and wrappers
                //注册host，host又注册context，context又注册wrapper
                registerHost(host);
            }
        }
    }
    
    //(*1*)
    private void addListeners(Container container) {
        container.addContainerListener(this);
        container.addLifecycleListener(this);
        for (Container child : container.findChildren()) {
            addListeners(child);
        }
    }
    

注册Host

private void org.apache.catalina.mapper.MapperListener.registerHost(Host host) {
        //获取host的别名
        String[] aliases = host.findAliases();
        //注册host
        mapper.addHost(host.getName(), aliases, host);
        //注册context
        for (Container container : host.findChildren()) {
            if (container.getState().isAvailable()) {
                registerContext((Context) container);
            }
        }
        if(log.isDebugEnabled()) {
            log.debug(sm.getString("mapperListener.registerHost",
                    host.getName(), domain, service));
        }
    }

mapper.addHost

public synchronized void org.apache.catalina.mapper.Mapper.addHost(String name, String[] aliases,
                                     Host host) {
        //重命名通配符的host名字，如果是*.开头，那么会从1开始截取
        name = renameWildcardHost(name);
        //MappedHost对象数组，用于包装host，别名Host，context集合
        MappedHost[] newHosts = new MappedHost[hosts.length + 1];
        //创建一个MappedHost
        MappedHost newHost = new MappedHost(name, host);
        //插入host到数组中
        //(*1*)
        if (insertMap(hosts, newHosts, newHost)) {
            //插入成功，赋值新数组
            hosts = newHosts;
            //如果是默认的host，那么额外进行赋值
            if (newHost.name.equals(defaultHostName)) {
                defaultHost = newHost;
            }
            if (log.isDebugEnabled()) {
                log.debug(sm.getString("mapper.addHost.success", name));
            }
        } else {
            //如果插入失败，那就说明存在冲突，找出重复的MappedHost
            MappedHost duplicate = hosts[find(hosts, name)];
            //如果连host对象都相同，那么直接打印debug信息
            if (duplicate.object == host) {
                // The host is already registered in the mapper.
                // E.g. it might have been added by addContextVersion()
                if (log.isDebugEnabled()) {
                    log.debug(sm.getString("mapper.addHost.sameHost", name));
                }
                //用旧的MappedHost覆盖newHost引用，以便后面直接设置别名MappedHost集合
                newHost = duplicate;
            } else {
                如果是不同的Host对象，那么出现了冲突，打印错误日志，并直接返回
                log.error(sm.getString("mapper.duplicateHost", name,
                        duplicate.getRealHostName()));
                // Do not add aliases, as removeHost(hostName) won't be able to
                // remove them
                return;
            }
        }
        //别名MappedHost集合
        List<MappedHost> newAliases = new ArrayList<>(aliases.length);
        for (String alias : aliases) {
            alias = renameWildcardHost(alias);
            //创建别名MappedHost，alias别名，newHost是前面插入的MappedHost对象
            MappedHost newAlias = new MappedHost(alias, newHost);
            //添加别名MappedHost
            //(*3*)
            if (addHostAliasImpl(newAlias)) {
                //如果成功，添加到别名集合中
                newAliases.add(newAlias);
            }
        }
        //添加与原始MappedHost的关联集合中
        newHost.addAliases(newAliases);
    }
    
    
    //(*1*)
     private static final <T> boolean insertMap
        (MapElement<T>[] oldMap, MapElement<T>[] newMap, MapElement<T> newElement) {
        //二分法查找
        int pos = find(oldMap, newElement.name);
        //如果找到了相同的MapHost，那么直接返回，不允许插入相同的MapHost，否则就出现了歧义
        if ((pos != -1) && (newElement.name.equals(oldMap[pos].name))) {
            return false;
        }
        //拷贝0到pos位置的MapHost
        System.arraycopy(oldMap, 0, newMap, 0, pos + 1);
        //将新的MapHost插入到pos的后面一个，这就保持了从小到大的顺序
        newMap[pos + 1] = newElement;
        //拷贝剩下的MapHost
        System.arraycopy
            (oldMap, pos + 1, newMap, pos + 2, oldMap.length - pos - 1);
        //表示插入成功
        return true;
    }
    
    //(*2*)
    private static final <T> int find(MapElement<T>[] map, String name) {

        int a = 0;
        int b = map.length - 1;

        // Special cases: -1 and 0
        //如果旧的mapHost数组就没有值，那么直接返回-1
        if (b == -1) {
            return -1;
        }
        //如果这个名字比第一个的host都还小，那么肯定不存在旧的maphost
        if (name.compareTo(map[0].name) < 0) {
            return -1;
        }
        //如果b为零，说明只存在一个MapHost，直接返回下标零。因为只有一个MapHost的时候
        //将要插入的MapHost肯定是大于或者等于旧的这个MapHost，肯定是要插在零下标的后面
        if (b == 0) {
            return 0;
        }

        int i = 0;
        //二分法查找
        while (true) {
            i = (b + a) / 2;
            int result = name.compareTo(map[i].name);
            if (result > 0) {
                a = i;
            } else if (result == 0) {
                return i;
            } else {
                b = i;
            }
            //找到最后一个比将要插入MapHost要小的MapHost，返回其下标
            if ((b - a) == 1) {
                int result2 = name.compareTo(map[b].name);
                if (result2 < 0) {
                    return a;
                } else {
                    return b;
                }
            }
        }

    }
    
    //(*3*)
     private synchronized boolean org.apache.catalina.mapper.Mapper.addHostAliasImpl(MappedHost newAlias) {
        MappedHost[] newHosts = new MappedHost[hosts.length + 1];
        //插入别名MappedHost对象
        if (insertMap(hosts, newHosts, newAlias)) {
            hosts = newHosts;
            //是否为默认MappedHost
            if (newAlias.name.equals(defaultHostName)) {
                defaultHost = newAlias;
            }
            if (log.isDebugEnabled()) {
                log.debug(sm.getString("mapper.addHostAlias.success",
                        newAlias.name, newAlias.getRealHostName()));
            }
            return true;
        } else {
            //查找重复名称的MappedHost
            MappedHost duplicate = hosts[find(hosts, newAlias.name)];
            //获取原始的MappedHost对象，如果他们原始MappedHost对象相同，那么表示别名冲突
            if (duplicate.getRealHost() == newAlias.getRealHost()) {
                // A duplicate Alias for the same Host.
                // A harmless redundancy. E.g.
                // <Host name="localhost"><Alias>localhost</Alias></Host>
                if (log.isDebugEnabled()) {
                    log.debug(sm.getString("mapper.addHostAlias.sameHost",
                            newAlias.name, newAlias.getRealHostName()));
                }
                return false;
            }
            //打印错误，发生别名与其他Host的名字冲突
            log.error(sm.getString("mapper.duplicateHostAlias", newAlias.name,
                    newAlias.getRealHostName(), duplicate.getRealHostName()));
            return false;
        }
    }

registerContext

注册Host的子容器Context

private void org.apache.catalina.mapper.MapperListener.registerContext(Context context) {
        //获取context容器的请求路径
        String contextPath = context.getPath();
        //如果是根路径，contextPath设置为空字符串
        if ("/".equals(contextPath)) {
            contextPath = "";
        }
        //获取父容器Host
        Host host = (Host)context.getParent();
        //获取资源根节点
        WebResourceRoot resources = context.getResources();
        //获取欢迎页面名
        String[] welcomeFiles = context.findWelcomeFiles();
        //WrapperMappingInfo集合，用于维护Mapping，Wrapper等一些信息
        List<WrapperMappingInfo> wrappers = new ArrayList<>();
        //获取Wrapper
        for (Container container : context.findChildren()) {
            
            //创建WrapperMappingInfo集合
            //(*1*)
            prepareWrapperMappingInfo(context, (Wrapper) container, wrappers);

            if(log.isDebugEnabled()) {
                log.debug(sm.getString("mapperListener.registerWrapper",
                        container.getName(), contextPath, service));
            }
        }
        //注册context
        mapper.addContextVersion(host.getName(), host, contextPath,
                context.getWebappVersion(), context, welcomeFiles, resources,
                wrappers);

        if(log.isDebugEnabled()) {
            log.debug(sm.getString("mapperListener.registerContext",
                    contextPath, service));
        }
    }
    
     //(*1*)
     private void org.apache.catalina.mapper.MapperListener.prepareWrapperMappingInfo(Context context, Wrapper wrapper,
            List<WrapperMappingInfo> wrappers) {
        //获取servletName
        String wrapperName = wrapper.getName();
        boolean resourceOnly = context.isResourceOnlyServlet(wrapperName);
        //获取该Servlet的映射数组
        String[] mappings = wrapper.findMappings();
        //每个mapping创建一个WrapperMappingInfo对象
        for (String mapping : mappings) {
            //判断是否为jsp通配符模式
            boolean jspWildCard = (wrapperName.equals("jsp")
                                   && mapping.endsWith("/*"));
            wrappers.add(new WrapperMappingInfo(mapping, wrapper, jspWildCard,
                    resourceOnly));
        }
    }
    

注册context

//hostName, host, contextPath路径，version版本，welcomeResources欢迎页数组，context的根resources， wrappers刚才的Servlet容器集合
public void org.apache.catalina.mapper.Mapper.addContextVersion(String hostName, Host host, String path,
            String version, Context context, String[] welcomeResources,
            WebResourceRoot resources, Collection<WrapperMappingInfo> wrappers) {
        //和前面设置Host是一样的
        hostName = renameWildcardHost(hostName);
        //精确查找MappedHost
        MappedHost mappedHost  = exactFind(hosts, hostName);
        
        //按道理应该已经存在的，如果真的没有，那么重新注册
        if (mappedHost == null) {
            addHost(hostName, new String[0], host);
            //精确查找
            mappedHost = exactFind(hosts, hostName);
            if (mappedHost == null) {
                log.error("No host found: " + hostName);
                return;
            }
        }
        //如果找出来的是一个别名Host，那么表示没有找到原始的Host
        if (mappedHost.isAlias()) {
            log.error("No host found: " + hostName);
            return;
        }
        //"/"的个数
        int slashCount = slashCount(path);
        synchronized (mappedHost) {
            //维护context，wrapper，版本的关系
            ContextVersion newContextVersion = new ContextVersion(version,
                    path, slashCount, context, resources, welcomeResources);
            if (wrappers != null) {
                //注册wrapper，分为三种类型的wrapper，通配符wrapper，扩展名wrapper，精确匹配的wrapper
                addWrappers(newContextVersion, wrappers);
            }
            //获取维护host与context关系的集合对象
            ContextList contextList = mappedHost.contextList;
            //精确匹配对应的MappedContext，与查找host是一样的，不过多的说明了
            MappedContext mappedContext = exactFind(contextList.contexts, path);
            if (mappedContext == null) {
                //构建MappedContext
                mappedContext = new MappedContext(path, newContextVersion);
                //注册MappedContext，与注册Host一样的套路，从小到大的顺序
                ContextList newContextList = contextList.addContext(
                        mappedContext, slashCount);
                if (newContextList != null) {
                    //给mappedHost与其别名MappedHost设置ContextList
                    updateContextList(mappedHost, newContextList);
                    //Mapper的一个成员变量context-》ContextVersion
                    contextObjectToContextVersionMap.put(context, newContextVersion);
                }
            } else {
                //如果已经存在旧得MappedContext了，那么获取它所维护的不同版本的contextversion
                ContextVersion[] contextVersions = mappedContext.versions;
                ContextVersion[] newContextVersions = new ContextVersion[contextVersions.length + 1];
                //像host那样从小到大插入
                if (insertMap(contextVersions, newContextVersions,
                        newContextVersion)) {
                    mappedContext.versions = newContextVersions;
                    //Mapper的一个成员变量context-》ContextVersion
                    contextObjectToContextVersionMap.put(context, newContextVersion);
                } else {
                    // Re-registration after Context.reload()
                    // Replace ContextVersion with the new one
                    int pos = find(contextVersions, version);
                    //如果已经存在相同版本的contextVersion，那么覆盖
                    if (pos >= 0 && contextVersions[pos].name.equals(version)) {
                        contextVersions[pos] = newContextVersion;
                        contextObjectToContextVersionMap.put(context, newContextVersion);
                    }
                }
            }
        }

    }

注册Wrapper

 private void org.apache.catalina.mapper.Mapper.addWrappers(ContextVersion contextVersion,
            Collection<WrapperMappingInfo> wrappers) {
        for (WrapperMappingInfo wrapper : wrappers) {
            addWrapper(contextVersion, wrapper.getMapping(),
                    wrapper.getWrapper(), wrapper.isJspWildCard(),
                    wrapper.isResourceOnly());
        }
    }
    
    protected void addWrapper(ContextVersion context, String path,
            Wrapper wrapper, boolean jspWildCard, boolean resourceOnly) {

        synchronized (context) {
            //如果是以/*结尾
            if (path.endsWith("/*")) {
                // Wildcard wrapper
                //如/user/*，截取之后就是/user
                String name = path.substring(0, path.length() - 2);
                //包装成MappedWrapper
                MappedWrapper newWrapper = new MappedWrapper(name, wrapper,
                        jspWildCard, resourceOnly);
                MappedWrapper[] oldWrappers = context.wildcardWrappers;
                MappedWrapper[] newWrappers = new MappedWrapper[oldWrappers.length + 1];
                //像注册host一样从小到大注册（以name进行排序）
                if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                    context.wildcardWrappers = newWrappers;
                    //计算wrapper的/个数
                    int slashCount = slashCount(newWrapper.name);
                    //给context保存最长路径的/个数（嵌套层数最多的那个）
                    if (slashCount > context.nesting) {
                        context.nesting = slashCount;
                    }
                }
                //后缀
            } else if (path.startsWith("*.")) {
                // Extension wrapper
                //获取后缀
                String name = path.substring(2);
                MappedWrapper newWrapper = new MappedWrapper(name, wrapper,
                        jspWildCard, resourceOnly);
                MappedWrapper[] oldWrappers = context.extensionWrappers;
                MappedWrapper[] newWrappers =
                    new MappedWrapper[oldWrappers.length + 1];
                if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                    context.extensionWrappers = newWrappers;
                }
                //默认wrapper
            } else if (path.equals("/")) {
                // Default wrapper
                MappedWrapper newWrapper = new MappedWrapper("", wrapper,
                        jspWildCard, resourceOnly);
                context.defaultWrapper = newWrapper;
            } else {
                // Exact wrapper
                //精确匹配wrapper
                final String name;
                if (path.length() == 0) {
                    // Special case for the Context Root mapping which is
                    // treated as an exact match
                    name = "/";
                } else {
                    name = path;
                }
                MappedWrapper newWrapper = new MappedWrapper(name, wrapper,
                        jspWildCard, resourceOnly);
                MappedWrapper[] oldWrappers = context.exactWrappers;
                MappedWrapper[] newWrappers = new MappedWrapper[oldWrappers.length + 1];
                //操作方式与host，context一样，以name进行从小到大排序
                if (insertMap(oldWrappers, newWrappers, newWrapper)) {
                    context.exactWrappers = newWrappers;
                }
            }
        }
    }

    

以下为Mapper的类图