Java Language
Recursos (en classpath)

Introducción

Observaciones

package com.example;

public class ExampleApplication {
    public void readImage()
    throws IOException {

        URL imageURL = ExampleApplication.class.getResource("icon.png");

        // The above statement is identical to:
        // ClassLoader loader = ExampleApplication.class.getClassLoader();
        // URL imageURL = loader.getResource("com/example/icon.png");

        Image image = ImageIO.read(imageURL);
    }
}

Cargando una imagen de un recurso

Para cargar una imagen agrupada:

package com.example;

public class ExampleApplication {
    private Image getIcon() throws IOException {
        URL imageURL = ExampleApplication.class.getResource("icon.png");
        return ImageIO.read(imageURL);
    }
}

Cargando la configuración por defecto

Para leer las propiedades de configuración por defecto:

package com.example;

public class ExampleApplication {
    private Properties getDefaults() throws IOException {
        Properties defaults = new Properties();

        try (InputStream defaultsStream =
            ExampleApplication.class.getResourceAsStream("config.properties")) {

            defaults.load(defaultsStream);
        }

        return defaults;
    }
}

Cargando recursos del mismo nombre desde múltiples archivos JAR

El recurso con la misma ruta y nombre puede existir en más de un archivo JAR en la ruta de clase. Los casos comunes son recursos que siguen una convención o que son parte de una especificación de empaquetado. Ejemplos de tales recursos son

• META-INF / MANIFEST.MF
• META-INF / beans.xml (CDI Spec)
• Propiedades de ServiceLoader que contienen proveedores de implementación

Para obtener acceso a todos estos recursos en diferentes tarros, uno tiene que usar un ClassLoader, que tiene un método para esto. La Enumeration devuelta se puede convertir convenientemente en una List mediante una función de colecciones.

Enumeration<URL> resEnum = MyClass.class.getClassLoader().getResources("META-INF/MANIFEST.MF");
ArrayList<URL> resources = Collections.list(resEnum);

Encontrar y leer recursos usando un cargador de clases

La carga de recursos en Java comprende los siguientes pasos:

1. Encontrar la Class o ClassLoader que encontrará el recurso.
2. Encontrar el recurso.
3. Obtención del flujo de bytes para el recurso.
4. Lectura y procesamiento del flujo de bytes.
5. Cierre de la corriente de bytes.

Los últimos tres pasos se realizan normalmente al pasar la URL a un método de biblioteca o un constructor para cargar el recurso. Normalmente utilizarás un método getResource en este caso. También es posible leer los datos del recurso en el código de la aplicación. En este caso, normalmente getResourceAsStream .

Rutas de recursos absolutos y relativos

Los recursos que se pueden cargar desde la ruta de clase se indican mediante una ruta . La sintaxis de la ruta es similar a la ruta de un archivo UNIX / Linux. Consiste en nombres simples separados por caracteres de barra ( / ). Una ruta relativa comienza con un nombre y una ruta absoluta comienza con un separador.

Como describen los ejemplos de Classpath, la classpath de una JVM define un espacio de nombres superponiendo los espacios de nombres de los directorios y los archivos JAR o ZIP en la classpath. Cuando se resuelve una ruta absoluta, los cargadores de clases interpretan la inicial / como la raíz del espacio de nombres. Por el contrario, una ruta relativa puede resolverse en relación con cualquier "carpeta" en el espacio de nombres. La carpeta utilizada dependerá del objeto que utilice para resolver la ruta.

Obtención de una Clase o Classloader

Un recurso se puede ubicar utilizando un objeto Class o un objeto ClassLoader . Un objeto de Class puede resolver rutas relativas, por lo que normalmente usará una de estas si tiene un recurso relativo (clase). Hay varias formas de obtener un objeto de Class . Por ejemplo:

• Un literal de clase le dará el objeto de Class para cualquier clase que pueda nombrar en el código fuente de Java; por ejemplo, String.class te da el objeto Class para el tipo String .

• El Object.getClass() le dará el objeto Class para el tipo od cualquier objeto; por ejemplo, "hello".getClass() es otra forma de obtener la Class del tipo String .

• El método Class.forName(String) (si es necesario) cargará dinámicamente una clase y devolverá su objeto Class ; por ejemplo, Class.forName("java.lang.String") .

Un objeto ClassLoader se obtiene normalmente llamando a getClassLoader() en un objeto Class . También es posible obtener el cargador de clases predeterminado de la JVM utilizando el método estático ClassLoader.getSystemClassLoader() .

Los metodos de get

Una vez que tenga una instancia de Class o ClassLoader , puede encontrar un recurso, usando uno de los siguientes métodos:

Notas:

• La principal diferencia entre las versiones ClassLoader y Class de los métodos se encuentra en la forma en que se interpretan las rutas relativas.

  • Los métodos de Class resuelven una ruta relativa en la "carpeta" que corresponde al paquete de clases.
  • Los métodos de ClassLoader tratan las rutas relativas como si fueran absolutas; es decir, resolverlos en la "carpeta raíz" del espacio de nombres de classpath.

• Si no se puede encontrar el recurso (o recursos) solicitado, los methods return getResource y getResourceAsStream methods return valor nulo , and the methods return an empty getResources methods return an empty Enumeración methods return an empty .

• Las URL devueltas se podrán resolver mediante URL.toStream() . Pueden ser file: URL u otras URL convencionales, pero si el recurso reside en un archivo JAR, serán jar: URL que identifican el archivo JAR y un recurso específico dentro de él.

• Si su código utiliza un método getResourceAsStream (o URL.toStream() ) para obtener un InputStream , es responsable de cerrar el objeto de flujo. Si no se cierra el flujo, podría producirse una fuga de recursos.