Java LanguageRessources (sur classpath)


Introduction

Java permet la récupération des ressources basées sur des fichiers stockées dans un fichier JAR à côté des classes compilées. Cette rubrique se concentre sur le chargement de ces ressources et leur mise à disposition dans votre code.

Remarques

Une ressource est une donnée de type fichier avec un nom de chemin d'accès, qui réside dans le chemin de classe. L'utilisation la plus courante des ressources consiste à regrouper des images d'application, des sons et des données en lecture seule (telles que la configuration par défaut).

Les ressources sont accessibles avec les méthodes ClassLoader.getResource et ClassLoader.getResourceAsStream . Le cas d'utilisation le plus courant est d'avoir des ressources placées dans le même package que la classe qui les lit; les méthodes Class.getResource et Class.getResourceAsStream servent ce cas d'utilisation commun.

La seule différence entre une méthode getResource et la méthode getResourceAsStream est que la première renvoie une URL, tandis que la seconde ouvre cette URL et renvoie un InputStream.

Les méthodes de ClassLoader acceptent un nom de ressource de type chemin d'accès en tant qu'argument et effectuent une recherche dans chaque emplacement du chemin de classe du ClassLoader pour une entrée correspondant à ce nom.

  • Si un emplacement de chemin de classe est un fichier .jar, une entrée jar avec le nom spécifié est considérée comme une correspondance.
  • Si un emplacement de chemin de classe est un répertoire, un fichier relatif sous ce répertoire avec le nom spécifié est considéré comme une correspondance.

Le nom de la ressource est similaire à la portion de chemin d'une URL relative. Sur toutes les plateformes, il utilise des barres obliques ( / ) comme séparateurs de répertoires. Il ne doit pas commencer par une barre oblique.

Les méthodes correspondantes de la classe sont similaires, sauf:

  • Le nom de la ressource peut commencer par une barre oblique, auquel cas cette barre oblique initiale est supprimée et le reste du nom est transmis à la méthode correspondante de ClassLoader.
  • Si le nom de la ressource ne commence pas par une barre oblique, il est traité comme relatif à la classe dont la méthode getResource ou getResourceAsStream est appelée. Le nom de ressource réel devient package / name , où package est le nom du package auquel appartient la classe, chaque période étant remplacée par une barre oblique, et name est l'argument d'origine donné à la méthode.

Par exemple:

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

Les ressources doivent être placées dans des packages nommés, plutôt qu'à la racine d'un fichier .jar, pour la même raison, les classes sont placées dans des packages: pour empêcher les collisions entre plusieurs fournisseurs. Par exemple, si plusieurs chemins d'accès au fichier .jar se trouvent dans le chemin d'accès aux classes et que plusieurs d'entre eux contiennent une entrée config.properties dans sa racine, les appels aux méthodes getResource ou getResourceAsStream renvoient config.properties. le classpath. Ce comportement n'est pas prévisible dans les environnements où l'ordre de classpath n'est pas sous le contrôle direct de l'application, tel que Java EE.

Toutes les méthodes getResource et getResourceAsStream renvoient null si la ressource spécifiée n'existe pas. Comme les ressources doivent être ajoutées à l'application au moment de la construction, leurs emplacements doivent être connus lors de l'écriture du code; le fait de ne pas trouver une ressource à l'exécution est généralement le résultat d'une erreur du programmeur.

Les ressources sont en lecture seule. Il n'y a aucun moyen d'écrire sur une ressource. Les développeurs novices commettent souvent l'erreur de supposer que la ressource étant un fichier physique distinct lors du développement dans un IDE (comme Eclipse), il sera prudent de la traiter comme un fichier physique distinct dans le cas général. Cependant, ce n'est pas correct; les applications sont presque toujours distribuées sous forme d'archives telles que les fichiers .jar ou .war, et dans ce cas, une ressource ne sera pas un fichier distinct et ne sera pas accessible en écriture. (La méthode getFile de la classe d'URL n'est pas une solution de contournement pour cela; malgré son nom, elle renvoie simplement la portion de chemin d'une URL, ce qui n'est en aucun cas un nom de fichier valide.)

Il n'y a aucun moyen sûr de lister les ressources à l'exécution. Encore une fois, les développeurs étant responsables de l'ajout de fichiers de ressources à l'application au moment de la construction, les développeurs doivent déjà connaître leurs chemins. Bien qu'il existe des solutions de contournement, elles ne sont pas fiables et finiront par échouer.

Ressources (sur classpath) Exemples Liés