Java程序实现嵌套Zip文件递归遍历与日志读取的需求及问题求助

Hey there! The core issue with your current code is that it only processes top-level entries in the initial zip file—when it hits a nested zip like 2021-11-23_103518.zip, it just logs the path and moves on, never opening it to read the logs inside. Let's fix that with a recursive approach.

The Plan #

We need to:

• Detect when a zip entry is itself a zip file (via the .zip extension)
• Recursively process that nested zip, pulling out any errorlog.txt or windowlog.txt files inside
• Clean up resource handling to avoid leaks and optimize string building

Revised Code #

Here's the updated version with recursive logic, better resource management, and performance tweaks:

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

public class ZipLogExtractor {

    // Public entry point - call this with your zip path from the console
    public static String[] getLogBuffers(String zipPath) throws IOException {
        StringBuilder errorLogContent = new StringBuilder();
        StringBuilder windowLogContent = new StringBuilder();
        
        // Kick off recursive processing
        processNestedZip(new File(zipPath), errorLogContent, windowLogContent);
        
        return new String[]{errorLogContent.toString(), windowLogContent.toString()};
    }

    // Recursive method to handle zip files and their nested entries
    private static void processNestedZip(File zipFile, StringBuilder errorLog, StringBuilder windowLog) throws IOException {
        // Use try-with-resources to auto-close streams/ZipFile - no more manual close calls!
        try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile));
             ZipFile zip = new ZipFile(zipFile)) {
            
            ZipEntry currentEntry;
            while ((currentEntry = zis.getNextEntry()) != null) {
                String entryPath = zipFile.getAbsolutePath() + "/" + currentEntry.getName();
                System.out.println("Processing: " + entryPath);

                if (currentEntry.isDirectory()) {
                    zis.closeEntry();
                    continue; // Skip directories, we only care about files
                }

                if (currentEntry.getName().endsWith(".zip")) {
                    // This is a nested zip - save it to a temp file then process recursively
                    File tempNestedZip = File.createTempFile("tempZip", ".zip");
                    try (InputStream entryStream = zip.getInputStream(currentEntry);
                         FileOutputStream tempOut = new FileOutputStream(tempNestedZip)) {
                        
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = entryStream.read(buffer)) != -1) {
                            tempOut.write(buffer, 0, bytesRead);
                        }
                        // Recurse into this nested zip
                        processNestedZip(tempNestedZip, errorLog, windowLog);
                    } finally {
                        // Clean up the temp file after processing
                        tempNestedZip.delete();
                    }
                } else if (currentEntry.getName().endsWith("errorlog.txt")) {
                    // Read and append error log content
                    try (InputStream logStream = zip.getInputStream(currentEntry);
                         BufferedInputStream bufferedStream = new BufferedInputStream(logStream)) {
                        
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = bufferedStream.read(buffer)) != -1) {
                            errorLog.append(new String(buffer, 0, bytesRead));
                        }
                    }
                } else if (currentEntry.getName().endsWith("windowlog.txt")) {
                    // Read and append window log content
                    try (InputStream logStream = zip.getInputStream(currentEntry);
                         BufferedInputStream bufferedStream = new BufferedInputStream(logStream)) {
                        
                        byte[] buffer = new byte[1024];
                        int bytesRead;
                        while ((bytesRead = bufferedStream.read(buffer)) != -1) {
                            windowLog.append(new String(buffer, 0, bytesRead));
                        }
                    }
                }
                zis.closeEntry();
            }
        }
    }

    // Test with console input
    public static void main(String[] args) throws IOException {
        if (args.length == 0) {
            System.out.println("Please pass the zip file path as a command line argument!");
            return;
        }
        String[] logs = getLogBuffers(args[0]);
        System.out.println("\n=== Error Log Content ===");
        System.out.println(logs[0]);
        System.out.println("\n=== Window Log Content ===");
        System.out.println(logs[1]);
    }
}

Key Improvements #

• Recursive Nested Zip Handling: Now when the code hits a .zip entry, it saves it to a temporary file, processes it recursively, then cleans up the temp file.
• Auto Resource Management: try-with-resources ensures all streams and ZipFile instances are closed automatically, preventing memory leaks.
• StringBuilder for Performance: Replaced repeated String concatenation with StringBuilder—this is way more efficient, especially for large log files.
• Cleaner Code Structure: Split logic into a public entry point and a private recursive method, making the code easier to read and maintain.

What It Does Now #

Your console output will now show processing entries inside nested zips, and all errorlog.txt/windowlog.txt files—no matter how deep they are in the zip hierarchy—will have their contents merged into the final result array.

内容的提问来源于stack exchange，提问作者kanishka malpana