Differences

This shows you the differences between two versions of the page.

--- development:software-architecture:design-patterns:abstract-factory [2024/08/08 05:05] – tungnt
+++ development:software-architecture:design-patterns:abstract-factory [2024/08/14 13:43] (current) – [Tham khảo] tungnt
@@ Line 1: / Line 1: @@
 ====== Abstract Factory ======
+Giả sử bạn đang tạo một chương trình mô phỏng cửa hàng đồ nội thất. Code của bạn bao gồm các lớp biểu diễn:
+  * Một nhóm các sản phẩm liên quan: Chair + Sofa + CoffeeTable.
+  * Một số biến thể của họ này. Ví dụ: Chair + Sofa + CoffeeTable có sẵn trong các biến thể sau: Modern, Victorian, ArtDeco.
+{{ :development:software-architecture:design-patterns:problem-en.png |}}
+Bạn cần một cách để tạo ra các đồ nội thất riêng lẻ sao cho chúng phù hợp với các đồ vật khác cùng loại. Khách hàng sẽ rất tức giận khi nhận được đồ nội thất không phù hợp.
+Ngoài ra, bạn không muốn thay đổi mã hiện có khi thêm sản phẩm mới hoặc nhóm sản phẩm mới vào chương trình. Các nhà cung cấp đồ nội thất cập nhật danh mục của họ rất thường xuyên và bạn sẽ không muốn thay đổi mã cốt lõi mỗi lần như vậy.
+**Code mẫu:**
 <file php>
@@ Line 174: / Line 187: @@
 </file>
-====== Tham khảo ======
+**Ví dụ:**
+<file php>
+<?php
+namespace RefactoringGuru\AbstractFactory\RealWorld;
+/**
+ * The Abstract Factory interface declares creation methods for each distinct
+ * product type.
+ */
+interface TemplateFactory
+{
+    public function createTitleTemplate(): TitleTemplate;
+    public function createPageTemplate(): PageTemplate;
+    public function getRenderer(): TemplateRenderer;
+}
+/**
+ * Each Concrete Factory corresponds to a specific variant (or family) of
+ * products.
+ *
+ * This Concrete Factory creates Twig templates.
+ */
+class TwigTemplateFactory implements TemplateFactory
+{
+    public function createTitleTemplate(): TitleTemplate
+    {
+        return new TwigTitleTemplate();
+    }
+    public function createPageTemplate(): PageTemplate
+    {
+        return new TwigPageTemplate($this->createTitleTemplate());
+    }
+    public function getRenderer(): TemplateRenderer
+    {
+        return new TwigRenderer();
+    }
+}
+/**
+ * And this Concrete Factory creates PHPTemplate templates.
+ */
+class PHPTemplateFactory implements TemplateFactory
+{
+    public function createTitleTemplate(): TitleTemplate
+    {
+        return new PHPTemplateTitleTemplate();
+    }
+    public function createPageTemplate(): PageTemplate
+    {
+        return new PHPTemplatePageTemplate($this->createTitleTemplate());
+    }
+    public function getRenderer(): TemplateRenderer
+    {
+        return new PHPTemplateRenderer();
+    }
+}
+/**
+ * Each distinct product type should have a separate interface. All variants of
+ * the product must follow the same interface.
+ *
+ * For instance, this Abstract Product interface describes the behavior of page
+ * title templates.
+ */
+interface TitleTemplate
+{
+    public function getTemplateString(): string;
+}
+/**
+ * This Concrete Product provides Twig page title templates.
+ */
+class TwigTitleTemplate implements TitleTemplate
+{
+    public function getTemplateString(): string
+    {
+        return "<h1>{{ title }}</h1>";
+    }
+}
+/**
+ * And this Concrete Product provides PHPTemplate page title templates.
+ */
+class PHPTemplateTitleTemplate implements TitleTemplate
+{
+    public function getTemplateString(): string
+    {
+        return "<h1><?= \$title; ?></h1>";
+    }
+}
+/**
+ * This is another Abstract Product type, which describes whole page templates.
+ */
+interface PageTemplate
+{
+    public function getTemplateString(): string;
+}
+/**
+ * The page template uses the title sub-template, so we have to provide the way
+ * to set it in the sub-template object. The abstract factory will link the page
+ * template with a title template of the same variant.
+ */
+abstract class BasePageTemplate implements PageTemplate
+{
+    protected $titleTemplate;
+    public function __construct(TitleTemplate $titleTemplate)
+    {
+        $this->titleTemplate = $titleTemplate;
+    }
+}
+/**
+ * The Twig variant of the whole page templates.
+ */
+class TwigPageTemplate extends BasePageTemplate
+{
+    public function getTemplateString(): string
+    {
+        $renderedTitle = $this->titleTemplate->getTemplateString();
+        return <<<HTML
+        <div class="page">
+            $renderedTitle
+            <article class="content">{{ content }}</article>
+        </div>
+        HTML;
+    }
+}
+/**
+ * The PHPTemplate variant of the whole page templates.
+ */
+class PHPTemplatePageTemplate extends BasePageTemplate
+{
+    public function getTemplateString(): string
+    {
+        $renderedTitle = $this->titleTemplate->getTemplateString();
+        return <<<HTML
+        <div class="page">
+            $renderedTitle
+            <article class="content"><?= \$content; ?></article>
+        </div>
+        HTML;
+    }
+}
+/**
+ * The renderer is responsible for converting a template string into the actual
+ * HTML code. Each renderer behaves differently and expects its own type of
+ * template strings passed to it. Baking templates with the factory let you pass
+ * proper types of templates to proper renders.
+ */
+interface TemplateRenderer
+{
+    public function render(string $templateString, array $arguments = []): string;
+}
+/**
+ * The renderer for Twig templates.
+ */
+class TwigRenderer implements TemplateRenderer
+{
+    public function render(string $templateString, array $arguments = []): string
+    {
+        return \Twig::render($templateString, $arguments);
+    }
+}
+/**
+ * The renderer for PHPTemplate templates. Note that this implementation is very
+ * basic, if not crude. Using the `eval` function has many security
+ * implications, so use it with caution in real projects.
+ */
+class PHPTemplateRenderer implements TemplateRenderer
+{
+    public function render(string $templateString, array $arguments = []): string
+    {
+        extract($arguments);
+        ob_start();
+        eval(' ?>' . $templateString . '<?php ');
+        $result = ob_get_contents();
+        ob_end_clean();
+        return $result;
+    }
+}
+/**
+ * The client code. Note that it accepts the Abstract Factory class as the
+ * parameter, which allows the client to work with any concrete factory type.
+ */
+class Page
+{
+    public $title;
+    public $content;
+    public function __construct($title, $content)
+    {
+        $this->title = $title;
+        $this->content = $content;
+    }
+    // Here's how would you use the template further in real life. Note that the
+    // page class does not depend on any concrete template classes.
+    public function render(TemplateFactory $factory): string
+    {
+        $pageTemplate = $factory->createPageTemplate();
+        $renderer = $factory->getRenderer();
+        return $renderer->render($pageTemplate->getTemplateString(), [
+            'title' => $this->title,
+            'content' => $this->content
+        ]);
+    }
+}
+/**
+ * Now, in other parts of the app, the client code can accept factory objects of
+ * any type.
+ */
+$page = new Page('Sample page', 'This is the body.');
+echo "Testing actual rendering with the PHPTemplate factory:\n";
+echo $page->render(new PHPTemplateFactory());
+// Uncomment the following if you have Twig installed.
+// echo "Testing rendering with the Twig factory:\n"; echo $page->render(new
+// TwigTemplateFactory());
+</file>
-  * https://refactoring.guru/design-patterns/abstract-factory