Je cherche un moyen d'obtenir une liste de tous les noms de ressources à partir d'un répertoire classpath donné, quelque chose comme une méthode List<String> getResourceNames (String directoryName).

Par exemple, étant donné un répertoire classpath x/y/zfichiers contenant a.html, b.html, c.htmlet un sous - répertoire d, getResourceNames("x/y/z")doit retourner un List<String>contenant les chaînes suivantes: ['a.html', 'b.html', 'c.html', 'd'].

Il devrait fonctionner à la fois pour les ressources du système de fichiers et les fichiers jar.

Je sais que je peux écrire un extrait rapide avec Files, JarFiles et URLs, mais je ne veux pas réinventer la roue. Ma question est, étant donné les bibliothèques publiques existantes, quel est le moyen le plus rapide à mettre en œuvre getResourceNames? Les piles Spring et Apache Commons sont toutes deux réalisables.

Scanner personnalisé

Implémentez votre propre scanner. Par exemple:

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

Cadre Spring

Utiliser PathMatchingResourcePatternResolverdepuis Spring Framework.

Ronmamo Reflections

Les autres techniques peuvent être lentes à l'exécution pour les énormes valeurs CLASSPATH. Une solution plus rapide consiste à utiliser l' API Reflections de ronmamo , qui précompile la recherche au moment de la compilation.

Voici le code
Source : 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);
        }
    }
}  

Si vous utilisez Spring Jetez un œil à PathMatchingResourcePatternResolver

Utiliser des réflexions

Obtenez tout sur le chemin de classe:

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

Un autre exemple - obtenez tous les fichiers avec l'extension .csv de some.package :

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

Si vous utilisez apache commonsIO, vous pouvez utiliser pour le système de fichiers (en option avec le filtre d'extension):

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

et pour les ressources / classpath:

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

Si vous ne savez pas si "directoy /" est dans le système de fichiers ou dans les ressources, vous pouvez ajouter un

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

ou

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

avant les appels et utilisez les deux en combinaison ...

Donc, en termes de PathMatchingResourcePatternResolver, c'est ce qui est nécessaire dans le code:

@Autowired
ResourcePatternResolver resourceResolver;

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

Les Spring framework« s PathMatchingResourcePatternResolverest vraiment génial pour ces choses:

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

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

Dépendance Maven:

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

Utilisé une combinaison de la réponse de Rob.

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
}

Avec Spring, c'est facile. Qu'il s'agisse d'un fichier, d'un dossier ou même de plusieurs fichiers, il y a des chances que vous puissiez le faire par injection.

Cet exemple illustre l'injection de plusieurs fichiers situés dans le x/y/zdossier.

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

Il fonctionne pour les ressources dans le système de fichiers ainsi que dans les fichiers JAR.

Cela devrait fonctionner (si le printemps n'est pas une option):

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

À ma façon, pas de printemps, utilisé lors d'un test unitaire:

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

Le mécanisme le plus robuste pour répertorier toutes les ressources dans le chemin de classe est actuellement d'utiliser ce modèle avec ClassGraph , car il gère le plus large éventail possible de mécanismes de spécification de chemin de classe, y compris le nouveau système de modules JPMS. (Je suis l'auteur de ClassGraph.)

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

Je pense que vous pouvez utiliser le [ Fournisseur de système de fichiers Zip ] [1] pour y parvenir. Lors de son utilisation, FileSystems.newFileSystemil semble que vous puissiez traiter les objets de ce fichier ZIP comme un fichier "normal".

Dans la documentation liée ci-dessus:

Spécifiez les options de configuration du système de fichiers zip dans l'objet java.util.Map transmis à la FileSystems.newFileSystem méthode. Consultez la rubrique [Propriétés du système de fichiers zip] [2] pour plus d'informations sur les propriétés de configuration spécifiques au fournisseur pour le système de fichiers zip.

Une fois que vous disposez d'une instance d'un système de fichiers zip, vous pouvez appeler les méthodes des classes [ java.nio.file.FileSystem] [3] et [ java.nio.file.Path] [4] pour effectuer des opérations telles que la copie, le déplacement et le changement de nom des fichiers, ainsi que la modification des attributs de fichier.

La documentation du jdk.zipfsmodule dans [États Java 11] [5]:

Le fournisseur de système de fichiers zip traite un fichier zip ou JAR comme un système de fichiers et offre la possibilité de manipuler le contenu du fichier. Le fournisseur du système de fichiers zip peut être créé par [ FileSystems.newFileSystem] [6] s'il est installé.

Voici un exemple artificiel que j'ai fait en utilisant vos ressources d'exemple. Notez que a .zipest un .jar, mais vous pouvez adapter votre code pour utiliser à la place des ressources de chemin de classe:

Installer

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

}

Production

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

Aucune des réponses n'a fonctionné pour moi, même si mes ressources ont été placées dans des dossiers de ressources et que j'ai suivi les réponses ci-dessus. Ce qui a fait un tour était:

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

Sur la base des informations de @rob ci-dessus, j'ai créé l'implémentation que je publie dans le domaine public:

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
}

Bien que je ne m'attendais pas getResourcesAsStreamà travailler comme ça sur un répertoire, ça marche vraiment et ça marche bien.