Teilen eines Beispiels für ein Fassadenmuster in PHP

Dieser Artikel stellt Ihnen hauptsächlich die detaillierte Verwendung und Codebeispiele des Fassadenmusters in PHP vor. Freunde, die dies benötigen, können darauf verweisen.

Ü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 „Fassade“ übersetzt Der inländische Fokus auf das Wort Fassade hängt möglicherweise eher von der Popularität von Laravel ab. Es scheint, dass sie alle das Wort Fassade in Laravel einhellig als „Fassade“ übersetzen. 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 (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:

Um sie bequemer bedienen zu können, haben wir kann einen Look erstellen Klasse (Fassade):

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) {
  ...
 }
}

Dann können unsere Kunden ganz einfach so anrufen:

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

Beispiel 2: Eine schlechte Mail-Klasse eines Drittanbieters

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

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

Zu diesem Zeitpunkt können Sie den Quellcode nicht direkt ändern Erstellen Sie eine Fassade.

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

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

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

Jetzt kann es mit der Erscheinungsklasse so aussehen:

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

Beispiel 3: Den komplexen Prozess einer Warentransaktion abschließen

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

Angenommen, eine Warentransaktion erfordert die folgenden Schritte:

Wie Sie sehen können, enthält ein Prozess viele Schritte und umfasst 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:

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

Auf diese Weise ruft unser Terminal es auf kann in zwei Zeilen gelöst werden:

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

Beispiel 4: Prozess der Synchronisierung von Nachrichten mit mehreren sozialen Medien

$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）——用来给一个或多个复杂的子系统、或者第三方库，提供统一的入口，或者说统一的终端调用方式

相关推荐：

JavaScript的外观模式

php设计模式之Facade(外观模式)介绍

详解PHP外观模式的实例代码分享

Das obige ist der detaillierte Inhalt vonTeilen eines Beispiels für ein Fassadenmuster in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!