Differences

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

--- development:software-architecture:design-patterns:proxy [2024/08/15 07:30] – tungnt
+++ development:software-architecture:design-patterns:proxy [2024/08/19 10:52] (current) – [Proxy] tungnt
@@ Line 10: / Line 10: @@
 {{ :development:software-architecture:design-patterns:proxy-solution-en.png |}}
+Trong phần mềm hệ thống proxy chủ yếu dùng để kiểm soát, bảo vệ & điều hướng dữ liệu đầu vào.
 **Ví dụ 1:**
@@ Line 139: / Line 141: @@
 **Ví dụ 2:**
+<file php>
+<?php
+namespace RefactoringGuru\Proxy\Conceptual;
+/**
+ * The Subject interface declares common operations for both RealSubject and the
+ * Proxy. As long as the client works with RealSubject using this interface,
+ * you'll be able to pass it a proxy instead of a real subject.
+ */
+interface Subject
+{
+    public function request(): void;
+}
+/**
+ * The RealSubject contains some core business logic. Usually, RealSubjects are
+ * capable of doing some useful work which may also be very slow or sensitive -
+ * e.g. correcting input data. A Proxy can solve these issues without any
+ * changes to the RealSubject's code.
+ */
+class RealSubject implements Subject
+{
+    public function request(): void
+    {
+        echo "RealSubject: Handling request.\n";
+    }
+}
+/**
+ * The Proxy has an interface identical to the RealSubject.
+ */
+class Proxy implements Subject
+{
+    /**
+     * @var RealSubject
+     */
+    private $realSubject;
+    /**
+     * The Proxy maintains a reference to an object of the RealSubject class. It
+     * can be either lazy-loaded or passed to the Proxy by the client.
+     */
+    public function __construct(RealSubject $realSubject)
+    {
+        $this->realSubject = $realSubject;
+    }
+    /**
+     * The most common applications of the Proxy pattern are lazy loading,
+     * caching, controlling the access, logging, etc. A Proxy can perform one of
+     * these things and then, depending on the result, pass the execution to the
+     * same method in a linked RealSubject object.
+     */
+    public function request(): void
+    {
+        if ($this->checkAccess()) {
+            $this->realSubject->request();
+            $this->logAccess();
+        }
+    }
+    private function checkAccess(): bool
+    {
+        // Some real checks should go here.
+        echo "Proxy: Checking access prior to firing a real request.\n";
+        return true;
+    }
+    private function logAccess(): void
+    {
+        echo "Proxy: Logging the time of request.\n";
+    }
+}
+/**
+ * The client code is supposed to work with all objects (both subjects and
+ * proxies) via the Subject interface in order to support both real subjects and
+ * proxies. In real life, however, clients mostly work with their real subjects
+ * directly. In this case, to implement the pattern more easily, you can extend
+ * your proxy from the real subject's class.
+ */
+function clientCode(Subject $subject)
+{
+    // ...
+    $subject->request();
+    // ...
+}
+echo "Client: Executing the client code with a real subject:\n";
+$realSubject = new RealSubject();
+clientCode($realSubject);
+echo "\n";
+echo "Client: Executing the same client code with a proxy:\n";
+$proxy = new Proxy($realSubject);
+clientCode($proxy);
+</file>
+**Ví dụ 3:**
 <file php>
@@ Line 244: / Line 351: @@
 </file>
-==== Tham khảo ====
+===== Tham khảo =====
   * https://refactoring.guru/design-patterns/proxy