Differences

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

--- development:software-architecture:design-patterns:proxy [2024/08/15 06:56] – 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:**
+<file php LeaderObject.php>
+<?php
+namespace App\Utils\Object;
+/**
+ * LeaderObject
+ */
+class LeaderObject
+{
+  /**
+   * reviceRequestOffer
+   *
+   * @param  mixed $offer
+   * @return string
+   */
+  public function reviceRequestOffer($offer)
+  {
+      return "Offer {$offer} is ok!";
+  }
+}
+</file>
+<file php SecretaryProxy.php>
+<?php
+namespace App\Utils\Proxy;
+use App\Utils\Object\LeaderObject;
+/**
+ * SecretaryProxy
+ */
+class SecretaryProxy
+{
+    /**
+     * leader
+     *
+     * @var mixed
+     */
+    private $leader;
+    /**
+     * __construct
+     *
+     * @param  mixed $leader
+     * @return void
+     */
+    public function __construct(LeaderObject $leader) {
+        $this->leader = $leader;
+    }
+    /**
+     * reviceRequestOffer
+     *
+     * @param  mixed $offer
+     * @return string
+     */
+    public function reviceRequestOffer($offer)
+    {
+        // ...
+        return $this->leader->reviceRequestOffer($offer);
+    }
+}
+</file>
+<file php DeveloperObject.php>
+<?php
+namespace App\Utils\Object;
+use App\Utils\Proxy\SecretaryProxy;
+/**
+ * DeveloperObject
+ */
+class DeveloperObject
+{
+   /**
+    * applyFor
+    *
+    * @param  mixed $secretary
+    * @param  mixed $offer
+    * @return string
+    */
+   public function applyFor(SecretaryProxy $secretary, $offer)
+   {
+       return $secretary->reviceRequestOffer($offer);
+   }
+}
+</file>
+<file php ProxyCommand.php>
+<?php
+namespace App\Console\Commands\Test;
+use App\Utils\Object\DeveloperObject;
+use App\Utils\Object\LeaderObject;
+use App\Utils\Proxy\SecretaryProxy;
+use Illuminate\Console\Command;
+/**
+ * Class ProxyCommand
+ * @package Modules\Web\Console\Commands
+ */
+class ProxyCommand extends Command
+{
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $signature = 'test:proxy';
+    public function handle(){
+        $leader = new LeaderObject();
+        $developer = new DeveloperObject();
+        $result = $developer->applyFor(new SecretaryProxy($leader), '50M');
+        $this->info($result);
+    }
+}
+</file>
+**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>
+<?php
+namespace RefactoringGuru\Proxy\RealWorld;
+/**
+ * The Subject interface describes the interface of a real object.
+ *
+ * The truth is that many real apps may not have this interface clearly defined.
+ * If you're in that boat, your best bet would be to extend the Proxy from one
+ * of your existing application classes. If that's awkward, then extracting a
+ * proper interface should be your first step.
+ */
+interface Downloader
+{
+    public function download(string $url): string;
+}
+/**
+ * The Real Subject does the real job, albeit not in the most efficient way.
+ * When a client tries to download the same file for the second time, our
+ * downloader does just that, instead of fetching the result from cache.
+ */
+class SimpleDownloader implements Downloader
+{
+    public function download(string $url): string
+    {
+        echo "Downloading a file from the Internet.\n";
+        $result = file_get_contents($url);
+        echo "Downloaded bytes: " . strlen($result) . "\n";
+        return $result;
+    }
+}
+/**
+ * The Proxy class is our attempt to make the download more efficient. It wraps
+ * the real downloader object and delegates it the first download calls. The
+ * result is then cached, making subsequent calls return an existing file
+ * instead of downloading it again.
+ *
+ * Note that the Proxy MUST implement the same interface as the Real Subject.
+ */
+class CachingDownloader implements Downloader
+{
+    /**
+     * @var SimpleDownloader
+     */
+    private $downloader;
+    /**
+     * @var string[]
+     */
+    private $cache = [];
+    public function __construct(SimpleDownloader $downloader)
+    {
+        $this->downloader = $downloader;
+    }
+    public function download(string $url): string
+    {
+        if (!isset($this->cache[$url])) {
+            echo "CacheProxy MISS. ";
+            $result = $this->downloader->download($url);
+            $this->cache[$url] = $result;
+        } else {
+            echo "CacheProxy HIT. Retrieving result from cache.\n";
+        }
+        return $this->cache[$url];
+    }
+}
+/**
+ * The client code may issue several similar download requests. In this case,
+ * the caching proxy saves time and traffic by serving results from cache.
+ *
+ * The client is unaware that it works with a proxy because it works with
+ * downloaders via the abstract interface.
+ */
+function clientCode(Downloader $subject)
+{
+    // ...
+    $result = $subject->download("http://example.com/");
+    // Duplicate download requests could be cached for a speed gain.
+    $result = $subject->download("http://example.com/");
+    // ...
+}
+echo "Executing client code with real subject:\n";
+$realSubject = new SimpleDownloader();
+clientCode($realSubject);
+echo "\n";
+echo "Executing the same client code with a proxy:\n";
+$proxy = new CachingDownloader($realSubject);
+clientCode($proxy);
+</file>
+===== Tham khảo =====
+  * https://refactoring.guru/design-patterns/proxy
+  * https://www.youtube.com/watch?v=Z3mPTWuFw00