Let's talk about the strategy pattern in PHP

In the previous article "In-depth analysis of the command mode in PHP" we introduced the command mode in PHP. This article will take you to understand the strategy mode in PHP.

Strategy pattern, also known as policy pattern, is a behavioral design pattern.

Gof class diagram and explanation

GoF definition: Define a series of algorithms, encapsulate them one by one, and make them interchangeable. This pattern allows the algorithm to change independently of the client using it.

GoF class diagram

##Code implementation

interface Strategy{
    function AlgorithmInterface();
}

class ConcreteStrategyA implements Strategy{
    function AlgorithmInterface(){
        echo "算法A";
    }
}

class ConcreteStrategyB implements Strategy{
    function AlgorithmInterface(){
        echo "算法B";
    }
}

class ConcreteStrategyC implements Strategy{
    function AlgorithmInterface(){
        echo "算法C";
    }
}

Define algorithm abstraction and implementation.

class Context{
    private $strategy;
    function __construct(Strategy $s){
        $this->strategy = $s;
    }
    function ContextInterface(){
        
        $this->strategy->AlgorithmInterface();
    }
}

Define the execution environment context.

$strategyA = new ConcreteStrategyA();
$context = new Context($strategyA);
$context->ContextInterface();

$strategyB = new ConcreteStrategyB();
$context = new Context($strategyB);
$context->ContextInterface();

$strategyC = new ConcreteStrategyC();
$context = new Context($strategyC);
$context->ContextInterface();

Finally, the appropriate algorithm is called on the client side as needed.

Isn’t it a very simple design pattern. Have you noticed that this model is very similar to the
• Simple Factory we first talked about?
So what are their differences?
• The factory-related mode is a creation mode. As the name suggests, this mode is used to create objects and returns new objects. It is up to the client to decide which method of the object to call.
• The strategy mode attribute behavioral mode encapsulates the function method to be called through the execution context. The client only needs to call the method of the execution context. Okay
• Here, we will find that the client is required to instantiate specific algorithm classes, which seems not as easy to use as
• Simple factory. In this case, why not try to combine the factory How about implementing a pattern together with the strategy pattern?
I leave this implementation to everyone as a thinking question. Tip: Turn the __construct of the Context class into a simple factory method

Since it is so similar to a simple factory, Then we also follow the simple factory method: we are a mobile phone manufacturer (Client) and want to find a factory (ConcreteStrategy) to make a batch of mobile phones. We place an order with this factory to manufacture mobile phones through the channel provider (Context). The channel provider directly Contact the foundry (Strategy) and ship the completed mobile phone directly to me (ContextInterface()). Similarly, I don’t need to care about their specific implementation. I only need to supervise the channel vendors who contact us. Isn’t it very worry-free!

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/10.strategy/source/strategy.php

Example

It still has the SMS function. For specific requirements, please refer to the explanation in the

Simple Factory mode, but this time we use the strategy mode to implement it!

SMS sending class diagram

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

<?php

interface Message
{
    public function send();
}

class BaiduYunMessage implements Message
{
    function send()
    {
        echo &#39;百度云发送信息！&#39;;
    }
}

class AliYunMessage implements Message
{
    public function send()
    {
        echo &#39;阿里云发送信息！&#39;;
    }
}

class JiguangMessage implements Message
{
    public function send()
    {
        echo &#39;极光发送信息！&#39;;
    }
}

class MessageContext
{
    private $message;
    public function __construct(Message $msg)
    {
        $this->message = $msg;
    }
    public function SendMessage()
    {
        $this->message->send();
    }
}

$bdMsg = new BaiduYunMessage();
$msgCtx = new MessageContext($bdMsg);
$msgCtx->SendMessage();

$alMsg = new AliYunMessage();
$msgCtx = new MessageContext($alMsg);
$msgCtx->SendMessage();

$jgMsg = new JiguangMessage();
$msgCtx = new MessageContext($jgMsg);
$msgCtx->SendMessage();

Explanation

Pay attention to compare the following class diagrams, basically and
• Simple FactoryThere is no difference in the pattern
The strategy pattern defines algorithms. Conceptually, these algorithms complete the same work, but the implementation is different, but things are dead, people It is alive. How you want to use it depends on everyone's interest.
• Strategy mode can optimize unit testing, because each algorithm has its own class, so it can be tested individually through its own interface

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

Author: Hardcore Project Manager

Recommended study: "

PHP video tutorial》

The above is the detailed content of Let's talk about the strategy pattern in PHP. For more information, please follow other related articles on the PHP Chinese website!