In this article, Michael Feldman explains the three ways to implement the Decorator design pattern: inheritance, wrapper, and external. During his discussion, he presents the pros and cons of each implementation. (2,000 words)

Every now and then, we need to build a custom client/server model, especially if we are students and are required to submit some network project using Java's powerful network programming capabilities. In this article I attempt to provide a pattern/framework for developing custom client/server programming using the Java language. This article is divided into two parts: server development and client development.

The Decorator design pattern lets you attach responsibilities to objects at runtime. This pattern proves more flexible than inheritance, which is static. In this latest installment of Java Design Patterns, David Geary explores Decorator with an implementation example. (2,800 words)

Java Reflection provides a lot of information about a given class at runtime; you can easily know all its super classes, implemented interfaces, methods, constructors, fields, and so on. But in some cases, you may want to know all the classes implementing a given interface, or subclassing a given class. This tip, based on lessons learned from Java Tip 105, shows you how to retrieve all the classes from a package inheriting or implementing a given class or interface.
(1,200 words)

In most J2EE systems, it is desirable to have factories or managers (implemented as stateless session beans) that fire appropriate events. EJB containers handle the demand for stateless session beans by creating as many instances of them as required or by reusing existing ones. However, each new bean instance must be initialized with exactly the same set of listeners as exists for all other instances. This tip shows you how to correctly implement the Observer pattern when participants are EJBs.
(1,000 words)

Creating the client tier of an n-tier Web architecture is extremely time-consuming, with an immense chance for error. In this article, Jason Cai, Ranjit Kapila, and Gaurav Pal explain HMVC -- an industrial-strength design pattern that can significantly lower the risks and costs associated with developing a Java-based client tier. The authors outline HMVC's design philosophy and some key aspects of it; they also provide a lucid example of how you can apply it. HMVC is applicable to both Java applets and applications; indeed, any object-oriented language could take advantage of this architecture. (3,000 words) The task of designing and developing the client tier of an n-tier Web architecture often challenges developers. This is particularly true in the Web world, where the sheer variety of servers, deployment platforms, and protocols turns the challenge into a headache. A client-tier architect must address a number of questions:

• How should I structure my GUI?
• How will users interact with my GUI?
• How should I separate server-side/transport data formats from my GUI?
• How should I provide sound mechanisms for event management, application flows, and widget control?