The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Design Patterns

Next ►
►

Design patterns are typical solutions to common problems in software design. They are like blueprints that you can customize to solve a particular design problem in your code. Understanding and applying design patterns can help you create more flexible, reusable, and maintainable software architectures.

Key Concepts of Design Patterns

  1. Definition

Design patterns are general, reusable solutions to commonly occurring problems within a given context in software design. They are not finished designs that can be transformed directly into code but are templates for how to solve a problem in various situations.

  1. Categories of Design Patterns

Design patterns are generally categorized into three types:

  • Creational Patterns: Deal with object creation mechanisms, trying to create objects in a manner suitable to the situation.
  • Structural Patterns: Deal with object composition or the way to assemble objects to create new functionality.
  • Behavioral Patterns: Deal with object collaboration and the delegation of responsibilities among objects.

Common Design Patterns

  1. Singleton Pattern (Creational)

Ensures a class has only one instance and provides a global point of access to it.

Example:

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# Usage
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # Output: True

Explanation:

  • The __new__ method ensures that only one instance of the class is created.
  • Subsequent calls to the class return the same instance.

  1. Factory Method Pattern (Creational)

Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.

Example:

class Product:
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "Result of ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "Result of ConcreteProductB"

class Creator:
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        return product.operation()

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

# Usage
creator_a = ConcreteCreatorA()
print(creator_a.some_operation())  # Output: Result of ConcreteProductA

creator_b = ConcreteCreatorB()
print(creator_b.some_operation())  # Output: Result of ConcreteProductB

Explanation:

  • The Creator class declares the factory method that returns new product objects.
  • Subclasses (ConcreteCreatorA and ConcreteCreatorB) override the factory method to change the resulting product's type.

  1. Adapter Pattern (Structural)

Allows incompatible interfaces to work together by converting the interface of a class into another interface that a client expects.

Example:

class Target:
    def request(self):
        return "Target: The default target's behavior."

class Adaptee:
    def specific_request(self):
        return ".eetpadA eht fo roivaheb laicepS"

class Adapter(Target):
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        return f"Adapter: (TRANSLATED) {self.adaptee.specific_request()[::-1]}"

# Usage
adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())  # Output: Adapter: (TRANSLATED) Special behavior of the Adaptee.

Explanation:

  • The Adapter class makes the Adaptee's interface compatible with the Target interface.

  1. Observer Pattern (Behavioral)

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Example:

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self)

class ConcreteSubject(Subject):
    def __init__(self):
        super().__init__()
        self._state = None

    @property
    def state(self):
        return self._state

    @state.setter
    def state(self, value):
        self._state = value
        self.notify()

class Observer:
    def update(self, subject):
        pass

class ConcreteObserver(Observer):
    def update(self, subject):
        print(f"Observer: Reacted to the event. New state is {subject.state}")

# Usage
subject = ConcreteSubject()
observer = ConcreteObserver()
subject.attach(observer)

subject.state = 123  # Output: Observer: Reacted to the event. New state is 123

Explanation:

  • Subject maintains a list of observers and notifies them of state changes.
  • ConcreteSubject changes its state and notifies observers.
  • Observer defines an update interface for objects that should be notified of changes in a subject.

Practical Exercises

Exercise 1: Implementing the Singleton Pattern

Task: Implement a Singleton class in your preferred programming language.

Solution:

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# Test
singleton1 = Singleton()
singleton2 = Singleton()
assert singleton1 is singleton2, "Singleton instances are not the same"
print("Singleton pattern implemented successfully.")

Exercise 2: Using the Factory Method Pattern

Task: Create a factory method pattern for a simple shape creation system (e.g., Circle, Square).

Solution:

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        return "Drawing a Circle"

class Square(Shape):
    def draw(self):
        return "Drawing a Square"

class ShapeFactory:
    def create_shape(self, shape_type):
        if shape_type == "Circle":
            return Circle()
        elif shape_type == "Square":
            return Square()
        else:
            return None

# Test
factory = ShapeFactory()
circle = factory.create_shape("Circle")
square = factory.create_shape("Square")
assert circle.draw() == "Drawing a Circle"
assert square.draw() == "Drawing a Square"
print("Factory method pattern implemented successfully.")

Conclusion

Design patterns are essential tools in a software architect's toolkit. They provide proven solutions to common problems and help create more maintainable and scalable systems. By understanding and applying these patterns, you can improve the quality and robustness of your software architectures. In the next module, we will delve into the components of a system architecture, exploring the various layers and their interactions.

◄ Previous
◄
Next ►
►

System Architectures: Principles and Practices for Designing Robust and Scalable Technological Architectures

Module 1: Introduction to System Architectures

Module 2: Design Principles of Architectures

Module 3: Components of a System Architecture

Module 4: Scalability and Performance

Module 5: Security in System Architectures

Module 6: Tools and Technologies

Module 7: Case Studies and Practical Examples

Module 8: Trends and Future of System Architectures

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved