Re: different try-finally approach

From:

Lew <noone@lewscanon.com>

Newsgroups:

comp.lang.java.programmer

Date:

Mon, 03 Aug 2009 23:30:18 -0400

Message-ID:

<h58a0b$crq$1@news.albasani.net>

Pitch wrote:

Now, look at this one:

public void copyFiles(String inFile, String outFile)
throws IOException
{
    FileInputStream inStream = new FileInputStream(inFile);
    try
    {
        copyToFile(inStream, outFile);
    }
    finally
    {
        inStram.close();
    }
}

private void copyToFile(InputStream inStream, String outFile)
throws IOException
{
    FileOutputStream outStream = new FileOutputStream(inFile);
    try
    {
        // copying code...
    }
    finally
    {
        outStream.close();
    }
}

Eh. This approach breaks up the logic so it's harder to see that the input
and output streams are tightly coupled. It adds lines of source code without
appreciably improving clarity, perhaps even going the other way. It puts
streams that are at the same logic level in the algorithm into different
subroutine levels in the code. It factors the algorithm in a conceptually
jarring way.

I'd go with:

  public void copy( String in, String out )
   throws IOException
  {
    final InputStream is;
    final OutputStream os;

    try
    {
     is = new FileInputStream( in );
    }
    catch ( IOException exc )
    {
     logger.error( "Cannot open input stream", exc );
     throw exc;
    }

    try
    {
     os = new FileOutputStream( out );
    }
    catch ( IOException exc )
    {
     logger.error( "Cannot open output stream", exc );
     close( is );
     throw exc;
    }
    assert is != null && os != null;

    try
    {
      copy( is, os );
    }
    finally
    {
     close( os );
     close( is );
   }
  }

--
Lew