java - Acceso a archivos de recursos desde módulos externos

java-9 jigsaw

Question

Hasta ahora, hasta que Java no esté modularizado, simplemente debe colocar un archivo en src/main/java/resources para asegurarse de que esté en classpath y luego cargarlo con

file = getClass().getClassLoader().getResourceAsStream("myfilename"); 

desde prácticamente cualquier parte del classpath.

Ahora con módulos, la trama se complica.

La configuración de mi proyecto es la siguiente:

module playground.api {
requires java.base;
requires java.logging;
requires framework.core;
}

El archivo de configuración se coloca dentro de src/main/resources/config.yml .

El proyecto se ejecuta con

java -p target/classes:target/dependency -m framework.core/com.framework.Main

Como la clase principal no reside en mi propio proyecto, sino en un módulo de marco externo, no puede ver config.yml . Ahora la pregunta es, ¿hay alguna manera de poner de alguna manera mi archivo de configuración en el módulo o abrirlo? ¿Tengo que cambiar la forma en que el archivo se carga en el marco ascendente?

Traté de usar "exportaciones" o "abre" en la información del módulo, pero quiere tener un nombre de paquete, no un nombre de carpeta.

¿Cómo lograr esto de la mejor manera práctica para que funcione como en Java 8 y con la menor cantidad de cambios posible?

Answer 1

Mientras usa el comando java para iniciar una aplicación de la siguiente manera: -

java -p target/classes:target/dependency -m framework.core/com.framework.Main 

• está especificando el modulepath usando la opción -p alternativa para --module-path que buscaría en target / classes y target / dependency para sus módulos.

• Además, el uso de -m alternativo para --module especifica el módulo inicial para resolver con el nombre framework.core y construye el gráfico del módulo con la clase principal para ejecutar explícitamente como com.framework.Main .

Ahora, el problema aquí parece ser que el módulo framework.core no requires o lee el módulo playground.api debido a que el gráfico del módulo no incluye el módulo deseado que consiste en el recurso real config.yml .

Según lo sugerido por @Alan , una buena manera de enumerar la salida de resolución del módulo durante el inicio es utilizar la opción --show-module-resolution .

Intenté ingenuamente abrir src / main / resources, no compila ofc

Dado que el recurso en su módulo está en el nivel raíz , por lo tanto, no está encapsulado y no necesita abrirse ni exportarse a ningún otro módulo.

En su caso, solo necesita asegurarse de que el módulo playground.api termine en el gráfico del módulo y luego el recurso sea accesible para la aplicación. Para especificar los módulos raíz a resolver además del módulo inicial, puede utilizar la opción --add-modules .

Por lo tanto, la solución general para trabajar para usted junto con alguna depuración será:

java --module-path target/classes:target/dependency
--module framework.core/com.framework.Main
--add-modules playground.api
--show-module-resolution

Answer 2

// to scan the module path
ClassLoader.getSystemResources(resourceName)
// if you know a class where the resource is
Class.forName(className).getResourceAsStream(resourceName)
// if you know the module containing the resource
ModuleLayer.boot().findModule(moduleName).getResourceAsStream(resourceName)

Vea un ejemplo de trabajo a continuación.

Dado:

.
├── FrameworkCore
│ └── src
│ └── FrameworkCore
│ ├── com
│ │ └── framework
│ │ └── Main.java
│ └── module-info.java
└── PlaygroundApi
└── src
└── PlaygroundApi
├── com
│ └── playground
│ └── api
│ └── App.java
├── config.yml
└── module-info.java

Main.java podría ser

package com.framework;
import java.io.*;
import java.net.URL;
import java.util.Optional;
import java.util.stream.Collectors;
public class Main {
public static void main( String[] args )
{
// load from anywhere in the modulepath
try {
URL url = ClassLoader.getSystemResources("config.yml").nextElement();
InputStream is = url.openStream();
Main.read(is);
} catch (IOException e) {
throw new RuntimeException(e);
}
// load from the the module where a given class is
try {
InputStream is = Class.forName("com.playground.api.App").getResourceAsStream("/config.yml");
Main.read(is);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
// load from a specific module
Optional<Module> specificModule = ModuleLayer.boot().findModule("PlaygroundApi");
specificModule.ifPresent(module -> {
try {
InputStream is = module.getResourceAsStream("config.yml");
Main.read(is);
} catch (Exception e) {
throw new RuntimeException(e);
}
});
}
private static void read(InputStream is) {
String s = new BufferedReader(new InputStreamReader(is)).lines().collect(Collectors.joining("/n"));
System.out.println("config.yml: " + s);
}
}

Y lanzarías con

java --module-path ./FrameworkCore/target/classes:./PlaygroundApi/target/classes /
--add-modules FrameworkCore,PlaygroundApi /
com.framework.Main

Para clonar este ejemplo: git clone https://github.com/j4n0/SO-46861589.git