Learn about the facade pattern in PHP in one article

In the previous article " A Brief Talk on the Bridge Mode in PHP" we introduced the bridge mode in PHP. The following article will take you to understand the facade mode in the PHP design pattern.

Facade mode is also called appearance mode. Whether it is the facade or appearance, it is our medium to the outside world, just like our face. Therefore, the biggest feature of this model is that it should be "good-looking". how to say? A bunch of complex object calls make me confused, especially when upgrading and maintaining old systems. Use the facade to encapsulate the function calls of the old system. From the outside, it looks the same as the new system. This is the purpose of the facade pattern!

Gof class diagram and explanation

GoF definition: Provide a consistent interface for a set of interfaces in a subsystem. The Facade pattern defines a high-level interface. This interface Makes this subsystem easier to use.

GoF class diagram

##Code implementation

class SubSystemOne
{
    public function MethodOne()
    {
        echo '子系统方法一', PHP_EOL;
    }
}
class SubSystemTwo
{
    public function MethodTwo()
    {
        echo '子系统方法二', PHP_EOL;
    }
}
class SubSystemThree
{
    public function MethodThree()
    {
        echo '子系统方法三', PHP_EOL;
    }
}
class SubSystemFour
{
    public function MethodFour()
    {
        echo '子系统方法四', PHP_EOL;
    }
}

Define four or N more subsystems. There is nothing to say about this. You can imagine that there are many subsystems, and they are not necessarily the same as these four subsystems. They may be vastly different.

class Facade
{

    private $subStytemOne;
    private $subStytemTwo;
    private $subStytemThree;
    private $subStytemFour;
    public function __construct()
    {
        $this->subSystemOne = new SubSystemOne();
        $this->subSystemTwo = new SubSystemTwo();
        $this->subSystemThree = new SubSystemThree();
        $this->subSystemFour = new SubSystemFour();
    }

    public function MethodA()
    {
        $this->subSystemOne->MethodOne();
        $this->subSystemTwo->MethodTwo();
    }
    public function MethodB()
    {
        $this->subSystemOne->MethodOne();
        $this->subSystemTwo->MethodTwo();
        $this->subSystemThree->MethodThree();
        $this->subSystemFour->MethodFour();
    }
}

These subsystems are packaged through the facade class, and only the newly defined methods of the facade are provided to the outside world.

$facade = new Facade();
$facade->MethodA();
$facade->MethodB();

The client call is very simple. We don’t need to know which subsystems are called specifically. We only need to know what these methods on the facade do!

The facade mode is so simple, and as long as it is a real friend who has done development in the project, he must have used this mode without knowing it
When you The facade pattern is very suitable when you need to provide a simple interface to a complex subsystem. At the same time, if there is a large dependency between the client program and the implementation part of the abstract class, the facade pattern can also be introduced for decoupling to improve the independence and maintainability of the subsystem. In addition, when you need to build a hierarchical subsystem, the facade can serve as the entry point for each layer of subsystem
I believe that anyone who has used the framework must have used the facade system in Laravel, such as: Cache:: put(). In Laravel, the facade is implemented using a magic method __callStatic(). Then let the object's methods be called directly using static methods. Isn't it amazing? Interested friends can check out the source code, which is in /Illuminate/Support/Facades/Facade.php.
Key points: The three-tier structure or MVC is also a manifestation of the facade pattern. As mentioned above, the facade mode is suitable for the maintenance of hierarchical subsystems. The three-tier structure, MVC, MVP, and MVVM are essentially all for layering, and the purpose of layering is to reduce the complexity of the system.

Just selling our mobile phones is not enough. Being a high-tech home appliance company like X Mi is our ultimate goal. However, we cannot produce so many home appliances, so we decided to build a mall (Facade) to let some very high-quality merchants join our camp and put their products (SubSystem) in the mall to sell them together. Of course, these products have been carefully selected by us, and they are definitely the best among the best! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/19.facade/source/facade.php

Example

This time we package the sending of text messages in the sending dimension, and package the interfaces of different text messages and push operators. When sending, we only need to use the sending class You can control the sending of text messages or push notifications using different third-party services. It’s very convenient when you think about it!

SMS sending class diagram

Full source code: https://github.com/zhangyue0503/designpatterns-php /blob/master/19.facade/source/facade-push.php

<?php

class Send
{

    private $aliYunService;
    private $jiGuangService;

    private $message;
    private $push;

    public function __construct()
    {
        $this->aliYunService = new AliYunService();
        $this->jiGuangService = new JiGuangService();

        $this->message = new MessageInfo();
        $this->push = new PushInfo();
    }

    public function PushAndSendAliYun()
    {
        $this->message->Send($this->aliYunService);
        $this->push->Push($this->aliYunService);
    }

    public function PushAndSendJiGuang()
    {
        $this->message->Send($this->jiGuangService);
        $this->push->Push($this->jiGuangService);
    }
}

class MessageInfo
{
    public function Send($service)
    {
        $service->Send();
    }
}

class PushInfo
{
    public function Push($service)
    {
        $service->Push();
    }
}

class AliYunService
{
    public function Send()
    {
        echo &#39;发送阿里云短信！&#39;, PHP_EOL;
    }
    public function Push()
    {
        echo &#39;推送阿里云通知！&#39;, PHP_EOL;
    }
}

class JiGuangService
{
    public function Send()
    {
        echo &#39;发送极光短信！&#39;, PHP_EOL;
    }
    public function Push()
    {
        echo &#39;推送极光通知！&#39;, PHP_EOL;
    }
}

$send = new Send();
$send->PushAndSendAliYun();
$send->PushAndSendJiGuang();

Description

It’s still a familiar recipe and a familiar taste . Here, you can imagine that our third-party service classes are all older interfaces, or they are already very complex interfaces. At this time, using the appearance pattern can cooperate with the new system and reduce complexity
• But it should be noted that the appearance class itself may become a source of complexity, but fortunately we can comply with a single responsibility The principle is that one appearance class can do one thing

Original address: https://juejin.cn/post/6844903988085653518

Author: Hardcore Project Manager

Recommended study: "

PHP Video Tutorial"

The above is the detailed content of Learn about the facade pattern in PHP in one article. For more information, please follow other related articles on the PHP Chinese website!