Detaillierte Erläuterung der Verwendung von Fassadenmustern in PHP

Dieses Mal werde ich Ihnen eine detaillierte Erklärung der Verwendung des FassadenmustersFassadenmusters in PHP geben. Welche Vorsichtsmaßnahmen bei der Verwendung des Fassadenmusters in PHP gelten Werfen wir einen Blick darauf.

Über die Übersetzung des Wortes Fassade

Das Wort Fassade bezieht sich ursprünglich auf die Oberfläche und das Erscheinungsbild eines Gebäudes, es wird mit dem Begriff „Fassade“ übersetzt Das Wort Fassade hängt möglicherweise eher von der Beliebtheit von Laravel ab. Es scheint, dass jeder die Fassade in Laravel einstimmig 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 „Fassadenmuster“)

Ob in der realen Welt oder in der Programmierwelt, der Zweck der Fassade (Aussehen) Es bedeutet, ein schönes und attraktives Aussehen oder eine Maske für etwas anzulegen, das möglicherweise hässlich und unordentlich war. 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 wird ein Fassadenmuster verwendet?

Fassadenmuster („Aussehensmuster“) werden häufig verwendet, um eine einheitliche Eingabeschnittstelle für ein oder mehrere Subsysteme (Schnittstelle) bereitzustellen Bedienoberfläche.
Wenn Sie von anderen hinterlassene Projekte oder Code von Drittanbietern bedienen müssen. Insbesondere im Allgemeinen ist es für Sie nicht einfach, diese Codes umzugestalten, 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, nehmen wir ein paar Beispiele, um es intuitiver zu machen:

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

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 zu bedienen, können wir eine 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 unsere Kunden, It kann leicht so aufgerufen werden:

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

Beispiel 2: Eine schlechte E-Mail-Klasse eines Drittanbieters

Angenommen, Sie müssen die folgende verwenden, die schrecklich aussieht: Drittanbieter E-Mail-Klassen, insbesondere die einzelnen Methodennamen darin, müssen Sie einige Sekunden innehalten, um 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, es gibt keine andere Möglichkeit, erstellen wir eine Fassade

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 wir nun die Erscheinungsklasse haben, kann es so aussehen:

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

Beispiel 3: Vervollständigen Sie einen komplexen Prozess des Rohstoffhandels

Angenommen, ein Rohstoffhandelslink 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();
}

可以看到，一个流程呢包含了很多步骤，涉及到了很多Object，一旦类似环节要用在多个地方，可能就会导致问题，所以可以先创建一个外观类：

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();
 }
}

这样呢，我们的终端调用就可以两行解决：

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

示例四：往多个社交媒体同步消息的流程

// 发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中文网其它相关文章！

推荐阅读：

php与js打开本地exe应用程序传递参数步骤详解

如何实现php删除固定路径下文件夹与文件

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung von Fassadenmustern in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!