Tomcat 源码分析（五）

最新推荐文章于 2021-11-19 15:14:16 发布
最新推荐文章于 2021-11-19 15:14:16 发布
阅读量269 收藏
点赞数
分类专栏： tomcat 文章标签： tomcat 部署项目源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wf3155/article/details/85239594
版权

tomcat 中各个组件启动过程中会对web应用进行部署从而提供访问，本文分析web应用的部署方式。

tomcat 部署 Web 应用的方式

  1. 项目直接放入 webapps 目录中:将编译好的Web项目（注意是要编译好的），放入到 tomcat 的 webapps 目录下面，可以是一个 war 包，也可以是一个文件夹；
  2. 在 conf/server.xml 文件中配置 context:
     <Host appBase="webapps" autoDeploy="true" name="localhost" unpackWARs="true">
    <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" pattern="%h %l %u %t &quot;%r&quot; %s %b" prefix="localhost_access_log" suffix=".txt"/>
  	<Context docBase="Example" path="/Example" reloadable="true" source="org.eclipse.jst.jee.server:Example"/>
 </Host>
  3. 增加自定义 web 部署文件: 在 $CATALINA_HOME/conf/Catalina/localhost 目录下添加一个 xml 文件，文件名字就是访问路径。

部署方式的对比

第一种方法日常用的比较多，也可以用 context 描述文件对 context 进行定制，但无法覆盖 path 和 docBase 两个属性，所以此种部署方式无法自定义Web应用的的部署目录。
第二种方法直接在 server.xml 文件中配置，但是 server.xml 文件作为 tomcat 启动的主要配置文件，一旦 tomcat 启动后，便不会再读取这个文件，因此无法在 tomcat 服务启动后发布 web 项目，灵活性稍差，但可配置性最强。
第三种方法灵活性强，每个项目分开配置，tomcat 将以conf/Catalina/localhost目录下的 xml 文件的文件名作为 web 应用的上下文路径。

HostConfig 部署应用

HostConfig 是在创建 Host 实例时默认添加到 Host 实例中的生命周期监听器，在 HostConfig 的生命周期方法中根据生命周期的事件类型，执行对应的方法，代码如下所示：

public void lifecycleEvent(LifecycleEvent event) {

        // Identify the host we are associated with
        try {
            host = (Host) event.getLifecycle();
            if (host instanceof StandardHost) {
                setCopyXML(((StandardHost) host).isCopyXML());
                setDeployXML(((StandardHost) host).isDeployXML());
                setUnpackWARs(((StandardHost) host).isUnpackWARs());
                setContextClass(((StandardHost) host).getContextClass());
            }
        } catch (ClassCastException e) {
            log.error(sm.getString("hostConfig.cce", event.getLifecycle()), e);
            return;
        }

        // Process the event that has occurred
        if (event.getType().equals(Lifecycle.PERIODIC_EVENT)) {
            check();
        } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
            beforeStart();
        } else if (event.getType().equals(Lifecycle.START_EVENT)) {
            start();
        } else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
            stop();
        }
    }

重点看启动 (start) 方法：

public void start() {

        if (log.isDebugEnabled())
            log.debug(sm.getString("hostConfig.start"));

        try {
            ObjectName hostON = host.getObjectName();
            oname = new ObjectName
                (hostON.getDomain() + ":type=Deployer,host=" + host.getName());
            Registry.getRegistry(null, null).registerComponent
                (this, oname, this.getClass().getName());
        } catch (Exception e) {
            log.error(sm.getString("hostConfig.jmx.register", oname), e);
        }

        if (!host.getAppBaseFile().isDirectory()) {
            log.error(sm.getString("hostConfig.appBase", host.getName(),
                    host.getAppBaseFile().getPath()));
            host.setDeployOnStartup(false);
            host.setAutoDeploy(false);
        }

        if (host.getDeployOnStartup())
            deployApps();

    }

start 方法首先注册一个 jmx 的 Mbean ，之后根据getDeployOnStartup的返回结果决定是否部署项目。
deployApps() 方法:

protected void deployApps() {

        File appBase = host.getAppBaseFile();
        File configBase = host.getConfigBaseFile();
        String[] filteredAppPaths = filterAppPaths(appBase.list());
        // Deploy XML descriptors from configBase
        deployDescriptors(configBase, configBase.list());
        // Deploy WARs
        deployWARs(appBase, filteredAppPaths);
        // Deploy expanded folders
        deployDirectories(appBase, filteredAppPaths);

    }

appBase 文件是 Host 标签中的 appBase 属性的值，即指 webapps 目录，configBase 指向的是 $CATALINA_HOME/conf/Catalina/localhost 目录。

  1. deployDescriptors()方法对应的是上文描述到的第三种部署方式，即在$CATALINA_HOME/conf/Catalina/localhost目录下放置xml文件，Context描述文件部署。
  2. deployWARs()方法对应前面提到的第一种部署方式，在webapps目录下放置war包。
  3. deployDirectories()方法也是对应第一种部署方式，同deployWARs方法相差不多，可以理解为把war包解压放入webapp文件夹下。
    至于提到的第二种部署方式，在server.xml中配置Context标签的方式，前面提到过，是在server.xml文件的解析过程中进行的。

getConfigBaseFile 方法

	public File getConfigBaseFile() {
        if (hostConfigBase != null) {
            return hostConfigBase;
        }
        String path = null;
        if (getXmlBase()!=null) {
            path = getXmlBase();
        } else {
            StringBuilder xmlDir = new StringBuilder("conf");
            Container parent = getParent();
            if (parent instanceof Engine) {
                xmlDir.append('/');
                xmlDir.append(parent.getName());
            }
            xmlDir.append('/');
            xmlDir.append(getName());
            path = xmlDir.toString();
        }
        File file = new File(path);
        if (!file.isAbsolute())
            file = new File(getCatalinaBase(), path);
        try {
            file = file.getCanonicalFile();
        } catch (IOException e) {// ignore
        }
        this.hostConfigBase = file;
        return file;
    }

这个方法是获取Context描述文件所在位置，默认由xmlBase属性决定，否则就通过$CATALINA_HOME/conf/<Engine名称>/<Host名称>方式拼接路径。

deployDescriptors方法

protected void deployDescriptors(File configBase, String[] files) {

        if (files == null)
            return;

        ExecutorService es = host.getStartStopExecutor();
        List<Future<?>> results = new ArrayList<>();

        for (int i = 0; i < files.length; i++) {
            File contextXml = new File(configBase, files[i]);

            if (files[i].toLowerCase(Locale.ENGLISH).endsWith(".xml")) {
                ContextName cn = new ContextName(files[i], true);

                if (isServiced(cn.getName()) || deploymentExists(cn.getName()))
                    continue;

                results.add(
                        es.submit(new DeployDescriptor(this, cn, contextXml)));
            }
        }

        for (Future<?> result : results) {
            try {
                result.get();
            } catch (Exception e) {
                log.error(sm.getString(
                        "hostConfig.deployDescriptor.threaded.error"), e);
            }
        }
    }

在这个方法中，先从$CATALINA_HOME/conf/<Engine名称>/<Host名称>目录下获取所有的配置文件，接着通过线程池解析xml文件并部署项目。
线程池都是通过 deployDescriptor 方法对每个 xml 文件进行解析，部署。
该方法执行步骤如下：

  1. 使用 Digester 组件解析 Context 描述文件，创建 Context 实例；
  2. 为 Context 实例添加 ContextConfig 生命周期监听器；
  3. 更新 Context 的名称和路径等；
  4. 将 Context 描述文件、Web 应用目录及 web.xml 添加到守护资源，以便文件发生变更时（判断依据是修改时间），重新加载 Web 应用；
  5. 通过 Host 的 addChild 方法将 Context 实例添加到 Host 中。

具体代码如下，关键地方已添加注释：

protected void deployDescriptor(ContextName cn, File contextXml) {

        DeployedApplication deployedApp =
                new DeployedApplication(cn.getName(), true);

        long startTime = 0;
        // Assume this is a configuration descriptor and deploy it
        if(log.isInfoEnabled()) {
           startTime = System.currentTimeMillis();
           log.info(sm.getString("hostConfig.deployDescriptor",
                    contextXml.getAbsolutePath()));
        }

        Context context = null;
        boolean isExternalWar = false;
        boolean isExternal = false;
        File expandedDocBase = null;

        try (FileInputStream fis = new FileInputStream(contextXml)) {
        // 使用 Digester 解析 Context 描述文件，创建 Context 实例
            synchronized (digesterLock) {
                try {
                    context = (Context) digester.parse(fis);
                } catch (Exception e) {
                    log.error(sm.getString(
                            "hostConfig.deployDescriptor.error",
                            contextXml.getAbsolutePath()), e);
                } finally {
                    digester.reset();
                    if (context == null) {
                        context = new FailedContext();
                    }
                }
            }

            if (context.getPath() != null) {
                log.warn(sm.getString("hostConfig.deployDescriptor.path", context.getPath(),
                        contextXml.getAbsolutePath()));
            }

			// 为 Context 实例添加 ContextConfig 生命周期监听器
            Class<?> clazz = Class.forName(host.getConfigClass());
            LifecycleListener listener = (LifecycleListener) clazz.getConstructor().newInstance();
            context.addLifecycleListener(listener);

			// 更新 Context 的名称和路径等
            context.setConfigFile(contextXml.toURI().toURL());
            context.setName(cn.getName());
            context.setPath(cn.getPath());
            context.setWebappVersion(cn.getVersion());
            // Add the associated docBase to the redeployed list if it's a WAR
            if (context.getDocBase() != null) {
                File docBase = new File(context.getDocBase());
                if (!docBase.isAbsolute()) {
                    docBase = new File(host.getAppBaseFile(), context.getDocBase());
                }
                // If external docBase, register .xml as redeploy first
                if (!docBase.getCanonicalPath().startsWith(
                        host.getAppBaseFile().getAbsolutePath() + File.separator)) {
                    isExternal = true;
                    // 将 Context 描述文件、Web 应用目录及 web.xml 添加到守护资源
                    deployedApp.redeployResources.put(
                            contextXml.getAbsolutePath(),
                            Long.valueOf(contextXml.lastModified()));
                    deployedApp.redeployResources.put(docBase.getAbsolutePath(),
                            Long.valueOf(docBase.lastModified()));
                    if (docBase.getAbsolutePath().toLowerCase(Locale.ENGLISH).endsWith(".war")) {
                        isExternalWar = true;
                    }
                    // Check that a WAR or DIR in the appBase is not 'hidden'
                    File war = new File(host.getAppBaseFile(), cn.getBaseName() + ".war");
                    if (war.exists()) {
                        log.warn(sm.getString("hostConfig.deployDescriptor.hiddenWar",
                                contextXml.getAbsolutePath(), war.getAbsolutePath()));
                    }
                    File dir = new File(host.getAppBaseFile(), cn.getBaseName());
                    if (dir.exists()) {
                        log.warn(sm.getString("hostConfig.deployDescriptor.hiddenDir",
                                contextXml.getAbsolutePath(), dir.getAbsolutePath()));
                    }
                } else {
                    log.warn(sm.getString("hostConfig.deployDescriptor.localDocBaseSpecified",
                             docBase));
                    // Ignore specified docBase
                    context.setDocBase(null);
                }
            }

			// 通过 Host 的addChild方法将Context实例添加到Host中
            host.addChild(context);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("hostConfig.deployDescriptor.error",
                                   contextXml.getAbsolutePath()), t);
        } finally {
            // Get paths for WAR and expanded WAR in appBase

            // default to appBase dir + name
            expandedDocBase = new File(host.getAppBaseFile(), cn.getBaseName());
            if (context.getDocBase() != null
                    && !context.getDocBase().toLowerCase(Locale.ENGLISH).endsWith(".war")) {
                // first assume docBase is absolute
                expandedDocBase = new File(context.getDocBase());
                if (!expandedDocBase.isAbsolute()) {
                    // if docBase specified and relative, it must be relative to appBase
                    expandedDocBase = new File(host.getAppBaseFile(), context.getDocBase());
                }
            }

            boolean unpackWAR = unpackWARs;
            if (unpackWAR && context instanceof StandardContext) {
                unpackWAR = ((StandardContext) context).getUnpackWAR();
            }

            // Add the eventual unpacked WAR and all the resources which will be
            // watched inside it
            if (isExternalWar) {
                if (unpackWAR) {
                    deployedApp.redeployResources.put(expandedDocBase.getAbsolutePath(),
                            Long.valueOf(expandedDocBase.lastModified()));
                    addWatchedResources(deployedApp, expandedDocBase.getAbsolutePath(), context);
                } else {
                    addWatchedResources(deployedApp, null, context);
                }
            } else {
                // Find an existing matching war and expanded folder
                if (!isExternal) {
                    File warDocBase = new File(expandedDocBase.getAbsolutePath() + ".war");
                    if (warDocBase.exists()) {
                        deployedApp.redeployResources.put(warDocBase.getAbsolutePath(),
                                Long.valueOf(warDocBase.lastModified()));
                    } else {
                        // Trigger a redeploy if a WAR is added
                        deployedApp.redeployResources.put(
                                warDocBase.getAbsolutePath(),
                                Long.valueOf(0));
                    }
                }
                if (unpackWAR) {
                    deployedApp.redeployResources.put(expandedDocBase.getAbsolutePath(),
                            Long.valueOf(expandedDocBase.lastModified()));
                    addWatchedResources(deployedApp,
                            expandedDocBase.getAbsolutePath(), context);
                } else {
                    addWatchedResources(deployedApp, null, context);
                }
                if (!isExternal) {
                    // For external docBases, the context.xml will have been
                    // added above.
                    deployedApp.redeployResources.put(
                            contextXml.getAbsolutePath(),
                            Long.valueOf(contextXml.lastModified()));
                }
            }
            // Add the global redeploy resources (which are never deleted) at
            // the end so they don't interfere with the deletion process
            addGlobalRedeployResources(deployedApp);
        }

        if (host.findChild(context.getName()) != null) {
            deployed.put(context.getName(), deployedApp);
        }

        if (log.isInfoEnabled()) {
            log.info(sm.getString("hostConfig.deployDescriptor.finished",
                contextXml.getAbsolutePath(), Long.valueOf(System.currentTimeMillis() - startTime)));
        }
    }

deployDirectories 方法

deployDirectories 方法是以文件夹的形式发布并部署Web应用的调用方法，在该方法中将每一个符合条件的文件夹交由线程池去解析处理
代码如下：

protected void deployDirectories(File appBase, String[] files) {

        if (files == null)
            return;

        ExecutorService es = host.getStartStopExecutor();
        List<Future<?>> results = new ArrayList<>();

        for (int i = 0; i < files.length; i++) {

            if (files[i].equalsIgnoreCase("META-INF"))
                continue;
            if (files[i].equalsIgnoreCase("WEB-INF"))
                continue;
            File dir = new File(appBase, files[i]);
            if (dir.isDirectory()) {
                ContextName cn = new ContextName(files[i], false);

                if (isServiced(cn.getName()) || deploymentExists(cn.getName()))
                    continue;

                results.add(es.submit(new DeployDirectory(this, cn, dir)));
            }
        }

        for (Future<?> result : results) {
            try {
                result.get();
            } catch (Exception e) {
                log.error(sm.getString(
                        "hostConfig.deployDir.threaded.error"), e);
            }
        }
    }

每一个符合条件的文件夹都是通过 deployDirectory 方法处理的

protected void deployDirectory(ContextName cn, File dir) {


        long startTime = 0;
        // Deploy the application in this directory
        if( log.isInfoEnabled() ) {
            startTime = System.currentTimeMillis();
            log.info(sm.getString("hostConfig.deployDir",
                    dir.getAbsolutePath()));
        }

        Context context = null;
        File xml = new File(dir, Constants.ApplicationContextXml);
        File xmlCopy =
                new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml");


        DeployedApplication deployedApp;
        boolean copyThisXml = isCopyXML();
        boolean deployThisXML = isDeployThisXML(dir, cn);

        try {
        	// 如果Host的deployXML属性值为true（即通过Context描述文件部署），并且存在META-INF/context.xml文件，则使用Digester解析context.xml创建context实例
            if (deployThisXML && xml.exists()) {
                synchronized (digesterLock) {
                    try {
                        context = (Context) digester.parse(xml);
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "hostConfig.deployDescriptor.error",
                                xml), e);
                        context = new FailedContext();
                    } finally {
                        digester.reset();
                        if (context == null) {
                            context = new FailedContext();
                        }
                    }
                }

                if (copyThisXml == false && context instanceof StandardContext) {
                    // Host is using default value. Context may override it.
                    copyThisXml = ((StandardContext) context).getCopyXML();
                }

                if (copyThisXml) {
                // 如果Context的copyXML属性为true，则将描述文件复制到$CATALINA_HOME/conf/<Engine名称>/<Host名称>目录下，文件名与Web应用目录名相同
                    Files.copy(xml.toPath(), xmlCopy.toPath());
                    context.setConfigFile(xmlCopy.toURI().toURL());
                } else {
                    context.setConfigFile(xml.toURI().toURL());
                }
            } else if (!deployThisXML && xml.exists()) {
                // Block deployment as META-INF/context.xml may contain security
                // configuration necessary for a secure deployment.
               
               // 如果deployXML属性为false，但是存在META-INF/context.xml文件，则构造FailedContext（Container的空模式，用于表示Context部署失败）
                log.error(sm.getString("hostConfig.deployDescriptor.blocked",
                        cn.getPath(), xml, xmlCopy));
                context = new FailedContext();
            } else {
                context = (Context) Class.forName(contextClass).getConstructor().newInstance();
            }

			// 为Context添加生命周期监听器ContextConfig
            Class<?> clazz = Class.forName(host.getConfigClass());
            LifecycleListener listener = (LifecycleListener) clazz.getConstructor().newInstance();
            context.addLifecycleListener(listener);

			// 设置 name,path 等属性
            context.setName(cn.getName());
            context.setPath(cn.getPath());
            context.setWebappVersion(cn.getVersion());
            context.setDocBase(cn.getBaseName());
            // 通过Host的addChild方法将Context实例添加到Host中
            host.addChild(context);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("hostConfig.deployDir.error",
                    dir.getAbsolutePath()), t);
        } finally {
            deployedApp = new DeployedApplication(cn.getName(),
                    xml.exists() && deployThisXML && copyThisXml);

            // Fake re-deploy resource to detect if a WAR is added at a later
            // point
            // 将Context描述文件、Web应用目录及web.xml添加到守护资源，以便文件发生变更时（判断依据是修改时间），重新部署或者加载Web应用
            deployedApp.redeployResources.put(dir.getAbsolutePath() + ".war",
                    Long.valueOf(0));
            deployedApp.redeployResources.put(dir.getAbsolutePath(),
                    Long.valueOf(dir.lastModified()));
            if (deployThisXML && xml.exists()) {
                if (copyThisXml) {
                    deployedApp.redeployResources.put(
                            xmlCopy.getAbsolutePath(),
                            Long.valueOf(xmlCopy.lastModified()));
                } else {
                    deployedApp.redeployResources.put(
                            xml.getAbsolutePath(),
                            Long.valueOf(xml.lastModified()));
                    // Fake re-deploy resource to detect if a context.xml file is
                    // added at a later point
                    deployedApp.redeployResources.put(
                            xmlCopy.getAbsolutePath(),
                            Long.valueOf(0));
                }
            } else {
                // Fake re-deploy resource to detect if a context.xml file is
                // added at a later point
                deployedApp.redeployResources.put(
                        xmlCopy.getAbsolutePath(),
                        Long.valueOf(0));
                if (!xml.exists()) {
                    deployedApp.redeployResources.put(
                            xml.getAbsolutePath(),
                            Long.valueOf(0));
                }
            }
            addWatchedResources(deployedApp, dir.getAbsolutePath(), context);
            // Add the global redeploy resources (which are never deleted) at
            // the end so they don't interfere with the deletion process
            addGlobalRedeployResources(deployedApp);
        }

        deployed.put(cn.getName(), deployedApp);

        if( log.isInfoEnabled() ) {
            log.info(sm.getString("hostConfig.deployDir.finished",
                    dir.getAbsolutePath(), Long.valueOf(System.currentTimeMillis() - startTime)));
        }
    }

deployWARs 方法

对于 Host 的 appBase 目录（默认是$CATALINA_BASE/webapps）下所有符合条件的WAR包（不符合 deployIgnore 的过滤规则、目录名不为 META-INF 和 WEB-INF 且以 war 作为扩展名的文件），通过线程池完成部署

protected void deployWARs(File appBase, String[] files) {

        if (files == null)
            return;

        ExecutorService es = host.getStartStopExecutor();
        List<Future<?>> results = new ArrayList<>();

        for (int i = 0; i < files.length; i++) {

            if (files[i].equalsIgnoreCase("META-INF"))
                continue;
            if (files[i].equalsIgnoreCase("WEB-INF"))
                continue;
            File war = new File(appBase, files[i]);
            if (files[i].toLowerCase(Locale.ENGLISH).endsWith(".war") &&
                    war.isFile() && !invalidWars.contains(files[i]) ) {

                ContextName cn = new ContextName(files[i], true);

                if (isServiced(cn.getName())) {
                    continue;
                }
                if (deploymentExists(cn.getName())) {
                    DeployedApplication app = deployed.get(cn.getName());
                    boolean unpackWAR = unpackWARs;
                    if (unpackWAR && host.findChild(cn.getName()) instanceof StandardContext) {
                        unpackWAR = ((StandardContext) host.findChild(cn.getName())).getUnpackWAR();
                    }
                    if (!unpackWAR && app != null) {
                        // Need to check for a directory that should not be
                        // there
                        File dir = new File(appBase, cn.getBaseName());
                        if (dir.exists()) {
                            if (!app.loggedDirWarning) {
                                log.warn(sm.getString(
                                        "hostConfig.deployWar.hiddenDir",
                                        dir.getAbsoluteFile(),
                                        war.getAbsoluteFile()));
                                app.loggedDirWarning = true;
                            }
                        } else {
                            app.loggedDirWarning = false;
                        }
                    }
                    continue;
                }

                // Check for WARs with /../ /./ or similar sequences in the name
                if (!validateContextPath(appBase, cn.getBaseName())) {
                    log.error(sm.getString(
                            "hostConfig.illegalWarName", files[i]));
                    invalidWars.add(files[i]);
                    continue;
                }

                results.add(es.submit(new DeployWar(this, cn, war)));
            }
        }

        for (Future<?> result : results) {
            try {
                result.get();
            } catch (Exception e) {
                log.error(sm.getString(
                        "hostConfig.deployWar.threaded.error"), e);
            }
        }
    }

对于每一个符合条件的 war 包都通过 deployWAR 方法进行部署。
该方法执行步骤如下：

  1. 根据相关属性选择描述文件创建Context实例；
  2. 根据deployXML属性，将context.xml文件复制到$CATALINA-BASE/conf/<Engine名称>/<Host名称>目录下，文件名同WAR包名称
  3. 将Context描述文件、WAR包及web.xml添加到守护资源，以便文件发生变更时（判断依据是修改时间），重新加载Web应用
  4. 为Context实例添加ContextConfig生命周期监听器
  5. 更新Context的名称和路径等
  6. 通过Host的addChild方法将Context实例添加到Host中
protected void deployWAR(ContextName cn, File war) {

        File xml = new File(host.getAppBaseFile(),
                cn.getBaseName() + "/" + Constants.ApplicationContextXml);

        File warTracker = new File(host.getAppBaseFile(), cn.getBaseName() + Constants.WarTracker);

        boolean xmlInWar = false;
        try (JarFile jar = new JarFile(war)) {
            JarEntry entry = jar.getJarEntry(Constants.ApplicationContextXml);
            if (entry != null) {
                xmlInWar = true;
            }
        } catch (IOException e) {
            /* Ignore */
        }

        // If there is an expanded directory then any xml in that directory
        // should only be used if the directory is not out of date and
        // unpackWARs is true. Note the code below may apply further limits
        boolean useXml = false;
        // If the xml file exists then expandedDir must exists so no need to
        // test that here
        if (xml.exists() && unpackWARs &&
                (!warTracker.exists() || warTracker.lastModified() == war.lastModified())) {
            useXml = true;
        }

        Context context = null;
        boolean deployThisXML = isDeployThisXML(war, cn);

        try {
        // 根据相关属性选择描述文件创建Context实例
        // 如果Host的deployXML属性为true，且在WAR包同名目录下（就是去除了.war的目录下）存在META-INF/context.xml文件，同时Context的copyXML属性为false，则使用该描述文件创建Context实例
            if (deployThisXML && useXml && !copyXML) {
                synchronized (digesterLock) {
                    try {
                        context = (Context) digester.parse(xml);
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "hostConfig.deployDescriptor.error",
                                war.getAbsolutePath()), e);
                    } finally {
                        digester.reset();
                        if (context == null) {
                            context = new FailedContext();
                        }
                    }
                }
                context.setConfigFile(xml.toURI().toURL());
            } else if (deployThisXML && xmlInWar) {
            // 如果Host的deployXML属性为true且在WAR包压缩文件中存在META-INF/context.xml文件，就用该描述文件创建Context实例
                synchronized (digesterLock) {
                    try (JarFile jar = new JarFile(war)) {
                        JarEntry entry = jar.getJarEntry(Constants.ApplicationContextXml);
                        try (InputStream istream = jar.getInputStream(entry)) {
                            context = (Context) digester.parse(istream);
                        }
                    } catch (Exception e) {
                        log.error(sm.getString(
                                "hostConfig.deployDescriptor.error",
                                war.getAbsolutePath()), e);
                    } finally {
                        digester.reset();
                        if (context == null) {
                            context = new FailedContext();
                        }
                        context.setConfigFile(
                                UriUtil.buildJarUrl(war, Constants.ApplicationContextXml));
                    }
                }
            } else if (!deployThisXML && xmlInWar) {
                // Block deployment as META-INF/context.xml may contain security
                // configuration necessary for a secure deployment.
                
				// 如果Host的deployXML属性为false，且在WAR包下存在META-INF/context.xml文件，则记录错误日志，并在后续构建部署失败FailedContext对象                
				log.error(sm.getString("hostConfig.deployDescriptor.blocked",
                        cn.getPath(), Constants.ApplicationContextXml,
                        new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml")));
            } else {
                context = (Context) Class.forName(contextClass).getConstructor().newInstance();
            }
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("hostConfig.deployWar.error",
                    war.getAbsolutePath()), t);
        } finally {
            if (context == null) {
                context = new FailedContext();
            }
        }

        boolean copyThisXml = false;
        if (deployThisXML) {
        // 复制 context.xml 文件
            if (host instanceof StandardHost) {
                copyThisXml = ((StandardHost) host).isCopyXML();
            }

            // If Host is using default value Context can override it.
            if (!copyThisXml && context instanceof StandardContext) {
                copyThisXml = ((StandardContext) context).getCopyXML();
            }

            if (xmlInWar && copyThisXml) {
                // Change location of XML file to config base
                xml = new File(host.getConfigBaseFile(),
                        cn.getBaseName() + ".xml");
                try (JarFile jar = new JarFile(war)) {
                    JarEntry entry = jar.getJarEntry(Constants.ApplicationContextXml);
                    try (InputStream istream = jar.getInputStream(entry);
                            FileOutputStream fos = new FileOutputStream(xml);
                            BufferedOutputStream ostream = new BufferedOutputStream(fos, 1024)) {
                        byte buffer[] = new byte[1024];
                        while (true) {
                            int n = istream.read(buffer);
                            if (n < 0) {
                                break;
                            }
                            ostream.write(buffer, 0, n);
                        }
                        ostream.flush();
                    }
                } catch (IOException e) {
                    /* Ignore */
                }
            }
        }

        DeployedApplication deployedApp = new DeployedApplication(cn.getName(),
                xml.exists() && deployThisXML && copyThisXml);

        long startTime = 0;
        // Deploy the application in this WAR file
        if(log.isInfoEnabled()) {
            startTime = System.currentTimeMillis();
            log.info(sm.getString("hostConfig.deployWar",
                    war.getAbsolutePath()));
        }

        try {
        	// 将Context描述文件、WAR包及web.xml添加到守护资源，以便文件发生变更时（判断依据是修改时间），重新部署或者加载Web应用
            // Populate redeploy resources with the WAR file
            deployedApp.redeployResources.put
                (war.getAbsolutePath(), Long.valueOf(war.lastModified()));

            if (deployThisXML && xml.exists() && copyThisXml) {
                deployedApp.redeployResources.put(xml.getAbsolutePath(),
                        Long.valueOf(xml.lastModified()));
            } else {
                // In case an XML file is added to the config base later
                deployedApp.redeployResources.put(
                        (new File(host.getConfigBaseFile(),
                                cn.getBaseName() + ".xml")).getAbsolutePath(),
                        Long.valueOf(0));
            }

			// 为Context实例添加ContextConfig生命周期监听器
            Class<?> clazz = Class.forName(host.getConfigClass());
            LifecycleListener listener = (LifecycleListener) clazz.getConstructor().newInstance();
            context.addLifecycleListener(listener);
			// 更新Context的名称和路径等，其名字和路径是解析WAR包的名字所来，name、path、webappVersion、docBase这4个属性无法覆盖
            context.setName(cn.getName());
            context.setPath(cn.getPath());
            context.setWebappVersion(cn.getVersion());
            context.setDocBase(cn.getBaseName() + ".war");
            // 通过Host的addChild方法将Context实例添加到Host中
            host.addChild(context);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("hostConfig.deployWar.error",
                    war.getAbsolutePath()), t);
        } finally {
            // If we're unpacking WARs, the docBase will be mutated after
            // starting the context
            boolean unpackWAR = unpackWARs;
            if (unpackWAR && context instanceof StandardContext) {
                unpackWAR = ((StandardContext) context).getUnpackWAR();
            }
            if (unpackWAR && context.getDocBase() != null) {
                File docBase = new File(host.getAppBaseFile(), cn.getBaseName());
                deployedApp.redeployResources.put(docBase.getAbsolutePath(),
                        Long.valueOf(docBase.lastModified()));
                addWatchedResources(deployedApp, docBase.getAbsolutePath(),
                        context);
                if (deployThisXML && !copyThisXml && (xmlInWar || xml.exists())) {
                    deployedApp.redeployResources.put(xml.getAbsolutePath(),
                            Long.valueOf(xml.lastModified()));
                }
            } else {
                // Passing null for docBase means that no resources will be
                // watched. This will be logged at debug level.
                addWatchedResources(deployedApp, null, context);
            }
            // Add the global redeploy resources (which are never deleted) at
            // the end so they don't interfere with the deletion process
            addGlobalRedeployResources(deployedApp);
        }

        deployed.put(cn.getName(), deployedApp);

        if (log.isInfoEnabled()) {
            log.info(sm.getString("hostConfig.deployWar.finished",
                war.getAbsolutePath(), Long.valueOf(System.currentTimeMillis() - startTime)));
        }
    }

StandardContext 的启动

从前文的分析中可知，HostConfig根据对应项目的实际配置情况创建Context对象，具体初始化和启动工作由组件Context对象自身完成，接下来重点关注StandardContext的启动方法。

StandardContext的启动方法start继承自LifecycleBase，通过覆写startInternal方法来实现自身的启动逻辑。

下面具体分析 startInternal 方法

startInternal 方法

该方法是StandardContext启动的主要方法，主要有一下几步：

  1. 发布正在启动的JMX通知，这样可以通过NotificationListener来监听Web应用的启动；
  2. 启动JNDI资源；
  3. 初始化临时工作目录，命名为变量 workDir，若该目录未设置则默认以$CATALINA-BASE/work/<Engine名称>/<Host名称>/<Context名称>的形式拼接；
  4. 初始化当前Context使用的WebResouceRoot并启动。WebResouceRoot维护了Web应用所以的资源集合（Class文件、Jar包以及其他资源文件），主要用于类加载器和按照路径查找资源文件
  5. 创建Web应用类加载器webappLoader，webappLoader继承自LifecycleMBeanBase，在其启动后会去创建Web应用类加载器(ParallelWebappClassLoader)‘
  6. 如果没有设置Cookie处理器，默认为Rfc6265CookieProcessor
  7. 设置字符集映射，用于根据Locale获取字符集编码
  8. web应用的依赖检测
  9. NamingContextListener注册
  10. 启动Web应用类加载器，此时真正创建出ParallelWebappClassLoader实例
  11. 启动安全组件
  12. 发布CONFIGURE_START_EVENT事件，ContextConfig监听该事件以完成Servlet的创建
  13. 启动Context子节点Wrapper
  14. 启动Context的pipeline
  15. 创建会话管理器
  16. 将Context的Web资源集合添加到ServletContext
  17. 创建实例管理器instanceManager，用于创建对象实例，如Servlet、Filter等
  18. 将Jar包扫描器添加到ServletContext
  19. 合并参数
  20. 启动添加到Context的ServletContainerInitializer
  21. 实例化应用类监听器ApplicationListener
  22. 启动会话管理器
  23. 实例化FilterConfig、Filter并调用Filter.init()
  24. 对于loadOnStartup大于等于0的Wrapper，调用Wrapper.load()，该方法负责实例化Servlet，并调用Servlet.init()进行初始化
  25. 启动后台定时处理程序，只有backgroundProcessorDelay>0才启动，用于监控守护文件的变更
  26. 发布正在运行的JMX通知。
  27. 释放资源，如关闭jar文件
  28. 设置Context状态
protected synchronized void startInternal() throws LifecycleException {

        if(log.isDebugEnabled())
            log.debug("Starting " + getBaseName());

        // 发布正在启动的JMX通知
        if (this.getObjectName() != null) {
            Notification notification = new Notification("j2ee.state.starting",
                    this.getObjectName(), sequenceNumber.getAndIncrement());
            broadcaster.sendNotification(notification);
        }

        setConfigured(false);
        boolean ok = true;

        // 启动JNDI资源
        if (namingResources != null) {
            namingResources.start();
        }

        // 初始化临时工作目录
        postWorkDirectory();

        // Add missing components as necessary
        if (getResources() == null) {   // (1) Required by Loader
            if (log.isDebugEnabled())
                log.debug("Configuring default Resources");

            try {
                setResources(new StandardRoot(this));
            } catch (IllegalArgumentException e) {
                log.error(sm.getString("standardContext.resourcesInit"), e);
                ok = false;
            }
        }
        // 初始化当前Context使用的WebResouceRoot并启动
        if (ok) {
            resourcesStart();
        }

        // 创建Web应用类加载器
		if (getLoader() == null) {
            WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
            webappLoader.setDelegate(getDelegate());
            setLoader(webappLoader);
        }

        // 创建默认的cookie处理器
        if (cookieProcessor == null) {
            cookieProcessor = new Rfc6265CookieProcessor();
        }

        // 获取字符集映射
        getCharsetMapper();

        // 检测 web 应用的依赖
        boolean dependencyCheck = true;
        try {
            dependencyCheck = ExtensionValidator.validateApplication
                (getResources(), this);
        } catch (IOException ioe) {
            log.error(sm.getString("standardContext.extensionValidationError"), ioe);
            dependencyCheck = false;
        }

        if (!dependencyCheck) {
            // do not make application available if dependency check fails
            ok = false;
        }

        // Reading the "catalina.useNaming" environment variable
        String useNamingProperty = System.getProperty("catalina.useNaming");
        if ((useNamingProperty != null)
            && (useNamingProperty.equals("false"))) {
            useNaming = false;
        }

		// NamingContextListener注册
        if (ok && isUseNaming()) {
            if (getNamingContextListener() == null) {
                NamingContextListener ncl = new NamingContextListener();
                ncl.setName(getNamingContextName());
                ncl.setExceptionOnFailedWrite(getJndiExceptionOnFailedWrite());
                addLifecycleListener(ncl);
                setNamingContextListener(ncl);
            }
        }

        // Standard container startup
        if (log.isDebugEnabled())
            log.debug("Processing standard container startup");


        // Binding thread
        ClassLoader oldCCL = bindThread();

        try {
            if (ok) {
                // 启动Web应用类加载器
                Loader loader = getLoader();
                if (loader instanceof Lifecycle) {
                    ((Lifecycle) loader).start();
                }

                // since the loader just started, the webapp classloader is now
                // created.
                setClassLoaderProperty("clearReferencesRmiTargets",
                        getClearReferencesRmiTargets());
                setClassLoaderProperty("clearReferencesStopThreads",
                        getClearReferencesStopThreads());
                setClassLoaderProperty("clearReferencesStopTimerThreads",
                        getClearReferencesStopTimerThreads());
                setClassLoaderProperty("clearReferencesHttpClientKeepAliveThread",
                        getClearReferencesHttpClientKeepAliveThread());
                setClassLoaderProperty("clearReferencesObjectStreamClassCaches",
                        getClearReferencesObjectStreamClassCaches());
                setClassLoaderProperty("skipMemoryLeakChecksOnJvmShutdown",
                        getSkipMemoryLeakChecksOnJvmShutdown());

                // By calling unbindThread and bindThread in a row, we setup the
                // current Thread CCL to be the webapp classloader
                unbindThread(oldCCL);
                oldCCL = bindThread();

                // Initialize logger again. Other components might have used it
                // too early, so it should be reset.
                logger = null;
                getLogger();

                // 启动安全组件
                Realm realm = getRealmInternal();
                if(null != realm) {
                    if (realm instanceof Lifecycle) {
                        ((Lifecycle) realm).start();
                    }

                    // Place the CredentialHandler into the ServletContext so
                    // applications can have access to it. Wrap it in a "safe"
                    // handler so application's can't modify it.
                    CredentialHandler safeHandler = new CredentialHandler() {
                        @Override
                        public boolean matches(String inputCredentials, String storedCredentials) {
                            return getRealmInternal().getCredentialHandler().matches(inputCredentials, storedCredentials);
                        }

                        @Override
                        public String mutate(String inputCredentials) {
                            return getRealmInternal().getCredentialHandler().mutate(inputCredentials);
                        }
                    };
                    context.setAttribute(Globals.CREDENTIAL_HANDLER, safeHandler);
                }

                // 发布CONFIGURE_START_EVENT事件，ContextConfig监听该事件以完成Servlet的创建
                fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);

                // 启动Context子节点Wrapper
                for (Container child : findChildren()) {
                    if (!child.getState().isAvailable()) {
                        child.start();
                    }
                }

                // 启动Context的pipeline
                if (pipeline instanceof Lifecycle) {
                    ((Lifecycle) pipeline).start();
                }

                // 创建回话管理器
                Manager contextManager = null;
                Manager manager = getManager();
                if (manager == null) {
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("standardContext.cluster.noManager",
                                Boolean.valueOf((getCluster() != null)),
                                Boolean.valueOf(distributable)));
                    }
                    if ( (getCluster() != null) && distributable) {
                        try {
                            contextManager = getCluster().createManager(getName());
                        } catch (Exception ex) {
                            log.error("standardContext.clusterFail", ex);
                            ok = false;
                        }
                    } else {
                        contextManager = new StandardManager();
                    }
                }

                // Configure default manager if none was specified
                if (contextManager != null) {
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("standardContext.manager",
                                contextManager.getClass().getName()));
                    }
                    setManager(contextManager);
                }

                if (manager!=null && (getCluster() != null) && distributable) {
                    //let the cluster know that there is a context that is distributable
                    //and that it has its own manager
                    getCluster().registerManager(manager);
                }
            }

            if (!getConfigured()) {
                log.error(sm.getString("standardContext.configurationFail"));
                ok = false;
            }

            // 将Web资源集合添加到ServletContext
            if (ok)
                getServletContext().setAttribute
                    (Globals.RESOURCES_ATTR, getResources());

            if (ok ) {
            	// 创建实例管理器instanceManager
                if (getInstanceManager() == null) {
                    javax.naming.Context context = null;
                    if (isUseNaming() && getNamingContextListener() != null) {
                        context = getNamingContextListener().getEnvContext();
                    }
                    Map<String, Map<String, String>> injectionMap = buildInjectionMap(
                            getIgnoreAnnotations() ? new NamingResourcesImpl(): getNamingResources());
                    setInstanceManager(new DefaultInstanceManager(context,
                            injectionMap, this, this.getClass().getClassLoader()));
                }
                getServletContext().setAttribute(
                        InstanceManager.class.getName(), getInstanceManager());
                InstanceManagerBindings.bind(getLoader().getClassLoader(), getInstanceManager());
            }

            // 将Jar包扫描器添加到ServletContext
            if (ok) {
                getServletContext().setAttribute(
                        JarScanner.class.getName(), getJarScanner());
            }

            // 合并初始化参数
            mergeParameters();

            // 启动添加到Context的ServletContainerInitializer
            for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
                initializers.entrySet()) {
                try {
                    entry.getKey().onStartup(entry.getValue(),
                            getServletContext());
                } catch (ServletException e) {
                    log.error(sm.getString("standardContext.sciFail"), e);
                    ok = false;
                    break;
                }
            }

            // 实例化应用类监听器ApplicationListener
            if (ok) {
                if (!listenerStart()) {
                    log.error(sm.getString("standardContext.listenerFail"));
                    ok = false;
                }
            }

            // Check constraints for uncovered HTTP methods
            // Needs to be after SCIs and listeners as they may programmatically
            // change constraints
            if (ok) {
                checkConstraintsForUncoveredMethods(findConstraints());
            }

            try {
                // 启动会话管理器
                Manager manager = getManager();
                if (manager instanceof Lifecycle) {
                    ((Lifecycle) manager).start();
                }
            } catch(Exception e) {
                log.error(sm.getString("standardContext.managerFail"), e);
                ok = false;
            }

            // 实例化过滤器
            if (ok) {
                if (!filterStart()) {
                    log.error(sm.getString("standardContext.filterFail"));
                    ok = false;
                }
            }

            // 实例化 servlet
            if (ok) {
                if (!loadOnStartup(findChildren())){
                    log.error(sm.getString("standardContext.servletFail"));
                    ok = false;
                }
            }

            // 启动后台定时处理程序
            super.threadStart();
        } finally {
            // Unbinding thread
            unbindThread(oldCCL);
        }

        // Set available status depending upon startup success
        if (ok) {
            if (log.isDebugEnabled())
                log.debug("Starting completed");
        } else {
            log.error(sm.getString("standardContext.startFailed", getName()));
        }

        startTime=System.currentTimeMillis();

        // 发布正在运行的JMX通知
        if (ok && (this.getObjectName() != null)) {
            Notification notification =
                new Notification("j2ee.state.running", this.getObjectName(),
                                 sequenceNumber.getAndIncrement());
            broadcaster.sendNotification(notification);
        }

        // 释放资源
        getResources().gc();

        // 设置状态
        if (!ok) {
            setState(LifecycleState.FAILED);
        } else {
            setState(LifecycleState.STARTING);
        }
    }
司马老峰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tomcat源码分析
02-03
总体架构：1、面向组件架构2、基于JMX3、事件侦听tomcat代码看似很庞大，但从结构上看却很清晰和简单，它主要由一堆组件组成，如Server、Service、Connector等，并基于JMX管理这些组件，另外实现以上接口的组件也...
tomcat源码分析图谱
03-22
tomcat的基础脚本分析 tomcat的源码启动分析 tomcat的web应用启动分析 tomcat的socket分析 tomcat的cocket与容器对接时序分析
Tomcat服务器restart和redeploy的区别
krismile__qh的博客
05-04 3997
redeploy是把当前的一个项目重新部署到Tomcat服务器上（一个Web项目） restart是Tomcat服务器的重启，服务器上可以部署很多的项目；restart的一部分效果是：把服务器上部署的所有项目重新部署一次，所以这部分效果的本质就是重新部署所有的Web项目；还有一部分效果是对Tomcat的相关配置文件进行刷新。 所以一般选择重启服务器。 用MyEclipse进行web开发，因为...
Tomcat源码部署
苦行僧
10-24 402
1、下载源码 https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.54/src/apache-tomcat-9.0.54-src.zip 2、解压 3、在解压后的根目录创建目录：catalina-home 4、复制目录到catalina-home中 5、在根目录中创建pom.xml 并写入如下内容： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.
Tomcat源码分析 之 Tomcat如何监测部署应用的改变并进行重新部署
键圣的博客
04-26 715
使用eclipse和tomcat做web应用开发的童鞋都知道，有一个很强大的功能就是--我们的文件改变的时候Tomcat会自动的重新部署应用，给我们的开发调试带来了很大的便利，但是它是怎么实现的呢？我们下面来关注一下原理和Tomcat的处理办法。 我们都知道，我们修改了文件，并且保存了它，这个文件的修改时间就会被改变，当然了我们的应用处理逻辑也可能发生了变化，这时候我们就应该重新发布一下应用，让
tomcat解析(十三)StandardContext
holly2k的专栏
02-02 2687
在一个tomcat服务器的生命周期内可以会创建一个或多个StandardContext对象，StandardContext对象代表的是一个具体的工程项目，对应的可以是server.xml里的标签或webapps文件夹下的某一个工程文件夹或war包，也可以对应于conf/Catalina/localhost文件夹下的任一个xml文件里的Context配置，在tomcat中，这些context代表的是
Springboot 2使用外部Tomcat源码分析
08-25
主要介绍了Springboot 2使用外部Tomcat源码分析，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
tomcat 源码分析系列文档
05-18
tomcat 源码分析系列文档 http深入分析，tomcat中类的加载，tomcat的启动，tomcat的容器思想，
分析Java 死锁以及MemoryLeak问题
Edison Xu
07-25 706
最近一直在解决memorylink问题，觉得有必要记录下这个过程中用到的知识，以免以后忘记。JDK自身提供了很多关于分析java问题的工具，平时主要用到的有：jstatd启动jvm监控服 务。它是一个基于rmi的应用，向远程机器提供本机jvm应用程序的信息。默认端口1099。实例：jstatd -J-Djava.security.policy=my.policymy.policy文件需要自己建立，
tomcat8 源码部署项目，包含依赖所需的jar。
03-01
该部署项目可直接引入IDE,但是由于电脑环境的问题，VersionLoggerListener有可能存在启动乱码。可以通过配置-Dfile.encoding=UTF8 -Duser.language=en -Duser.region=US这样的启动参数解决乱码问题。
Tomcat服务端部署源码
11-14
测试demo: tomcat服务器servlet实现
Tomcat 源码的获取与部署
weixin_33796177的博客
01-26 137
为什么80%的码农都做不了架构师？>>> ...
tomcat源码浅析（四）之web.xml解析
烈冬冰夏的博客
04-01 1764
1.Context在start时先调用bindThread()将Loard的classLoader绑定到线程中，这样Digester在去classLoader时就可以取到Loard的classLoader。 Standardcontext.startinternal代码 protected synchronized void startInternal() throws Li
Tomcat8源码笔记(八)明白Tomcat怎么部署webapps下项目
aar49191的博客
04-14 1297
以前没想过这么个问题：Tomcat怎么处理webapps下项目，并且我访问浏览器ip: port/项目名/请求路径，以SSM为例，Tomcat怎么就能将请求找到项目呢，项目还是个文件夹类型的？ Tomcat部署webapps下项目方法位于：HostConfig#deployApps，别问怎么知道的，看源码，也可以支持看下我前面的博客，虽然介绍粗枝大叶，但是...
tomcat学习|通过tomcat源码启动web项目
微笑的小小刀
08-25 312
开头说两句小刀博客:https://www.lixiang.red小刀公众号: 程序员学习大本营学习背景上一波,我们学习了tomcat 中主要接口的方法及关系:https://www....
Tomcat应用自动重部署与WatchedResources
Tomcat那些事儿
02-14 712
上篇文章介绍了Tomcat中Context的描述文件使用方式。这次我们介绍下Context描述文件中可以配置的并且是默认就已经包含的一个配置，通过它，我们的应用在每次文件更新后才会重新加...
tomcat源码部署
helloword的博客
11-19 558
1. 源码下载 https://tomcat.apache.org/download-80.cgi 我这里下载的是tomcat8； 为其添加catalina-home 文件夹、pom.xml文件如下： catalina-home 文件夹目录如下，其中conf、wbapps是从源码文件夹src内复制过来的 pom.xml文件内容如下： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.ap
android手机应用源码Imsdroid语音视频通话源码.rar
最新发布
05-20
android手机应用源码Imsdroid语音视频通话源码.rar
tomcat8.5源码分析
04-02
总体来说，Tomcat8.5源码是一个庞大而复杂的项目，需要对JavaWeb开发有一定的了解才能进行源码分析。如果有兴趣了解Tomcat8.5的源码，可以先从官方文档和源码注释入手，逐步深入了解各个模块的实现原理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值