4th International Conference on Principles and Practices ... - MADOC

By representing resources as trees, and releasing entire trees at
once, this method can be simplified, as shown in Figure 2-5. The
try-catch-finally complexity has been reduced to a single trycatch-finally
block. The previous close() calls have been replaced
by a single release() call, on line 27. Exceptions during the
resource release phase are now passed to the ExceptionLogger,
described in Section 2.3, to avoid cluttering up the code.
Additionally, it is no longer necessary to declare most of the
resources outside the try block (e.g., the Socket, InputStream, and
OutputStream). Because the resources are accessible through the
tree, they do not need to be directly accessible by the finally
block. This allows more variables to be kept in smaller scopes,
where they are relevant. By using Furm, the number of lines has
been significantly cut. More importantly, communicating with
the server is now the focus of the code. The resource
management code has been pushed into the background, where it
belongs.
In this example, a ResourceGroup is the root of the tree, and the
ManagedSocket is its only child. When getInputStream() and
getOutputStream() are called, the ManagedSocket automatically
creates a ManagedInputStream and a ManagedOutputStream as
its children. Figure 2-6 shows the tree immediately before
01 static byte [] fetch(InetAddress addr,
02 int port,
03 byte [] msg) {
04 Socket s = null;
05 InputStream in = null;
06 OutputStream out = null;
07 ByteArrayOutputStream response =
08 new ByteArrayOutputStream();
09 boolean success = false;
10 try {
11 s = new Socket(addr,port);
12 out = s.getOutputStream();
13 out.write(msg);
14 out.flush();
15 in = s.getInputStream();
16 int i;
17 while ((i = in.read()) != -1) {
18 response.write(i);
19 }
20 success = true;
21 } catch (IOException exc) {
22 // log exception
23 } finally {
24 try {
25 if (out != null) out.close();
26 } catch (IOException exc) {
27 // log exception
28 } finally {
29 try {
30 if (in != null) in.close();
31 } catch (IOException exc) {
32 // log exception
33 } finally {
34 try {
35 if (s != null) s.close();
36 } catch (IOException exc) {
37 // log exception
38 }
39 }
40 }
41 }
42 if (!success) return null;
43 return response.toByteArray();
44 }
Figure 2-4. Connecting to a server to send a message
release() is called.
For another example, let us borrow a method from Apache
Tomcat, an open source Java Servlet container, produced by the
Apache Software Foundation. Tomcat is the official Reference
Implementation for the Java Servlet and JavaServer Pages
technologies [2].
The copy() method in Figure 2-7 is from the StandardContext
class, part of the Java engine (Catalina) built into Tomcat. Its task
is to copy from one file to another. A significant amount of effort
has gone into handling resources in exceptional situations in this
code. All resource releases are nicely wrapped in try-catch
blocks, which are in turn in a finally block. The method is well
thought out, carefully coded, and flawed. If the close() operation
on line 19 throws an Error, then the close() operation on line 22
will never occur, despite all the careful exception handling. This
is unlikely, but not impossible. This may have slipped by the
developers because the cleanup code is difficult to follow.
Note that the close() calls are duplicated. Lines 13 and 14 close
the resources in the normal conditions, while lines 19 and 22
close the resources in exceptional conditions. Such duplication
leads to less maintainable code. Note also that exceptions are
completely discarded, losing potentially useful information.
Figure 2-8 displays the code rewritten to use Furm. This code
correctly closes resources in both normal and exceptional
situations. The basic functionality is retained. However, the
cleanup code is completely different. Instead of nested try-catch
blocks, a single try-catch-finally block suffices. Rather than two
different close() calls (or four, counting the duplicates), a single
release() call is responsible for releasing the input and output
streams correctly in both normal and exceptional cases. The
return value of the release() call is checked on line 19 to
determine whether the cleanup was successful. A return value of
01 static byte [] fetchAgain(InetAddress addr,
02 int port,
04 byte [] msg) {
05 ResourceGroup tree = new ResourceGroup(
06 new ExceptionLogger());
07 ByteArrayOutputStream response =
08 new ByteArrayOutputStream();
09 boolean success = false;
11 try {
12 Socket s = new ManagedSocket(
13 addr,port,tree);
14 OutputStream out = s.getOutputStream();
15 out.write(msg)
16 out.flush();
17 InputStream in = s.getInputStream();
18 int i;
19 while ((i = in.read()) != -1) {
20 response.write(i);
21 }
22 success = true;
23 } catch (IOException exc) {
24 tree.getListener().
25 exceptionThrown(null,exc);
26 } finally {
27 tree.release();
28 }
29 if (!success) return null;
30 return response.toByteArray();
31 }
Figure 2-5. Connecting to a server using Furm
117