Nguyên lý Design Pattern của Microsoft là: "Tài liệu giới thiệu các Pattern và sau đó trình bày chúng trong Repository hoặc Catalogue, mà được tổ chức để giúp bạn xác định vị trí kết nối chính xác của các Pattern mà giải quyết vấn đề của bạn."

Ví dụ về Design Pattern trong PHP

Singleton Pattern trong PHP

Singleton Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để đảm bảo rằng một Class chỉ có một instance duy nhất và cung cấp một cách để truy cập global đến instance đó. Mục đích chính của Singleton Pattern là đảm bảo rằng chỉ có một thể hiện duy nhất của Class được tạo ra và sử dụng trong toàn bộ ứng dụng.

Dưới đây là một ví dụ về Singleton Pattern trong PHP:

class Singleton {
    // Biến private static để lưu trữ instance của lớp
    private static $instance;

    // Phương thức private constructor để ngăn việc tạo ra các instance mới từ bên ngoài
    private function __construct() {}

    // Phương thức public static để truy cập đến instance duy nhất của lớp
    public static function getInstance() {
        // Kiểm tra xem instance đã được tạo chưa, nếu chưa thì tạo mới
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    // Phương thức public để thực hiện các hành động của lớp
    public function doSomething() {
        echo "Singleton instance is doing something.";
    }
}

// Sử dụng Singleton Pattern
$singletonInstance = Singleton::getInstance();
$singletonInstance->doSomething();

//
$otherSingletonInstance = Singleton::getInstance();
$otherSingletonInstance->doSomething();

Trong ví dụ trên:

• Class Singleton có một biến static private $instance để lưu trữ instance duy nhất của Class.
• Phương thức __construct() được khai báo là private để ngăn việc tạo ra các instance mới từ bên ngoài.
• Phương thức getInstance() là phương thức public static được sử dụng để truy cập đến instance duy nhất của Class. Nếu instance chưa tồn tại, nó sẽ tạo mới instance và trả về.
• Phương thức doSomething() là phương thức public được sử dụng để thực hiện các hành động của Class.

Singleton Pattern đảm bảo rằng chỉ có một thể hiện (instance) duy nhất của một Class được tạo ra và sử dụng trong toàn bộ ứng dụng. Khi một instance của Class được tạo ra, nó sẽ được cung cấp một cách global để truy cập từ bất kỳ nơi nào trong ứng dụng.

Một số điểm chính về Singleton Pattern:

1. Instance duy nhất: Singleton Pattern đảm bảo rằng chỉ có một instance duy nhất của Class được tạo ra và sử dụng trong ứng dụng.

2. Truy cập global: Một instance của Class Singleton có thể được truy cập từ bất kỳ đâu trong ứng dụng thông qua phương thức tĩnh (static method) được cung cấp bởi Singleton Pattern.

3. Ngăn việc tạo nhiều instance: Singleton Pattern ngăn chặn việc tạo ra nhiều instance của Class bằng cách sử dụng constructor là private hoặc protected, điều này đảm bảo rằng chỉ có một instance được tạo ra.

4. Lazy initialization: Singleton Pattern thường triển khai lazy initialization, nghĩa là instance không được tạo ra cho đến khi nó được yêu cầu lần đầu tiên thông qua phương thức getInstance(), điều này giúp tối ưu hóa hiệu suất và tiết kiệm tài nguyên.

Ví dụ: Class quản lý cài đặt trong một ứng dụng có thể được triển khai bằng Singleton Pattern để đảm bảo rằng chỉ có một instance của Class quản lý cài đặt được sử dụng trong toàn bộ ứng dụng và cài đặt có thể được truy cập từ bất kỳ nơi nào trong ứng dụng.

Trường hợp sử dụng Singleton Pattern thường là khi bạn cần một Class chỉ có một instance duy nhất và bạn muốn đảm bảo rằng toàn bộ ứng dụng sử dụng cùng một instance của Class đó. Ví dụ: Class đối tượng kết nối cơ sở dữ liệu, Class ghi log, Class quản lý cài đặt...

Factory Pattern Trong PHP

Factory Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để tạo ra các đối tượng mà không cần phải chỉ định trực tiếp Class cụ thể của đối tượng đó. Thay vào đó, một phương thức tạo được sử dụng để tạo ra đối tượng, giúp tăng tính linh hoạt và giảm sự phụ thuộc vào Class cụ thể.

Dưới đây là một ví dụ về Factory Pattern trong PHP, sử dụng Class AutomobileFactory để tạo đối tượng Automobile:

class Automobile
{
    private $bikeMake;
    private $bikeModel;
    
    public function __construct($make, $model)
    {
        $this->bikeMake = $make;
        $this->bikeModel = $model;
    }
    
    public function getMakeAndModel()
    {
        return $this->bikeMake . ' ' . $this->bikeModel;
    }
}

class AutomobileFactory
{
    public static function create($make, $model)
    {
        return new Automobile($make, $model);
    }
}

$pulsar = AutomobileFactory::create('ktm', 'Pulsar');
echo $pulsar->getMakeAndModel(); // Output: ktm Pulsar

Trong ví dụ này:

• Class Automobile đại diện cho một đối tượng ô tô, có các thuộc tính là hãng xe và model xe, cũng như một phương thức để trả về thông tin hãng và model.
• Class AutomobileFactory là một factory class có một phương thức tạo đối tượng create() để tạo ra các đối tượng Automobile.
• Khi cần tạo một đối tượng Automobile, chúng ta chỉ cần gọi phương thức create() của AutomobileFactory với thông tin về hãng và model của xe.

Sử dụng Factory Pattern thay vì tạo đối tượng trực tiếp từ một Class cụ thể có một số lợi ích quan trọng:

1. Giảm sự phụ thuộc vào Class cụ thể: Khi sử dụng Factory Pattern, bạn chỉ cần giao tiếp với Factory thay vì giao tiếp trực tiếp với Class cụ thể. Điều này giảm sự phụ thuộc của mã của bạn vào Class cụ thể và làm cho mã của bạn linh hoạt hơn. Nếu bạn cần thay đổi Class cụ thể mà đối tượng được tạo từ, bạn chỉ cần thay đổi trong Factory mà không cần phải thay đổi trong toàn bộ mã.

2. Tăng tính linh hoạt: Factory Pattern cho phép bạn dễ dàng thay đổi cách tạo ra đối tượng mà không ảnh hưởng đến việc sử dụng đối tượng đó. Bằng cách thay đổi phương thức tạo trong Factory, bạn có thể thay đổi loại đối tượng được tạo ra hoặc thậm chí chuyển đổi giữa các Class cụ thể khác nhau mà không cần phải sửa đổi mã của các phần khác trong ứng dụng.

3. Tạo ra các đối tượng theo logic phức tạp: Factory Pattern cho phép bạn triển khai logic phức tạp để quyết định Class cụ thể nào sẽ được sử dụng để tạo đối tượng dựa trên các điều kiện hoặc tham số. Điều này làm cho việc tạo đối tượng linh hoạt hơn và có thể mở rộng được.

4. Dễ dàng kiểm soát quy trình tạo đối tượng: Bằng cách sử dụng Factory Pattern, bạn có thể tạo ra một Class Factory chuyên biệt để quản lý quá trình tạo đối tượng, bao gồm việc xác thực dữ liệu, ghi log, hoặc thậm chí lấy dữ liệu từ nguồn bên ngoài như cơ sở dữ liệu.

Tóm lại, việc sử dụng Factory Pattern thay vì tạo đối tượng trực tiếp từ Class cụ thể là một quyết định thiết kế có lợi vì nó giảm sự phụ thuộc vào Class cụ thể, tăng tính linh hoạt và kiểm soát quá trình tạo đối tượng.

Trường hợp sử dụng Factory Pattern:

1. Khi bạn muốn tạo ra các đối tượng một cách linh hoạt: Factory Pattern cho phép bạn tạo ra các đối tượng một cách linh hoạt dựa trên điều kiện, thông số hoặc logic phức tạp khác.

2. Khi bạn muốn giảm sự phụ thuộc vào Class cụ thể của đối tượng: Factory Pattern giúp giảm sự phụ thuộc vào Class cụ thể của đối tượng bằng cách sử dụng một phương thức tạo đối tượng thay vì việc tạo trực tiếp từ Class cụ thể đó. Điều này làm cho mã của bạn linh hoạt hơn và dễ dàng bảo trì.

Dependency Injection

Dependency Injection (DI) là một mẫu thiết kế (design pattern) trong lập trình phần mềm, giúp quản lý các phụ thuộc của một đối tượng bằng cách chuyển chúng vào từ bên ngoài thay vì tạo chúng trong đối tượng đó. Mục đích của DI là tạo ra các đối tượng có thể tái sử dụng, linh hoạt và dễ bảo trì bằng cách giảm bớt sự phụ thuộc giữa các thành phần của hệ thống.

Có hai cách chính để thực hiện Dependency Injection:

1. Constructor Injection: Phụ thuộc được chuyển vào thông qua constructor của đối tượng.

2. Setter Injection: Phụ thuộc được chuyển vào thông qua các phương thức setter của đối tượng sau khi nó được tạo ra.

Dưới đây là một ví dụ minh họa về cách sử dụng Dependency Injection trong PHP:

// Dependency
class DatabaseConnection {
    public function connect() {
        return "Connected to database";
    }
}

// Class using Dependency Injection
class UserManager {
    private $dbConnection;

    // Constructor Injection
    public function __construct(DatabaseConnection $dbConnection) {
        $this->dbConnection = $dbConnection;
    }
    
    // Getter Injection
    public function getUserData($userId) {
        // Use the injected database connection
        return $this->dbConnection->connect() . "\nFetching user data for user ID: $userId";
    }
}

// Usage
$databaseConnection = new DatabaseConnection();
$userManager = new UserManager($databaseConnection);
echo $userManager->getUserData(123);​

//Hoặc sử dụng getter và setter
// Dependency implementation
class DatabaseConnection implements Connection {
    public function connect() {
        return "Connected to database";
    }
}

// Class using Dependency Injection
class UserManager {
    private $dbConnection;

    // Setter Injection
    public function setDbConnection(Connection $dbConnection) {
        $this->dbConnection = $dbConnection;
    }

    public function getUserData($userId) {
        if (!$this->dbConnection) {
            throw new Exception("Database connection has not been injected");
        }
        // Use the injected database connection
        return $this->dbConnection->connect() . "\nFetching user data for user ID: $userId";
    }
}

// Usage
$userManager = new UserManager();
$databaseConnection = new DatabaseConnection();
$userManager->setDbConnection($databaseConnection);
echo $userManager->getUserData(123);

Trong ví dụ này:

• DatabaseConnection là dependency (phụ thuộc) mà UserManager sử dụng để kết nối và truy vấn cơ sở dữ liệu.
• UserManager là class sử dụng Dependency Injection. Nó nhận DatabaseConnection thông qua constructor của nó.
• Khi UserManager được khởi tạo, một instance của DatabaseConnection được chuyển vào và UserManager sẽ sử dụng nó khi cần.

Dependency Injection thường được sử dụng trong các trường hợp sau:

• Khi bạn muốn tạo các đối tượng có khả năng tái sử dụng và dễ bảo trì.
• Khi bạn muốn giảm sự phụ thuộc giữa các Class trong hệ thống của mình, làm cho mã của bạn trở nên linh hoạt và dễ dàng kiểm thử.
• Khi bạn muốn thay đổi hoặc mở rộng các thành phần của ứng dụng một cách dễ dàng mà không cần phải sửa đổi nhiều mã nguồn.

Repository Pattern

Repository Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để tạo ra một Class trung gian giữa logic business của ứng dụng và Class truy cập dữ liệu (data access layer). Mục tiêu của Repository Pattern là cung cấp một cách tiếp cận gọn nhẹ và chuẩn hóa cho việc truy cập dữ liệu từ cơ sở dữ liệu hoặc bất kỳ nguồn dữ liệu nào khác mà không làm rối logic business của ứng dụng.

Dưới đây là một ví dụ về Repository Pattern trong PHP và một số trường hợp sử dụng:

// Domain Entity
class Product {
    public $id;
    public $name;
    public $price;

    public function __construct($id, $name, $price) {
        $this->id = $id;
        $this->name = $name;
        $this->price = $price;
    }
}

// Repository Interface
interface ProductRepository {
    public function findById($id);
    public function findAll();
}

// Concrete Repository
class MySQLProductRepository implements ProductRepository {
    private $connection;

    public function __construct($connection) {
        $this->connection = $connection;
    }

    public function findById($id) {
        // Query the database to find a product by ID
        // Return a Product object
    }

    public function findAll() {
        // Query the database to find all products
        // Return an array of Product objects
    }
}

// Usage
$mysqlConnection = new MySQLConnection(); // Assume this class sets up the MySQL connection
$productRepository = new MySQLProductRepository($mysqlConnection);
$product = $productRepository->findById(1);
$products = $productRepository->findAll();​

Trong ví dụ này:

• Product là một domain entity đại diện cho một sản phẩm trong ứng dụng.
• ProductRepository là một interface định nghĩa các phương thức để truy xuất dữ liệu sản phẩm.
• MySQLProductRepository là một concrete repository implement ProductRepository, chịu trách nhiệm truy vấn cơ sở dữ liệu MySQL để lấy thông tin sản phẩm.

Các trường hợp sử dụng Repository Pattern bao gồm:

1. Tách biệt logic business và truy cập dữ liệu: Repository Pattern giúp tách biệt logic business của ứng dụng với Class truy cập dữ liệu, làm cho mã của bạn dễ đọc và bảo trì hơn.

2. Thử nghiệm dễ dàng: Khi bạn sử dụng Repository Pattern, bạn có thể dễ dàng thay thế repository thực tế bằng một giả định (mock) trong quá trình kiểm thử, giúp việc kiểm thử trở nên dễ dàng và linh hoạt hơn.

3. Đa nguồn dữ liệu: Repository Pattern cho phép bạn áp dụng logic chung để truy cập dữ liệu từ nhiều nguồn khác nhau, chẳng hạn như cơ sở dữ liệu, API, hoặc các dịch vụ khác. Điều này giúp bạn dễ dàng chuyển đổi giữa các nguồn dữ liệu mà không làm thay đổi logic business của ứng dụng.

Strategy pattern trong PHP

Strategy Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, mô tả một tập hợp các thuật toán và cho phép chúng có thể được chọn lựa hoặc thay đổi một cách độc lập với nhau. Mục đích chính của Strategy Pattern là tạo ra một family algorithm, tức là một nhóm các thuật toán tương tự, và bao đóng mỗi thuật toán trong một strategy object riêng biệt.

Dưới đây là một ví dụ cụ thể về Strategy Pattern trong PHP:

interface Comparator {
    public function compare($a, $b);
}

class IdComparator implements Comparator {
    public function compare($a, $b) {
        return $a['id'] - $b['id'];
    }
}

class DateComparator implements Comparator {
    public function compare($a, $b) {
        return strtotime($a['date']) - strtotime($b['date']);
    }
}

class ObjectCollection {
    public $elements;

    private $comparator;

    public function __construct(array $elements) {
        $this->elements = $elements;
    }

    public function setComparator(Comparator $comparator) {
        $this->comparator = $comparator;
    }

    public function sort() {
        usort($this->elements, array($this->comparator, 'compare'));
    }
}

$elements = array(
    array(
        'id' => 2,
        'date' => '2011-01-01',
    ),
    array(
        'id' => 1,
        'date' => '2011-02-01'
    )
);

$collection = new ObjectCollection($elements);

$collection->setComparator(new IdComparator());
$collection->sort();

echo "Sắp xếp theo ID:\n";
print_r($collection->elements);

$collection->setComparator(new DateComparator());
$collection->sort();

echo "Sắp xếp theo ngày tháng:\n";
print_r($collection->elements);

Trong ví dụ này:

• Interface Comparator định nghĩa một phương thức compare() để so sánh các phần tử.
• Class IdComparator và DateComparator triển khai interface Comparator để cung cấp các thuật toán so sánh theo ID và ngày tháng.
• Class ObjectCollection sử dụng strategy pattern bằng cách chấp nhận một Comparator và sử dụng nó để sắp xếp các phần tử trong mảng.

Trường hợp sử dụng Strategy Pattern:

• Khi bạn muốn chọn lựa giữa các thuật toán khác nhau tùy thuộc vào điều kiện hoặc yêu cầu cụ thể của ứng dụng.
• Khi bạn muốn tách biệt logic xử lý của thuật toán ra khỏi phần còn lại của ứng dụng, làm cho mã trở nên linh hoạt hơn và dễ bảo trì hơn.
• Khi bạn muốn tạo ra một tập hợp các thuật toán tương tự và quản lý chúng dễ dàng.

Observer Pattern

Observer Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, nó tạo ra một mối quan hệ một-nhiều giữa các đối tượng. Trong mẫu này, một đối tượng, được gọi là subject, duy trì danh sách các đối tượng phụ thuộc, được gọi là observers, và thông báo cho chúng mỗi khi trạng thái của nó thay đổi. Các observers có thể phản ứng theo cách của họ khi nhận thông báo này.

Dưới đây là một ví dụ về Observer Pattern trong PHP và một trường hợp sử dụng:

// Subject (Observable)
interface Subject {
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}

// Concrete Subject
class WeatherStation implements Subject {
    private $temperature;
    private $observers = [];

    public function setTemperature($temperature) {
        $this->temperature = $temperature;
        $this->notify();
    }

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function detach(Observer $observer) {
        $index = array_search($observer, $this->observers);
        if ($index !== false) {
            unset($this->observers[$index]);
        }
    }

    public function notify() {
        foreach ($this->observers as $observer) {
            $observer->update($this->temperature);
        }
    }
}

// Observer
interface Observer {
    public function update($temperature);
}

// Concrete Observer
class PhoneApp implements Observer {
    public function update($temperature) {
        echo "Phone App: The current temperature is $temperature°C\n";
    }
}

class EmailNotification implements Observer {
    public function update($temperature) {
        echo "Email Notification: The current temperature is $temperature°C\n";
    }
}

// Usage
$weatherStation = new WeatherStation();
$phoneApp = new PhoneApp();
$emailNotification = new EmailNotification();

$weatherStation->attach($phoneApp);
$weatherStation->attach($emailNotification);

$weatherStation->setTemperature(25);​

Trong ví dụ này:

• Subject là Subject interface với các phương thức attach, detach, và notify.
• WeatherStation là concrete subject, nó duy trì thông tin về nhiệt độ và thông báo cho các observers khi nhiệt độ thay đổi.
• Observer là Observer interface với phương thức update.
• PhoneApp và EmailNotification là các concrete observers, chúng thực hiện phương thức update để cập nhật thông tin nhiệt độ.

Trường hợp sử dụng Observer Pattern thích hợp khi bạn muốn các đối tượng trong ứng dụng của bạn phản ứng vào các sự kiện hoặc thay đổi từ một đối tượng khác một cách linh hoạt và không liên quan. Ví dụ, trong ứng dụng thời tiết, bạn có thể sử dụng Observer Pattern để thông báo cho các ứng dụng điện thoại hoặc gửi email khi nhiệt độ thay đổi.

Note: Khi một hàm trong một Class nhận một tham số là một interface, điều này có ý nghĩa là hàm đó mong đợi một đối tượng (hoặc các đối tượng) được cung cấp cho nó phải tuân theo interface đó. Trong trường hợp này, hàm đó sẽ làm việc với các đối tượng thuộc Class mà tuân theo interface đã được chỉ định.

Trong ví dụ của bạn, hàm attach trong class WeatherStation nhận một tham số là một đối tượng thuộc interface Observer. Điều này có nghĩa là hàm attach mong đợi các đối tượng mà nó được gọi với phải tuân theo Observer interface. Trong trường hợp này, hàm attach dùng để thêm các đối tượng quan sát (observers) vào danh sách các observers của WeatherStation.

Việc sử dụng interface trong hàm này giúp tạo ra sự linh hoạt và giảm thiểu sự phụ thuộc giữa các lớp, vì các đối tượng được truyền vào có thể thuộc bất kỳ lớp nào mà tuân theo Observer interface. Điều này giúp cho việc thêm các loại observers mới vào WeatherStation trở nên dễ dàng mà không cần sửa đổi nhiều code.

Decorator Pattern

Decorator Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để mở rộng hoặc thêm chức năng mới cho một đối tượng mà không làm thay đổi cấu trúc của nó. Mẫu này cho phép bạn gắn thêm các tính năng mới vào đối tượng một cách linh hoạt và độc lập với các đối tượng khác trong hệ thống.

Dưới đây là một ví dụ về Decorator Pattern trong PHP và một trường hợp sử dụng:

// Component interface
interface Coffee {
    public function cost();
}

// Concrete Component
class SimpleCoffee implements Coffee {
    public function cost() {
        return 10; // Giá của cà phê đơn giản là 10 đơn vị tiền tệ
    }
}

// Decorator
abstract class CoffeeDecorator implements Coffee {
    protected $coffee;

    public function __construct(Coffee $coffee) {
        $this->coffee = $coffee;
    }

    public function cost() {
        return $this->coffee->cost();
    }
}

// Concrete Decorator
class MilkDecorator extends CoffeeDecorator {
    public function cost() {
        return $this->coffee->cost() + 5; // Thêm giá của sữa
    }
}

class SugarDecorator extends CoffeeDecorator {
    public function cost() {
        return $this->coffee->cost() + 2; // Thêm giá của đường
    }
}

// Usage
$simpleCoffee = new SimpleCoffee();
echo "Giá của cà phê đơn giản: " . $simpleCoffee->cost() . " đơn vị tiền tệ\n";

$milkCoffee = new MilkDecorator($simpleCoffee);
echo "Giá của cà phê với sữa: " . $milkCoffee->cost() . " đơn vị tiền tệ\n";

$sugarMilkCoffee = new SugarDecorator($milkCoffee);
echo "Giá của cà phê với sữa và đường: " . $sugarMilkCoffee->cost() . " đơn vị tiền tệ\n";

Trong ví dụ này:

• Coffee là interface định nghĩa phương thức cost() cho một đối tượng cà phê.
• SimpleCoffee là concrete component, đại diện cho cà phê đơn giản mà không có thêm các chức năng.
• CoffeeDecorator là abstract decorator, cung cấp một interface chung cho các decorator cụ thể.
• MilkDecorator và SugarDecorator là các concrete decorator, thêm chức năng sữa và đường vào cà phê, mỗi loại một cách độc lập.

Trường hợp sử dụng Decorator Pattern phù hợp khi bạn cần mở rộng hoặc thêm các chức năng mới cho một đối tượng mà không muốn thay đổi cấu trúc của nó. Ví dụ, trong một ứng dụng đồ họa, bạn có thể sử dụng Decorator Pattern để thêm hiệu ứng hoặc biên của một hình ảnh mà không cần tạo ra một Class mới cho mỗi loại hiệu ứng hoặc biên khác nhau.

Adapter Pattern

Adapter Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để chuyển đổi interface của một Class thành một interface khác mà client mong muốn. Mục đích của Adapter Pattern là giúp các Class hoạt động cùng nhau mặc dù chúng có interface không tương thích ban đầu.

Dưới đây là một ví dụ về Adapter Pattern trong PHP và một số trường hợp sử dụng:

// Target interface
interface Target {
    public function request();
}

// Adaptee (đối tượng cần được chuyển đổi)
class Adaptee {
    public function specificRequest() {
        return "Adaptee's specific request";
    }
}

// Adapter
class Adapter implements Target {
    private $adaptee;

    public function __construct(Adaptee $adaptee) {
        $this->adaptee = $adaptee;
    }

    public function request() {
        return "Adapter: " . $this->adaptee->specificRequest();
    }
}

// Client code
function clientCode(Target $target) {
    echo $target->request();
}

// Usage
$adaptee = new Adaptee();
$adapter = new Adapter($adaptee);
clientCode($adapter);​

Trong ví dụ này:

• Target là interface mà client mong muốn sử dụng.
• Adaptee là đối tượng cần được chuyển đổi để phù hợp với interface của Target.
• Adapter là Class thực hiện Target interface và sử dụng Adaptee để cung cấp interface phù hợp cho client.
• clientCode() là client code sử dụng Target interface để gọi request.

Trong Adapter Pattern, chúng ta sử dụng adapter để "đính kèm" một Class không tương thích vào hệ thống của chúng ta mà không làm thay đổi interface của client. Các trường hợp sử dụng Adapter Pattern bao gồm:

1. Kết nối giữa các hệ thống không tương thích: Adapter Pattern có thể được sử dụng để kết nối giữa các hệ thống hoặc API không tương thích với nhau bằng cách chuyển đổi các interface hoặc định dạng dữ liệu.

2. Tích hợp mới vào hệ thống hiện có: Adapter Pattern cho phép bạn tích hợp các thành phần mới vào hệ thống hiện có mà không cần sửa đổi code hiện tại, giảm thiểu rủi ro và chi phí của việc thay đổi.

3. Tái sử dụng code: Adapter Pattern giúp tái sử dụng code hiện có bằng cách chuyển đổi các interface hoặc phương thức không tương thích thành các interface đã được xác định sẵn.

Builder Pattern

Builder Pattern là một mẫu thiết kế (design pattern) trong lập trình phần mềm, được sử dụng để tạo ra các đối tượng phức tạp bằng cách chia nhỏ quá trình xây dựng thành các bước đơn giản. Mục đích của Builder Pattern là tạo ra một cách tiếp cận linh hoạt và dễ bảo trì cho việc xây dựng các đối tượng có cấu trúc phức tạp mà không làm tăng độ phức tạp của constructor hoặc giao diện.

Dưới đây là một ví dụ về Builder Pattern trong PHP và một số trường hợp sử dụng:

// Product class
class Pizza {
    private $dough;
    private $sauce;
    private $toppings = [];

    public function setDough($dough) {
        $this->dough = $dough;
    }

    public function setSauce($sauce) {
        $this->sauce = $sauce;
    }

    public function addTopping($topping) {
        $this->toppings[] = $topping;
    }

    public function getDescription() {
        $toppingsList = implode(', ', $this->toppings);
        return "Pizza with {$this->dough} dough, {$this->sauce} sauce, and toppings: {$toppingsList}";
    }
}

// Builder interface
interface PizzaBuilder {
    public function buildDough();
    public function buildSauce();
    public function buildToppings();
    public function getPizza();
}

// Concrete builder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private $pizza;

    public function __construct() {
        $this->pizza = new Pizza();
    }

    public function buildDough() {
        $this->pizza->setDough('thin');
    }

    public function buildSauce() {
        $this->pizza->setSauce('tomato');
    }

    public function buildToppings() {
        $this->pizza->addTopping('cheese');
    }

    public function getPizza() {
        return $this->pizza;
    }
}

// Director
class PizzaDirector {
    private $builder;

    public function setBuilder(PizzaBuilder $builder) {
        $this->builder = $builder;
    }

    public function constructPizza() {
        $this->builder->buildDough();
        $this->builder->buildSauce();
        $this->builder->buildToppings();
        return $this->builder->getPizza();
    }
}

// Usage
$director = new PizzaDirector();
$builder = new MargheritaPizzaBuilder();
$director->setBuilder($builder);
$pizza = $director->constructPizza();
echo $pizza->getDescription();​

Trong ví dụ này:

• Pizza là Class sản phẩm cuối cùng cần được xây dựng.
• PizzaBuilder là giao diện định nghĩa các phương thức để xây dựng một loại pizza.
• MargheritaPizzaBuilder là concrete builder implement PizzaBuilder, cung cấp cách xây dựng cho pizza Margherita cụ thể.
• PizzaDirector là đạo diễn (director) quản lý quá trình xây dựng của pizza.

Các trường hợp sử dụng Builder Pattern bao gồm:

1. Xây dựng các đối tượng phức tạp: Khi bạn cần xây dựng các đối tượng có cấu trúc phức tạp với nhiều thuộc tính và phương thức, Builder Pattern giúp làm cho quá trình này trở nên dễ dàng và linh hoạt.

2. Tách biệt logic xây dựng từ logic kinh doanh: Builder Pattern cho phép bạn tách biệt quá trình xây dựng đối tượng ra khỏi logic kinh doanh, làm cho mã của bạn trở nên rõ ràng và dễ bảo trì hơn.

3. Tạo ra các biến thể của đối tượng: Builder Pattern cho phép bạn dễ dàng tạo ra các biến thể của một đối tượng bằng cách cung cấp các concrete builder khác nhau cho các biến thể khác nhau của đối tượng.

Mô hình MVC trong PHP

Mô hình MVC (Model-View-Controller) không phải là một design pattern cụ thể mà là một kiến trúc phần mềm (software architecture). Kiến trúc này được sử dụng để phân chia một ứng dụng thành ba phần chính: Model, View và Controller. Mỗi phần có trách nhiệm cụ thể trong quá trình xử lý và hiển thị dữ liệu. Mặc dù không phải là một design pattern như Singleton hay Factory, nhưng MVC thường được coi là một hướng dẫn thiết kế phổ biến cho việc phát triển ứng dụng web.

Dưới đây là mô tả ngắn gọn về các thành phần chính của MVC:

1. Model: Đại diện cho dữ liệu của ứng dụng và các logic liên quan đến dữ liệu. Model thường là nơi tương tác với cơ sở dữ liệu để lấy hoặc lưu trữ dữ liệu.

2. View: Đại diện cho interface người dùng và hiển thị dữ liệu cho người dùng. View thường chứa mã HTML hoặc các templates để render dữ liệu từ Model.

3. Controller: Điều khiển luồng của ứng dụng và xử lý các yêu cầu từ người dùng. Controller nhận yêu cầu từ người dùng, tương tác với Model để lấy dữ liệu và sau đó chuyển dữ liệu đó cho View để hiển thị cho người dùng.

Mô hình MVC giúp tách biệt logic xử lý dữ liệu (Model) với interface người dùng (View) và điều khiển luồng ứng dụng (Controller). Điều này làm cho mã của bạn trở nên dễ bảo trì hơn, linh hoạt hơn và tái sử dụng được hơn.

Trong PHP, MVC thường được sử dụng để phát triển các ứng dụng web, nhưng nó cũng có thể được áp dụng trong các ứng dụng khác như ứng dụng desktop hoặc ứng dụng di động.

Các bài học PHP phổ biến khác tại s2sontech:

• PHP - Cú pháp
• PHP - Các kiểu biến
• PHP - Hằng (Constant)
• PHP - Toán tử
• PHP - Lệnh if, else, switch