TungNT (Blue)

You've loaded an old revision of the document! If you save it, you will create a new version with this data.

====== Factory ======

===== Simple Factory Pattern =====

**Cách code khi không dùng Factory Pattern:**

<file php>
//...

private function getServiceLogistics($cargoVolume)
    {
        switch ($cargoVolume) {
            case 10:
                return [
                    'name' => 'Truck 10',
                    'door' => 6,
                    'price' => 250000,
                ];
            case 20:
                return [
                    'name' => 'Truck 20',
                    'door' => 16,
                    'price' => 1500000,
                ];            
            default:
                return [];
        }
    }
    
//...

var_dump($this->getServiceLogistics(10));
</file>

**Cách code khi dùng Simple Factory Pattern:**

<file php>
/**
 * ServiceLogistics
 */
class ServiceLogistics{
    private $name;
    private $door;
    private $price;
    
    /**
     * __construct
     *
     * @param  mixed $name
     * @param  mixed $door
     * @param  mixed $price
     * @return void
     */
    public function __construct($name = "Truck 10", $door = 6, $price = 250000) {
        $this->name = $name;
        $this->door = $door;
        $this->price = $price;
    }
    
    /**
     * getTransport
     *
     * @param  mixed $cargoVolume
     * @return void
     * 
     * Đã chuyển logic thành các class thực thi, tuy nhiên khó mở rộng được do function getTransport ngày càng phình to
     */
    public static function getTransport($cargoVolume)
    {
        switch ($cargoVolume) {
            case 10:
                return new ServiceLogistics();
            case 20:    
                return new ServiceLogistics('Truck 20', 16, 1500000);    
            default:
                return [];
        }
    }
}

var_dump(ServiceLogistics::getTransport(20));

</file>
===== Factory Method Pattern =====

Hãy tưởng tượng rằng bạn đang tạo một ứng dụng quản lý hậu cần. Phiên bản đầu tiên của ứng dụng của bạn chỉ có thể xử lý vận chuyển bằng xe tải, vì vậy phần lớn mã của bạn nằm trong lớp Truck.

Sau một thời gian, ứng dụng của bạn trở nên khá phổ biến. Mỗi ngày, bạn nhận được hàng chục yêu cầu từ các công ty vận tải biển để tích hợp hậu cần đường biển vào ứng dụng.

Tin tuyệt vời, phải không? Nhưng còn mã thì sao? Hiện tại, hầu hết mã của bạn được ghép nối với lớp Truck. Việc thêm Ships vào ứng dụng sẽ yêu cầu phải thay đổi toàn bộ cơ sở mã. Hơn nữa, nếu sau này bạn quyết định thêm một loại phương tiện giao thông khác vào ứng dụng, có thể bạn sẽ cần phải thực hiện lại tất cả những thay đổi này.

Kết quả là, bạn sẽ có một mã khá khó chịu, chứa đầy các điều kiện chuyển đổi hành vi của ứng dụng tùy thuộc vào lớp đối tượng phương tiện giao thông.

{{ :development:software-architecture:design-patterns:factory-method-en.png |}}

<file php>
<?php

namespace RefactoringGuru\FactoryMethod\Conceptual;

/**
 * The Creator class declares the factory method that is supposed to return an
 * object of a Product class. The Creator's subclasses usually provide the
 * implementation of this method.
 */
abstract class Creator
{
    /**
     * Note that the Creator may also provide some default implementation of the
     * factory method.
     */
    abstract public function factoryMethod(): Product;

/**
     * Also note that, despite its name, the Creator's primary responsibility is
     * not creating products. Usually, it contains some core business logic that
     * relies on Product objects, returned by the factory method. Subclasses can
     * indirectly change that business logic by overriding the factory method
     * and returning a different type of product from it.
     */
    public function someOperation(): string
    {
        // Call the factory method to create a Product object.
        $product = $this->factoryMethod();
        // Now, use the product.
        $result = "Creator: The same creator's code has just worked with " .
            $product->operation();

return $result;
    }
}

/**
 * Concrete Creators override the factory method in order to change the
 * resulting product's type.
 */
class ConcreteCreator1 extends Creator
{
    /**
     * Note that the signature of the method still uses the abstract product
     * type, even though the concrete product is actually returned from the
     * method. This way the Creator can stay independent of concrete product
     * classes.
     */
    public function factoryMethod(): Product
    {
        return new ConcreteProduct1();
    }
}

class ConcreteCreator2 extends Creator
{
    public function factoryMethod(): Product
    {
        return new ConcreteProduct2();
    }
}

/**
 * The Product interface declares the operations that all concrete products must
 * implement.
 */
interface Product
{
    public function operation(): string;
}

/**
 * Concrete Products provide various implementations of the Product interface.
 */
class ConcreteProduct1 implements Product
{
    public function operation(): string
    {
        return "{Result of the ConcreteProduct1}";
    }
}

class ConcreteProduct2 implements Product
{
    public function operation(): string
    {
        return "{Result of the ConcreteProduct2}";
    }
}

/**
 * The client code works with an instance of a concrete creator, albeit through
 * its base interface. As long as the client keeps working with the creator via
 * the base interface, you can pass it any creator's subclass.
 */
function clientCode(Creator $creator)
{
    // ...
    echo "Client: I'm not aware of the creator's class, but it still works.\n"
        . $creator->someOperation();
    // ...
}

/**
 * The Application picks a creator's type depending on the configuration or
 * environment.
 */
echo "App: Launched with the ConcreteCreator1.\n";
clientCode(new ConcreteCreator1());
echo "\n\n";

echo "App: Launched with the ConcreteCreator2.\n";
clientCode(new ConcreteCreator2());
</file>

Trong số những kiểu mẫu thiết kế hay design pattern trong PHP thì Factory là một trong những pattern được sử dụng phổ biến nhất.

<file php>
class XMLParser {
    function __construct($filePath) {
        file_get_content($filePath);
    }
}

class JSONParser {
    function __construct($filePath) {
        file_get_content($filePath);
    }
}

abstract class ParserFactory {
    public static function __construct($param) {
         if ($param['type'] = 'XML') {
                return new XMLParser($param["filePath"]);
        }
        if ($param['type'] = 'JSON') {
                return new JSONParser($param["filePath"]);
        }
    }
}
</file>

Ở trên chúng ta có hai class là XMLParser và JSONParser dùng để parse nội dung của tập tin tuỳ thuộc vào tập tin được lưu dưới định dạng là XML hay JSON. Tuy nhiên thay vì tạo parser object trực tiếp từ hai class này mà thông qua một Factory class ParserFactory.

Như ví dụ trên nếu chúng ta thay đổi tên của class XMLParser thì chúng ta chỉ cần thay đổi một dòng code trong method construct của ParserFactory. Nếu như chúng ta không sử dụng Factory thì sẽ phải thay đổi ở tất cả các object được tạo từ class XMLParser.

===== Abstract Factory Pattern =====

[[development:software-architecture:design-patterns:abstract-factory|Abstract Factory]]

====== Tham khảo ======

* https://refactoring.guru/design-patterns/factory-method
  * https://refactoring.guru/design-patterns/abstract-factory
  * https://www.youtube.com/watch?v=O6TsDdKtyz0

Please fill all the letters into the box to prove you're human. A᠎ V U T P Please keep this field empty:

Edit summary