The Problem

If you've been a Java programmer for long enough you've probably come across the situation where you have one API that can write to an OutputStream and you need to stitch it to another API which wants to read from an InputStream. No problem right? The Java API is large and there must be a class implements InputStream that can be constructed with an OutputStream. What? No? Well, then a quick internet search should reveal a utility class that will do the trick.

If you do a google search for the terms OutputStream InputStream you will quickly find Stephen Ostermiller's excellent article that outlines three approaches to solving the problem. The PipedInputStream and PipedOutputStream approach is one I've used in the past, but the solution falls short in the area of exception handling. What happens if while writing the output an exception occurs? This exception will be uncaught in the new thread. The thread reading the InputStream will never see the cause of the exception. With this in mind and with the desire to make it easy to reuse the piped solution we created the a static method and a supporting class and interface shown below.

Using the new method requires only a few lines. Any IOException thrown by class2.write will get re-thrown by the class1.read method. If class2.write throws other types of exceptions these can be caught and wrapped with an IOException.

class1.read(IOUtils.toInputStream(new OutputStreamConsumer() {
 public void write(OutputStream os) throws IOException {
   class2.write(os);
 }
}));

The Code

/**
   * Creates an InputStream which reads data written by the {@link OutputStreamConsumer}.
   * An OutputStreamConsumer is an interface which provides a single write method that takes
   * an OutputStream.
   *
   * Sample use
   * 
   * {@literal
   * class1.read(IOUtils.toInputStream(new OutputStreamConsumer() {
   *   @Override
   *   public void write(OutputStream os) throws IOException {
   *     class2.write(os);
   *   }
   * }));
   * 
   *
   * @param ss
   * @return an InputStream which reads data written by the OutputStreamConsumer.
   */
  public static InputStream toInputStream(final OutputStreamConsumer ss) throws IOException {
    final ExceptionPassingPipedInputStream in = new ExceptionPassingPipedInputStream();
    final PipedOutputStream out = new PipedOutputStream(in);
    new Thread(
        new Runnable(){
          public void run(){
            try {
              ss.write(out);
            } catch (IOException e) {
              in.ex = e;
            }
          }
        }
    ).start();
    return in;
  }

  /**
   * A class used to pass IOExceptions generated while writing to an associated output stream
   * to the reader.
   */
  private static class ExceptionPassingPipedInputStream extends PipedInputStream {
    private IOException ex = null;

    @Override
    public synchronized int available() throws IOException {
      if (ex!=null) throwException();
      return super.available();
    }
    @Override
    public synchronized int read() throws IOException {
      if (ex!=null) throwException();
      return super.read();
    }
    @Override
    public synchronized int read(byte[] b, int off, int len) throws IOException {
      if (ex!=null) throwException();
      return super.read(b, off, len);
    }
    @Override
    public void close() throws IOException {
      super.close();
      if (ex!=null) throwException();
    }

    public synchronized void throwException() throws IOException {
      if (ex == null) return;
      try { throw new IOException(ex); }
      finally { ex = null; }
    }

  }

  /** Used for copying an OutputStream into an InputStream.
   * @see IOUtils#toInputStream(OutputStreamConsumer)
   * */
  public static interface OutputStreamConsumer {
    /** Write contents to OutputStream. */
    void write(OutputStream s) throws IOException;
  }

Author Bio

Since graduating from MIT with a computer science degree, Martin Serrano has spent most his career developing high-performance distributed systems with a concentration in analytic algorithms. In 1993 he was one of the first engineers to develop commercial data processing software for a parallel computer (the CM5 from Thinking Machines), including efficient algorithms for multiplying large floating-point vectors and porting the popular gzip compression program. As the first engineer hired by high-performance computing systems integrator, Tessera Enterprise Systems (later acquired by iXL), Martin was responsible for developing data visualization software and led the team (in 1996) that designed AT&T's next generation business intelligence data warehouse which held 17TB of data. Martin then joined Ab Initio Software, the defacto leader in high-performance parallel business data processing. As an early employee at Ab Initio, Martin was responsible for the design and development of the SAS AnalyzerTM , a system that automatically analyzes programs from the SAS Institute's analytic software suite and schedules them for parallel execution. Turning his attention to bioinformatics, Martin became a Group Leader at the Broad Institute, responsible for leading the team which develops one of the largest chemical compound and biological experiment results search websites available. Martin is currently one of the Chief Architects at Attivio.

TrackBack URI for this entry

Comments (2)