Preview of Patterns in Java Volume 3

If you have any comments or suggestions, please send mail to  mgrand@mindspring.com . Synopsis of the design patterns in volume 1 and the patterns in volume 2 are available on a separate page.
 
 

Transaction Patterns

• ACID Transaction

Ensure that a transaction will never have any unexpected or inconsistent outcome. You do that by ensuring that the transaction has the ACID properties: atomicity, consistency, isolation and durability.

Related patterns are

• Snapshot

The Snapshot pattern describes techniques for saving and restoring the state of objects. This is the better way to recover from a transaction failure when a transaction involves a long sequence of operations that modify the state of a small number of simple objects.
 
• Command

The command pattern describes techniques for remembering and undoing a sequence of operations. This is the better way to recover from a transaction failure when a transaction involves a short sequence of operations that modify the state of a large number of complex objects.
 
• Audit Trail

Logging a sequence of operations to support the Command Pattern is structurally similar to maintaining an audit trail.
 
• System Testing

The System Testing pattern should be used to ensure the consistency of transactions.
 
• Unit Testing

The Unit Testing pattern may also help to ensure the consistency of transactions.
 
• Single Threaded Execution

The Single Threaded Execution Pattern can be used to keep transactions that modify the state of the same object isolated from each other, so that the modifications each transaction makes to the object’s state do not interfere with each other.
 
• Read/Write Lock

The Read/Write Lock pattern can be used to keep transactions that use the same object isolated from each other while allowing transactions that do not modify the object’s state to execute concurrently.
 
• Read/Write Consistency

If you directly manage the storage of persistent distributed objects, you may need the Read/Write Consistency pattern to ensure that data and objects that are read from files are consistent wit the most recent write operation.
 
• Copy on Write Proxy

The Copy on Write Proxy pattern can be used to help ensured the isolation property of transactions. The Copy on Write Proxy is described as part of the write-up of the Proxy pattern in Volume 1.
 
• Copy Mutable Parameters

The Copy Mutable Parameters pattern can be used to help ensure the isoplation property of transactions.
 
• Return New Objects from Accessor Method

The Return New Objects from Accessor Method pattern (described in Volume 2) can be used to help ensure the isolation property of transactions.

Return Mutable Objects from Accessor Method
The Return Mutable Objects from Accessor Method (described in Volume 2) can be used to help ensure the isolation property of transactions.
 

• Cache Consistency

If you directly manage the storage of persistent distributed objects, you may need the Cache Consistency pattern to ensure that the result of a locally initiated read operation matches the current contents of a remote store.
 
• Decorator

If an object that does not support access controls such as single threaded execution or read/write lock must participate in an ACID transaction, the object’s deficiency can be compensated for by making the TransactionManager access the object through a decorator object.
 
• Composite Transaction

You want to design and implement transactions correctly and with a minimum of effort. Simple transactions are easier to implement and make correct than complex transactions. Design and implement complex transactions from simpler ACID transactions.

Related patterns are

• ACID Transaction

The Composite Transaction pattern is built on the ACID transaction pattern.
 
• Command

The Command Pattern can be the basis for an undo mechanism used to undo operations and restore object to the state they were in at the beginning of a transaction.
 
• Composed Method

 The Composed Method pattern is a coding pattern that describes a way of composing methods from other methods that is structurally similar to the way the Composite Transaction pattern composes transactions.
 
• Lock File

 The Lock File pattern can be used to enforce the isolation property for a composite transaction.

• Two Phase Commit

The Two Phase Commit pattern can be used to ensure the ACID properties of a composite transaction composed from simpler ACID transactions.
 
• Mailbox

When there is a need to ensure the reliability a composite transaction, you will want to take steps to ensure the reliability of the component transactions that constitute it. If the composite transaction is distributed, you will also want to ensure the reliable transmission of messages between the objects that participate in the transaction by such means as the Mailbox pattern.
 
•  Two Phase Commit

If a transaction is composed of simpler transactions, you want them to either all complete successfully or to all abort, leaving all objects as they were before the transactions. You achieve this by making an object responsible for coordinating the transactions so that they all complete successfully or all abort.

Related patterns are

• ACID Transaction

The Two Phase Commit pattern is used to build composite transactions having the ACID properties from component transactions that have the ACID properties.
 
• Composite Transaction

The Two Phase Commit pattern is used with the Composite Transaction pattern
 
• Decorator

The Decorator pattern provides the basis for the organization of the wrapper objects used in the Two Phase Commit pattern.
 
• Heartbeat

The Heartbeat pattern may be used with the Two Phase Commit pattern to ensure that the Coordinator object is able to detect catastrophic failures of component transactions in a bounded amount of time.
 
Audit Trail
You need to verify that transactions are being processed correctly and honestly. Maintain an historical record of transactions that have been applied to an object or set of objects. The record should contain enough detail to determine how the objects affected by the transactions reached their current state.

Related patterns are

• ACID Transaction

If the transactions in an historical record do not have the ACID properties, then it may not be possible to unambiguously determine the effect of each transaction on an object.
 
• Snapshot

The Snapshot pattern provides advice on how to capture the state of an object.

Distributed Architecture Patterns

Shared Object
You have some information or a limited quantity of a resource. You Sshare objects among multiple clients to facilitate sharing of encapsulated information or underlying resources. You organize the sharing so that it does not add to the complexity of the objects being shared or the objects sharing them.
 
Related patterns are
• Object Replication

The Object Replication pattern provides a different way for the clients of an object to share information.
 
• Object Request Broker

The Object Request Broker pattern can be used to allow objects to be shared by remote clients.
 
• Singleton

The Singleton pattern describes classes that have a single instance that may or may not be shared. The Shared Object pattern describes objects that are shared and may have multiple instances.
 
• Flyweight

The Flywieght pattern describes a way that objects with no intrinsic state can be shared by local clients.
 
Object Request Broker
Objects in a distributed environment need to call methods of remote objects. Provide an infrastructure that allows objects in a distributed environment to call each other’s methods, receive the results of those calls or exceptions thrown from those calls. The infrastructure allows remote calls to be made through an interface, with most of the details of the call handled automatically by the infrastructure.

Related patterns are

• Object Identifier

The Object Identifier pattern provides additional guidance on uniquely identifying possibly remote objects.
 
• Heartbeat Pattern

The Heartbeat pattern provides a general purpose way to detect when the caller of a remote method will never see the call complete because the machine that the remote call runs on has crashed or the network connection to the remote machine has been lost.
 
• Registry

The Registry pattern describes a way for an Object Request Broker implementation to find remote objects that have a know name or unique object identifier.
 
• Thread Pool

CallDispatcher objects need a thread to process each remote call. An implementation of the Object Request Broker pattern can use the Thread Pool pattern to recycle threads and avoid the expense of creating new threads.
• Object Replication

You need to improve the throughput or availability of a distributed computation. A distributed computation is a computation that involves objects that reside on multiple computing elements and are able to communicate with each other. In some circumstances, it is possible to improve the availability and throughput of a computation by replicating an object onto multiple computing elements while maintaining the illusion to the object’s clients of there only being a single object.

Related patterns are

• High Availability

The High Availability pattern is a more specialized pattern that describes the use of replication to make objects highly available.
 
• Data Lock

The Data Lock pattern describes techniques that can be used to lock replicas of an object.
 
• Optimistic Concurrency

The Optimistic Concurrency pattern describes how to update data without the use of locks.
 
• Immutable

The Immutable pattern explains the simplicity and safety that comes from designing objects to be immutable.
 
• Object Request Broker

The Object Request Broker pattern allows an object to be used in multiple places at the same time without it being in multiple places or replicated.

 

• High Availability

You need to Eensure the high availability of an object. You can accomplish this through by using redundancy redundant and failfast components along with theand promptly repairing of failures.

Related patterns are

• Object Replication

The High Availability pattern is a specialized version of the Object Replication pattern.
 
• Process Pair

The Process Pair pattern can be used to ensure that software components are restarted when they fail.
 
• Snapshot

The Snapshot pattern can be used to implement checkpoint/restart
 
• Mobile Agent

An object needs to access very large volume of remote data. To conserve network bandwidth, Instead instead of bringing data to an object, move the object to the data.
 
Related patterns are:
• Object Request Broker

The Object Request Broker pattern is usually used with the Mobile Agent pattern to facilitate communications between mobile agents and other objects. Mobile agents can be implemented on top of the Object Request Broker pattern.
 
• Object Replication

One of the applications of the Object Replication pattern is to ensure that an object is near its accessors. The Mobile Agent pattern provides a way for an object’s accessors to be near the object.
 
 
• Demilitarized Zone

You don’t want hackers to be able to gain access to servers containing sensitive information if they are able to compromise the security of a publicly accessible server. Put servers that are accessible to the public Internet on a publicly accessible LAN that connects with bothbetween your private networkfirewall and the public Internet.

Related pattern are

• Protection Proxy

The Protection Proxy pattern, at the object level, is structurally similar to the Demilitarized Zone pattern at the network level.
 
• Process Pair

To keep a process or software component highly available, you want it to be automatically restarted if it fails. Organize highly available software components in pairs, so that if one fails the other restarts it.

Related pattern are

• Heartbeat

The Process Pair pattern uses the Heartbeat pattern.

Distributed Computing Patterns

• Object Identifier

You need to uniquely identify an object that exists in multiple environments. Assign a globally unique identifier to the object, allowing it to have a unique identity when it is shared between programs or databases.

Related patterns are

• Objecct Request Broker and Registry

You can use the Object Request Broker pattern with the Registry pattern to encapsulate an implmentation of the Object Identifier pattern and minimize the number of classes that are dependent on it.
 
• Mobile Agent

The Mobile Agent pattern uses the Object ID pattern.
 
• Object Replication

The Object Replication pattern uses the Object ID pattern.
 
• Registry

Objects need to contact another object, knowing only the object’s name or the name of the service it provides, but not its object identifier. An object identifier is sufficient information to allow objects to contact the identified object. Provide a service that takes the name of an object, service or role and returns a corresponding object identifier.

Related patterns are

• Object Identifier

The Registry pattern uses the Object Identifier pattern.
 
• Object Request Broker

The Registry pattern is often used the Object Request Broker pattern.
 
• Shared Object

Registry objects are shared objects.
 
• Protection Proxy

Malicious objects may attempt to violate the integrity of other objects by using reflection or other means to access methods or variables they should not. You can prevent this by requiring other objects to access sensitive objects through a proxy that limits access based on security considerations. The proxy implements measures to ensure that other objects do not gain access to features of a sensitive object that they are not entitled to.

Related patterns are

• Proxy

The Protection Proxy pattern is a specialized version of the Proxy pattern.
 
• Template Method

The Protection Proxy pattern uses the Template Method pattern to abstract out the reusable portion of the thread management logic.
 
• Thread Pool

You can use the Thread Pool pattern with the Protection Proxy pattern to create a multi-threaded proxy.
 
• Publish-Subscribe

You need to provide reliable delivery of messages to objects. Deliver messages to subscribed recipient objects by transmitting each message to each recipient. Ensure reliable delivery by repeating the transmission after an attempt fails until delivery is successful.

Related patterns are:

• Object Request Broker

The Publish-Subscribe pattern is often used with the Object Reqest Broker pattern to deliver messages to remote objects.
 
• Mailbox

The Mailbox pattern provides an alternate solution for the reliable delivery of messages.
 
• High Availability

You can use the High Availability pattern to minimize the likelihood that the Publisher object will crash or become otherwise unavailable.
 
• Object Replication

In order for message delivery to be as reliable as possible the Publisher object must be highly available. The Object Replication pattern describes a way to make the Publisher object highly available.
 
• Process Pair

The Process Pair pattern describes a way to ensure that a Publisher object is automatically restarted after a crash.
 
• Registry

The registry pattern provides a way for Subscriber objects to find Publisher objects.
 
• Remote Proxy

Publisher objects and Subscriber objects communicate with each other through remote proxies.
 
• Mailbox

You need to provide reliable delivery of messages to objects. Facilitate the delivery of messages by storing messages for later retrieval by each recipient.
 
Related patterns are:
• Publish-Subscribe

The Publish-Subscribe pattern provides an alternate solution for the reliable delivery of messages.
 
• High Availability

The High Availability pattern can be used to ensure that a MailboxServer is highly available.
 
• Objecg Request Broker

The Mailbox pattern is often used with the Object Request Broker pattern to deliver messages to remote objects.
 
• Process Pair

The Process Pair pattern describes a way to ensure that a MailboxServer object is automatically restarted after a crash.
 
• Registry

The registry pattern provides a way for Subscriber objects to find MailboxServer objects.
 

• Heavyweight/Lightweight Object

You are designing an application client that should be as small and thin as possible. The client must access some objects that have many attributes and/or attributes that are large objects. The client does not always need the attributes, so you arrange for the client to download the objects without the attributes and then lazily download the attributes on an as needed basis.

Related Patterns are:

• Object Request Broker

The Heavyweight/Lightweight pattern is usually implemented using the Object Request Broker to facilitate communication between the client and the server.
 
• Lazy Initialization

The lazy Initialization pattern can be used to manage the download of Data objects if client objects are responsible for the download of their own Data object.
 
• Virtual Proxy

The Virtual Proxy pattern should be used to manage the download of Data objects if the same class is used to implement the client and server version of the shared object.
 
• Object Replication

The Object Replication pattern addresses issues related to keeping the state of the client and server objects consistent.
 
• Facade

Like a façade object, a lightweight object hides the details of accessing objects behind it.

• Heartbeat

While a remote object is performing an operation on behalf of a client, periodically send a message back to the client indicating that the remote object is still alive.

Related patterns are:

• Object Request Broker

The Heartbeat pattern is used with the Object Request Broker pattern.
 
• Connection Multiplexing

Whether or not the ORB being used with the Heartbeat pattern implements the Connection Multiplexing pattern can determine how you choose to implement the Heartbeat pattern.
 
• Connection Multiplexing

You are designing a distributed system in which one object may establish many connections with another object. To avoid the overhead of setting up and shutting down many connections between the same two objects, you arrange for one actual connection to carry the contents of multiple virtual connections.

Related patterns are

• Object Pool

The Connection Multiplexing pattern uses the Object Pool pattern to manage data buffers.
 
• Object Identifier

The ConnectionID objects used by the Connection Multiplexing pattern are an application of the Object Identifier pattern.
 
• Scheduler

The Scheduler pattern can be used to ensure that all virtual connections get their fair share of the actual connection’s bandwidth. The Scheduling pattern describes how to enforce a policy that determines when a thread is scheduled to use a resource.
 

 Concurrency Patterns

• Session Object

A server’s sessions with clients have state information associated with them, but you don’t want to duplicate a lot of objects for each session. Use a single object to contain all the state information needed during a session by the server and make that object accessible to all other objects that need state information for the current session.

Reelated patterns are

• Singleton

The Singleton pattern (described in Volume 1) uses a single instance of a class for an entire program. The Session pattern uses a single instance of a class per session.
 
• Thread Pool

You can use the Thread Pool pattern to manage the association between threads and sessions over time.
 
• Data Lock

 
• Lock File

 
• Optimistic Concurrency

 
• Thread Pool

 
• Cache Consistency

 
• Read/Write Consistency

Temporal Patterns

Database Patterns

Return to Mark Grand's home page.