Java ArchiveOutputStream.createArchiveEntry方法代码示例

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
private InputStream getArchiveInputStream(String format, String ...resourceFiles)
        throws ArchiveException, URISyntaxException, IOException {
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    ArchiveStreamFactory factory = new ArchiveStreamFactory();
    ArchiveOutputStream aout = factory.createArchiveOutputStream(format, bout);

    for (String resource : resourceFiles) {
        File f = new File(getClass().getResource(resource).toURI());
        ArchiveEntry entry = aout.createArchiveEntry(f, resource);
        aout.putArchiveEntry(entry);
        IOUtils.copy(new FileInputStream(f),aout);
        aout.closeArchiveEntry();
    }
    aout.finish();
    aout.close();

    return new ByteArrayInputStream(bout.toByteArray());
}
 

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
/**
 * Adds an entry to the zip.
 *
 * @param archiveOutputStream {@code ArchiveOutputStream} to output zip entry to.
 * @param filename Name of the file to add to the zip.
 * @throws IOException If an error occurs adding the file to the zip.
 */
private void addZipEntry(final ArchiveOutputStream archiveOutputStream, final String filename) throws IOException {
    FileInputStream fileInputStream = null;
    try {
        File file = new File("src/main/resources/" + filename);
        ArchiveEntry archiveEntry = archiveOutputStream.createArchiveEntry(file, filename);
        archiveOutputStream.putArchiveEntry(archiveEntry);
        fileInputStream = new FileInputStream(file);
        IOUtils.copy(fileInputStream, archiveOutputStream);
        archiveOutputStream.closeArchiveEntry();
    } catch (IOException e) {
        LOGGER.log(Level.SEVERE, "Unable to create zip entry for file: [{0}]. {1}",
                new String[]{filename, e.getMessage()});
    } finally {
        if (fileInputStream != null) {
            fileInputStream.close();
        }
    }
}
 

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
/**
 * Creates a new {@link ArchiveEntry} in the given {@link ArchiveOutputStream}, and copies the given {@link File}
 * into the new entry.
 * 
 * @param file the file to add to the archive
 * @param entryName the name of the archive entry
 * @param archive the archive to write to
 * @throws IOException when an I/O error occurs during FileInputStream creation or during copying
 */
protected void createArchiveEntry(File file, String entryName, ArchiveOutputStream archive) throws IOException {
    ArchiveEntry entry = archive.createArchiveEntry(file, entryName);
    // TODO #23: read permission from file, write it to the ArchiveEntry
    archive.putArchiveEntry(entry);

    if (!entry.isDirectory()) {
        FileInputStream input = null;
        try {
            input = new FileInputStream(file);
            IOUtils.copy(input, archive);
        } finally {
            IOUtils.closeQuietly(input);
        }
    }

    archive.closeArchiveEntry();
}
 

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
private void addFile(ArchiveOutputStream archive, String tarFileName, Path filePath)
    throws IOException {
  ArchiveEntry archiveEntry = archive.createArchiveEntry(filePath.toFile(), tarFileName);

  archive.putArchiveEntry(archiveEntry);
  Files.copy(filePath, archive);
  archive.closeArchiveEntry();

  logger.debug("Added file {} as {}", filePath.toAbsolutePath(), tarFileName);
}
 

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
/**
 * Private method for compression and recursive call.
 *
 * @param files the files to compress.
 * @param base the base path to store files to.
 * @param aos the output stream to use.
 * @throws IOException if an I/O error occurs.
 */
private void compress(File[] files, String base, ArchiveOutputStream aos) throws IOException {

    final byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
    int readBytes;

    if (files.length > 0) {
        for (int i = 0; !_interrupt && i < files.length; ++i) {
            // create next file and define entry name based on folder level
            final File newFile = files[i];
            String entryName = base + newFile.getName();
            // start compressing the file
            if (newFile.isFile()) {
                try (BufferedInputStream buf = new BufferedInputStream(
                        new FileInputStream(newFile))) {
                    // create next archive entry and put it on output stream
                    ArchiveEntry entry = aos.createArchiveEntry(newFile, entryName);
                    aos.putArchiveEntry(entry);
                    // write bytes to file
                    while (!_interrupt && (readBytes = buf.read(buffer)) != -1) {
                        aos.write(buffer, 0, readBytes);
                        updateProgress(readBytes);
                    }
                    aos.closeArchiveEntry();
                } catch (IOException ex) {
                    if (!_interrupt) {
                        Log.e(ex.getLocalizedMessage(), ex);
                        Log.e("{0}\n{1}",
                                I18N.getString("errorReadingFile.text"), newFile.getPath()
                        );
                        throw ex; // re-throw
                    }
                }
            } else { // child is a directory
                File[] children = getFiles(newFile.getAbsolutePath());
                compress(children, entryName + "/", aos);
            }
        }
    }
}
 

import org.apache.commons.compress.archivers.ArchiveOutputStream; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private void testArchive(String archiveType) throws Exception {
  //create an archive with multiple files, files containing multiple objects
  File dir = new File("target", UUID.randomUUID().toString());
  dir.mkdirs();

  OutputStream archiveOut = new FileOutputStream(new File(dir, "myArchive"));
  ArchiveOutputStream archiveOutputStream = new ArchiveStreamFactory().createArchiveOutputStream(archiveType, archiveOut);

  File inputFile;
  ArchiveEntry archiveEntry;
  FileOutputStream fileOutputStream;
  for(int i = 0; i < 5; i++) {
    String fileName = "file-" + i + ".txt";
    inputFile = new File(dir, fileName);
    fileOutputStream = new FileOutputStream(inputFile);
    IOUtils.write(("StreamSets" + i).getBytes(), fileOutputStream);
    fileOutputStream.close();
    archiveEntry = archiveOutputStream.createArchiveEntry(inputFile, fileName);
    archiveOutputStream.putArchiveEntry(archiveEntry);
    IOUtils.copy(new FileInputStream(inputFile), archiveOutputStream);
    archiveOutputStream.closeArchiveEntry();
  }
  archiveOutputStream.finish();
  archiveOut.close();

  //create compression input
  FileInputStream fileInputStream = new FileInputStream(new File(dir, "myArchive"));
  CompressionDataParser.CompressionInputBuilder compressionInputBuilder =
      new CompressionDataParser.CompressionInputBuilder(Compression.ARCHIVE, "*.txt", fileInputStream, "0");
  CompressionDataParser.CompressionInput input = compressionInputBuilder.build();

  // before reading
  Assert.assertNotNull(input);

  // The default wrapped offset before reading any file
  String wrappedOffset = "{\"fileName\": \"myfile\", \"fileOffset\":\"0\"}";

  Map<String, Object> archiveInputOffset = OBJECT_MAPPER.readValue(wrappedOffset, Map.class);
  Assert.assertNotNull(archiveInputOffset);
  Assert.assertEquals("myfile", archiveInputOffset.get("fileName"));
  Assert.assertEquals("0", archiveInputOffset.get("fileOffset"));

  Assert.assertEquals("0", input.getStreamPosition(wrappedOffset));
  // read and check wrapped offset
  BufferedReader reader = new BufferedReader(
      new InputStreamReader(input.getNextInputStream()));
  Assert.assertEquals("StreamSets0", reader.readLine());
  wrappedOffset = input.wrapOffset("4567");
  archiveInputOffset = OBJECT_MAPPER.readValue(wrappedOffset, Map.class);
  Assert.assertNotNull(archiveInputOffset);
  Assert.assertEquals("file-0.txt", archiveInputOffset.get("fileName"));
  Assert.assertEquals("4567", archiveInputOffset.get("fileOffset"));
  checkHeader(input, "file-0.txt", input.getStreamPosition(wrappedOffset));

  String recordIdPattern = "myFile/file-0.txt";
  Assert.assertEquals(recordIdPattern, input.wrapRecordId("myFile"));

}