JAVA EE: Real Time Examples

Showing posts with label Real Time Examples. Show all posts

Saturday, 7 December 2013

Template Design pattern or Template Method Design pattern - Real Time Example [Coffee]

Master Practical Software Design Patterns!

Subscribe to Ram N Java for clean code concepts, clear architecture diagrams, and real-world Java walkthroughs!

The Concept: Real-Time Coffee Making Analogy

When making any type of coffee—whether you prefer Bru Coffee, Nescafé, or a custom filter blend—the overarching routine follows a predefined set of actions:

Boil water
Add milk
Add sugar
Add the designated coffee powder

Even though the sequence of preparation steps is universal, the exact amount of sugar, quantity of milk, and brand or type of coffee powder depend entirely on the specific coffee flavor being brewed.

How the Template Method Pattern Solves This

Without a structured pattern, you might find yourself copying and pasting the preparation steps inside every single coffee class. If the sequence changes later, you would have to update multiple files.

The Template Method Design Pattern elegantly solves this problem:

Base Template Class: An abstract class (such as CoffeeTemplate) provides the overarching algorithm in a template method.
Preserving the Flow: The template method calls each step in order and is typically marked final to stop subclasses from reordering the recipe.
Subclass Flexibility: Individual steps are declared as abstract methods so specific subclasses can implement their unique ingredients and measurements.

Key Architectural Takeaways

Applying this pattern guarantees a standardized workflow across all implementations while maintaining low coupling:

Eliminates Redundancy: Shared execution code resides strictly in one parent class.
Consistent Execution: Guarantees that essential steps (like boiling water before serving) are never bypassed.
Extensibility: Introducing a new recipe (such as Cappuccino or Espresso) only requires extending the base template and implementing the missing step methods.

Saturday, 9 November 2013

Memento Design pattern - Realtime Example

🚀 Master Java Design Patterns & Software Architecture!

Subscribe to Ram N Java for clean software architecture patterns, design pattern deep dives, and production-ready implementation guides!

🔔 Subscribe to Ram N Java

Real-World Application: Memento Pattern in Action

Capturing and restoring state history is essential across various software systems—from document text editors and graphic design software to game checkpoints and multi-step transaction forms. The challenge lies in saving these snapshots without exposing an object's internal private fields. The Memento Design Pattern provides an elegant solution by encapsulating an object's state inside a dedicated snapshot without violating object-oriented encapsulation principles.

Practical Demonstration & Workflow

State Changes: The user performs actions (such as typing text or modifying document properties), which update the internal state of the Originator.
Taking Checkpoints: Before executing high-impact modifications, the application triggers a save point. The Originator packages its active attributes into an immutable Memento.
Safe Storage: The Caretaker receives the Memento and pushes it onto an undo stack, keeping track of history without inspecting what is inside the checkpoint.
Rolling Back: When an undo operation is requested, the Caretaker pops the latest snapshot from its stack and passes it back to the Originator to restore its prior state effortlessly.

Core Roles in the Demonstration

Originator: Maintains the active business state (e.g., text content, configuration settings) and possesses full knowledge of how to create and restore from snapshots.
Memento: Stores the snapshot data securely and immutably, ensuring external objects cannot tamper with the saved values.
Caretaker: Coordinates save and rollback requests and manages the history timeline (e.g., stack or list of mementos).

Architectural Advantages

Strict Encapsulation: Eliminates the bad practice of exposing private fields via public getters and setters solely for state persistence.
Simplified Business Logic: The Originator focuses purely on its domain tasks while delegating the history tracking lifecycle to the Caretaker.
Robust Undo/Redo Capabilities: Provides a predictable, decoupled foundation for implementing multi-level undo, rollback, and recovery workflows in enterprise applications.