ressource ouvert avec chemin relatif en java

Question

Dans mon application Java je dois obtenir des fichiers et des répertoires.

Ceci est la structure du programme:

./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 charge la classe resourcesloader qui chargera mes ressources (fichiers et de répertoires).

En ce qui concerne le fichier, j'ai essayé

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

afin d'obtenir le vrai chemin, mais cette façon ne fonctionne pas.

Je ne sais pas comment faire le répertoire.

Answer 1

Alimenter le chemin relatif au classloader, pas la classe que vous obtenez le chargeur de. Par exemple:

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

Answer 2

J'ai eu des problèmes avec l'aide de la méthode getClass().getResource("filename.txt"). A la lecture des instructions Java docs, si votre ressource n'est pas dans le même package que la classe que vous essayez d'accéder à la ressource à partir, alors vous devez lui donner un chemin relatif en commençant par '/'. La stratégie recommandée est de mettre vos fichiers de ressources dans un dossier « ressources » dans le répertoire racine. Ainsi, par exemple si vous avez la structure:

src/main/com/mycompany/myapp

vous pouvez ajouter un dossier de ressources tel que recommandé par Maven dans:

src/main/resources

En outre, vous pouvez ajouter des sous-dossiers dans le dossier des ressources

src/main/resources/textfiles

et dire que votre fichier est appelé myfile.txt si vous avez

src/main/resources/textfiles/myfile.txt

Maintenant, voici où le problème de chemin stupide entre en jeu. Disons que vous avez une classe dans votre com.mycompany.myapp package, et que vous voulez accéder au fichier myfile.txt à partir de votre dossier de ressources. Certains disent que vous devez donner:

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

ou

"/resources/textfiles/myfile.txt"

les deux sont faux. Après avoir couru mvn clean compile, les fichiers et les dossiers sont copiés dans le:

myapp/target/classes 

dossier

. Mais le dossier des ressources est pas là, seulement les dossiers dans le dossier des ressources. Vous avez donc:

myapp/target/classes/textfiles/myfile.txt

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

de sorte que le chemin correct pour donner à la méthode de getClass().getResource("") est:

"/textfiles/myfile.txt"

ici est:

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

Ce ne retournera plus nulle, mais retournera votre classe. J'espère que cela aide quelqu'un. Il est étrange pour moi, que le dossier "resources" n'est pas copié aussi, mais seulement les sous-dossiers et fichiers directement dans le dossier "resources". Il me semble logique que le dossier "resources" serait également trouvé sous "myapp/target/classes"

Answer 3

Dans l'espoir de fournir des informations supplémentaires pour ceux qui ne prennent pas aussi rapidement que d'autres, je voudrais donner mon scénario car il a une configuration légèrement différente. Mon projet a été installé avec la structure de répertoire suivant (en utilisant 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

Je faisais mes questions charger des ressources de la res . Je voulais que tous mes ressources distinctes de mon code source (simplement pour des fins managment / organisation). Alors, ce que je devais faire était d'ajouter le res répertoire build-chemin , puis accéder à la ressource via:

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");

Remarque: Le / est omis depuis le début de la chaîne de ressource parce que je suis en utilisant ClassLoader.getResource (String) au lieu de Class.getResource (String) .

Answer 4

@GianCarlo: Vous pouvez essayer d'appeler user.dir la propriété système qui vous donnera la racine de votre projet java, puis ajoutez ce chemin ne à votre chemin relatif par exemple:

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

Lorsque vous utilisez « getResource » sur une classe, un chemin relatif est résolu basé sur l'emballage de la classe est. Lorsque vous utilisez « getResource » sur un ClassLoader, un chemin relatif est résolu sur la base du dossier racine.

Si vous utilisez un chemin absolu, les méthodes à la fois « GetResource » commencera au dossier racine.

Answer 6

Pour ceux qui utilisent Eclipse + Maven. Dites que vous essayez d'accéder au fichier images/pic.jpg dans src/main/resources. En procédant ainsi:

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

est tout à fait correct, mais peut entraîner une exception de pointeur NULL. On dirait que l'éclipse ne reconnaît pas les dossiers dans la structure des répertoires Maven sous forme de dossiers source tout de suite. En supprimant et le dossier src/main/resources de la liste des dossiers source du projet et de le remettre (projet> Propriétés> Chemin de compilation Java> source> supprimer / ajouter le dossier), j'ai pu résoudre ce problème.

Answer 7

resourcesloader.class.getClass()

Peut être décomposé à:

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

Ce qui signifie que vous essayez de charger la ressource en utilisant une classe bootstrap.

Au lieu de cela, vous voulez probablement quelque chose comme:

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

Si seulement javac mis en garde contre l'appel de méthodes statiques sur des contextes non statiques ...

Answer 8

Doe le travail suivant?

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

Y at-il une raison que vous ne pouvez pas spécifier le chemin complet, y compris le paquet?

Answer 9

Voulez-vous profiter des deux réponses comme mentionné ci-dessus. Le premier

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

doit être une seule et même chose?

Answer 10

J'ai fait une petite modification sur un paquebot @ jonathan.cone (en ajoutant .getFile()) pour éviter NullPointerException, et la définition du chemin vers le répertoire de données. Voici ce qui a fonctionné pour moi:

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

Answer 11

Utilisez ceci:

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

Answer 12

Pour obtenir vrai chemin du fichier que vous pouvez essayer ceci:

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

ResourceLoader est classname ici. « Ressources / dépôt / SSL-clés / cert.jks » est le chemin relatif au fichier. Si vous aviez votre guiclass en ./package1/java avec le reste de la structure du dossier restant, vous prendriez « ../resources/repository/SSL-Key/cert.jks » comme chemin relatif en raison des règles définissant le chemin relatif.

De cette façon, vous pouvez lire votre fichier avec BufferedReader. NE PAS UTILISER LE STRING pour identifier le chemin du fichier, parce que si vous avez des espaces ou des caractères de l'alphabet pas l'anglais sur votre chemin, vous obtiendrez des problèmes et le fichier ne sera pas trouvé.

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