java.nio.fichier.Chemin d'accès d'un chemin de classe de ressource

Celui-ci fonctionne pour moi:

return Paths.get(ClassLoader.getSystemResource(resourceName).toURI());

La plus générale, la solution est la suivante:

interface IOConsumer<T> {
    void accept(T t) throws IOException;
}
public static void processRessource(URI uri, IOConsumer<Path> action) throws IOException {
    try {
        Path p=Paths.get(uri);
        action.accept(p);
    }
    catch(FileSystemNotFoundException ex) {
        try(FileSystem fs = FileSystems.newFileSystem(
                uri, Collections.<String,Object>emptyMap())) {
            Path p = fs.provider().getPath(uri);
            action.accept(p);
        }
    }
}

L'obstacle principal est de traiter les deux possibilités, soit, avoir un système de fichier en cours que nous devrions utiliser, mais pas à proximité (comme avec file Uri ou le Java 9 du module de stockage), ou d'avoir à ouvrir et donc de fermer le système de fichiers nous-mêmes (zip/fichiers jar).

Par conséquent, la solution ci-dessus encapsule l'action réelle dans un interface, gère les deux cas, la sécurité de fermeture par la suite dans le second cas, et des œuvres de Java 7 de Java 10. Il examine s'il existe déjà un système de fichiers ouverts avant d'en ouvrir un nouveau, de sorte qu'il fonctionne également dans le cas où un autre composant de votre application dispose déjà d'un système de fichiers pour le même zip/fichier jar.

Il peut être utilisé dans toutes les versions de Java nommé ci-dessus, par exemple pour lister le contenu d'un paquet (java.lang dans l'exemple) que Paths, comme ceci:

processRessource(Object.class.getResource("Object.class").toURI(), new IOConsumer<Path>() {
    public void accept(Path path) throws IOException {
        try(DirectoryStream<Path> ds = Files.newDirectoryStream(path.getParent())) {
            for(Path p: ds)
                System.out.println(p);
        }
    }
});

Avec Java 8 ou plus récent, vous pouvez utiliser des expressions lambda ou de la méthode références de représenter le réel de l'action, par exemple

processRessource(Object.class.getResource("Object.class").toURI(), path -> {
    try(Stream<Path> stream = Files.list(path.getParent())) {
        stream.forEach(System.out::println);
    }
});

à faire de même.

---

La dernière version de Java 9 module du système a brisé le code ci-dessus par exemple. La JRE de façon incohérente retourne le chemin d'accès /java.base/java/lang/Object.class pour Object.class.getResource("Object.class") alors qu'elle devrait être /modules/java.base/java/lang/Object.class. Ceci peut être corrigé en ajoutant le manque /modules/ lorsque le chemin d'accès parent est signalé comme non-existant:

processRessource(Object.class.getResource("Object.class").toURI(), path -> {
    Path p = path.getParent();
    if(!Files.exists(p))
        p = p.resolve("/modules").resolve(p.getRoot().relativize(p));
    try(Stream<Path> stream = Files.list(p)) {
        stream.forEach(System.out::println);
    }
});

Ensuite, il travaillera de nouveau avec toutes les versions et les méthodes de stockage.

J'ai écrit une petite méthode d'aide à lire Paths à partir de votre classe de ressources. Il est assez pratique à utiliser car il ne nécessite qu'une seule référence de la classe, vous avez stocké vos ressources ainsi que le nom de la ressource elle-même.

public static Path getResourcePath(Class<?> resourceClass, String resourceName) throws URISyntaxException {
    URL url = resourceClass.getResource(resourceName);
    return Paths.get(url.toURI());
}  

Lire un Fichier à partir du dossier de ressources à l'aide de NIO, dans java8

public static String read(String fileName) {

        Path path;
        StringBuilder data = new StringBuilder();
        Stream<String> lines = null;
        try {
            path = Paths.get(Thread.currentThread().getContextClassLoader().getResource(fileName).toURI());
            lines = Files.lines(path);
        } catch (URISyntaxException | IOException e) {
            logger.error("Error in reading propertied file " + e);
            throw new RuntimeException(e);
        }

        lines.forEach(line -> data.append(line));
        lines.close();
        return data.toString();
    }