Ich suche nach einer Möglichkeit, eine Liste aller Ressourcennamen aus einem bestimmten Klassenpfadverzeichnis abzurufen, ähnlich einer Methode List<String> getResourceNames (String directoryName).

Um zum Beispiel ein Classpath - Verzeichnis angegeben x/y/zenthält Dateien a.html, b.html, c.htmlund ein Unterverzeichnis d, getResourceNames("x/y/z")sollte zurückgeben eine List<String>der folgenden Zeichenketten enthalten: ['a.html', 'b.html', 'c.html', 'd'].

Es sollte sowohl für Ressourcen im Dateisystem als auch für Jars funktionieren.

Ich weiß, dass ich mit Files, JarFiles und URLs einen kurzen Ausschnitt schreiben kann , aber ich möchte das Rad nicht neu erfinden. Meine Frage ist angesichts der vorhandenen öffentlich verfügbaren Bibliotheken, wie diese am schnellsten implementiert werden kann getResourceNames. Spring- und Apache Commons-Stapel sind beide machbar.

Benutzerdefinierter Scanner

Implementieren Sie Ihren eigenen Scanner. Beispielsweise:

private List<String> getResourceFiles(String path) throws IOException {
    List<String> filenames = new ArrayList<>();

    try (
            InputStream in = getResourceAsStream(path);
            BufferedReader br = new BufferedReader(new InputStreamReader(in))) {
        String resource;

        while ((resource = br.readLine()) != null) {
            filenames.add(resource);
        }
    }

    return filenames;
}

private InputStream getResourceAsStream(String resource) {
    final InputStream in
            = getContextClassLoader().getResourceAsStream(resource);

    return in == null ? getClass().getResourceAsStream(resource) : in;
}

private ClassLoader getContextClassLoader() {
    return Thread.currentThread().getContextClassLoader();
}

Frühlingsrahmen

Verwendung PathMatchingResourcePatternResolveraus Spring Framework.

Ronmamo Reflexionen

Die anderen Techniken können zur Laufzeit für große CLASSPATH-Werte langsam sein. Eine schnellere Lösung ist die Verwendung der Reflections-API von ronmamo , die die Suche zur Kompilierungszeit vorkompiliert.

Hier ist der Code
Quelle : forums.devx.com/showthread.php?t=153784

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

/**
 * list resources available from the classpath @ *
 */
public class ResourceList{

    /**
     * for all elements of java.class.path get a Collection of resources Pattern
     * pattern = Pattern.compile(".*"); gets all resources
     * 
     * @param pattern
     *            the pattern to match
     * @return the resources in the order they are found
     */
    public static Collection<String> getResources(
        final Pattern pattern){
        final ArrayList<String> retval = new ArrayList<String>();
        final String classPath = System.getProperty("java.class.path", ".");
        final String[] classPathElements = classPath.split(System.getProperty("path.separator"));
        for(final String element : classPathElements){
            retval.addAll(getResources(element, pattern));
        }
        return retval;
    }

    private static Collection<String> getResources(
        final String element,
        final Pattern pattern){
        final ArrayList<String> retval = new ArrayList<String>();
        final File file = new File(element);
        if(file.isDirectory()){
            retval.addAll(getResourcesFromDirectory(file, pattern));
        } else{
            retval.addAll(getResourcesFromJarFile(file, pattern));
        }
        return retval;
    }

    private static Collection<String> getResourcesFromJarFile(
        final File file,
        final Pattern pattern){
        final ArrayList<String> retval = new ArrayList<String>();
        ZipFile zf;
        try{
            zf = new ZipFile(file);
        } catch(final ZipException e){
            throw new Error(e);
        } catch(final IOException e){
            throw new Error(e);
        }
        final Enumeration e = zf.entries();
        while(e.hasMoreElements()){
            final ZipEntry ze = (ZipEntry) e.nextElement();
            final String fileName = ze.getName();
            final boolean accept = pattern.matcher(fileName).matches();
            if(accept){
                retval.add(fileName);
            }
        }
        try{
            zf.close();
        } catch(final IOException e1){
            throw new Error(e1);
        }
        return retval;
    }

    private static Collection<String> getResourcesFromDirectory(
        final File directory,
        final Pattern pattern){
        final ArrayList<String> retval = new ArrayList<String>();
        final File[] fileList = directory.listFiles();
        for(final File file : fileList){
            if(file.isDirectory()){
                retval.addAll(getResourcesFromDirectory(file, pattern));
            } else{
                try{
                    final String fileName = file.getCanonicalPath();
                    final boolean accept = pattern.matcher(fileName).matches();
                    if(accept){
                        retval.add(fileName);
                    }
                } catch(final IOException e){
                    throw new Error(e);
                }
            }
        }
        return retval;
    }

    /**
     * list the resources that match args[0]
     * 
     * @param args
     *            args[0] is the pattern to match, or list all resources if
     *            there are no args
     */
    public static void main(final String[] args){
        Pattern pattern;
        if(args.length < 1){
            pattern = Pattern.compile(".*");
        } else{
            pattern = Pattern.compile(args[0]);
        }
        final Collection<String> list = ResourceList.getResources(pattern);
        for(final String name : list){
            System.out.println(name);
        }
    }
}  

Wenn Sie Spring verwenden, schauen Sie sich PathMatchingResourcePatternResolver an

Mit Reflexionen

Holen Sie sich alles auf den Klassenpfad:

Reflections reflections = new Reflections(null, new ResourcesScanner());
Set<String> resourceList = reflections.getResources(x -> true);

Ein weiteres Beispiel : Holen Sie sich alle Dateien mit der Erweiterung .csv aus some.package :

Reflections reflections = new Reflections("some.package", new ResourcesScanner());
Set<String> fileNames = reflections.getResources(Pattern.compile(".*\\.csv"));

Wenn Sie Apache commonsIO verwenden, können Sie für das Dateisystem verwenden (optional mit Erweiterungsfilter):

Collection<File> files = FileUtils.listFiles(new File("directory/"), null, false);

und für Ressourcen / Klassenpfad:

List<String> files = IOUtils.readLines(MyClass.class.getClassLoader().getResourceAsStream("directory/"), Charsets.UTF_8);

Wenn Sie nicht wissen, ob sich "directoy /" im Dateisystem oder in Ressourcen befindet, können Sie a hinzufügen

if (new File("directory/").isDirectory())

oder

if (MyClass.class.getClassLoader().getResource("directory/") != null)

vor den Anrufen und verwenden Sie beide in Kombination ...

In Bezug auf den PathMatchingResourcePatternResolver wird im Code Folgendes benötigt:

@Autowired
ResourcePatternResolver resourceResolver;

public void getResources() {
  resourceResolver.getResources("classpath:config/*.xml");
}

Die Spring framework‚s PathMatchingResourcePatternResolverist wirklich genial für diese Dinge:

private Resource[] getXMLResources() throws IOException
{
    ClassLoader classLoader = MethodHandles.lookup().getClass().getClassLoader();
    PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(classLoader);

    return resolver.getResources("classpath:x/y/z/*.xml");
}

Maven-Abhängigkeit:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>LATEST</version>
</dependency>

Verwendete eine Kombination aus Robs Antwort.

final String resourceDir = "resourceDirectory/";
List<String> files = IOUtils.readLines(Thread.currentThread().getClass().getClassLoader().getResourceAsStream(resourceDir), Charsets.UTF_8);

for(String f : files){
  String data= IOUtils.toString(Thread.currentThread().getClass().getClassLoader().getResourceAsStream(resourceDir + f));
  ....process data
}

Mit Spring ist es einfach. Sei es eine Datei oder ein Ordner oder sogar mehrere Dateien, es besteht die Möglichkeit, dass Sie dies per Injektion tun können.

Dieses Beispiel zeigt das Einfügen mehrerer Dateien im x/y/zOrdner.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;

@Service
public class StackoverflowService {
    @Value("classpath:x/y/z/*")
    private Resource[] resources;

    public List<String> getResourceNames() {
        return Arrays.stream(resources)
                .map(Resource::getFilename)
                .collect(Collectors.toList());
    }
}

Es funktioniert sowohl für Ressourcen im Dateisystem als auch in JARs.

Dies sollte funktionieren (wenn der Frühling keine Option ist):

public static List<String> getFilenamesForDirnameFromCP(String directoryName) throws URISyntaxException, UnsupportedEncodingException, IOException {
    List<String> filenames = new ArrayList<>();

    URL url = Thread.currentThread().getContextClassLoader().getResource(directoryName);
    if (url != null) {
        if (url.getProtocol().equals("file")) {
            File file = Paths.get(url.toURI()).toFile();
            if (file != null) {
                File[] files = file.listFiles();
                if (files != null) {
                    for (File filename : files) {
                        filenames.add(filename.toString());
                    }
                }
            }
        } else if (url.getProtocol().equals("jar")) {
            String dirname = directoryName + "/";
            String path = url.getPath();
            String jarPath = path.substring(5, path.indexOf("!"));
            try (JarFile jar = new JarFile(URLDecoder.decode(jarPath, StandardCharsets.UTF_8.name()))) {
                Enumeration<JarEntry> entries = jar.entries();
                while (entries.hasMoreElements()) {
                    JarEntry entry = entries.nextElement();
                    String name = entry.getName();
                    if (name.startsWith(dirname) && !dirname.equals(name)) {
                        URL resource = Thread.currentThread().getContextClassLoader().getResource(name);
                        filenames.add(resource.toString());
                    }
                }
            }
        }
    }
    return filenames;
}

Mein Weg, keine Feder, während eines Unit-Tests verwendet:

URI uri = TestClass.class.getResource("/resources").toURI();
Path myPath = Paths.get(uri);
Stream<Path> walk = Files.walk(myPath, 1);
for (Iterator<Path> it = walk.iterator(); it.hasNext(); ) {
    Path filename = it.next();   
    System.out.println(filename);
}

Der robusteste Mechanismus zum Auflisten aller Ressourcen im Klassenpfad ist derzeit die Verwendung dieses Musters mit ClassGraph , da es die größtmögliche Anzahl von Klassenpfadspezifikationsmechanismen verarbeitet , einschließlich des neuen JPMS-Modulsystems. (Ich bin der Autor von ClassGraph.)

List<String> resourceNames;
try (ScanResult scanResult = new ClassGraph().whitelistPaths("x/y/z").scan()) {
    resourceNames = scanResult.getAllResources().getNames();
}

Ich denke, Sie können den [ Zip File System Provider ] [1] nutzen, um dies zu erreichen. Wenn FileSystems.newFileSystemSie es verwenden, können Sie die Objekte in dieser ZIP-Datei als "normale" Datei behandeln.

In der oben verlinkten Dokumentation:

Geben Sie die Konfigurationsoptionen für das Zip-Dateisystem im Objekt java.util.Map an, das an übergeben wird FileSystems.newFileSystem Methode übergeben wird. Informationen zu den anbieterspezifischen Konfigurationseigenschaften für das Zip-Dateisystem finden Sie im Thema [Eigenschaften des Zip-Dateisystems] [2].

Sobald Sie eine Instanz eines Zip-Dateisystems haben, können Sie die Methoden der Klassen [ java.nio.file.FileSystem] [3] und [ java.nio.file.Path] [4] aufrufen , um Vorgänge wie das Kopieren, Verschieben und Umbenennen von Dateien sowie das Ändern von Dateiattributen auszuführen.

Die Dokumentation für das jdk.zipfsModul in [Java 11-Zustände] [5]:

Der Zip-Dateisystemanbieter behandelt eine Zip- oder JAR-Datei als Dateisystem und bietet die Möglichkeit, den Inhalt der Datei zu bearbeiten. Der Zip-Dateisystemanbieter kann FileSystems.newFileSystembei Installation von [ ] [6] erstellt werden.

Hier ist ein erfundenes Beispiel, das ich mit Ihren Beispielressourcen erstellt habe. Beachten Sie, dass a a .zipist.jar , aber Sie können Ihren Code anpassen, um stattdessen Klassenpfadressourcen zu verwenden:

Konfiguration

cd /tmp
mkdir -p x/y/z
touch x/y/z/{a,b,c}.html
echo 'hello world' > x/y/z/d
zip -r example.zip x

Java

import java.io.IOException;
import java.net.URI;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.util.Collections;
import java.util.stream.Collectors;

public class MkobitZipRead {

  public static void main(String[] args) throws IOException {
    final URI uri = URI.create("jar:file:/tmp/example.zip");
    try (
        final FileSystem zipfs = FileSystems.newFileSystem(uri, Collections.emptyMap());
    ) {
      Files.walk(zipfs.getPath("/")).forEach(path -> System.out.println("Files in zip:" + path));
      System.out.println("-----");
      final String manifest = Files.readAllLines(
          zipfs.getPath("x", "y", "z").resolve("d")
      ).stream().collect(Collectors.joining(System.lineSeparator()));
      System.out.println(manifest);
    }
  }

}

Ausgabe

Files in zip:/
Files in zip:/x/
Files in zip:/x/y/
Files in zip:/x/y/z/
Files in zip:/x/y/z/c.html
Files in zip:/x/y/z/b.html
Files in zip:/x/y/z/a.html
Files in zip:/x/y/z/d
-----
hello world

Keine der Antworten funktionierte für mich, obwohl ich meine Ressourcen in Ressourcenordnern abgelegt hatte und den obigen Antworten folgte. Was einen Trick machte, war:

@Value("file:*/**/resources/**/schema/*.json")
private Resource[] resources;

Basierend auf den obigen Informationen von @rob habe ich die Implementierung erstellt, die ich öffentlich zugänglich mache:

private static List<String> getClasspathEntriesByPath(String path) throws IOException {
    InputStream is = Main.class.getClassLoader().getResourceAsStream(path);

    StringBuilder sb = new StringBuilder();
    while (is.available()>0) {
        byte[] buffer = new byte[1024];
        sb.append(new String(buffer, Charset.defaultCharset()));
    }

    return Arrays
            .asList(sb.toString().split("\n"))          // Convert StringBuilder to individual lines
            .stream()                                   // Stream the list
            .filter(line -> line.trim().length()>0)     // Filter out empty lines
            .collect(Collectors.toList());              // Collect remaining lines into a List again
}

Ich hätte zwar nicht erwartet getResourcesAsStream, dass es in einem Verzeichnis so funktioniert, aber es funktioniert wirklich und es funktioniert gut.