1. 全栈程序员必看首页

tomcat重启会重新解压war包吗_tomcat解压版

全栈程序员-站长 • • 未分类 • 阅读 0

tomcat重启会重新解压war包吗_tomcat解压版tomcat解压war包的一点例外

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用
我在项目的开发过程中，发现Tomcat解压war 的一点例外。
   
   现象如下：

       使用ANT工具把web应用程序打包为war文件。然后把war文件放到tomcat的webapps，让tomcat自己解压。结果出现解压的web应用程序文件丢失。使用rar工具打开war文件。文件都齐全。怎么有这种现象呢？？查看tomcat的log文档。发现在解压war文档NullpointException.我升级tomcat到5.0还是出现这种现象。

jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/startup/HostConfig.java

   解决方法：

       我从tomcat网站下载了catalina 的原代码，进行分析。发现是在解压war文件出现input为null,而 input= jar.getInputStream(entry);然后提高tomcat的debug级别。可以在tomcat的log文档看到tomcat解压war文档的过程。发现如果某些文件名为???.txt,经检查发现原来这个文件的文件名为汉字。
      噢！才发现war文件在解压的过程中无法处理汉字的文件名。（因为找不到文件名为???.txt的文件而导致null例外。原来这个文件是个注释文档），所以在使用ant把web应用程序打包为war文件，一定要把文件名为汉字的文件去掉。使用Forte for java的IDE工具把web应用程序打包为war文件会不包含这些文件名为汉字的文件
。

下面是部分war文档解压的部分代码

代码采自jakarta.org 



 类HostConfig.java

jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/startup/HostConfig.java



   解决方法：

       我从tomcat网站下载了catalina 的原代码，进行分析。发现是在解压war文件出现input为null,而 input= jar.getInputStream(entry);然后提高tomcat的debug级别。可以在tomcat的log文档看到tomcat解压war文档的过程。发现如果某些文件名为???.txt,经检查发现原来这个文件的文件名为汉字。
      噢！才发现war文件在解压的过程中无法处理汉字的文件名。（因为找不到文件名为???.txt的文件而导致null例外。原来这个文件是个注释文档），所以在使用ant把web应用程序打包为war文件，一定要把文件名为汉字的文件去掉。使用Forte for java的IDE工具把web应用程序打包为war文件会不包含这些文件名为汉字的文件
。

下面是部分war文档解压的部分代码

代码采自jakarta.org 



 类HostConfig.java

jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/startup/HostConfig.java

  1.  protected void deployWARs(File appBase, String[] files) {
  3.         for (int i = 0; i < files.length; i++) {
  5.             if (files[i].equalsIgnoreCase(“META-INF”))
  6.                 continue;
  7.             if (files[i].equalsIgnoreCase(“WEB-INF”))
  8.                 continue;
  9.             if (deployed.contains(files[i]))
  10.                 continue;
  11.             File dir = new File(appBase, files[i]);
  12.             if (files[i].toLowerCase().endsWith(“.war”)) {
  14.                 deployed.add(files[i]);
  16.                 // Calculate the context path and make sure it is unique
  17.                 String contextPath = “/” + files[i];
  18.                 int period = contextPath.lastIndexOf(“.”);
  19.                 if (period >= 0)
  20.                     contextPath = contextPath.substring(0, period);
  21.                 if (contextPath.equals(“/ROOT”))
  22.                     contextPath = “”;
  23.                 if (host.findChild(contextPath) != null)
  24.                     continue;
  26.                 // Checking for a nested /META-INF/context.xml
  27.                 JarFile jar = null;
  28.                 JarEntry entry = null;
  29.                 InputStream istream = null;
  30.                 BufferedOutputStream ostream = null;
  31.                 File xml = new File
  32.                     (configBase, files[i].substring
  33.                      (0, files[i].lastIndexOf(“.”)) + “.xml”);
  34.                 if (!xml.exists()) {
  35.                     try {
  36.                         jar = new JarFile(dir);
  37.                         entry = jar.getJarEntry(“META-INF/context.xml”);
  38.                         if (entry != null) {
  39.                             istream = jar.getInputStream(entry);
  40.                             ostream =
  41.                                 new BufferedOutputStream
  42.                                 (new FileOutputStream(xml), 1024);
  43.                             byte buffer[] = new byte[1024];
  44.                             while (true) {
  45.                                 int n = istream.read(buffer);
  46.                                 if (n < 0) {
  47.                                     break;
  48.                                 }
  49.                                 ostream.write(buffer, 0, n);
  50.                             }
  51.                             ostream.flush();
  52.                             ostream.close();
  53.                             ostream = null;
  54.                             istream.close();
  55.                             istream = null;
  56.                             entry = null;
  57.                             jar.close();
  58.                             jar = null;
  59.                             deployDescriptors(configBase(), configBase.list());
  60.                             return;
  61.                         }
  62.                     } catch (Exception e) {
  63.                         // Ignore and continue
  64.                         if (ostream != null) {
  65.                             try {
  66.                                 ostream.close();
  67.                             } catch (Throwable t) {
  68.                                 ;
  69.                             }
  70.                             ostream = null;
  71.                         }
  72.                         if (istream != null) {
  73.                             try {
  74.                                 istream.close();
  75.                             } catch (Throwable t) {
  76.                                 ;
  77.                             }
  78.                             istream = null;
  79.                         }
  80.                         entry = null;
  81.                         if (jar != null) {
  82.                             try {
  83.                                 jar.close();
  84.                             } catch (Throwable t) {
  85.                                 ;
  86.                             }
  87.                             jar = null;
  88.                         }
  89.                     }
  90.                 }
  92.                 if (isUnpackWARs()) {
  94.                     // Expand and deploy this application as a directory
  95.                     log.debug(sm.getString(“hostConfig.expand”, files[i]));
  96.                     URL url = null;
  97.                     String path = null;
  98.                     try {
  99.                         url = new URL(“jar:file:” +
  100.                                       dir.getCanonicalPath() + “!/”);
  101.                         path = ExpandWar.expand(host, url);
  102.                     } catch (IOException e) {
  103.                         // JAR decompression failure
  104.                         log.warn(sm.getString
  105.                                  (“hostConfig.expand.error”, files[i]));
  106.                         continue;
  107.                     } catch (Throwable t) {
  108.                         log.error(sm.getString
  109.                                   (“hostConfig.expand.error”, files[i]), t);
  110.                         continue;
  111.                     }
  112.                     try {
  113.                         if (path != null) {
  114.                             url = new URL(“file:” + path);
  115.                             ((Deployer) host).install(contextPath, url);
  116.                         }
  117.                     } catch (Throwable t) {
  118.                         log.error(sm.getString
  119.                                   (“hostConfig.expand.error”, files[i]), t);
  120.                     }
  122.                 } else {
  124.                     // Deploy the application in this WAR file
  125.                     log.info(sm.getString(“hostConfig.deployJar”, files[i]));
  126.                     try {
  127.                         URL url = new URL(“file”, null,
  128.                                           dir.getCanonicalPath());
  129.                         url = new URL(“jar:” + url.toString() + “!/”);
  130.                         ((Deployer) host).install(contextPath, url);
  131.                     } catch (Throwable t) {
  132.                         log.error(sm.getString(“hostConfig.deployJar.error”,
  133.                                          files[i]), t);
  134.                     }
  136.                 }
  138.             }
  140.         }
  142.     }


类 ExpandWar.java
jakarta-tomcat-catalina/catalina/src/share/org/apache/catalina/startup/ExpandWar.java

  1. package org.apache.catalina.startup;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6. import java.io.InputStream;
  7. import java.io.IOException;
  8. import java.net.JarURLConnection;
  9. import java.net.URL;
  10. import java.util.Enumeration;
  11. import java.util.jar.JarEntry;
  12. import java.util.jar.JarFile;
  14. import org.apache.catalina.Host;
  15. import org.apache.catalina.Logger;
  16. import org.apache.catalina.core.StandardHost;
  17. import org.apache.catalina.util.StringManager;
  19. /**
  20.  * Expand out a WAR in a Host‘s appBase.
  21.  *
  22.  * @author Craig R. McClanahan
  23.  * @author Remy Maucherat
  24.  * @author Glenn L. Nielsen
  25.  * @version $Revision: 1.4 $
  26.  */
  28. public class ExpandWar {
  31.     /**
  32.      * The string resources for this package.
  33.      */
  34.     protected static final StringManager sm =
  35.         StringManager.getManager(Constants.Package);
  38.     /**
  39.      * Expand the WAR file found at the specified URL into an unpacked
  40.      * directory structure, and return the absolute pathname to the expanded
  41.      * directory.
  42.      *
  43.      * @param host Host war is being installed for
  44.      * @param war URL of the web application archive to be expanded
  45.      *  (must start with “jar:”)
  46.      *
  47.      * @exception IllegalArgumentException if this is not a “jar:” URL
  48.      * @exception IOException if an input/output error was encountered
  49.      *  during expansion
  50.      */
  51.     public static String expand(Host host, URL war)
  52.         throws IOException {
  54.         int debug = 0;
  55.         Logger logger = host.getLogger();
  57.         if (host instanceof StandardHost) {
  58.             debug = ((StandardHost) host).getDebug();
  59.         }
  61.         // Calculate the directory name of the expanded directory
  62.         if (debug >= 1) {
  63.             logger.log(“expand(“ + war.toString() + “)”);
  64.         }
  65.         String pathname = war.toString().replace(‘\\‘, ‘/‘);
  66.         if (pathname.endsWith(“!/”)) {
  67.             pathname = pathname.substring(0, pathname.length() – 2);
  68.         }
  69.         int period = pathname.lastIndexOf(‘.‘);
  70.         if (period >= pathname.length() – 4)
  71.             pathname = pathname.substring(0, period);
  72.         int slash = pathname.lastIndexOf(‘/‘);
  73.         if (slash >= 0) {
  74.             pathname = pathname.substring(slash + 1);
  75.         }
  76.         if (debug >= 1) {
  77.             logger.log(”  Proposed directory name: “ + pathname);
  78.         }
  79.         return expand(host, war, pathname);
  81.     }
  84.     /**
  85.      * Expand the WAR file found at the specified URL into an unpacked
  86.      * directory structure, and return the absolute pathname to the expanded
  87.      * directory.
  88.      *
  89.      * @param host Host war is being installed for
  90.      * @param war URL of the web application archive to be expanded
  91.      *  (must start with “jar:”)
  92.      * @param pathname Context path name for web application
  93.      *
  94.      * @exception IllegalArgumentException if this is not a “jar:” URL
  95.      * @exception IOException if an input/output error was encountered
  96.      *  during expansion
  97.      */
  98.     public static String expand(Host host, URL war, String pathname)
  99.         throws IOException {
  101.         int debug = 0;
  102.         Logger logger = host.getLogger();
  104.         if (host instanceof StandardHost) {
  105.             debug = ((StandardHost) host).getDebug();
  106.         }
  108.         // Make sure that there is no such directory already existing
  109.         File appBase = new File(host.getAppBase());
  110.         if (!appBase.isAbsolute()) {
  111.             appBase = new File(System.getProperty(“catalina.base”),
  112.                                host.getAppBase());
  113.         }
  114.         if (!appBase.exists() || !appBase.isDirectory()) {
  115.             throw new IOException
  116.                 (sm.getString(“hostConfig.appBase”,
  117.                               appBase.getAbsolutePath()));
  118.         }
  119.         File docBase = new File(appBase, pathname);
  120.         if (docBase.exists()) {
  121.             // War file is already installed
  122.             return (docBase.getAbsolutePath());
  123.         }
  125.         // Create the new document base directory
  126.         docBase.mkdir();
  127.         if (debug >= 2) {
  128.             logger.log(”  Have created expansion directory “ +
  129.                 docBase.getAbsolutePath());
  130.         }
  132.         // Expand the WAR into the new document base directory
  133.         JarURLConnection juc = (JarURLConnection) war.openConnection();
  134.         juc.setUseCaches(false);
  135.         JarFile jarFile = null;
  136.         InputStream input = null;
  137.         try {
  138.             jarFile = juc.getJarFile();
  139.             if (debug >= 2) {
  140.                 logger.log(”  Have opened JAR file successfully”);
  141.             }
  142.             Enumeration jarEntries = jarFile.entries();
  143.             if (debug >= 2) {
  144.                 logger.log(”  Have retrieved entries enumeration”);
  145.             }
  146.             while (jarEntries.hasMoreElements()) {
  147.                 JarEntry jarEntry = (JarEntry) jarEntries.nextElement();
  148.                 String name = jarEntry.getName();
  149.                 if (debug >= 2) {
  150.                     logger.log(”  Am processing entry “ + name);
  151.                 }
  152.                 int last = name.lastIndexOf(‘/‘);
  153.                 if (last >= 0) {
  154.                     File parent = new File(docBase,
  155.                                            name.substring(0, last));
  156.                     if (debug >= 2) {
  157.                         logger.log(”  Creating parent directory “ + parent);
  158.                     }
  159.                     parent.mkdirs();
  160.                 }
  161.                 if (name.endsWith(“/”)) {
  162.                     continue;
  163.                 }
  164.                 if (debug >= 2) {
  165.                     logger.log(”  Creating expanded file “ + name);
  166.                 }
  167.                 input = jarFile.getInputStream(jarEntry);
  168.                 expand(input, docBase, name);
  169.                 input.close();
  170.                 input = null;
  171.             }
  172.         } catch (IOException e) {
  173.             // If something went wrong, delete expanded dir to keep things 
  174.             // clean
  175.             deleteDir(docBase);
  176.             throw e;
  177.         } finally {
  178.             if (input != null) {
  179.                 try {
  180.                     input.close();
  181.                 } catch (Throwable t) {
  182.                     ;
  183.                 }
  184.                 input = null;
  185.             }
  186.             if (jarFile != null) {
  187.                 try {
  188.                     jarFile.close();
  189.                 } catch (Throwable t) {
  190.                     ;
  191.                 }
  192.                 jarFile = null;
  193.             }
  194.         }
  196.         // Return the absolute path to our new document base directory
  197.         return (docBase.getAbsolutePath());
  199.     }
  202.     /**
  203.      * Delete the specified directory, including all of its contents and
  204.      * subdirectories recursively.
  205.      *
  206.      * @param dir File object representing the directory to be deleted
  207.      */
  208.     public static void deleteDir(File dir) {
  210.         String files[] = dir.list();
  211.         if (files == null) {
  212.             files = new String[0];
  213.         }
  214.         for (int i = 0; i < files.length; i++) {
  215.             File file = new File(dir, files[i]);
  216.             if (file.isDirectory()) {
  217.                 deleteDir(file);
  218.             } else {
  219.                 file.delete();
  220.             }
  221.         }
  222.         dir.delete();
  224.     }
  227.     /**
  228.      * Expand the specified input stream into the specified directory, creating
  229.      * a file named from the specified relative path.
  230.      *
  231.      * @param input InputStream to be copied
  232.      * @param docBase Document base directory into which we are expanding
  233.      * @param name Relative pathname of the file to be created
  234.      *
  235.      * @exception IOException if an input/output error occurs
  236.      */
  237.     protected static void expand(InputStream input, File docBase, String name)
  238.         throws IOException {
  240.         File file = new File(docBase, name);
  241.         BufferedOutputStream output = null;
  242.         try {
  243.             output = 
  244.                 new BufferedOutputStream(new FileOutputStream(file));
  245.             byte buffer[] = new byte[2048];
  246.             while (true) {
  247.                 [b]int n = input.read(buffer);[/b]               
  248.                 if (n <= 0)
  249.                     break;
  250.                 output.write(buffer, 0, n);
  251.             }
  252.         } finally {
  253.             if (output != null) {
  254.                 try {
  255.                     output.close();
  256.                 } catch (IOException e) {
  257.                     // Ignore
  258.                 }
  259.             }
  260.         }
  262.     }
  265. }
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/188775.html原文链接：https://javaforall.net

赞 (0)
全栈程序员-站长的头像全栈程序员-站长
0 0


相关推荐

  • 软件工程实验报告：图书管理系统

    软件工程实验报告：图书管理系统

    软件工程实验报告：图书管理系统一、课程设计的目的与要求课程设计目的软件工程课程设计是学习软件工程课程后所进行的实践环节，目的是培养学生用工程化的思想和标准文档化的思想进行软件开发。本次课程设计通过开发一个小型实用的软件系统，亲身体验软件生命周期中的各个环节，以加深对软件工程课程的深入理解、锻炼独立分析、解决问题的能力。课程设计要求2.1课程设计准备1）复习软件工程课程的主要内容，熟练掌握软件生命周期的理论以及各阶段的基本概念。2）明确可行性分析、需求分析、设计、测试等阶段的基本任务和基本方法。3）熟练运用规范化的描述

    全栈程序员-站长的头像 全栈程序员-站长
    2022年8月22日
    8
  • plsql直接连接远程数据库_plsql远程连接oracle

    plsql直接连接远程数据库_plsql远程连接oracle

    plsql直接连接远程数据库_plsql远程连接oracle前言每次安装Oracle以后，都会出现使用plsql连接不上的问题！多次重启电脑、重装系统的磨人经历之后，终于做出这么一篇文章，希望能帮助广大技术人员减少一些时间，顺利进行连接。注：也可以用plsql连接远程数据库（只要有oracle的network\admin\tnsnames.ora就行）。首先下载64位oracle以及32位轻量级客户端(注意版本的对应，我用的是11g的oracl……

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月20日
    0
  • 基于H5的移动端APP开发框架

    基于H5的移动端APP开发框架

    基于H5的移动端APP开发框架快速增长的APP应用软件市场，以及智能手机的普及，手机应用：Native（原生）APP快速占领了APP市场，成为了APP开发的主流，但其平台的不通用性，开发成本高，多版本开发等问题，一直困扰着专业APP开发企业，和APP服务提供商。安卓和IOS的操作方式，开发模式，界面UI显示方面的差别，也使得原生APP的不同版本体验有很大的区别，光是做兼容性调测，都要花费开发企业不少的时间。近年来，…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年6月16日
    26
  • 【超详细】计算机组成原理总结及思维导图[通俗易懂]

    【超详细】计算机组成原理总结及思维导图[通俗易懂]

    计算机组成第一章计算机系统概论冯诺依曼型计算机特点1.计算机由运算器，控制器，存储器，输入和输出设备5部分组成2.采用存储程序的方式，程序和数据放在同一个存储器中，并以二进制表示。3.指令由操作码和地址码组成4.指令在存储器中按执行顺序存放，由指令计数器(即程序计数器PC)指明要执行的指令所在的储存单元地址，一般按顺序递增，但可按运算结果或外界条件而改变5.机器以运…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年4月17日
    64
  • 一般人到底要不要学Python_Python值得学吗

    一般人到底要不要学Python_Python值得学吗

    一般人到底要不要学Python_Python值得学吗前言本人纯屌丝一枚，在学python之前对电脑的认知也就只限于上个网，玩个办公软件。这里不能跑题，我为啥说自学python，一般人我还是劝你算了吧。因为我就是那个一般人。基础真的很简单，是个人稍微认点真都能懂，这就是好多人说的python简单、易懂、好学，然后就是一顿浮夸的言论，误导那些小白，再然后那些小白也就跟着浮夸。这里我就给那些轻浮的人泼一桶冷水，懂跟学会是一码事吗？先来说哈python这个就业哈，我现在生活在祖国的肚皮上–成都，（嗯，有想了解川西迷你小环线的在下面留言哦），下面亲身经历，我喃，

    全栈程序员-站长的头像 全栈程序员-站长
    2022年9月3日
    2
  • android 设备usb调试模式,如何打开Android设备的USB调试模式「建议收藏」

    android 设备usb调试模式,如何打开Android设备的USB调试模式「建议收藏」

    android 设备usb调试模式,如何打开Android设备的USB调试模式「建议收藏」目前大部分刷机等工具都是采用Adb方式连接，所以需要您在设备上打开USB调试模式Android设备打开USB调试模式总共有三种不同方法，根据系统版本而不同，以下为Android所有系统版本对应的打开方法壹2.1~2.3.7系统打开方法：点击手机Menu键(菜单键)，在弹出的菜单中选择设置(Setting),或在应用程序中找到设置程序点击进入进入设置界面的应用程序即可打开…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年9月13日
    0

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号