¿Cómo leer un archivo del jar en Java?

Question

Quiero leer un archivo XML que se encuentra dentro de uno de los jar incluidos en mi ruta de clase. ¿Cómo puedo leer cualquier archivo que esté incluido en el jar?

Answer 1

Si desea leer ese archivo desde el interior de su uso de la aplicación:

InputStream input = getClass().getResourceAsStream("/classpath/to/my/file"); 

La ruta comienza con "/", pero eso no es el camino en su sistema de archivos, pero en la ruta de clases. Por lo tanto, si su archivo está en classpath "org.xml" y se llama myxml.xml, su ruta de acceso se verá como "/org/xml/myxml.xml".

El InputStream lee el contenido de su archivo. Puede envolverlo en un lector, si lo desea.

Espero que ayude.

Answer 2

Ah, este es uno de mis temas favoritos. Fundamentalmente, hay dos maneras en que puede cargar un recurso a través de la ruta de clases:

Class.getResourceAsStream(resource) 

y

ClassLoader.getResourceAsStream(resource) 

(hay otras formas que implican obtener una URL para el recurso de una manera similar, a continuación, abrir una conexión, pero estas son las dos formas directas).

El primer método realmente delega en el segundo, después de modificar el nombre del recurso. En esencia, hay dos tipos de nombres de recursos: absoluto (por ejemplo, "/ ruta/a/recurso/recurso") y relativo (por ejemplo, "recurso"). Los caminos absolutos comienzan con "/".

Aquí hay un ejemplo que debería ilustrar. Considere una clase com.example.A. Considere dos recursos, uno ubicado en/com/example/anidado, el otro en/top, en el classpath. El programa siguiente muestra nueve posibles maneras de acceder a los dos recursos:

 
package com.example; 

public class A { 

    public static void main(String args[]) { 

     // Class.getResourceAsStream 
     Object resource = A.class.getResourceAsStream("nested"); 
     System.out.println("1: A.class nested=" + resource); 

     resource = A.class.getResourceAsStream("/com/example/nested"); 
     System.out.println("2: A.class /com/example/nested=" + resource); 

     resource = A.class.getResourceAsStream("top"); 
     System.out.println("3: A.class top=" + resource); 

     resource = A.class.getResourceAsStream("/top"); 
     System.out.println("4: A.class /top=" + resource); 

     // ClassLoader.getResourceAsStream 
     ClassLoader cl = A.class.getClassLoader(); 
     resource = cl.getResourceAsStream("nested");   
     System.out.println("5: cl nested=" + resource); 

     resource = cl.getResourceAsStream("/com/example/nested"); 
     System.out.println("6: cl /com/example/nested=" + resource); 
     resource = cl.getResourceAsStream("com/example/nested"); 
     System.out.println("7: cl com/example/nested=" + resource); 

     resource = cl.getResourceAsStream("top"); 
     System.out.println("8: cl top=" + resource); 

     resource = cl.getResourceAsStream("/top"); 
     System.out.println("9: cl /top=" + resource); 
    } 

} 

La salida del programa es:

 
1: A.class nested=java.io.BufferedInputStream@19821f 
2: A.class /com/example/nested=java.io.BufferedInputStream@addbf1 
3: A.class top=null 
4: A.class /top=java.io.BufferedInputStream@42e816 
5: cl nested=null 
6: cl /com/example/nested=null 
7: cl com/example/nested=java.io.BufferedInputStream@9304b1 
8: cl top=java.io.BufferedInputStream@190d11 
9: cl /top=null 

Parcialmente cosas hacen lo que cabría esperar. El Caso-3 falla porque la resolución relativa de la clase es con respecto a la Clase, por lo que "arriba" significa "/ com/example/top", pero "/ top" significa lo que dice.

Case-5 falla porque la resolución relativa del cargador de clases está con respecto al cargador de clases. Pero, inesperadamente, Case-6 también falla: uno podría esperar que "/ com/example/anidado" se resolviera correctamente. Para acceder a un recurso anidado a través del cargador de clases, necesita utilizar Case-7, es decir, la ruta anidada es relativa a la raíz del cargador de clases. Del mismo modo, Case-9 falla, pero Case-8 pasa.

Recuerde: para java.lang.Class, getResourceAsStream() no delegar en el cargador de clases:

 
    public InputStream getResourceAsStream(String name) { 
     name = resolveName(name); 
     ClassLoader cl = getClassLoader0(); 
     if (cl==null) { 
      // A system class. 
      return ClassLoader.getSystemResourceAsStream(name); 
     } 
     return cl.getResourceAsStream(name); 
    } 

por lo que es el comportamiento de ResolveName() que es importante.

Finalmente, dado que es el comportamiento del cargador de clases que cargó la clase que esencialmente controla getResourceAsStream(), y el cargador de clases suele ser un cargador personalizado, las reglas de carga de recursos pueden ser aún más complejas. p.ej.para aplicaciones web, cargue desde WEB-INF/classes o WEB-INF/lib en el contexto de la aplicación web, pero no desde otras aplicaciones web que estén aisladas. Además, los cargadores de clases de buen comportamiento delegan a los padres, por lo que los recursos duplicados en el classpath pueden no ser accesibles usando este mecanismo.

Answer 3

Un JAR es básicamente un archivo ZIP, así que trátelo como tal. A continuación, se incluye un ejemplo sobre cómo extraer un archivo de un archivo WAR (también trátelo como un archivo ZIP) y muestra el contenido de la cadena. Para el binario necesitarás modificar el proceso de extracción, pero hay muchos ejemplos para eso.

public static void main(String args[]) { 
    String relativeFilePath = "style/someCSSFile.css"; 
    String zipFilePath = "/someDirectory/someWarFile.war"; 
    String contents = readZipFile(zipFilePath,relativeFilePath); 
    System.out.println(contents); 
} 

public static String readZipFile(String zipFilePath, String relativeFilePath) { 
    try { 
     ZipFile zipFile = new ZipFile(zipFilePath); 
     Enumeration<? extends ZipEntry> e = zipFile.entries(); 

     while (e.hasMoreElements()) { 
      ZipEntry entry = (ZipEntry) e.nextElement(); 
      // if the entry is not directory and matches relative file then extract it 
      if (!entry.isDirectory() && entry.getName().equals(relativeFilePath)) { 
       BufferedInputStream bis = new BufferedInputStream(
         zipFile.getInputStream(entry)); 
       // Read the file 
        // With Apache Commons I/O 
       String fileContentsStr = IOUtils.toString(bis, "UTF-8"); 

        // With Guava 
       //String fileContentsStr = new String(ByteStreams.toByteArray(bis),Charsets.UTF_8); 
       // close the input stream. 
       bis.close(); 
       return fileContentsStr; 
      } else { 
       continue; 
      } 
     } 
    } catch (IOException e) { 
     logger.error("IOError :" + e); 
     e.printStackTrace(); 
    } 
    return null; 
} 

En este ejemplo estoy usando Apache Commons E/S y si está utilizando Maven aquí es la dependencia:

<dependency> 
    <groupId>commons-io</groupId> 
    <artifactId>commons-io</artifactId> 
    <version>2.4</version> 
</dependency> 

Answer 4

Comprobar primero el cargador de clases.

ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); 

if (classLoader == null) { 
    classLoader = Class.class.getClassLoader(); 
} 

classLoader.getResourceAsStream("xmlFileNameInJarFile.xml"); 

// xml file location at xxx.jar 
// + folder 
// + folder 
// xmlFileNameInJarFile.xml 

Answer 5

simplemente para la corrección, se ha producido recientemente un question en la lista de correo Jython, donde una de las respuestas se hace referencia a este hilo.

La pregunta era cómo llamar a un script en Python que está contenida en un archivo .jar desde dentro Jython, la respuesta sugerida es la siguiente (con "InputStream" como se explica en una de las respuestas anteriores:

PythonInterpreter.execfile(InputStream)