In this Article
Software architecture often boils down to managing complexity. As applications grow, spaghetti code becomes a liability. Design patterns provide a shared vocabulary and standardized solutions to common problems we face in object-oriented design. They aren't algorithms, but rather descriptions of how to solve a problem that can be used in many different situations.
In Java, these patterns are critical for building scalable, maintainable systems. This guide breaks down the standard GoF (Gang of Four) patterns and J2EE enterprise patterns, with implementation examples for the most critical ones.
Creational Patterns
Creational patterns abstract the instantiation process. They make a system independent of how its objects are created, composed, and represented. This becomes vital when a system needs to evolve without modifying the code that interacts with the classes.
The core patterns in this category include:
- Abstract Factory
- Builder
- Factory Method
- Prototype
- Singleton
The Singleton Pattern
This is perhaps the most debated pattern, but it remains a staple in Java for things like logging drivers or configuration managers. The goal is to ensure a class has only one instance and provide a global point of access to it.
Here is a thread-safe implementation using the "Bill Pugh" Singleton approach, which leverages the class loader mechanism for safety without synchronization overhead.
public class ConfigurationManager {
// Private constructor prevents instantiation from other classes
private ConfigurationManager() {
// Load configuration settings here
System.out.println("Configuration Manager Initialized");
}
// Static inner class - inner classes are not loaded until they are referenced.
private static class SingletonHelper {
private static final ConfigurationManager INSTANCE = new ConfigurationManager();
}
public static ConfigurationManager getInstance() {
return SingletonHelper.INSTANCE;
}
public String getConfig(String key) {
return "Value for " + key;
}
}The Builder Pattern
When you have an object with many optional parameters, constructors become messy ("telescoping constructors"). The Builder pattern separates the construction of a complex object from its representation.
public class ServerConfig {
// Required parameters
private String host;
private int port;
// Optional parameters
private boolean sslEnabled;
private int timeout;
private ServerConfig(ServerBuilder builder) {
this.host = builder.host;
this.port = builder.port;
this.sslEnabled = builder.sslEnabled;
this.timeout = builder.timeout;
}
// Getters only (Immutable object)
public String getHost() { return host; }
public static class ServerBuilder {
private String host;
private int port;
private boolean sslEnabled;
private int timeout;
public ServerBuilder(String host, int port) {
this.host = host;
this.port = port;
}
public ServerBuilder enableSSL(boolean sslEnabled) {
this.sslEnabled = sslEnabled;
return this; // Return builder for chaining
}
public ServerBuilder setTimeout(int timeout) {
this.timeout = timeout;
return this;
}
public ServerConfig build() {
return new ServerConfig(this);
}
}
}
// Usage
// ServerConfig config = new ServerConfig.ServerBuilder("192.168.1.1", 8080)
// .enableSSL(true)
// .setTimeout(5000)
// .build();Structural Patterns
Structural patterns deal with class and object composition. They help ensure that if one part of a system changes, the entire structure doesn't need to do the same. They generally rely on inheritance to compose interfaces or implementations.
The list includes:
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
The Adapter Pattern
As illustrated in the diagram, the Adapter allows classes with incompatible interfaces to work together. It wraps an existing class with a new interface so that it becomes compatible with the client's expected interface. This is common when integrating legacy code or third-party libraries.
// 1. The interface your application expects
interface MediaPlayer {
void play(String audioType, String fileName);
}
// 2. An advanced interface from a library (incompatible)
interface AdvancedMediaPlayer {
void playVlc(String fileName);
void playMp4(String fileName);
}
// 3. Concrete implementation of the advanced interface
class VlcPlayer implements AdvancedMediaPlayer {
public void playVlc(String fileName) {
System.out.println("Playing vlc file: " + fileName);
}
public void playMp4(String fileName) { /* do nothing */ }
}
// 4. The Adapter implementation
class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMusicPlayer;
public MediaAdapter(String audioType) {
if(audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer = new VlcPlayer();
}
}
@Override
public void play(String audioType, String fileName) {
if(audioType.equalsIgnoreCase("vlc")) {
advancedMusicPlayer.playVlc(fileName);
}
}
}
// 5. Client code using the Adapter
class AudioPlayer implements MediaPlayer {
MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
// Built-in support for mp3
if(audioType.equalsIgnoreCase("mp3")) {
System.out.println("Playing mp3 file: " + fileName);
}
// MediaAdapter provides support for other formats
else if(audioType.equalsIgnoreCase("vlc")) {
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
}
}
}Behavioral Patterns
Behavioral patterns focus on communication between objects. They characterize complex control flow that's difficult to follow at run-time. They shift your focus away from the flow of control to let you concentrate just on the way objects are interconnected.
The patterns here are:
- Chain of Responsibility
- Command
- Interpreter
- Iterator
- Mediator
- Memento
- Observer
- State
- Strategy
- Template Method
- Visitor
The Observer Pattern
This pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. It is the backbone of event handling systems.
import java.util.ArrayList;
import java.util.List;
// 1. The Subject (Broadcaster)
class NewsAgency {
private String news;
private List<Channel> channels = new ArrayList<>();
public void addObserver(Channel channel) {
this.channels.add(channel);
}
public void removeObserver(Channel channel) {
this.channels.remove(channel);
}
public void setNews(String news) {
this.news = news;
// Notify all observers when state changes
for (Channel channel : this.channels) {
channel.update(this.news);
}
}
}
// 2. The Observer Interface
interface Channel {
void update(String news);
}
// 3. Concrete Observers
class NewsChannel implements Channel {
private String name;
public NewsChannel(String name) {
this.name = name;
}
@Override
public void update(String news) {
System.out.println(this.name + " received news: " + news);
}
}
// Usage:
// NewsAgency agency = new NewsAgency();
// agency.addObserver(new NewsChannel("CNN"));
// agency.addObserver(new NewsChannel("FOX"));
// agency.setNews("Java 21 Released!");
// Output: Both channels print the news.J2EE / Enterprise Patterns
These are specifically tailored for the presentation and business tiers of enterprise applications. They address issues related to distributed resources, data persistence, and service lookup.
Key enterprise patterns include:
- Business Delegate
- Composite Entity
- Data Access Object (DAO)
- Dependency Injection (DI)
- Front Controller
- Intercepting Filter
- Model-View-Controller (MVC)
- Service Locator
- Transfer Object (Value Object)
Data Access Object (DAO) Pattern
The DAO pattern abstracts and encapsulates all access to the data source. The DAO manages the connection with the data source to obtain and store data. It completely hides the data access implementation details from the rest of the application.
This separation allows you to switch from a MySQL database to a flat file or Oracle database without changing the business logic client code.
// 1. Transfer Object / Value Object
class User {
private int id;
private String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() { return id; }
public String getName() { return name; }
}
// 2. DAO Interface
interface UserDAO {
List<User> getAllUsers();
User getUser(int id);
void updateUser(User user);
void deleteUser(User user);
}
// 3. Concrete DAO Implementation
class UserDAOImpl implements UserDAO {
// Simulating a database with a list
List<User> users;
public UserDAOImpl() {
users = new ArrayList<>();
users.add(new User(0, "Robert"));
users.add(new User(1, "John"));
}
@Override
public List<User> getAllUsers() {
return users;
}
@Override
public User getUser(int id) {
return users.get(id);
}
@Override
public void updateUser(User user) {
users.get(user.getId()).setName(user.getName());
System.out.println("User: " + user.getId() + ", updated in database");
}
@Override
public void deleteUser(User user) {
users.remove(user.getId());
System.out.println("User: " + user.getId() + ", deleted from database");
}
}
// Usage in Business Logic
// UserDAO userDao = new UserDAOImpl();
// for (User user : userDao.getAllUsers()) {
// System.out.println("User: " + user.getName());
// }Dependency Injection (DI)
While heavily associated with frameworks like Spring, DI is a core pattern where an object receives other objects that it depends on. These other objects are called dependencies. This removes the responsibility of object creation from the client object, promoting loose coupling.
Summary
Understanding these patterns allows you to communicate ideas rapidly with other developers. When you say "we need a Facade here" or "use a Factory for the repositories," the implementation details are immediately understood without writing a single line of code. However, use them judiciously. Applying patterns where they aren't needed leads to over-engineering and unnecessary complexity. Start simple, and refactor to patterns as the requirements evolve.