Moyen privilégié de chargement des ressources en Java

Je voudrais savoir le meilleur moyen de chargement d'une ressource en Java:

this.getClass().getResource() (or getResourceAsStream()),
Thread.currentThread().getContextClassLoader().getResource(name),
System.class.getResource(name).

InformationsquelleAutor PomCompot | 2010-10-05

129

De travail de la solution en fonction de ce que vous voulez...

Il y a deux choses que getResource/getResourceAsStream() aurez à partir de la classe, il est appelé sur...
1. Le chargeur de classe
2. L'emplacement de départ
Donc, si vous ne
```
this.getClass().getResource("foo.txt");
```
il va tenter de charger foo.txt à partir de la même formule que le "il" de la classe et avec le chargeur de classe de la "ce" de la classe. Si vous mettez un "/" devant alors vous êtes absolument référencer la ressource.
```
this.getClass().getResource("/x/y/z/foo.txt")
```
va charger la ressource à partir de la classe loader de "ce" et de la "x".y.z paquet (il devra être dans le même répertoire que les classes de ce package).
```
Thread.currentThread().getContextClassLoader().getResource(name)
```
sera chargé avec le contexte de la classe loader, mais ne permettra pas de résoudre le nom selon l'une quelconque paquet (il doit être absolument référencé)
```
System.class.getResource(name)
```
Va charger la ressource avec le système de chargeur de classe (il devrait être absolument référencé en tant que bien, car vous ne serez pas en mesure de mettre n'importe quoi dans le java.lang package (le package de Système).

Il suffit de prendre un coup d'oeil à la source. Indique également que getResourceAsStream appelle simplement "openStream" sur l'URL renvoyée à partir de getResource et des rendements.
- Autant que je sache les noms des paquetages n'ont pas d'importance, c'est le chemin de classe de la classe loader qui ne.
- si vous regardez le code source, vous remarquerez que le nom de la classe n'importe quand vous appelez getResource sur une classe. La première chose que cet appel ne fait qu'appeler "resolveName" qui ajoute le paquet préfixe si approprié. Javadoc pour resolveName est "Ajouter un package préfixe de nom si le nom n'est pas absolue Supprimer "/" si le nom est absolue"
- Ah, je vois. Absolue signifie ici par rapport à la variable classpath, plutôt que de système de fichiers absolue.
- Je tiens juste à ajouter que vous devriez toujours vérifier que le flux retourné à partir de getResourceAsStream() n'est pas nulle, car il sera si la ressource n'est pas dans le classpath.
- Il faut également noter que l'utilisation du contexte de la classe loader permet au chargeur de classe à être modifiée lors de l'exécution via Thread#setContextClassLoader. Ceci est utile si vous devez modifier le chemin de classe, tandis que le programme est en cours d'exécution.
- Que si l'utilisateur final à l'aide de pot de la probject? Les pots sont des archives vous savez donc ce qui se passe si l'on précise certaines ressources avec une adresse par rapport à certains de la classe alors qu'il est emballé dans un fichier JAR?
- ce sera très bien. La raison pour laquelle vous utiliser ce mécanisme pour charger les ressources, c'est qu'il est capable de charger, même si la ressource est dans un bocal.
- et si une application a besoin de créer des ressources temporelles? Pas android, je veux dire de l'application Java en général. Par exemple, mon app veut générer un certificat en tant que ressource et de l'utiliser. Ce mécanisme est-il du travail?
- Mohamadi Vous ne devriez pas écrire quoi que ce soit pour les ressources Java puisque vous ne savez jamais si c'est encore possible (c'est pas si c'est un jar, vous êtes en cours d'exécution). Aussi, ils n'ont pas à être des fichiers (cela pourrait être une boutique virtuelle fournie par le conteneur). Au lieu de copier les ressources nécessaires dans le dossier tmp (il y a une util pour ce départ avec Java 7, IIRC) et ensuite modifier à votre convenance. BTW, il est possible d'obtenir une ressource du chemin d'accès au fichier et il va même travail, par exemple lors de l'exécution des tests unitaires à partir d'Eclipse (mais ne le faites pas ;)).
InformationsquelleAutor Michael Wiles
13

Bien, en partie dépend de ce que vous voulez faire si vous êtes fait dans une classe dérivée.

Par exemple, supposons que SuperClass est dans A.jar et SubClass est dans B.jar et vous êtes à l'exécution de code dans une méthode d'instance a déclaré dans SuperClass mais où this fait référence à une instance de SubClass. Si vous utilisez this.getClass().getResource() il va chercher par rapport à SubClass, dans B.jar. Je pense que c'est généralement pas ce qui est nécessaire.

Personnellement, je serais probablement utiliser Foo.class.getResourceAsStream(name) le plus souvent - si vous connaissez déjà le nom de la ressource que vous êtes après, et vous êtes sûr de l'endroit où elle est relative à Foo, c'est le plus robuste de la façon de faire de l'OMI.

Bien sûr il y a des moments où c'est pas ce que vous voulez: juger chaque cas selon ses mérites. C'est juste le "je sais que cette ressource est livré avec cette classe" est la plus commune que j'ai pu croiser.
- skeet: le doute dans l'énoncé "vous êtes l'exécution de code dans une méthode d'instance de la super-classe, mais où cela fait référence à une instance de la sous-classe" si nous sommes à l'exécution d'instructions à l'intérieur de la méthode d'instance de la super-classe alors "ce" fera référence à la super-classe de ne pas la sous-classe.
- Non, il ne le pourra pas. L'essayer! Créer deux classes, la fabrication d'un dériver de l'autre, et puis dans la superclasse imprimer this.getClass(). Créer une instance de la sous-classe et l'appel à la méthode... ça va imprimer le nom de la sous-classe, pas la super-classe.
- grâce sous-classe de la méthode d'instance appelle la méthode de la superclasse.
- Ce que je me demandais, est de savoir si l'utilisation de ce.getResourceAsStream ne seront en mesure de charger une ressource à partir de la même bocal que cette clas, et non d'un autre bocal. Selon mes estimations, c'est le chargeur de classe qui se charge de la ressource et sûrement ne pas être confiné à partir de chargement à partir de seulement l'un bocal?
InformationsquelleAutor Jon Skeet

Je recherche trois endroits comme indiqué ci-dessous. Commentaires bienvenus.

public URL getResource(String resource){

    URL url ;

    //Try with the Thread Context Loader. 
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    if(classLoader != null){
        url = classLoader.getResource(resource);
        if(url != null){
            return url;
        }
    }

    //Let's now try with the classloader that loaded this class.
    classLoader = Loader.class.getClassLoader();
    if(classLoader != null){
        url = classLoader.getResource(resource);
        if(url != null){
            return url;
        }
    }

    //Last ditch attempt. Get the resource from the classpath.
    return ClassLoader.getSystemResource(resource);
}

Merci, c'est une excellente idée. Juste ce dont j'avais besoin.
J'ai été en regardant les commentaires dans votre code et le dernier a l'air intéressant. Ne sont pas toutes les ressources chargées depuis le classpath? Et ce cas, le chargeur de classe.getSystemResource() couvrent que le ci-dessus n'a pas réussi?
En toute honnêteté, je ne comprends pas pourquoi vous voulez charger des fichiers à partir de 3 endroits différents. Vous ne savez pas où sont stockés les fichiers ?

InformationsquelleAutor dogbane

Je sais que ce vraiment la fin pour une autre réponse, mais je voulais juste partager ce qui m'a aidé à la fin. Il sera aussi charger des ressources/fichiers à partir du chemin d'accès absolu du système de fichier (pas seulement le classpath).

public class ResourceLoader {

    public static URL getResource(String resource) {
        final List<ClassLoader> classLoaders = new ArrayList<ClassLoader>();
        classLoaders.add(Thread.currentThread().getContextClassLoader());
        classLoaders.add(ResourceLoader.class.getClassLoader());

        for (ClassLoader classLoader : classLoaders) {
            final URL url = getResourceWith(classLoader, resource);
            if (url != null) {
                return url;
            }
        }

        final URL systemResource = ClassLoader.getSystemResource(resource);
        if (systemResource != null) {
            return systemResource;
        } else {
            try {
                return new File(resource).toURI().toURL();
            } catch (MalformedURLException e) {
                return null;
            }
        }
    }

    private static URL getResourceWith(ClassLoader classLoader, String resource) {
        if (classLoader != null) {
            return classLoader.getResource(resource);
        }
        return null;
    }

}

InformationsquelleAutor nyxz

-1

J'ai essayé beaucoup de moyens et fonctions que suggéré ci-dessus, mais ils n'ont pas de travail dans mon projet. De toute façon j'ai trouvé la solution et c'est ici:
```
try {
    InputStream path = this.getClass().getClassLoader().getResourceAsStream("img/left-hand.png");
    img = ImageIO.read(path);
} catch (IOException e) {
    e.printStackTrace();
}
```
- Il est mieux d'utiliser this.getClass().getResourceAsStream() dans ce cas. Si vous obtenez un coup d'oeil à la source de la getResourceAsStream méthode, vous remarquerez qu'il fait la même chose que vous, mais de façon plus intelligente (de secours si aucune ClassLoader peut être trouvé sur la classe). Il indique également que vous pouvez rencontrer un potentiel null sur getClassLoader dans votre code ...
- comme je l'ai dit this.getClass().getResourceAsStream() ne fonctionne pas pour moi, donc j'utilise et qui fonctionne. Je pense qu'il y a certaines personnes qui peut faire face à un problème comme le mien.
InformationsquelleAutor Vladislav

Vous devez vous connecter pour publier un commentaire.