DEV Community: Iyanu Falaye

Design Patterns: Singleton

Iyanu Falaye — Mon, 26 Feb 2024 13:32:02 +0000

Design patterns are a collection of standard solutions to solve software development design problems. Software engineers need to know how to use design patterns as essential tools. They can utilize design patterns to discover elegant solutions for commonly occurring challenges in software design, just as architects in building architecture learn to address design difficulties using established patterns. The efficiency, scalability, and readability of code are all improved by comprehending and utilizing these patterns.
The three categories that these patterns fall into are creational, behavioural, and structural. To keep things brief, we’ll define these categories and explore examples that fall into these categories over a series.

Creational Pattern: These patterns address procedures for creating objects. They assist in crafting objects in a way that makes sense for the scenario. The simplest method of creating objects may lead to problems with design or more complexity in a design. This issue is resolved by creational design patterns, which regulate the creation process. Some of the popular creational patterns include:

Builder
Factory
Abstract Factory
Singleton
Prototype

Structural Pattern: The composition of classes and objects is central to structural patterns. They support the formation of complex structures with classes and objects. Structural patterns use inheritance to create interfaces and implementations. Several well-known patterns of structure include:

Adapter
Decorator
Facade

Behavioural Pattern: a category of software design patterns that helps control how various system elements communicate and interact. Example includes:

Observer
Strategy
State
Iterator

We’ll start the series with one of the creational patterns: Singleton.

Singleton Pattern

Singleton pattern ensures that the instance of a class is instantiated once and provides global access to the instance. It is part of the creational design pattern category.

Motivation

When building a system, sometimes we want the system to have access to a shared resource, e.g. a database and a logging system. To make this work as intended, a single instance of an object or resource must exist at a time. Instantiating a constructor would not work because it returns a new instance of an object whenever it is called. Singleton pattern solves for us by ensuring that the regular constructor is called only once under the hood, and that is when it is being created for the first time.
Singleton pattern also provides global access to an object by making an object available everywhere in a program, which helps with;

Consistency: there should be at most one instance of a database in a system; if there is, it would further improve the level of consistency in the application's behaviour.
It helps to conserve resources
It also helps to control the means to access an object.

public class DataBaseService {
    public DataBaseService(){
    }
}

Creating a DataBaseService class like the example above,
every time the class is instantiated, a new instance of the DatabaseService class is created, as shown below, which makes the class inconsistent for the intended use.

dataBase3: singleton.DataBaseService@135fbaa4
dataBase4: singleton.DataBaseService@45ee12a7

This is the implementation of a singleton pattern with respect to multithreaded environments like a Java program. This code below exposes a getInstance() method, which is called when we want to access the DataBaseService object, and it handles creating or providing an existing instance of the DataBaseService object. The private constructor in the class ensures the creation of an object using the regular constructor calling is controlled internally by the class. If dataBaseService is null, the class has not been created before and the regular constructor will be called.

public class DataBaseService {

    private static volatile DataBaseService dataBaseService = null;

    private DataBaseService() {
        if (dataBaseService != null) {
            throw  new RuntimeException("There can only be one instance of Database");
        }
    }

    public static DataBaseService getInstance() {
        if (dataBaseService == null){
        synchronized (DataBaseService.class) {
            if (dataBaseService == null) {
                dataBaseService = new DataBaseService();
            }
        }
    }

        return dataBaseService;
    }

}

When we want to access the DataBaseService, we simply call the getInstance method, which creates or returns one instance of the class.

 DataBaseService dataBaseService1 = DataBaseService.getInstance();
        DataBaseService dataBaseService2 = DataBaseService.getInstance();
        System.out.println("dataBaseService1: "+ dataBaseService1);
        System.out.println("dataBaseService2: " + dataBaseService2);

When the two instances are logged, it is evidently the same, which shows that our singleton pattern is properly implemented as shown below.

dataBaseService1: singleton.DataBaseService@135fbaa4
dataBaseService12: singleton.DataBaseService@135fbaa4

Advantages

It is sure that there is only one instance of a class.
You can provide a global instance to a class.

Disadvantages

Violates single responsibility principles

Use cases

Databases
Logging system

Real-Life Examples

Java Runtime Library

Conclusion

Singleton Pattern's approach to instance control makes it significant, but it's equally crucial to understand its strengths and weaknesses. Here's a link to check the full implementation.

Shout out to Markus Spiske for the cover photo.

Design Patterns: Proxy

Iyanu Falaye — Sat, 11 Nov 2023 23:03:47 +0000

The proxy design pattern is a structural design pattern where a class often known as the intermediary represents the functionality of another class. the main object is known as the real object while the intermediary is known as the proxy. The proxy when invoked can access the real object behind the scenes.

Motivation
When creating an object is resource-intensive or requires significant overhead. It can be inefficient to instantiate these objects when they might not be needed. Or, take into account scenarios where you need to restrict access to an object for security, logging, or other reasons. To tackle these situations, the Proxy Pattern can be used without changing the code of the real object.

Implementation
A proxy implements the same interface as the real object. Considering a system that fetches images from a server. Here is the Image Interface that the proxy (ProxyImage) and the real object (RemoteImage) implement.

public interface Image{
    void loadImage(String fileName);
}

RemoteImage is the concrete implementation of the Image interface and the loadImage method fetches the image from the server.

public class RemoteImage implements Image {
    @Override
    public void loadImage(String fileName) {
        System.out.println("Fetching From server..." + fileName +".png");
    }
}

ProxyImage class is the object that the client interacts with, when rhe loadImage method is called, the system attempts to fetch the image from the cache by checking if the filename exists if it exists it prints the image if the image doesn't exist it fetches from the remote source.

public class ProxyImage implements Image {

    private final Map<String, String> imageCache = new HashMap<>();

    @Override
    public void loadImage(String fileName) {
        if (imageCache.containsKey(fileName)) {
            String image = imageCache.get(fileName);
            System.out.println("Loading Image From cache : " + image);
        } else {
            RemoteImage remoteImage = new RemoteImage();
            remoteImage.loadImage(fileName);
            imageCache.put(fileName, fileName + ".png");
            System.out.println("No Image From Cache... Loading From remote" + remoteImage);

        }
    }
}

This is the client communicating with the proxy and the output.

ProxyImage proxyImageService = new ProxyImage();
        proxyImageService.loadImage("image");
        proxyImageService.loadImage("image");

Loading From Url...image.png
No Image From Cache... Loading From remoteproxy.RemoteImage@2503dbd3
Loading Image From cache : image.png

Advantages

The proxy can control access to the real object, adding security.
The real object is shielded from direct exposure to the system.

Disadvantages

The code can become more complicated, as you need to introduce additional classes.

Conclusion
The proxy pattern regulates access to objects by serving as an intermediary. It adds an abstraction layer that can be applied to access control, logging, and other things. The Proxy Pattern can dramatically improve the architecture and functionality of software systems when implemented wisely.

Design Patterns: Adapter

Iyanu Falaye — Sat, 11 Nov 2023 23:03:42 +0000

It is a structural pattern that allows objects with incompatible interfaces to work together. It helps by converting a class’ interface to a target.

Motivation
Where there’s a need to integrate classes with incompatible interfaces.
To reuse an existing code that does not align with a current system’s interface.

Implementation

Considering there is an existing payment system that supports cards, with the increase in the need for digital wallets, we want to provide support for payment from wallet in our payment system. instead of rewriting the whole system to fit this new mode of payment, we can make use of the adapter pattern to integrate the wallet mode seamlessly.

This is the existing PaymentProcessor interface that handles the card payment. it defines the processPayment method

public interface PaymentProcessor {
    void processPayment();
}

This is the proposed Digital Wallet interface that different wallets can implement e.g. binance, coinbase, etc.

public interface DigitalWallet {
    void makePaymentFromWallet();
}

Using Binance as an example;

public class BinanceWallet implements DigitalWallet{
    @Override
    public void makePaymentFromWallet() {
        System.out.println("making payment from my binance wallet");
    }
}

The Adapter wraps DigitalWallet and provides an implementation that is compatible with PaymentProcessor

public class DigitalWalletAdapter implements PaymentProcessor {
    private DigitalWallet binanceWallet;

    public DigitalWalletAdapter(DigitalWallet binanceWallet) {
        this.binanceWallet = binanceWallet;
    }

    @Override
    public void processPayment() {
        binanceWallet.makePaymentFromWallet();
    }
}

Advantages

Single Responsibility: you can separate the interface and the code that converts from the logic of the program.
Open-Closed principle: you can keep adding adapters without breaking or modifying the existing code.

Disadvantages

Complexity increases

Examples

RecylerView Adapter in Android

Conclusion
When a system needs to evolve, the need for adapter pattern cannot be overstated to make it easier to integrate new functionalities with existing components. It ensures that a system is resilient and adaptable when requirements change.