如何在Go语言中从嵌套的ZIP文件条目获取io.ReaderAt接口

package main

import (
    "archive/zip"
    "bytes"
    "fmt"
    "io"
    "log"
    "os"
)

// simulateZipFileContent creates a simple in-memory zip file for demonstration
func simulateZipFileContent() *bytes.Reader {
    buf := new(bytes.Buffer)
    zipWriter := zip.NewWriter(buf)

    // Add an entry to the zip file
    header := &zip.FileHeader{
        Name:   "nested/example.xlsx", // Simulating a nested xlsx file
        Method: zip.Deflate,
    }
    writer, err := zipWriter.CreateHeader(header)
    if err != nil {
        log.Fatal(err)
    }
    _, err = writer.Write([]byte("This is the content of the nested Excel file."))
    if err != nil {
        log.Fatal(err)
    }

    err = zipWriter.Close()
    if err != nil {
        log.Fatal(err)
    }
    return bytes.NewReader(buf.Bytes())
}

func main() {
    // Step 1: Simulate getting a zip archive (e.g., from a file or network)
    // For this example, we create an in-memory zip reader.
    // In a real application, you might use zip.OpenReader("archive.zip")
    // or zip.NewReader(someReaderAt, size)
    zipContentReader := simulateZipFileContent()
    zipSize := zipContentReader.Size()

    zipReader, err := zip.NewReader(zipContentReader, zipSize)
    if err != nil {
        log.Fatalf("Error opening zip archive: %v", err)
    }

    var readerAt io.ReaderAt
    foundEntry := false

    // Step 2 & 3: Iterate through entries, find the target, and read its content
    for _, f := range zipReader.File {
        if f.Name == "nested/example.xlsx" {
            fmt.Printf("Found target entry: %s\n", f.Name)

            rc, err := f.Open()
            if err != nil {
                log.Fatalf("Error opening zip entry %s: %v", f.Name, err)
            }
            defer rc.Close() // Ensure the ReadCloser is closed

            // Read all content from the ReadCloser into a byte slice
            b, err := io.ReadAll(rc)
            if err != nil {
                log.Fatalf("Error reading content of %s: %v", f.Name, err)
            }

            // Step 4: Create a bytes.Reader from the byte slice
            // This bytes.Reader implements io.ReaderAt
            readerAt = bytes.NewReader(b)
            foundEntry = true
            break
        }
    }

    if !foundEntry {
        log.Fatal("Target entry 'nested/example.xlsx' not found in the archive.")
    }

    // Now you have io.ReaderAt and can use its ReadAt method
    // For demonstration, let's read some bytes from a specific offset
    readBuffer := make([]byte, 5)
    n, err := readerAt.ReadAt(readBuffer, 10) // Read 5 bytes starting from offset 10
    if err != nil && err != io.EOF {
        log.Fatalf("Error reading from ReaderAt: %v", err)
    }

    fmt.Printf("Read %d bytes from ReaderAt at offset 10: %s\n", n, string(readBuffer[:n]))

    // You can also get other interfaces from bytes.Reader
    // reader := readerAt.(io.Reader) // If you need io.Reader
    // seeker := readerAt.(io.Seeker) // If you need io.Seeker
}