JAR 파일 내의 파일을 나열하는 방법은 무엇입니까?

디렉토리에서 모든 파일을 읽는 코드가 있습니다.

    File textFolder = new File("text_directory");

    File [] texFiles = textFolder.listFiles( new FileFilter() {
           public boolean accept( File file ) {
               return file.getName().endsWith(".txt");
           }
    });

잘 작동합니다. "text_directory"디렉토리에서 ".txt"로 끝나는 모든 파일로 배열을 채 웁니다.

JAR 파일 내 에서 비슷한 방식으로 디렉토리의 내용을 어떻게 읽을 수 있습니까?

그래서 제가 정말로하고 싶은 것은 내 JAR 파일 내의 모든 이미지를 나열하는 것입니다. 그래서 다음과 같이로드 할 수 있습니다.

ImageIO.read(this.getClass().getResource("CompanyLogo.png"));

( "CompanyLogo"가 "하드 코딩"되어 있기 때문에 작동하지만 JAR 파일 내의 이미지 수는 가변 길이가 10 ~ 200 개일 수 있습니다.)

편집하다

그래서 내 주요 문제는 다음과 같습니다 . 내 메인 클래스 가있는 JAR 파일 의 이름 을 아는 방법 ?

나는 그것을 사용하여 읽을 수 있었다 java.util.Zip.

내 구조는 다음과 같습니다.

그들은 다음과 같습니다.

my.jar!/Main.class
my.jar!/Aux.class
my.jar!/Other.class
my.jar!/images/image01.png
my.jar!/images/image02a.png
my.jar!/images/imwge034.png
my.jar!/images/imagAe01q.png
my.jar!/META-INF/manifest 

지금은 다음을 사용하여 "images / image01.png"인스턴스를로드 할 수 있습니다.

    ImageIO.read(this.getClass().getResource("images/image01.png));

하지만 파일 이름을 알고 있기 때문에 나머지 파일을 동적으로로드해야합니다.

CodeSource src = MyClass.class.getProtectionDomain().getCodeSource();
if (src != null) {
  URL jar = src.getLocation();
  ZipInputStream zip = new ZipInputStream(jar.openStream());
  while(true) {
    ZipEntry e = zip.getNextEntry();
    if (e == null)
      break;
    String name = e.getName();
    if (name.startsWith("path/to/your/dir/")) {
      /* Do something with this entry. */
      ...
    }
  }
} 
else {
  /* Fail... */
}

Java 7에서는 FileSystemJAR (zip) 파일에서을 생성 한 다음 NIO의 디렉토리 검색 및 필터링 메커니즘을 사용하여 검색 할 수 있습니다. 이렇게하면 JAR 및 "폭발 된"디렉토리를 처리하는 코드를 더 쉽게 작성할 수 있습니다.

IDE 및 .jar 파일 모두에서 작동하는 코드 :

import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class ResourceWalker {
    public static void main(String[] args) throws URISyntaxException, IOException {
        URI uri = ResourceWalker.class.getResource("/resources").toURI();
        Path myPath;
        if (uri.getScheme().equals("jar")) {
            FileSystem fileSystem = FileSystems.newFileSystem(uri, Collections.<String, Object>emptyMap());
            myPath = fileSystem.getPath("/resources");
        } else {
            myPath = Paths.get(uri);
        }
        Stream<Path> walk = Files.walk(myPath, 1);
        for (Iterator<Path> it = walk.iterator(); it.hasNext();){
            System.out.println(it.next());
        }
    }
}

erickson의 대답 은 완벽하게 작동했습니다.

다음은 작동 코드입니다.

CodeSource src = MyClass.class.getProtectionDomain().getCodeSource();
List<String> list = new ArrayList<String>();

if( src != null ) {
    URL jar = src.getLocation();
    ZipInputStream zip = new ZipInputStream( jar.openStream());
    ZipEntry ze = null;

    while( ( ze = zip.getNextEntry() ) != null ) {
        String entryName = ze.getName();
        if( entryName.startsWith("images") &&  entryName.endsWith(".png") ) {
            list.add( entryName  );
        }
    }

 }
 webimages = list.toArray( new String[ list.size() ] );

그리고 다음과 같이 내로드 방법을 수정했습니다.

File[] webimages = ... 
BufferedImage image = ImageIO.read(this.getClass().getResource(webimages[nextIndex].getName() ));

이에:

String  [] webimages = ...

BufferedImage image = ImageIO.read(this.getClass().getResource(webimages[nextIndex]));

여러 가지 이유로 매우 안전하지 않은 솔루션이기 때문에 acheron55의 답변 을 확장하고 싶습니다 .

1. FileSystem개체를 닫지 않습니다 .
2. FileSystem개체가 이미 존재 하는지 확인하지 않습니다 .
3. 스레드로부터 안전하지 않습니다.

이것은 다소 안전한 해결책입니다.

private static ConcurrentMap<String, Object> locks = new ConcurrentHashMap<>();

public void walk(String path) throws Exception {

    URI uri = getClass().getResource(path).toURI();
    if ("jar".equals(uri.getScheme()) {
        safeWalkJar(path, uri);
    } else {
        Files.walk(Paths.get(path));
    }
}

private void safeWalkJar(String path, URI uri) throws Exception {

    synchronized (getLock(uri)) {    
        // this'll close the FileSystem object at the end
        try (FileSystem fs = getFileSystem(uri)) {
            Files.walk(fs.getPath(path));
        }
    }
}

private Object getLock(URI uri) {

    String fileName = parseFileName(uri);  
    locks.computeIfAbsent(fileName, s -> new Object());
    return locks.get(fileName);
}

private String parseFileName(URI uri) {

    String schemeSpecificPart = uri.getSchemeSpecificPart();
    return schemeSpecificPart.substring(0, schemeSpecificPart.indexOf("!"));
}

private FileSystem getFileSystem(URI uri) throws IOException {

    try {
        return FileSystems.getFileSystem(uri);
    } catch (FileSystemNotFoundException e) {
        return FileSystems.newFileSystem(uri, Collections.<String, String>emptyMap());
    }
}   

파일 이름을 동기화 할 필요가 없습니다. 매번 동일한 객체에서 동기화 할 수 있습니다 (또는 메서드를 만들 수 있습니다 synchronized). 순전히 최적화입니다.

FileSystem동일한 파일에 대해 인터페이스 를 사용하는 코드에 다른 부분이있을 수 있고 (단일 스레드 응용 프로그램에서도) 간섭을 일으킬 수 있기 때문에 이것이 여전히 문제가되는 해결책이라고 말하고 싶습니다 .
또한 nulls를 확인하지 않습니다 (예 : on getClass().getResource().

이 특정 Java NIO 인터페이스는 스레드로부터 안전하지 않은 전역 / 싱글 톤 리소스를 도입하고 문서가 매우 모호합니다 (제공 업체별 구현으로 인해 많은 알 수 없음). 결과는 다른 FileSystem공급자 (JAR 아님)에 따라 다를 수 있습니다 . 아마 그럴만 한 이유가있을 것입니다. 모르겠습니다. 구현을 조사하지 않았습니다.

그래서 내 주된 문제는 내 메인 클래스가 사는 항아리의 이름을 아는 방법입니다.

프로젝트가 Jar에 압축되어 있다고 가정하면 (반드시 사실은 아닙니다!), ClassLoader.getResource () 또는 findResource ()를 클래스 이름 (.class가 뒤 따름)과 함께 사용하여 지정된 클래스가 포함 된 jar를 가져올 수 있습니다. 반환되는 URL에서 jar 이름을 구문 분석해야합니다 (그다지 어렵지 않음). 독자를위한 연습으로 남겨 둘 것입니다. :-)

클래스가 항아리의 일부가 아닌 경우를 테스트해야합니다.

Java 7에 대한 acheron55의 답변 을 포팅 하고 FileSystem객체를 닫았습니다 . 이 코드는 IDE, jar 파일 및 Tomcat 7과의 전쟁 내의 jar에서 작동합니다. 그러나 JBoss 7과의 전쟁에서 항아리에서 작동 하지 않습니다 ( 이 게시물FileSystemNotFoundException: Provider "vfs" not installed 도 참조하십시오 ). 또한 원본 코드와 마찬가지로 errr이 제안한 것처럼 스레드로부터 안전하지 않습니다 . 이러한 이유로 저는이 솔루션을 포기했습니다. 그러나 이러한 문제를 받아 들일 수 있다면 기성 코드는 다음과 같습니다.

import java.io.IOException;
import java.net.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Collections;

public class ResourceWalker {

    public static void main(String[] args) throws URISyntaxException, IOException {
        URI uri = ResourceWalker.class.getResource("/resources").toURI();
        System.out.println("Starting from: " + uri);
        try (FileSystem fileSystem = (uri.getScheme().equals("jar") ? FileSystems.newFileSystem(uri, Collections.<String, Object>emptyMap()) : null)) {
            Path myPath = Paths.get(uri);
            Files.walkFileTree(myPath, new SimpleFileVisitor<Path>() { 
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    System.out.println(file);
                    return FileVisitResult.CONTINUE;
                }
            });
        }
    }
}

다음은 "패키지에서 모든 JUnits 실행"을 위해 작성한 방법입니다. 필요에 맞게 조정할 수 있어야합니다.

private static void findClassesInJar(List<String> classFiles, String path) throws IOException {
    final String[] parts = path.split("\\Q.jar\\\\E");
    if (parts.length == 2) {
        String jarFilename = parts[0] + ".jar";
        String relativePath = parts[1].replace(File.separatorChar, '/');
        JarFile jarFile = new JarFile(jarFilename);
        final Enumeration<JarEntry> entries = jarFile.entries();
        while (entries.hasMoreElements()) {
            final JarEntry entry = entries.nextElement();
            final String entryName = entry.getName();
            if (entryName.startsWith(relativePath)) {
                classFiles.add(entryName.replace('/', File.separatorChar));
            }
        }
    }
}

편집 : 아,이 경우이 스 니펫도 필요할 수 있습니다 (동일한 사용 사례 :))

private static File findClassesDir(Class<?> clazz) {
    try {
        String path = clazz.getProtectionDomain().getCodeSource().getLocation().getFile();
        final String codeSourcePath = URLDecoder.decode(path, "UTF-8");
        final String thisClassPath = new File(codeSourcePath, clazz.getPackage().getName().repalce('.', File.separatorChar));
    } catch (UnsupportedEncodingException e) {
        throw new AssertionError("impossible", e);
    }
}

다음은 Reflections 라이브러리를 사용하여 리소스 콘텐츠를 가져 오기 위해 몇 가지 Guava 특전으로 강화 된 정규식 이름 패턴으로 클래스 경로를 재귀 적으로 스캔 하는 예입니다 .

Reflections reflections = new Reflections("com.example.package", new ResourcesScanner());
Set<String> paths = reflections.getResources(Pattern.compile(".*\\.template$"));

Map<String, String> templates = new LinkedHashMap<>();
for (String path : paths) {
    log.info("Found " + path);
    String templateName = Files.getNameWithoutExtension(path);
    URL resource = getClass().getClassLoader().getResource(path);
    String text = Resources.toString(resource, StandardCharsets.UTF_8);
    templates.put(templateName, text);
}

이것은 항아리와 폭발 클래스 모두에서 작동합니다.

jar 파일은 구조화 된 매니페스트가있는 zip 파일입니다. 일반적인 자바 zip 도구를 사용하여 jar 파일을 열고 그런 방식으로 파일 내용을 스캔하고 스트림을 확장 할 수 있습니다. 그런 다음 getResourceAsStream 호출에서이를 사용하면 모든 것이 엉망이됩니다.

수정 / 설명 후

모든 비트와 조각을 기억하는 데 1 분이 걸렸고이를 수행 할 수있는 더 깨끗한 방법이 있다고 확신합니다.하지만 제가 미쳤다는 것을 알고 싶었습니다. 내 프로젝트에서 image.jpg는 기본 jar 파일의 일부에있는 파일입니다. 메인 클래스 (SomeClass가 진입 점)의 클래스 로더를 가져 와서 image.jpg 리소스를 검색하는 데 사용합니다. 그런 다음이 ImageInputStream 사물에 들어가는 스트림 마술과 모든 것이 좋습니다.

InputStream inputStream = SomeClass.class.getClassLoader().getResourceAsStream("image.jpg");
JPEGImageReaderSpi imageReaderSpi = new JPEGImageReaderSpi();
ImageReader ir = imageReaderSpi.createReaderInstance();
ImageInputStream iis = new MemoryCacheImageInputStream(inputStream);
ir.setInput(iis);
....
ir.read(0); //will hand us a buffered image

실제 JAR 파일이 주어지면 JarFile.entries(). 하지만 JAR 파일의 위치를 ​​알아야합니다. 클래스 로더에게 얻을 수있는 모든 것을 나열하도록 요청할 수는 없습니다.

에서 반환 된 URL을 기반으로 JAR 파일의 위치를 ​​알아낼 수 있어야 ThisClassName.class.getResource("ThisClassName.class")하지만 약간 까다로울 수 있습니다.

얼마 전에 JAR 내부에서 클래스를 가져 오는 함수를 만들었습니다.

public static Class[] getClasses(String packageName) 
throws ClassNotFoundException{
    ArrayList<Class> classes = new ArrayList<Class> ();

    packageName = packageName.replaceAll("\\." , "/");
    File f = new File(jarName);
    if(f.exists()){
        try{
            JarInputStream jarFile = new JarInputStream(
                    new FileInputStream (jarName));
            JarEntry jarEntry;

            while(true) {
                jarEntry=jarFile.getNextJarEntry ();
                if(jarEntry == null){
                    break;
                }
                if((jarEntry.getName ().startsWith (packageName)) &&
                        (jarEntry.getName ().endsWith (".class")) ) {
                    classes.add(Class.forName(jarEntry.getName().
                            replaceAll("/", "\\.").
                            substring(0, jarEntry.getName().length() - 6)));
                }
            }
        }
        catch( Exception e){
            e.printStackTrace ();
        }
        Class[] classesA = new Class[classes.size()];
        classes.toArray(classesA);
        return classesA;
    }else
        return null;
}

public static ArrayList<String> listItems(String path) throws Exception{
    InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(path);
    byte[] b = new byte[in.available()];
    in.read(b);
    String data = new String(b);
    String[] s = data.split("\n");
    List<String> a = Arrays.asList(s);
    ArrayList<String> m = new ArrayList<>(a);
    return m;
}

JarScan이라는 두 가지 매우 유용한 유틸리티가 있습니다.

1. www.inetfeedback.com/jarscan

2. jarscan.dev.java.net

이 질문도 참조하십시오 : JarScan, 특정 클래스에 대한 모든 하위 폴더의 모든 JAR 파일 스캔

클래스 경로의 모든 리소스를 나열하는 가장 강력한 메커니즘은 현재이 패턴을 ClassGraph와 함께 사용하는 것입니다 . 새로운 JPMS 모듈 시스템을 포함하여 가능한 가장 광범위한 클래스 경로 사양 메커니즘을 처리하기 때문 입니다. (저는 ClassGraph의 저자입니다.)

내 메인 클래스가있는 JAR 파일의 이름을 아는 방법은 무엇입니까?

URI mainClasspathElementURI;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("x.y.z")
        .enableClassInfo().scan()) {
    mainClasspathElementURI =
            scanResult.getClassInfo("x.y.z.MainClass").getClasspathElementURI();
}

JAR 파일 내에서 비슷한 방식으로 디렉토리의 내용을 어떻게 읽을 수 있습니까?

List<String> classpathElementResourcePaths;
try (ScanResult scanResult = new ClassGraph().overrideClasspath(mainClasspathElementURI)
        .scan()) {
    classpathElementResourcePaths = scanResult.getAllResources().getPaths();
}

자원을 다루는 다른 방법 도 많이 있습니다.

jar URL에서 파일을 나열 / 읽는 다른 방법이며 중첩 된 jar에 대해 반복적으로 수행합니다.

https://gist.github.com/trung/2cd90faab7f75b3bcbaa

URL urlResource = Thead.currentThread().getContextClassLoader().getResource("foo");
JarReader.read(urlResource, new InputStreamCallback() {
    @Override
    public void onFile(String name, InputStream is) throws IOException {
        // got file name and content stream 
    }
});

도로를위한 또 하나 :

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.*;
import java.util.ArrayList;
import java.util.List;

import static java.nio.file.FileSystems.newFileSystem;
import static java.util.Collections.emptyMap;

public class ResourceWalker {
  private static final PathMatcher FILE_MATCHER =
      FileSystems.getDefault().getPathMatcher( "glob:**.ttf" );

  public static List<Path> walk( final String directory )
      throws URISyntaxException, IOException {
    final List<Path> filenames = new ArrayList<>();
    final var resource = ResourceWalker.class.getResource( directory );

    if( resource != null ) {
      final var uri = resource.toURI();
      final var path = uri.getScheme().equals( "jar" )
          ? newFileSystem( uri, emptyMap() ).getPath( directory )
          : Paths.get( uri );
      final var walk = Files.walk( path, 10 );

      for( final var it = walk.iterator(); it.hasNext(); ) {
        final Path p = it.next();
        if( FILE_MATCHER.matches( p ) ) {
          filenames.add( p );
        }
      }
    }

    return filenames;
  }
}

와일드 카드 글 로빙을 사용하기 때문에 특정 파일 이름을 일치시키는 데 좀 더 유연합니다.

보다 기능적인 스타일 :

import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.*;
import java.util.function.Consumer;

import static java.nio.file.FileSystems.newFileSystem;
import static java.util.Collections.emptyMap;

/**
 * Responsible for finding file resources.
 */
public class ResourceWalker {
  private static final PathMatcher FILE_MATCHER =
      FileSystems.getDefault().getPathMatcher( "glob:**.ttf" );

  public static void walk( final String dirName, final Consumer<Path> f )
      throws URISyntaxException, IOException {
    final var resource = ResourceWalker.class.getResource( dirName );

    if( resource != null ) {
      final var uri = resource.toURI();
      final var path = uri.getScheme().equals( "jar" )
          ? newFileSystem( uri, emptyMap() ).getPath( dirName )
          : Paths.get( uri );
      final var walk = Files.walk( path, 10 );

      for( final var it = walk.iterator(); it.hasNext(); ) {
        final Path p = it.next();
        if( FILE_MATCHER.matches( p ) ) {
          f.accept( p );
        }
      }
    }
  }
}