Über die Analyse von Fassadenmustern in PHP

In diesem Artikel werden hauptsächlich die detaillierten Verwendungs- und Codebeispiele des Fassadenmusters in PHP vorgestellt. Freunde, die dies benötigen, können darauf zurückgreifen.

Über die Übersetzung des Wortes Fassade

Das Wort Fassade bezieht sich ursprünglich auf die Oberfläche und das Erscheinungsbild eines Gebäudes und wird in der Architektur mit dem Begriff „Fassade“ übersetzt Häusliche Aufmerksamkeit auf Das Wort Fassade hängt möglicherweise eher von der Beliebtheit von Laravel ab. Es scheint, dass jeder einstimmig Fassade in Laravel als „Fassade“ übersetzt. Ehrlich gesagt, als ich zum ersten Mal die Erwähnung von „Fassade“ im Übersetzungsdokument sah, denke ich, dass Sie den gleichen Gedanken hatten wie ich: „Wovon zum Teufel reden Sie? Reden Sie über den Laden oder die Läden?“ Fassade?

Was ist die beste Übersetzung von Fassade? Einige Leute plädieren jedoch einfach dafür, nicht zu übersetzen und nur die englischen Wörter zu verwenden. Dies ist keine langfristige Lösung. Schließlich geht es darum, Neulingen den Weg zum Verständnis zu ebnen. Später sah ich zufällig, dass taiwanesische Gelehrte, genauer gesagt Taiwans Wikipedia, Fassadenmuster als „Erscheinungsmuster“ übersetzten. Angesichts der tatsächlichen Wirkung dieses Musters fühlte ich mich sofort erleichtert. Auch wenn es sich bei der Fassade in Laravel nicht unbedingt um ein Fassadenmuster handelt, kritisieren viele Leute Laravel immer noch für den Missbrauch und die Irreführung des Wortes Fassade, aber es leiht oder imitiert immer noch das Fassadenmuster, so die Fassade in Laravel, dieser Artikel Außerdem denke ich, dass es besser wäre, es mit „Aussehen“ zu übersetzen. Zum besseren Verständnis kann es natürlich auch „Aussehen im Dienst“ lauten. Trotzdem würde ich es aus persönlicher Sicht eher „Service Locator“, „Service Agent“ oder „Service Alias“ nennen. Tatsächlich schlagen viele Leute im Ausland auch vor, den Namen auf diese Weise zu ändern, aber Taylors Einstellung zu diesem Thema ist es Ungewöhnlich hart, daher besteht vorerst kein Grund, es zu erzwingen.

Nachdem Sie im Folgenden tatsächlich verstanden haben, was ein Fassadenmuster ist, werden Sie meines Erachtens besser verstehen, warum es treffender als „Fassadenmuster“ übersetzt wird.

Was ist ein Fassadenmuster (Definition von „Erscheinungsmuster“)

Ob in der realen Welt oder der Programmierwelt, der Zweck der Fassade (Erscheinung) ist es, etwas, das ursprünglich hässlich und unordentlich war, ein schönes, attraktives Aussehen oder eine Maske zu verleihen. Im chinesischen Sprichwort: Was ist Aussehen? „Ein Mann ist auf seine Kleidung angewiesen und ein Pferd auf seinen Sattel.“ Auf dieser Grundlage besteht das Fassadenmuster darin, eine oder mehrere chaotische, komplexe und schwer umgestaltbare Klassen zu einer schönen und eleganten Schnittstelle hinzuzufügen (oder umzuwandeln), damit Sie zufriedener und komfortabler sein können bequem zu bedienen und damit indirekt die eigentliche Logik dahinter zu bedienen.

Wann müssen Sie eine Eingangsschnittstelle (Schnittstelle) oder eine Bedienschnittstelle verwenden? Wenn Sie von anderen hinterlassene Projekte oder Code von Drittanbietern bedienen müssen. Insbesondere im Allgemeinen lassen sich diese Codes nicht einfach umgestalten und es werden keine Tests bereitgestellt. Zu diesem Zeitpunkt können Sie eine Fassade („Erscheinungsbild“) erstellen, um den ursprünglichen Code zu „umhüllen“, um seine Verwendungsszenarien zu vereinfachen oder zu optimieren.

Egal wie viel ich sage, geben wir ein paar Beispiele, um es intuitiver zu machen:

Beispiel 1: In Java werden komplexe Systeminformationen im Computer manipuliert durch die Fassade

Angenommen, wir haben eine komplexe Subsystemlogik:

class CPU {
 public void freeze() { ... }
 public void jump(long position) { ... }
 public void execute() { ... }
}
class Memory {
 public void load(long position, byte[] data) {
  ...
 }
}
class HardDrive {
 public byte[] read(long lba, int size) {
  ...
 }
}

Um sie bequemer bedienen zu können, Wir können eine Erscheinungsklasse (Fassade) erstellen:

class Computer {
 public void startComputer() {
  cpu.freeze();
  memory.load(BOOT_ADDRESS, hardDrive.read(BOOT_SECTOR, SECTOR_SIZE));
  cpu.jump(BOOT_ADDRESS);
  cpu.execute();
 }
}

Dann können unsere Kunden ganz einfach so aufrufen:

class You {
 public static void main(String[] args) {
  Computer facade = new Computer();
  facade.startComputer();
 }
}

Beispiel 2: Eine schlechte Mail-Klasse eines Drittanbieters

Angenommen, Sie müssen die folgende Mail-Klasse eines Drittanbieters verwenden, die insbesondere schrecklich aussieht Sie müssen einige Sekunden innehalten, um die einzelnen Methodennamen zu verstehen:

interface SendMailInterface
{
 public function setSendToEmailAddress($emailAddress);
 public function setSubjectName($subject);
 public function setTheEmailContents($body);
 public function setTheHeaders($headers);
 public function getTheHeaders();
 public function getTheHeadersText();
 public function sendTheEmailNow();
}
class SendMail implements SendMailInterface
{
 public $to, $subject, $body;
 public $headers = array();
 
 public function setSendToEmailAddress($emailAddress)
 {
  $this->to = $emailAddress;
 }
 public function setSubjectName($subject)
 {
  $this->subject = $subject;
 }
 public function setTheEmailContents($body)
 {
  $this->body = $body;
 }
 public function setTheHeaders($headers)
 {
  $this->headers = $headers;
 }
 public function getTheHeaders()
 {
  return $this->headers;
 }
 public function getTheHeadersText()
 {
  $headers = "";
  foreach ($this->getTheHeaders() as $header) {
   $headers .= $header . "\r\n";
  }
 }
 
 public function sendTheEmailNow()
 {
  mail($this->to, $this->subject, $this->body, $this->getTheHeadersText());
 }
}

Zu diesem Zeitpunkt können Sie den Quellcode nicht direkt ändern Keine andere Möglichkeit. Lass uns eine Fassade erstellen

class SendMailFacade
{
 private $sendMail;
 public function __construct(SendMailInterface $sendMail)
 {
  $this->sendMail = $sendMail;
 }
 public function setTo($to)
 {
  $this->sendMail->setSendToEmailAddress($to);
  return $this;
 }
 public function setSubject($subject)
 {
  $this->sendMail->setSubjectName($subject);
  return $this;
 }
 public function setBody($body)
 {
  $this->sendMail->setTheEmailContents($body);
  return $this;
 }
 public function setHeaders($headers)
 {
  $this->sendMail->setTheHeaders($headers);
  return $this;
 }
 public function send()
 {
  $this->sendMail->sendTheEmailNow();
 }
}

Dann könnte der ursprüngliche Terminalaufruf ohne Optimierung so aussehen:

$sendMail = new SendMail();
$sendMail->setSendToEmailAddress($to);
$sendMail->setSubjectName($subject);
$sendMail->setTheEmailContents($body);
$sendMail->setTheHeaders($headers);
$sendMail->sendTheEmailNow();

Da Sie nun die Erscheinungsklasse haben, können Sie Folgendes tun:

$sendMail  = new SendMail();
$sendMailFacade = new sendMailFacade($sendMail);
$sendMailFacade->setTo($to)->setSubject($subject)->setBody($body)->setHeaders($headers)->send();

Beispiel 3: Schließen Sie den komplexen Prozess ab einer Produkttransaktion

Angenommen, eine Warentransaktion erfordert die folgenden Schritte:

$productID = $_GET['productId']; 
$qtyCheck = new productQty();

 // 检查库存
if($qtyCheck->checkQty($productID) > 0) {
  
 // 添加商品到购物车
 $addToCart = new addToCart($productID);
  
 // 计算运费
 $shipping = new shippingCharge();
 $shipping->updateCharge();
  
 // 计算打折
 $discount = new discount();
 $discount->applyDiscount();
  
 $order = new order();
 $order->generateOrder();
}

Wie Sie sehen können, Ein Prozess umfasst viele Schritte und viele Objekte. Sobald ähnliche Links an mehreren Stellen verwendet werden, kann dies zu Problemen führen. Sie können daher zunächst eine Erscheinungsklasse erstellen:

class productOrderFacade {
 public $productID = '';  
 public function __construct($pID) {
  $this->productID = $pID;
 }
 public function generateOrder() {   
  if($this->qtyCheck()) {
   $this->addToCart();
   $this->calulateShipping();
   $this->applyDiscount();
   $this->placeOrder();
  }   
 }
 private function addToCart () {
  /* .. add product to cart .. */
 } 
 private function qtyCheck() {
  $qty = 'get product quantity from database';
  if($qty > 0) {
   return true;
  } else {
   return true;
  }
 }
  private function calulateShipping() {
  $shipping = new shippingCharge();
  $shipping->calculateCharge();
 }
 private function applyDiscount() {
  $discount = new discount();
  $discount->applyDiscount();
 }
 private function placeOrder() {
  $order = new order();
  $order->generateOrder();
 }
}

Auf diese Weise kann unser Terminalaufruf in zwei Zeilen gelöst werden:

$order = new productOrderFacade($productID);
$order->generateOrder();

Beispiel 4: Prozess der Synchronisierung von Nachrichten mit mehrere soziale Medien

// 发Twitter消息
class CodeTwit {
 function tweet($status, $url)
 {
 var_dump('Tweeted:'.$status.' from:'.$url);
 }
}
// 分享到Google plus上
class Googlize {
 function share($url)
 {
 var_dump('Shared on Google plus:'.$url);
 }
}
//分享到Reddit上
class Reddiator {
 function reddit($url, $title)
 {
 var_dump('Reddit! url:'.$url.' title:'.$title);
 }
}

如果每次我们写了一篇文章，想着转发到其他平台，都得分别去调用相应方法，这工作量就太大了，后期平台数量往往只增不减呢。这个时候借助于facade class：

class shareFacade {
 
 protected $twitter; 
 protected $google; 
 protected $reddit; 
 function __construct($twitterObj,$gooleObj,$redditObj)
 {
 $this->twitter = $twitterObj;
 $this->google = $gooleObj;
 $this->reddit = $redditObj;
 } 
 function share($url,$title,$status)
 {
 $this->twitter->tweet($status, $url);
 $this->google->share($url);
 $this->reddit->reddit($url, $title);
 }
}

这样终端调用就可以：

$shareObj = new shareFacade($twitterObj,$gooleObj,$redditObj);
$shareObj->share('//myBlog.com/post-awsome','My greatest post','Read my greatest post ever.');

facade pattern的优劣势

优势

能够使你的终端调用与背后的子系统逻辑解耦，这往往发生在你的controller里，就意味着你的controller可以有更少的依赖，controller关注的更少了，从而责任和逻辑也更明确了，同时也意味着你子系统里的逻辑更改，并不会影响到你的controller里终端调用。

劣势

虽然特别有用，但是一个常见的陷阱就是，过度使用这个模式，明明可能那个时候你并不需要，这个往往注意即可。当然也有人争论说，明明我原来的代码都能用，干嘛费这个劲，那么同样是房子，你是喜欢住在精致的屋子里呢，还是说有四面墙就行了呢？

感觉facade pattern与其他的设计模式似曾相识？

认真学过我们《Laravel底层核心技术实战揭秘》这一课程的同学，可能到这里就会尤其觉得这个facade pattern好像在哪里见过？可能你会脱口而出：“这货跟之前咱们学的decorator pattern有啥区别呢？为啥不直接说成修饰者模式呢？”

确实，在“包装”逻辑方面，它们确实类似，但是：

修饰者模式（Decorator）——用来给一个Object添加、包裹上新的行为、逻辑，而不需要改动原来的代码

外观模式（facade pattern）——用来给一个或多个复杂的子系统、或者第三方库，提供统一的入口，或者说统一的终端调用方式

还是有一定差别的~

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

学习laravel的模型事件的几种用法

关于PHP的Laravel框架中使用消息队列queue及异步队列的方法分析

Laravel 5框架的模型和控制器以及视图基础流程的学习

Das obige ist der detaillierte Inhalt vonÜber die Analyse von Fassadenmustern in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!