- Design Pattern: Singleton
- Design Pattern: Builder Design Pattern
- Design Pattern: Prototype Design Pattern
- Design Pattern: Factory Design Pattern
-
Shared Resource: Imagine having a class responsible for managing the database connection or logging mechanism. You want to ensure that only one instance of this class exists to avoid multiple connections or log files.
-
Single Access Point: Applications often require configuration. For instance, configuring database connection parameters. You want a single access point for the configuration parameters to prevent multiple instances and conflicting configurations.
The Singleton pattern is a creational design pattern that ensures a class has only one instance while providing a global access point to this instance. The following steps are involved in implementing the Singleton pattern:
-
Constructor Hiding: The constructor of the singleton class should be private or protected to prevent external instantiation.
-
Global Access Point: The singleton class should provide a global access point to retrieve its instance. This access point should be static and return the same instance every time it's called.
public class Database {
private static Database instance = new Database();
private Database() {
}
public static Database getInstance() {
return instance;
}
}To implement the getInstance() method, a static variable is used for lazy initialization.
To make the simple singleton thread-safe, make the getInstance() method synchronized.
public class Database {
private static Database instance = null;
private Database() {
}
public static synchronized Database getInstance() {
if (instance == null) {
instance = new Database();
}
return instance;
}
}To improve efficiency, use double-checked locking.
public class Database {
private static Database instance = null;
private Database() {
}
public static Database getInstance() {
if (instance == null) {
synchronized (Database.class) {
if (instance == null) {
instance = new Database();
}
}
}
return instance;
}
}- The singleton pattern ensures a class has only one instance with a global access point.
- Use cases: Shared resources like database connections, logging mechanisms, and objects that should be instantiated only once, such as configuration objects.
- Hide the constructor of the singleton class by making it private.
- Add a static method to return the instance, creating it if it doesn't exist.
- For thread safety, make the
getInstance()method synchronized or use double-checked locking.
-
Complex Object Creation:
- Multiple ways to create an object using constructors can lead to the telescoping constructor anti-pattern. This arises when there is a need to create an object with many parameters, making constructors unmanageable.
-
Validation and Failing Object Creation:
- When parameters need validation before object creation, using the default constructor prevents failing object creation if parameters are invalid.
-
Immutability:
- Mutable objects, whose state can change after creation, can lead to bugs. However, using the default constructor makes it challenging to create immutable objects.
public class Database {
private String host;
private int port;
private String username;
private String password;
public Database(Map<String, String> config) {
// Parameter validation and object creation logic
}
}Some problems:
- Type safety
- Difficulty identifying parameters
public class Database {
private String host;
private int port;
private String username;
private String password;
public Database(DatabaseParameters parameter) {
// Parameter validation and object creation logic
}
}
class DatabaseParameters {
// Fields for parameters
}Issues:
- Cumbersome to use
- Changes in parameter names require modification in Database class
public class Database {
private String host;
private int port;
private String username;
private String password;
private Database() {
}
public static class DatabaseBuilder {
private String host;
private int port;
private String username;
private String password;
public Database build() {
// Object creation logic
}
}
}Usage:
Database database = new Database.DatabaseBuilder()
.host("localhost")
.port(3306)
.username("root")
.password("password")
.build();- The builder pattern constructs complex objects step by step.
- Use cases:
- Complex object creation
- Validation and failing object creation
- Immutability
- Steps:
- Add a static inner class (builder class).
- Add a private constructor to the target class.
- Implement the
build()method in the builder class. - Add a method for each parameter in the builder class.
The Prototype pattern allows hiding the complexity of creating new instances from the client. It involves copying an existing object instead of creating a new instance from scratch, particularly useful for objects with costly operations during creation. The existing object acts as a prototype, and the new object may change specific properties if needed, saving resources and time.
Suppose we need to test a new User API by creating a new user. Instead of repeatedly calling an API for random values, we can clone an existing user and modify necessary fields.
User user = new User("John", "Doe", "john@doe.in", "1234567890");
User user2 = user.clone();
user2.setId(2);public abstract class User {
public abstract User clone();
}Extend the prototype pattern with a registry of pre-defined prototypes, allowing the client code to request a clone from the registry instead of creating a new object from scratch.
public interface UserRegistry {
User getPrototype(UserRole role);
void addPrototype(UserRole role, User user);
}
class UserRegistryImpl implements UserRegistry {
private Map<UserRole, User> registry = new HashMap<>();
@Override
public User getPrototype(UserRole role) {
return registry.get(role).clone();
}
@Override
public void addPrototype(UserRole role, User user) {
registry.put(role, user);
}
}Usage
UserRegistry registry = new UserRegistryImpl();
registry.addPrototype(UserRole.STUDENT, new Student("John", "Doe", "john@doe.in", "1234567890", UserRole.STUDENT, "CS"));
User user = registry.getPrototype(UserRole.STUDENT);
user.setId(1);- The prototype pattern creates objects similar to each other, avoiding the costly process of creating objects from scratch.
- It helps in reducing complexity for client code by allowing it to clone existing objects and modify them as needed.
- Implementation steps:
- Clonable Interface: Create a common interface for cloneable objects.
- Object Class: Implement a concrete class that overrides the
clone()method. - Registry: Create a registry of pre-defined prototypes.
- Prototype: Create a prototype object and store it in the registry.
- Clone: Request a clone from the registry and modify it as needed.
The Factory Method pattern is a creational design pattern that addresses the problem of creating objects without specifying their exact class. It utilizes factory methods, either defined in an interface and implemented by child classes or implemented in a base class and optionally overridden by derived classes.
In scenarios where the exact class of an object is unknown, such as when using an external library or creating objects with changing classes, the prototype pattern is employed to create a clone of an existing object. However, to enhance code independence from the object's class, the factory pattern is introduced.
The Simple Factory pattern provides a static method in a factory class for creating objects, reducing the need to specify the exact class. This method is implemented using a switch statement based on the input.
class UserFactory {
public static User createUser(UserRole role) {
// Object creation logic based on role
}
}
User user = UserFactory.createUser(UserRole.STUDENT);Complete steps for implementing the simple factory pattern:
- Factory class: Create a class with a static method for object creation.
- Conditional: Use a conditional statement to create the object based on the input.
- Request: Request an object from the factory class without knowing the exact class.
The Factory Method pattern overcomes drawbacks of the simple factory by shifting the responsibility of creating objects to child classes. The base class contains a factory method that child classes can override to create objects of their type.
abstract class UserFactory {
public abstract User createUser(String firstName, String lastName);
}
class StudentFactory extends UserFactory {
@Override
public User createUser(String firstName, String lastName) {
// Object creation logic for Student
}
}Usage:
UserFactory factory = new StudentFactory();
User user = factory.createUser("John", "Doe");Complete steps for implementing the factory method pattern:
- Base factory interface: Create a class with a method for object creation.
- Child factory class: Create a child class extending the base class and override the factory method.
- Request: Request an object from the factory class without knowing the exact class.
The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. It uses a family of factories, each responsible for creating a different product.
abstract class ClassroomFactory {
public abstract Student createStudent(String firstName, String lastName);
public abstract Teacher createTeacher(String firstName, String lastName);
}
class BiologyClassroomFactory extends ClassroomFactory {
@Override
public Student createStudent(String firstName, String lastName) {
// Object creation logic for Biology Student
}
@Override
public Teacher createTeacher(String firstName, String lastName) {
// Object creation logic for Biology Teacher
}
}Usage:
ClassroomFactory factory = new BiologyClassroomFactory();
Student student = factory.createStudent("John", "Doe");
Teacher teacher = factory.createTeacher("John", "Doe");The abstract factory becomes a factory of factories, allowing easy exchange of product families, promoting consistency among products, and isolating concrete classes from client code.
- The factory pattern enables object creation without specifying the exact class.
- Simple Factory: The factory class contains a static method for object creation. It is easy to implement but not extensible and reusable.
- Factory Method: The responsibility of object creation is shifted to child classes using a factory method. It is extensible, reusable, and follows design principles.
- Abstract Factory: Provides an interface for creating families of related objects, promoting consistency, and isolating concrete classes from client code.