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

ManagedInputStream
ResourceGroup
ManagedSocket
ManagedOutputStream
Figure 2-6. A potential resource tree associated
with a Socket
zero indicates that no exceptions occurred.
Among the most obvious differences is the reduction in cleanup
code. The release and exception-handling code has been reduced
by almost half. The nested try-catch blocks are no longer needed
because that functionality is now encapsulated in the release()
call. Additionally, exceptions are no longer discarded silently.
Instead they are passed to an ExceptionListener. The overall
method is shorter as well, even with the overhead of creating the
ResourceGroup. Compared to the original, use of Furm reduced
the amount of code, eliminated the resource cleanup error, and
minimized the loss of information related to exceptions.
2.2 Creating Managed Resources
Adding new resources to Furm is straightforward. The most
difficult issue with using Furm is that each type of resource to be
added to the tree must be wrapped in a new class to produce the
equivalent managed resource. For example, to add an
01 private boolean copy(File src, File dest) {
02 FileInputStream is = null;
03 FileOutputStream os = null;
04 try {
05 is = new FileInputStream(src);
06 os = new FileOutputStream(dest);
07 byte[] buf = new byte[4096];
08 while (true) {
09 int len = is.read(buf);
10 if (len < 0) break;
11 os.write(buf, 0, len);
12 }
13 is.close();
14 os.close();
15 } catch (IOException e) {
16 return false;
17 } finally {
18 try {
19 if (is != null) is.close();
20 } catch (Exception e) {/*Ignore*/}
21 try {
22 if (os != null) os.close();
23 } catch (Exception e) {/*Ignore*/}
24 }
25 return true;
26 }
Figure 2-7. The copy() method from Tomcat’s Java engine
InputStream to the tree, a new wrapper class,
ManagedInputStream, must be defined. Additionally, each
managed resource must define its own subclass of ResourceNode,
described in Section 2.3, to override the cleanup() method. In
practice, these requirements pose little problem.
Figure 2-9 shows one possible implementation of the
ManagedInputStream class. This class extends FilterInputStream
to wrap an underlying InputStream. ManagedInputStream uses
an anonymous inner class [8] to subclass ResourceNode and
override its cleanup() method. Use of an anonymous inner class
is not necessary. A named class would be sufficient, but less
succinct. The close() method is also overridden to call the
release() method of ResourceNode. This will automatically
release any child resources and call the cleanup() method of the
ResourceNode subclass, which in turn will call
ManagedInputStream’s superclass close() method.
ManagedInputStream exposes its ResourceNode instance variable
publicly to expose the ResourceNode functionality. This is the
recommended practice. Because forwarding all relevant calls to
the underlying ResourceNode would be a tedious task, the choice
was made to simply expose the ResourceNode directly, rather
than hide it. In practice, this means little except that to release the
resource, the correct call is stream.node.release() rather than
stream.release(). For the sake of consistency, the name node is
recommended, but not mandated by Furm. The node variable
should be declared final to protect it from modification.
It is recommended that managed resource classes extend (or
implement) the class they are intended to replace. In this
example, ManagedInputStream extends FilterInputStream (so that
it indirectly implements InputStream). This allows
ManagedInputStream to be passed to methods and constructors
which expect an InputStream. ManagedInputStream thus
becomes a drop-in replacement.
In cases where the original resource is a class, the constructors of
the original resource class will need to be duplicated in the
managed subclass. In cases where a resource has a large number
of constructors, this could be tedious. However, a tool could
automate this task. In cases where the original resource is an
01 private boolean copy(File src, File dest) {
02 ResourceGroup root = new ResourceGroup(…);
03 boolean success = false;
04 try {
05 InputStream is =
06 new ManagedFileInputStream(src,root);
07 OutputStream os =
08 new ManagedFileOutputStream(dest,root);
09 byte[] buf = new byte[4096];
10 int len;
11 while ((len = is.read(buf)) >= 0) {
12 os.write(buf, 0, len);
13 }
14 success = true;
15 } catch (IOException exc) {
16 root.getListener().
17 exceptionThrown(null, exc);
18 } finally {
19 if (root.release() != 0) success = false;
20 }
21 return success;
22 }
Figure 2-8. A version of the copy() method using Furm
118