java.nio.file.Path dla zasobu classpath

Question

Czy istnieje interfejs API, aby uzyskać zasoby klasy classpath (np. Co otrzymam z Class.getResource(String)) jako java.nio.file.Path? Idealnie, chciałbym użyć nowych, fantazyjnych API Path z zasobami classpath.

Answer 1

Ten działa dla mnie:

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

Answer 2

Okazuje się, że możesz to zrobić, korzystając z wbudowanego Zip File System provider. Jednak przekazanie identyfikatora URI zasobu bezpośrednio do Paths.get nie będzie działać; Zamiast tego, trzeba najpierw stworzyć system plików zip na jar URI bez nazwy wejścia, a następnie odwołać się do wpisu w tym systemie plików:

static Path resourceToPath(URL resource) 
throws IOException, 
     URISyntaxException { 

    Objects.requireNonNull(resource, "Resource URL cannot be null"); 
    URI uri = resource.toURI(); 

    String scheme = uri.getScheme(); 
    if (scheme.equals("file")) { 
     return Paths.get(uri); 
    } 

    if (!scheme.equals("jar")) { 
     throw new IllegalArgumentException("Cannot convert to Path: " + uri); 
    } 

    String s = uri.toString(); 
    int separator = s.indexOf("!/"); 
    String entryName = s.substring(separator + 2); 
    URI fileURI = URI.create(s.substring(0, separator)); 

    FileSystem fs = FileSystems.newFileSystem(fileURI, 
     Collections.<String, Object>emptyMap()); 
    return fs.getPath(entryName); 
} 

Answer 3

pisałem mała pomocnicza metoda odczytu Paths z zasobów twojej klasy. Jest dość przydatny w użyciu, ponieważ wymaga jedynie odniesienia do klasy, w której przechowywane są twoje zasoby, jak również nazwy samego zasobu.

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

Answer 4

Zgadywanie, że to, co chcesz zrobić, to wywołanie Files.lines (...) na zasobie pochodzącym ze ścieżki klas - prawdopodobnie z poziomu słoika.

Od Oracle zawiłe pojęcia kiedy ścieżka jest ścieżką, nie czyniąc getResource powrócić użytkowej ścieżkę, jeśli przebywa w pliku jar, co trzeba zrobić, to coś takiego:

Stream<String> stream = new BufferedReader(new InputStreamReader(ClassLoader.getSystemResourceAsStream("/filename.txt"))).lines(); 

Answer 5

You trzeba zdefiniować system plików do odczytu zasobu z pliku jar, jak wspomniano w https://docs.oracle.com/javase/8/docs/technotes/guides/io/fsp/zipfilesystemprovider.html. I sukces czytać zasobu z pliku jar z poniższych kodów:

Map<String, Object> env = new HashMap<>(); 
try (FileSystem fs = FileSystems.newFileSystem(uri, env)) { 

     Path path = fs.getPath("/path/myResource"); 

     try (Stream<String> lines = Files.lines(path)) { 
      .... 
     } 
    } 

Answer 6

najbardziej ogólne rozwiązanie jest następujące:

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

Główną przeszkodą jest do czynienia z dwoma możliwościami, albo mając istniejący system plików, który powinniśmy używać, ale nie w pobliżu (jak w przypadku URI z file lub nadchodzącego modułu Java 9) lub konieczności otwarcia i bezpiecznego zamknięcia systemu plików (takich jak pliki zip/jar).

Dlatego powyższe rozwiązanie zawiera rzeczywistą akcję w interface, obsługuje oba przypadki, następnie bezpiecznie zamyka się w drugim przypadku i działa z poziomu Java 7 do Javy 9. Sprawdza, czy istnieje już otwarty system plików przed otwarciem nowy, więc działa również w przypadku, gdy inny składnik twojej aplikacji już otworzył system plików dla tego samego pliku zip/jar.

Może być używany we wszystkich wymienionych wyżej wersjach Java, np. do wymieniający zawartość pakietu (java.lang w przykładzie) jak Path s, podobnie jak to:

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

Z Java 8 lub nowszej, można użyć wyrażeń lambda lub odniesienia metoda reprezentują rzeczywiste działania, na przykład

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

zrobić to samo.

---

Ostateczne wydanie systemu modułu Java 9 spowodowało zerwanie powyższego przykładu kodu.JRE niekonsekwentnie zwraca ścieżkę /java.base/java/lang/Object.class dla Object.class.getResource("Object.class"), podczas gdy powinno być /modules/java.base/java/lang/AbstractMethodError.class. To może być ustalona przez poprzedzenie brakującą /modules/ gdy ścieżka rodzic jest zgłaszane jako nieistniejące:

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

Potem będzie znowu działać ze wszystkimi wersjami i metod przechowywania.

Answer 7

Nie można utworzyć identyfikatora URI z zasobów znajdujących się w pliku jar. Można po prostu zapisać go do pliku tymczasowego, a następnie użyć go (java8):

Path path = File.createTempFile("some", "address").toPath(); 
Files.copy(ClassLoader.getSystemResourceAsStream("/path/to/resource"), path, StandardCopyOption.REPLACE_EXISTING);