Explication détaillée de l'utilisation du motif de façade en PHP

Cette fois, je vais vous apporter une explication détaillée de l'utilisation du motif de façademotif de façade en PHP. Quelles sont les précautions lors de l'utilisation du motif de façade en PHP. cas pratiques. Jetons un coup d'oeil.

À propos de la traduction du mot façade

Le mot façade fait à l'origine référence à la surface et à l'apparence d'un bâtiment, en architecture, il est traduit par le terme « façade ». Le mot façade dépend peut-être davantage de la popularité de Laravel. Il semble que tout le monde traduise à l'unanimité le mot façade dans Laravel par « façade ». Pour être honnête, lorsque j'ai vu pour la première fois la mention de « façade » dans le document de traduction, je pense que vous avez eu la même pensée que moi : « De quoi tu parles ? Tu parles du magasin ou du magasin ? façade?" "Jusqu'à présent, si je dois utiliser le mot "façade" en chinois ou le mot "façade", mon cœur ne "clique" pas consciemment, et je sais qu'il y a un problème ici.

Quelle est la meilleure traduction de façade ? Cependant, certaines personnes préconisent simplement de ne pas traduire et d'utiliser simplement les mots anglais lorsqu'elles les rencontrent. Ce n'est pas une solution à long terme. Après tout, il s'agit d'ouvrir la voie à la compréhension des débutants. Plus tard, j'ai vu par hasard que des érudits taïwanais, ou Wikipédia taïwanais pour être plus précis, traduisaient le motif de façade par « motif d'apparence ». Compte tenu de l'effet réel de ce motif, je me suis senti immédiatement soulagé. Même si la façade de Laravel n'est pas strictement un motif de façade, beaucoup de gens critiquent encore Laravel pour son utilisation abusive et trompeuse du mot façade, mais il emprunte ou imite toujours le motif de façade après tout, donc la façade de Laravel, cet article aussi je pense qu'il serait préférable de le traduire par "apparence". Bien sûr, pour une meilleure compréhension, cela peut être "apparence de service". Même ainsi, d'un point de vue personnel, je préfère l'appeler « localisateur de service », « agent de service » ou « alias de service ». En fait, de nombreuses personnes à l'étranger suggèrent également de changer le nom de cette manière, mais l'attitude de Taylor à ce sujet est la suivante. Exceptionnellement résistant, il n’est donc pas nécessaire de le forcer pour l’instant.

Grâce à ce qui suit, après avoir réellement compris ce qu'est un motif de façade, je pense que vous comprendrez mieux pourquoi il est plus approprié de le traduire par « motif de façade ».

Qu'est-ce que le motif de façade (définition de "motif de façade")

Que ce soit dans le monde réel ou dans le monde de la programmation, le but de la façade (apparence) Il s'agit de « revêtir » une apparence belle et attrayante, ou un masque, pour quelque chose qui aurait pu être laid et désordonné. Dans le proverbe chinois : Qu'est-ce que l'apparence ? "Un homme dépend de ses vêtements et un cheval dépend de sa selle." Sur cette base, le modèle de façade consiste à ajouter (ou convertir) une ou plusieurs classes désordonnées, complexes et difficiles à refactoriser en une interface (interface) belle et élégante, afin que vous puissiez être plus heureux et plus à l'aise. pratique de le faire fonctionner, exploitant ainsi indirectement la logique réelle qui le sous-tend.

Quand utiliser le motif de façade

le motif de façade (« motif d'apparence ») est souvent utilisé pour fournir une interface d'entrée unifiée pour un ou plusieurs sous-systèmes (interface), ou interface d'opération.
Lorsque vous devez exploiter des projets laissés par d'autres ou du code tiers. En général, ces codes ne sont pas faciles à refactoriser et aucun test n'est fourni. A ce stade, vous pouvez créer une façade (« apparence ») pour « envelopper » le code d'origine afin de simplifier ou d'optimiser ses scénarios d'utilisation.

Peu importe ce que je dis, prenons quelques exemples pour le rendre plus intuitif :

Exemple 1 : En Java, les informations système complexes à l'intérieur de l'ordinateur sont manipulées à travers la façade

Supposons que nous ayons une logique de sous-système complexe :

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

Afin de les faire fonctionner plus facilement, nous pouvons créer une façade :

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

Ensuite Nos clients peuvent facilement appeler ceci :

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

Exemple 2 : Une mauvaise classe d'e-mail tiers

Supposons que vous deviez utiliser ce qui suit : Cet e-mail tiers la classe a l'air terrible, d'autant plus qu'il faut faire une pause de plusieurs secondes pour comprendre chaque nom de méthode qu'elle contient :

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

Pour le moment, vous ne pouvez pas changer directement le code source, il n'y a pas d'autre moyen, créons une façade

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

Ensuite, l'appel du terminal d'origine sans optimisation peut ressembler à ceci :

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

Maintenant qu'il existe une classe d'apparence, cela peut être comme ceci :

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

Exemple 3 : Compléter le processus complexe d'une transaction sur matières premières

Supposons qu'une transaction sur matières premières nécessite les étapes suivantes :

$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删除固定路径下文件夹与文件

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!