A brief discussion on the bridge mode in PHP

In the previous article "Let’s talk about the memo mode in PHP" we introduced the memo mode in PHP. The following article will take you to understand the bridge mode in PHP design pattern.

Bridge mode, in the programming world, is actually synonymous with combination/aggregation. Why do you say that? We who are familiar with object-oriented all know the benefits of inheritance. Subclasses can share many attributes and functions of the parent class. However, inheritance also brings a problem, that is, serious coupling. Modifications of the parent class will have an impact on subclasses to some extent. Even a modification of a method or attribute may require all subclasses to modify it. This violates the principle of open encapsulation. Bridging is to solve this problem. It emphasizes the use of combination/aggregation to share some available methods. I believe you must have thought of traits in PHP. If you have used this feature at work, then you have already used bridge mode!

Gof class diagram and explanation

GoF definition: Separate the abstract part from its implementation part so that they can change independently.

GoF class diagram

##Code implementation

interface Implementor
{
    public function OperationImp();
}

class ConcreteImplementorA implements Implementor
{
    public function OperationImp()
    {
        echo '具体实现A', PHP_EOL;
    }
}

class ConcreteImplementorB implements Implementor
{
    public function OperationImp()
    {
        echo '具体实现B', PHP_EOL;
    }
}

Let's first define the implementation interfaces and their specific implementations, which are the functions that are actually to be performed. It's like Adaptee in the adapter pattern.

abstract class Abstraction
{
    protected $imp;
    public function SetImplementor(Implementor $imp)
    {
        $this->imp = $imp;
    }
    abstract public function Operation();
}

class RefinedAbstraction extends Abstraction
{
    public function Operation()
    {
        $this->imp->OperationImp();
    }
}

Define the interface of the abstract class and maintain a reference to the implementation. In the implementation method of a specific abstract class, we directly call the real operation method that implements the interface. Similar to Adapter in adapter.

$impA = new ConcreteImplementorA();
$impB = new ConcreteImplementorB();

$ra = new RefinedAbstraction();

$ra->SetImplementor($impA);
$ra->Operation();

$ra->SetImplementor($impB);
$ra->Operation();

When called by the client, our abstract class can use different implementation classes to make the operation method polymorphic.

In the source code explanation, we will find that this mode is very similar to the adapter mode. However, the purpose of an adapter is to help two unrelated classes work together to achieve intermediate conversion work. The purpose of bridging is to decouple the inheritance of method behavior, easily add, modify, and dynamically call behaviors, so that the abstract interface and implementation parts can be changed independently
so that the abstract interface and implementation parts can be changed independently This means that as long as the reference to the implementation interface is maintained, the specific implementation class of our implementation interface can be a completely different class with different functions and can be changed arbitrarily. Let the implementation decide what it is.
Advantages of the bridge mode: sharing interfaces and their implementation parts, improving scalability, and making implementation details transparent to customers
The main problem solved by the bridge mode is caused by the continuous growth of inheritance Tight coupling problem
Composition and aggregation: Aggregation is a weak relationship, A can contain B, but B is not part of A; combination is a strong relationship, A contains B, B is also a part of A, the relationship between the whole and the part

Our mobile phones have different models, and each model produces roughly the same but different accessories. For example, X1 mobile phone case, film, and earphones; X2 mobile phone case, film, and earphones, etc. Due to cost issues, we will not produce completely different accessories for each model of mobile phone. Instead, try to use external universal accessories (Implementor), so that each model of mobile phone (Abstraction) can be combined (Bridge) and sold to consumers. In this way, our mobile phone brand will not run out of financing and close down too early. It seems that there are really many correlations between running a business and learning design patterns! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/18.bridge/source/bridge.php

Example

Our SMS sending can also be implemented using bridging. Suppose we have a lot of text message templates, and then use different text message providers to send text messages. At this time, we can use the bridge mode to form various combinations.

SMS sending class diagram

Full source code: https://github.com/zhangyue0503/designpatterns-php /blob/master/18.bridge/source/bridge-message.php

<?php

interface MessageTemplate
{
    public function GetTemplate();
}

class LoginMessage implements MessageTemplate
{
    public function GetTemplate()
    {
        echo &#39;您的登录验证码是【AAA】，请不要泄露给他人【XXX公司】！&#39;, PHP_EOL;
    }
}
class RegisterMessage implements MessageTemplate
{
    public function GetTemplate()
    {
        echo &#39;您的注册验证码是【BBB】，请不要泄露给他人【XXX公司】！&#39;, PHP_EOL;
    }
}
class FindPasswordMessage implements MessageTemplate
{
    public function GetTemplate()
    {
        echo &#39;您的找回密码验证码是【CCC】，请不要泄露给他人【XXX公司】！&#39;, PHP_EOL;
    }
}

abstract class MessageService
{
    protected $template;
    public function SetTemplate($template)
    {
        $this->template = $template;
    }
    abstract public function Send();
}

class AliYunService extends MessageService
{
    public function Send()
    {
        echo &#39;阿里云开始发送短信：&#39;;
        $this->template->GetTemplate();
    }
}

class JiGuangService extends MessageService
{
    public function Send()
    {
        echo &#39;极光开始发送短信：&#39;;
        $this->template->GetTemplate();
    }
}

// 三个短信模板
$loginTemplate = new LoginMessage();
$registerTemplate = new RegisterMessage();
$findPwTemplate = new FindPasswordMessage();

// 两个短信服务商
$aliYun = new AliYunService();
$jg = new JiGuangService();

// 随意组合
// 极光发注册短信
$jg->SetTemplate($registerTemplate);
$jg->Send();

// 阿里云发登录短信
$aliYun->SetTemplate($loginTemplate);
$aliYun->Send();

// 阿里云发找回密码短信
$aliYun->SetTemplate($findPwTemplate);
$aliYun->Send();

// 极光发登录短信
$jg->SetTemplate($loginTemplate);
$jg->Send();

// ......

Explanation

This is an aggregation mode. Templates are not part of SMS sending. We can send them directly without using templates. They have no strong relationship.
• The SMS sending method does not need to be changed. You only need to pass in different SMS templates to implement various templates. Quickly send
• When you are not sure whether it must be an is-a relationship, it is more recommended to use a combination/aggregation design method such as bridge mode. If it is determined that the current class relationship is is-a, Then don’t hesitate to use inheritance

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

Author: Hardcore Project Manager

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of A brief discussion on the bridge mode in PHP. For more information, please follow other related articles on the PHP Chinese website!