Groovy DSL/Builders: ZIP Output Streams

Let's follow up last week's post with another example of a very similar, very simple builder.

This one is for outputting ZIPped data to a stream. Let's take the standard example of using Java's ZIP support to zip up a folder of files.

Because the JDK does not include methods to traverse the filesystem, we need to define a method to be called recursively for subdirectories:

  private void zipDirectory(File dir, ZipOutputStream zos) throws IOException {
    for (File file : dir.listFiles()) {
      if (file.isDirectory()) {
        zipDirectory(file, zos);
      }
      else {
        ZipEntry entry = new ZipEntry(file.getPath());
        entry.setSize(file.length());
        entry.setTime(file.lastModified());
        zos.putNextEntry(entry);
        IOUtils.copy(new FileInputStream(file), zos);
      }
    }
  }

We cheated a little here by using the Apache Commons IO IOUtils class to actually copy the file bytes to the ZIP file. Also, we don't do anything here with IOExceptions.

With this method in place, we can create a ZIP file from a folder using:

  ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile));
  zipDirectory(new File(dir), zos);
  zos.close();

Groovy's JDK IO extensions, and filesystem traversal methods, make this job quite a bit easier. Here's the Groovy code to do the same thing:

  new ZipOutputStream(new FileOutputStream(zipFile)).withStream {zos ->
    new File(dir).traverse(type: FileType.FILES) {File file ->
      def entry = new ZipEntry(file.path)
      entry.size = file.length()
      entry.time = file.lastModified()
      zos.putNextEntry(entry)
      zos << file.bytes
    }

This code is still a bit awkward in how it interacts with Java's ZIP API, in particular the creation of the ZipEntry object.

Using a simple builder, we can rewrite this as follows:

  new ZipBuilder(new FileOutputStream(zipFile)).zip {
    new File(dir).traverse(type: FileType.FILES) {File file ->
      entry(file.path, size: file.length(), time: file.lastModified()) {it << file.bytes}
    }
  }

The ZipBuilder provides two methods:

• zip(): creates and manages the ZipOutputStream


• entry() (nested): creates and adds a ZipEntry to the enclosing zip stream

As with other builders, this builder promotes readable code that reflects the structure of the object to be created.

Here's the code for the builder itself:

class ZipBuilder {

  @InheritConstructors
  static class NonClosingOutputStream extends FilterOutputStream {
    void close() {
      // do nothing
    }
  }

  ZipOutputStream zos

  ZipBuilder(OutputStream os) {
    zos = new ZipOutputStream(os)
  }

  void zip(Closure closure) {
    closure.delegate = this
    closure.call()
    zos.close()
  }

  void entry(Map props, String name, Closure closure) {
    def entry = new ZipEntry(name)
    props.each {k, v -> entry[k] = v}
    zos.putNextEntry(entry)
    NonClosingOutputStream ncos = new NonClosingOutputStream(zos)
    closure.call(ncos)
  }

  void entry(String name, Closure closure) {
    entry([:], name, closure)
  }
}

This builder uses the same style with Closures as the HSSFWorkbookBuilder described earlier.

There are a few other Groovy (and Java) features to note:

• Java's ZIP library requires clients to write to the ZipOutputStream for each entry created. We need to make sure that no entry closes the ZipOutputStream -- it must be closed only when the zip stream is finished. (Many of Groovy's output methods close streams automatically.) For this reason, we wrap the output stream in a NonClosingOutputStream before passing it to an entry. This class is simply defined as a FilterOutputStream (OutputStream decorator) with a no-op close() method.


• We use Groovy's @InheritConstructors to save repeating the trivial constructor.


• The entry() method creates a new ZipEntry with its mandatory name property. It then populates additional optional properties from a Map, using Groovy's support for setting Java Beans properties as Map keys. These properties are intended to be provided as named arguments to the method, as shown in the example earlier. This makes for a very concise and intuitive way to set the properties.


• The main overload of entry() is declared to take its arguments in this order: Map props, String name, Closure closure. When called, entry() is (typically) given arguments in a different order: String name, Map props, Closure closure. This is due to Groovy's convention for passing named arguments to a method, described here, in the section "Named Arguments".

One final note about this builder -- it doesn't just work with files. Because the constructor takes an OutputStream, it can write to any stream. So it could be used to write directly to a servlet response, for example. Similarly, the entries are populated as streams, so they can be filled by anything that can write to a stream.