recurso abierto con ruta relativa en java

Question

En mi aplicación Java necesito obtener algunos archivos y directorios.

Esta es la estructura del programa:

./main.java
./package1/guiclass.java
./package1/resources/resourcesloader.java
./package1/resources/repository/modules/   -> this is the dir I need to get
./package1/resources/repository/SSL-Key/cert.jks    -> this is the file I need to get

guiclass carga la clase de cargador de recursos que cargará mis recursos (directorio y archivo).

En cuanto al archivo, lo intenté

resourcesloader.class.getClass().getResource("repository/SSL-Key/cert.jks").toString()

para obtener el camino real, pero de esta manera no funciona.

No tengo idea de cómo hacer el directorio.

Answer 1

Accesorios para la ruta relativa al cargador de clases, no a la clase que está recibiendo el cargador desde. Por ejemplo:

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();

Answer 2

he tenido problemas con el uso del método getClass().getResource("filename.txt"). Tras la lectura de las instrucciones docs Java, si su recurso no está en el mismo paquete que la clase que está intentando tener acceso al recurso desde, entonces usted tiene que darle ruta relativa comenzando con '/'. La estrategia recomendada es poner sus archivos de recursos en una carpeta "recursos" en el directorio raíz. Así por ejemplo, si usted tiene la estructura:

src/main/com/mycompany/myapp

A continuación, se puede añadir una carpeta de recursos según lo recomendado por el experto en:

src/main/resources

Además se puede añadir subcarpetas en la carpeta de recursos

src/main/resources/textfiles

y dicen que su archivo se llama myfile.txt por lo que tiene

src/main/resources/textfiles/myfile.txt

Ahora aquí es donde el problema del camino estúpida entra en acción. Digamos que tienes una clase en su com.mycompany.myapp package, y que desea acceder al archivo myfile.txt de su carpeta de recursos. Algunos dicen que necesita para dar el:

"/main/resources/textfiles/myfile.txt" path

o

"/resources/textfiles/myfile.txt"

ambos están equivocados. Después me encontré mvn clean compile, los archivos y las carpetas se copian en el:

myapp/target/classes 

carpeta. Sin embargo, la carpeta de recursos no está allí, sólo las carpetas en la carpeta de recursos. Por lo que tiene:

myapp/target/classes/textfiles/myfile.txt

myapp/target/classes/com/mycompany/myapp/*

lo que el camino correcto para dar al método getClass().getResource("") es:

"/textfiles/myfile.txt"

aquí está:

getClass().getResource("/textfiles/myfile.txt")

Esto ya no devolverá un valor nulo, pero volverá a su clase. Espero que esto ayude a alguien. Es extraño para mí, que la carpeta "resources" no se copia también, pero sólo las subcarpetas y archivos directamente en la carpeta "resources". Parecería lógico que la carpeta "resources" también se encuentra bajo "myapp/target/classes"

Answer 3

Con la esperanza de brindar información adicional para aquellos que no aprenden esto tan rápido como los demás, me gustaría brindarles mi escenario, ya que tiene una configuración ligeramente diferente.Mi proyecto se configuró con la siguiente estructura de directorios (usando Eclipse):

Project/
  src/                // application source code
    org/
      myproject/
        MyClass.java
  test/               // unit tests
  res/                // resources
    images/           // PNG images for icons
      my-image.png
    xml/              // XSD files for validating XML files with JAXB
      my-schema.xsd
    conf/             // default .conf file for Log4j
      log4j.conf
  lib/                // libraries added to build-path via project settings

Estaba teniendo problemas para cargar mis recursos desde el res directorio.Quería que todos mis recursos estuvieran separados de mi código fuente (simplemente para fines de gestión/organización).Entonces lo que tuve que hacer fue agregar el res directorio al Construir camino y luego acceder al recurso a través de:

static final ClassLoader loader = MyClass.class.getClassLoader();

// in some function
loader.getResource("images/my-image.png");
loader.getResource("xml/my-schema.xsd");
loader.getResource("conf/log4j.conf");

NOTA: El / se omite desde el principio de la cadena de recursos porque estoy usando ClassLoader.getResource(Cadena) en lugar de Clase.getResource(Cadena).

Answer 4

@GianCarlo: Puede intentar llamar Sistema user.dir propiedad que le dará raíz de su proyecto Java y luego hacer añada esta ruta a su ruta relativa, por ejemplo:

String root = System.getProperty("user.dir");
String filepath = "/path/to/yourfile.txt"; // in case of Windows: "\\path \\to\\yourfile.txt
String abspath = root+filepath;



// using above path read your file into byte []
File file = new File(abspath);
FileInputStream fis = new FileInputStream(file);
byte []filebytes = new byte[(int)file.length()];
fis.read(filebytes);

Answer 5

Cuando se utiliza 'getResource' en una clase, una ruta relativa se resuelve basa en el paquete de la clase está en. Cuando se utiliza 'getResource' en un cargador de clases, una ruta relativa se resuelve en base a la carpeta raíz.

Si utiliza una ruta absoluta, tanto los métodos 'getResource' comenzarán en la carpeta raíz.

Answer 6

Para aquellos que utilizan Eclipse + experto. Digamos que intenta acceder al archivo en images/pic.jpg src/main/resources. Hacerlo de esta manera:

ClassLoader loader = MyClass.class.getClassLoader();
File file = new File(loader.getResource("images/pic.jpg").getFile());

es perfectamente correcto, pero puede dar lugar a una excepción de puntero nulo. Parece que el eclipse no reconoce las carpetas en la estructura de directorios experto como carpetas de origen inmediato. Al eliminar la carpeta y src/main/resources de la lista de carpetas de origen del proyecto y ponerlo de nuevo (proyecto> propiedades> java build path> fuente> eliminar / añadir Carpeta), yo era capaz de resolver esto.

Answer 7

resourcesloader.class.getClass()

Se puede desglosarse en:

Class<resourcesloader> clazz = resourceloader.class;
Class<Class> classClass = clazz.getClass();

Lo que significa que está tratando de cargar el recurso utilizando una clase de arranque.

En su lugar es probable que desee algo como:

resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

Si tan sólo javac advirtió acerca de llamar a métodos estáticos en contextos no estáticos ...

Answer 8

Doe el siguiente trabajo?

resourcesloader.class.getClass().getResource("/package1/resources/repository/SSL-Key/cert.jks")

¿Hay alguna razón no se puede especificar la ruta completa que incluye el paquete?

Answer 9

Ir con las dos respuestas que se han mencionado anteriormente. El primero

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();
resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

En caso de ser uno y lo mismo?

Answer 10

Hice una pequeña modificación en un trazador de líneas de @ jonathan.cone (mediante la adición de .getFile()) para evitar la excepción de puntero nulo, y el establecimiento de la ruta de acceso a directorio de datos. Esto es lo que funcionó para mí:

String realmID = new java.util.Scanner(new java.io.File(RandomDataGenerator.class.getClassLoader().getResource("data/aa-qa-id.csv").getFile().toString())).next();

Answer 11

Utilice esta:

resourcesloader.class.getClassLoader().getResource("/path/to/file").**getPath();**

Answer 12

Con el fin de obtener la ruta de acceso real al archivo puede probar esto:

URL fileUrl = Resourceloader.class.getResource("resources/repository/SSL-Key/cert.jks");
String pathToClass = fileUrl.getPath;    

ResourceLoader es nombre de clase aquí. "Recursos / repositorio / SSL-dominantes / cert.jks" es la ruta relativa al archivo. Si usted tenía su guiclass en ./package1/java con resto de la estructura de carpetas restantes, que tomaría "../resources/repository/SSL-Key/cert.jks" como ruta relativa debido a las reglas que definen la ruta relativa.

De esta manera se puede leer el archivo con BufferedReader. NO utilizar la cadena para identificar la ruta de acceso al archivo, ya que si tiene espacios o algunos caracteres del alfabeto Inglés no en su camino, obtendrá los problemas y el archivo no será encontrado.

BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(fileUrl.openStream()));