getResourceAsStream renvoie null

Je charge un fichier texte à partir d'un package dans un JAR compilé de mon projet Java. La structure de répertoire pertinente est la suivante:

/src/initialization/Lifepaths.txt

Mon code charge un fichier en appelant Class::getResourceAsStreampour retourner un fichier InputStream.

public class Lifepaths {
    public static void execute() {
        System.out.println(Lifepaths.class.getClass().
            getResourceAsStream("/initialization/Lifepaths.txt"));
    }

    private Lifepaths() {}

    //This is temporary; will eventually be called from outside
    public static void main(String[] args) {execute();}
}

L'impression sera toujours imprimée null, peu importe ce que j'utilise. Je ne sais pas pourquoi ce qui précède ne fonctionnerait pas, alors j'ai également essayé:

• "/src/initialization/Lifepaths.txt"
• "initialization/Lifepaths.txt"
• "Lifepaths.txt"

Aucun de ces travaux. J'ai lu de nombreuses questions sur le sujet jusqu'à présent, mais aucune d'entre elles n'a été utile - généralement, ils disent simplement de charger les fichiers en utilisant le chemin racine, ce que je fais déjà. Cela, ou simplement charger le fichier à partir du répertoire actuel (juste charger filename), que j'ai également essayé. Le fichier est en cours de compilation dans le JAR à l'emplacement approprié avec le nom approprié.

Comment résoudre ce problème?

Lifepaths.class.getClass().getResourceAsStream(...) charge les ressources à l'aide du chargeur de classe système, il échoue évidemment car il ne voit pas vos JAR

Lifepaths.class.getResourceAsStream(...) charge les ressources en utilisant le même chargeur de classe que celui qui a chargé la classe Lifepaths et il doit avoir accès aux ressources de vos JAR

Les règles sont les suivantes:

1. vérifiez l'emplacement du fichier que vous souhaitez charger dans le JAR (et assurez-vous ainsi qu'il est effectivement ajouté au JAR)
2. utilisez soit un chemin absolu: le chemin commence à la racine du JAR
3. utilisez un chemin relatif: le chemin commence au répertoire du package de la classe que vous appelez getResource / getResoucreAsStream

Et essaye:

Lifepaths.class.getResourceAsStream("/initialization/Lifepaths.txt")

au lieu de

Lifepaths.class.getClass().getResourceAsStream("/initialization/Lifepaths.txt")

(je ne sais pas si cela fait une différence, mais le premier utilisera le bon ClassLoader / JAR, alors que je ne suis pas sûr du dernier)

Il existe donc plusieurs façons d'obtenir une ressource à partir d'un fichier jar et chacune a une syntaxe légèrement différente où le chemin doit être spécifié différemment.

La meilleure explication que j'ai vue est cet article de JavaWorld . Je vais résumer ici, mais si vous voulez en savoir plus, vous devriez consulter l'article.

Méthodes

1) ClassLoader.getResourceAsStream() .

Format: "/" - noms séparés; pas de "/" de tête (tous les noms sont absolus).

Exemple: this.getClass().getClassLoader().getResourceAsStream("some/pkg/resource.properties");

2) Class.getResourceAsStream()

Format: "/" - noms séparés; "/" en tête indique des noms absolus; tous les autres noms sont relatifs au package de la classe

Exemple: this.getClass().getResourceAsStream("/some/pkg/resource.properties");

N'utilisez pas de chemins absolus, rendez-les relatifs au répertoire 'resources' de votre projet. Code rapide et sale qui affiche le contenu de MyTest.txt à partir du répertoire 'resources'.

@Test
public void testDefaultResource() {
    // can we see default resources
    BufferedInputStream result = (BufferedInputStream) 
         Config.class.getClassLoader().getResourceAsStream("MyTest.txt");
    byte [] b = new byte[256];
    int val = 0;
    String txt = null;
    do {
        try {
            val = result.read(b);
            if (val > 0) {
                txt += new String(b, 0, val);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
    } while (val > -1);
    System.out.println(txt);
}

Vous voudrez peut-être essayer ceci pour obtenir le flux, c'est-à-dire obtenir d'abord l'url puis l'ouvrir en tant que flux.

URL url = getClass().getResource("/initialization/Lifepaths.txt"); 
InputStream strm = url.openStream(); 

Une fois, j'ai eu une question similaire: la lecture du fichier txt à partir du jar échoue mais la lecture de l'image fonctionne

Il semble y avoir un problème avec le ClassLoader que vous utilisez. Utilisez le contextClassLoader pour charger la classe. Ceci indépendamment du fait que ce soit dans une méthode statique / non statique

Thread.currentThread().getContextClassLoader().getResourceAsStream......

Je me suis retrouvé dans un problème similaire. Depuis que j'utilise maven, j'ai dû mettre à jour mon pom.xml pour inclure quelque chose comme ceci:

   ...
</dependencies>
<build>
    <resources>
        <resource>
            <directory>/src/main/resources</directory>
        </resource>
        <resource>
            <directory>../src/main/resources</directory>
        </resource>
    </resources>
    <pluginManagement>
        ...

Notez la balise de ressource pour spécifier où se trouve ce dossier. Si vous avez des projets imbriqués (comme moi), vous voudrez peut-être obtenir des ressources d'autres domaines plutôt que simplement dans le module dans lequel vous travaillez. Cela permet de réduire la conservation du même fichier dans chaque dépôt si vous utilisez des données de configuration similaires

Ce qui a fonctionné pour moi, c'est d'ajouter le fichier sous My Project/Java Resources/srcpuis d'utiliser

this.getClass().getClassLoader().getResourceAsStream("myfile.txt");

Je n'avais pas besoin d'ajouter explicitement ce fichier au chemin (l'ajouter à le /srcfait apparemment)

Je ne sais pas si cela est utile, mais dans mon cas, j'avais ma ressource dans le dossier / src / et j'obtenais cette erreur. J'ai ensuite déplacé l'image dans le dossier bin et cela a résolu le problème.

Assurez-vous que votre répertoire de ressources (par exemple "src") est dans votre chemin de classe (assurez-vous qu'il s'agit d'un répertoire source dans votre chemin de construction dans eclipse).

Assurez-vous que clazz est chargé depuis le chargeur de classe principal.

Ensuite, pour charger src / initialization / Lifepaths.txt, utilisez

clazz.getResourceAsStream("/initialization/Lifepaths.txt");

Pourquoi: clazz.getResourcesAsStream(foo)recherche foo dans le classpath de clazz , par rapport au répertoire dans lequel clazz vit . Le premier "/" le charge à partir de la racine de n'importe quel répertoire dans le classpath de clazz.

À moins que vous ne soyez dans un conteneur d'un type quelconque, comme Tomcat, ou que vous fassiez quelque chose directement avec ClassLoaders, vous pouvez simplement traiter votre chemin de classe eclipse / ligne de commande comme le seul chemin de classe du chargeur de classe.

Le chargeur de classe JVM par défaut utilisera le chargeur de classe parent pour charger les ressources en premier: .

Lifepaths.class.getClass()Le chargeur de classe est bootstrap classloader, donc getResourceAsStreamrecherchera uniquement $ JAVA_HOME, quel que soit l'utilisateur fourni classpath. De toute évidence, Lifepaths.txt n'est pas là.

Lifepaths.classLe classloader de est system classpath classloader, de même getResourceAsStreamque la recherche définie par l'utilisateur classpathet Lifepaths.txt est là.

Lors de l'utilisation java.lang.Class#getResourceAsStream(String name), le nom qui ne commence pas par '/' sera ajouté avec package namecomme préfixe. Si vous voulez éviter cela, veuillez utiliser java.lang.ClassLoader#getResourceAsStream. Par exemple:

ClassLoader loader = Thread.currentThread().getContextClassLoader();
String resourceName = "Lifepaths.txt";
InputStream resourceStream = loader.getResourceAsStream(resourceName); 

Grosso modo:

getClass().getResource("/") ~ = Thread.currentThread().getContextClassLoader().getResource(".")

Supposons que la structure de votre projet soit la suivante:

├── src
│   ├── main
│   └── test
│   └── test
│       ├── java
│       │   └── com
│       │       └── github
│       │           └── xyz
│       │               └── proj
│       │                   ├── MainTest.java
│       │                   └── TestBase.java
│       └── resources
│           └── abcd.txt
└── target
    └── test-classes
        ├── com
        └── abcd.txt

// in MainClass.java
this.getClass.getResource("/") -> "~/proj_dir/target/test-classes/"
this.getClass.getResource(".") -> "~/proj_dir/target/test-classes/com/github/xyz/proj/"
Thread.currentThread().getContextClassLoader().getResources(".") -> "~/proj_dir/target/test-classes/"
Thread.currentThread().getContextClassLoader().getResources("/") ->  null

si vous utilisez Maven, assurez-vous que votre emballage est «pot» et non «pom».

<packaging>jar</packaging>

Ce dont vous avez vraiment besoin est un chemin de classe absolu complet pour le fichier. Donc, au lieu de le deviner, essayez de trouver le ROOT, puis déplacez le fichier vers un meilleur emplacement base une structure de fichier <.war> ...

URL test1 = getClass().getResource("/");
URL test2 = getClass().getClassLoader().getResource("/");            
URL test3 = getClass().getClassLoader().getResource("../");

logger.info(test1.getPath()); 
logger.info(test2.getPath());
logger.info(test3.getPath());

Ce qui a fonctionné pour moi, c'est que j'ai placé le fichier sous

src/main/java/myfile.log

et

InputStream is = getClass().getClassLoader().getResourceAsStream("myfile.log");
        
        if (is == null) {
            throw new FileNotFoundException("Log file not provided");
        }

@Emracool ... Je vous suggère une alternative. Puisque vous semblez essayer de charger un fichier * .txt. Mieux vaut utiliser FileInputStream()plutôt que ce getClass().getClassLoader().getResourceAsStream()ou ennuyeux getClass().getResourceAsStream(). Au moins, votre code s'exécutera correctement.