This step is in charge of abilities. Next Step available : BuildStep

Base class for concrete creatures.

Base class for order processing filters. Handles chain management.

Action is the data payload dispatched to the stores when something happens.

Action enumeration.

Types of actions.

Concrete implementation of filter This filter is responsible for checking/filtering the input in the address field. @author joshzambales

AdvancedWizard implements inversion of control. It depends on abstraction that can be injected through its constructor.

AlchemistShop holds potions on its shelves. It uses PotionFactory to provide the potions.

Angry state.

Service locator pattern, used to lookup jndi services and cache them for subsequent requests. @author saifasif

One of possible approaches to terminate Producer-Consumer pattern is using PoisonPill idiom. If you use PoisonPill as termination signal then Producer

Flux is the application architecture that Facebook uses for building client-side web applications. Flux eschews MVC in favor of a unidirectional data

Decorator pattern is more flexible alternative to subclassing. The decorator class implements the same interface as the target and uses composition to

In Bridge pattern both abstraction (MagicWeapon) and implementation (MagicWeaponImp) have their own class hierarchies. The interface of the implementa

With Composite we can treat tree hierarchies of objects with uniform interface (LetterComposite). In this example we have sentences composed of words

The Business Delegate pattern adds an abstraction layer between presentation and business tiers. By using the pattern we gain loose coupling between t

Strategy (DragonSlayingStrategy) encapsulates an algorithm. The containing object (DragonSlayer) can alter its behavior by changing its strategy.

The essence of the Abstract Factory pattern is a factory interface (KingdomFactory) and its implementations (ElfKingdomFactory, OrcKingdomFactory). T

Facade (DwarvenGoldmineFacade) provides simpler interface to subsystem. http://en.wikipedia.org/wiki/Facade_pattern

Memento pattern is for storing and restoring object state. The object (Star) gives out a "memento" (StarMemento) that contains the state of the object

Interpreter pattern breaks sentences into expressions (Expression) that can be evaluated and as a whole form the result.

In Command pattern actions are objects that can be executed and undone. Four terms always associated with the command pattern are command, receiver,

The central idea of Specification pattern is to separate the statement of how to match a candidate, from the candidate object that it is matched again

Resource Acquisition Is Initialization pattern was developed for exception safe resource management by C++ creator Bjarne Stroustrup. In RAII resourc

The Private Class Data design pattern seeks to reduce exposure of attributes by limiting their visibility. It reduces the number of class attributes b

Singleton pattern ensures that the class (IvoryTower) can have only one existing instance per java classloader instance and provides global access to

Repository pattern mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects. A system with c

In State pattern the container object (Mammoth) has an internal state object (State) that defines the current behavior. The state object can be change

Model-View-Controller is a pattern for implementing user interfaces. It divides the application into three interconnected parts namely the model, the

In Factory Method we have an interface (Blacksmith) with a method for creating objects (manufactureWeapon). The concrete subclasses (OrcBlacksmith, El

Mediator encapsulates how a set of objects (PartyMember) interact. Instead of referring to each other directly they use a mediator (Party) interface.

Tolerant Reader is an integration pattern that helps creating robust communication systems. The idea is to be as tolerant as possible when reading dat

Proxy (WizardTowerProxy) controls access to the actual object (WizardTower).

This is an app that checks whether the order request is valid through pre-processing done via Filters Each field has its own corresponding Filter @aut

<p> Layers is an architectural style where software responsibilities are divided among the different layers of the application. </p> <p> This example

Iterator (ItemIterator) adds abstraction layer on top of a collection (TreasureChest). This way the collection can change its internal implementation

Dependency Injection pattern deals with how objects handle their dependencies. The pattern implements so called inversion of control principle. Invers

Chain of Responsibility organizes request handlers (RequestHandler) into a chain where each handler has a chance to act on the request on its turn. In

When it is necessary to work with a large number of objects that are particularly expensive to instantiate and each object is only needed for a short

Servant offers some functionality to a group of classes without defining that functionality in each of them. A Servant is a class whose instance provi

Service layer defines an application's boundary with a layer of services that establishes a set of available operations and coordinates the applicatio

Thread Pool pattern is where a number of threads are created to perform a number of tasks, which are usually organized in a queue. The results from t

With the DAO pattern, we can use various method calls to retrieve/add/delete/update data without directly interacting with the data. The below example

Whereas Singleton design pattern introduces single globally accessible object the Multiton pattern defines many globally accessible objects. The clien

In Inventory we store the items with a given size. However, we do not store more items than the inventory size. To address concurrent access problems

When a message with a parameter is sent to an object, the resultant behaviour is defined by the implementation of that method in the receiver. Sometim

Visitor pattern defines mechanism to apply operations on nodes in hierarchy. New operations can be added without altering the node interface. In this

The Execute Around idiom specifies some code to be executed before and after a method. Typically the idiom is used when the API has methods to be exec

This application demonstrates Half-Sync/Half-Async pattern. Key parts of the pattern are {@link AsyncTask} and {@link AsynchronousService}. <p> <i>PR

Flyweight pattern is useful when the program needs a huge amount of objects. It provides means to decrease resource usage by sharing object instances.

There are two variations of the Adapter pattern: The class adapter implements the adaptee's interface whereas the object adapter uses composition to c

Null Object pattern replaces null values with neutral objects. Many times this simplifies algorithms since no extra null checks are needed. In this e

The Event Aggregator pattern channels events from multiple objects into a single object to simplify registration for clients. In the example LordBael

This is the Builder pattern variation as described by Joshua Bloch in Effective Java 2nd Edition. We want to build Hero objects, but its construction

<p> This application demonstrates the async method invocation pattern. Key parts of the pattern are <code>AsyncResult</code> which is an intermediate

Step Builder Pattern <p><b>Intent</b> <br/> An extension of the Builder pattern that fully guides the user through the creation of the object with no

Example of Character instantiation using Property pattern (as concept also known like Prototype inheritance). In prototype inheritance instead of clas

The Front Controller is a presentation tier pattern. Essentially it defines a controller that handles all requests for a web site. The Front Controll

Callback pattern is more native for functional languages where function is treated as first-class citizen. Prior to Java8 can be simulated using simpl

Template Method defines a skeleton for an algorithm. The algorithm subclasses provide implementation for the blank parts. In this example HalflingThi

Lazy loading idiom defers object creation until needed. This example shows different implementations of the pattern with increasing sophistication.

Observer pattern defines one-to-many relationship between objects. The target object sends change notifications to its registered observers.

In Prototype we have a factory class (HeroFactoryImpl) producing objects by cloning existing ones. In this example the factory's prototype objects are