Leggere un file zip all'interno del file zip

Question

Ho un file zip che si trova all'interno di una cartella in un file zip per favore suggerirmi come leggerlo usando lo stream di input zip.

es .:

abc.zip 
    | 
     documents/bcd.zip 

Come leggere un file zip all'interno di file zip?

Answer 1

Il seguente frammento di codice elenca le voci di un file ZIP all'interno di un altro file ZIP. Adattalo alle tue esigenze. ZipFile utilizza ZipInputStreams sotto il cofano.

Lo snippet di codice utilizza Apache Commons IO, in particolare IOUtils.copy.

public static void readInnerZipFile(File zipFile, String innerZipFileEntryName) { 
    ZipFile outerZipFile = null; 
    File tempFile = null; 
    FileOutputStream tempOut = null; 
    ZipFile innerZipFile = null; 
    try { 
     outerZipFile = new ZipFile(zipFile); 
     tempFile = File.createTempFile("tempFile", "zip"); 
     tempOut = new FileOutputStream(tempFile); 
     IOUtils.copy(// 
       outerZipFile.getInputStream(new ZipEntry(innerZipFileEntryName)), // 
       tempOut); 
     innerZipFile = new ZipFile(tempFile); 
     Enumeration<? extends ZipEntry> entries = innerZipFile.entries(); 
     while (entries.hasMoreElements()) { 
      ZipEntry entry = entries.nextElement(); 
      System.out.println(entry); 
      // InputStream entryIn = innerZipFile.getInputStream(entry); 
     } 

    } catch (IOException e) { 
     e.printStackTrace(); 
    } finally { 
     // Make sure to clean up your I/O streams 
     try { 
      if (outerZipFile != null) 
       outerZipFile.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
     IOUtils.closeQuietly(tempOut); 
     if (tempFile != null && !tempFile.delete()) { 
      System.out.println("Could not delete " + tempFile); 
     } 
     try { 
      if (innerZipFile != null) 
       innerZipFile.close(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

public static void main(String[] args) { 
    readInnerZipFile(new File("abc.zip"), "documents/bcd.zip"); 
} 

Answer 2

Se si vuole guardare attraverso i file zip all'interno di file zip in modo ricorsivo,

public void lookupSomethingInZip(InputStream fileInputStream) throws IOException { 
     ZipInputStream zipInputStream = new ZipInputStream(fileInputStream); 
     String entryName = ""; 
     ZipEntry entry = zipInputStream.getNextEntry(); 
     while (entry!=null) { 
      entryName = entry.getName(); 
      if (entryName.endsWith("zip")) { 
       //recur if the entry is a zip file 
       lookupSomethingInZip(zipInputStream); 
      } 
      //do other operation with the entries.. 

      entry=zipInputStream.getNextEntry(); 
     } 
    } 

chiamata al metodo con il flusso di input del file derivato dal file -

File file = new File(name); 
lookupSomethingInZip(new FileInputStream(file)); 

Answer 3

ho scritto un codice che può decomprimere tutti i file zip all'interno di un file zip. Può anche decomprimere a n livelli di compressione. Ad esempio, se avessi un file zip all'interno di un file zip, all'interno di un file zip (e così via) estrarrebbe tutti loro. Utilizzare il metodo zipFileExtract di questa classe e passare il file zip di origine e la directory di destinazione come argomento.

import java.io.*; 
import java.nio.file.Files; 
import java.nio.file.Path; 
import java.nio.file.Paths; 
import java.util.*; 
import java.util.concurrent.ConcurrentLinkedQueue; 
import java.util.zip.ZipEntry; 
import java.util.zip.ZipInputStream; 

public class RecursiveFileExtract { 

private static final int BUFFER_SIZE = 4096; 
private static Queue<File> current; 
private static List<File> visited; 

public static void zipFileExtract(File sourceZipFile, File destinationDirectory) { 
    Path temp = null; 
    if(!destinationDirectory.exists()) 
    { 
     destinationDirectory.mkdirs(); 
    } 
    try { 
     temp = Files.move(Paths.get(sourceZipFile.getAbsolutePath()), Paths.get(destinationDirectory.getAbsolutePath()+File.separator+sourceZipFile.getName())); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    File zipFile = new File(temp.toAbsolutePath().toString()); 
    current = new ConcurrentLinkedQueue<>(); 
    visited = new ArrayList<>(); 
    current.add(zipFile); 
    do { 
     unzipCurrent(); 
     zipFinder(destinationDirectory); 
    } 
    while (!current.isEmpty()); 
} 

private static void zipFinder(File directory) { 
    try { 
     if (directory != null) { 
      File fileArray[] = directory.listFiles(); 
      if (fileArray != null) { 
       for (File file : fileArray) { 
        if (file != null) { 
         if (file.isDirectory()) { 
          zipFinder(file); 
         } else { 
          if (file.getName().endsWith(".zip")) { 
           if (!visited.contains(file)) { 
            current.add(file); 
           } 
          } 
         } 
        } 
       } 
      } 
     } 
    } catch (Exception e) { 
     System.out.println(e.getLocalizedMessage()); 
    } 
} 

private static void unzipCurrent() { 
    try { 
     while (!current.isEmpty()) { 
      File file = current.remove(); 
      visited.add(file); 
      File zipDirectory = new File(file.getParentFile().getAbsolutePath()); 
      unzip(file.getAbsolutePath(), zipDirectory.getAbsolutePath()); 
     } 
    } catch (Exception e) { 
     System.out.println(e.getLocalizedMessage()); 
    } 
} 

public static void unzip(String zipFilePath, String destDirectory) { 
    try { 
     ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath)); 
     ZipEntry entry = zipIn.getNextEntry(); 

     while (entry != null) { 
      String filePath = destDirectory + File.separator + entry.getName(); 
      if (!entry.isDirectory()) { 
       extractFile(zipIn, filePath); 
      } else { 

       File dir = new File(filePath); 
       Boolean result = dir.mkdir(); 
      } 
      zipIn.closeEntry(); 
      entry = zipIn.getNextEntry(); 
     } 
     zipIn.close(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

private static void extractFile(ZipInputStream zipIn, String filePath) { 
    try { 
     File file = new File(filePath); 
     File parentFile = file.getParentFile(); 
     if (!parentFile.exists()) { 
      Boolean result = parentFile.mkdirs(); 
      if (!result) { 
       throw new Exception(); 
      } 
     } 
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath)); 
     byte[] bytesIn = new byte[BUFFER_SIZE]; 
     int read = 0; 
     while ((read = zipIn.read(bytesIn)) != -1) { 
      bos.write(bytesIn, 0, read); 
     } 
     bos.close(); 
    } catch (Exception e) { 
     System.out.println(e.getLocalizedMessage()); 
    } 
} 

}