Learn about the flyweight pattern in PHP in one article

In the previous article "Talk about the proxy mode in PHP (forward proxy and reverse proxy)" we introduced the proxy mode in PHP. This article will take you to understand PHP Flyweight pattern in design patterns.

Flyweight mode, the word "flyweight" actually has no special meaning in Chinese, so we have to break it down and look at it. "Xiang" means sharing, and "Yuan" means elements. It seems easy to understand, sharing certain elements.

Gof class diagram and explanation

GoF definition: Use sharing technology to effectively support a large number of fine-grained objects

GoF Class Diagram

Code Implementation

interface Flyweight
{
    public function operation($extrinsicState) : void;
}

class ConcreteFlyweight implements Flyweight
{
    private $intrinsicState = 101;
    function operation($extrinsicState) : void
    {
        echo '共享享元对象' . ($extrinsicState + $this->intrinsicState) . PHP_EOL;
    }
}

class UnsharedConcreteFlyweight implements Flyweight
{
    private $allState = 1000;
    public function operation($extrinsicState) : void
    {
        echo '非共享享元对象：' . ($extrinsicState + $this->allState) . PHP_EOL;
    }
}

Define the shared interface and its Implementation, note that there are two implementations here, ConcreteFlyweigh shares state, UnsharedConcreteFlyweight does not share or its state does not need to be shared

class FlyweightFactory
{
    private $flyweights = [];

    public function getFlyweight($key) : Flyweight
    {
        if (!array_key_exists($key, $this->flyweights)) {
            $this->flyweights[$key] = new ConcreteFlyweight();
        }
        return $this->flyweights[$key];
    }
}

Save the objects that need to be shared and use it as a factory to create the required shares Object, ensuring that there will only be a unique object under the same key value, saving the cost of creating the same object

$factory = new FlyweightFactory();

$extrinsicState = 100;
$flA = $factory->getFlyweight('a');
$flA->operation(--$extrinsicState);

$flB = $factory->getFlyweight('b');
$flB->operation(--$extrinsicState);

$flC = $factory->getFlyweight('c');
$flC->operation(--$extrinsicState);

$flD = new UnsharedConcreteFlyweight();
$flD->operation(--$extrinsicState);

The client's call allows the external state $extrinsicState to be shared between each object

• It’s a bit interesting, the amount of code in this mode is not small
• When an application uses a large number of very similar objects, and most of the objects’ states can be changed to external states, it is very suitable to enjoy Meta pattern
• The factory here stores a list of objects. It does not create objects like a factory method or an abstract factory. Although it is also created here, if the object exists, it will be returned directly, and the list is also The
• flyweight mode that has been maintained has been used in reality. You must have used it to some extent. Various pool technologies are its typical applications: thread pool, connection pool, etc. The other two identical string String types are in === can be used in PHP or Java. This also applies to the flyweight mode. They even have the same memory address. Isn’t this a kind of sharing?
• Regarding the flyweight mode, there is an extremely A classic example, much better than the example I give below, is about the Go board. Go only has two colors: black and white, so two objects are enough. What next? Just change their location status! Friends who are interested can search it!
• The IoC container in Laravel can be regarded as an implementation of the Flyweight pattern. It saves the object in an array and retrieves it through the closure mechanism when needed. There are also some classes that share some state attributes. You can look at the code to understand.

Let’s talk about the fact that technology is based on changing its shell. After all, everyone still likes mobile phones in various colors to show their personality. As I said before, if we had to build a production line for each color, wouldn’t it be a huge investment? Fortunately, our factory (Xiangyuan Factory) only produces the most basic background shell (object) for each model, and then it is colored through a special printing line (state change)! Well, the next Iphone will imitate us sooner or later. It seems that we have to collect all kinds of gold and various rich colors first. Maybe we can also summon the dragon! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/13.flyweights/source/flyweights.php

Example

As expected, we still send text messages. This time the text messages are still sent using Alibaba Cloud and Jiguang SMS, but this time we use flyweight mode. Implementation, in the flyweight factory here we save two different types of objects, let's make them ever-changing through internal and external states!

SMS sending class diagram

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

<?php

interface Message
{
    public function send(User $user);
}

class AliYunMessage implements Message
{
    private $template;
    public function __construct($template)
    {
        $this->template = $template;
    }
    public function send(User $user)
    {
        echo &#39;使用阿里云短信向&#39; . $user->GetName() . &#39;发送：&#39;;
        echo $this->template->GetTemplate(), PHP_EOL;
    }
}

class JiGuangMessage implements Message
{
    private $template;
    public function __construct($template)
    {
        $this->template = $template;
    }
    public function send(User $user)
    {
        echo &#39;使用极光短信向&#39; . $user->GetName() . &#39;发送：&#39;;
        echo $this->template->GetTemplate(), PHP_EOL;
    }
}

class MessageFactory
{
    private $messages = [];
    public function GetMessage(Template $template, $type = &#39;ali&#39;)
    {
        $key = md5($template->GetTemplate() . $type);
        if (!key_exists($key, $this->messages)) {
            if ($type == &#39;ali&#39;) {
                $this->messages[$key] = new AliYunMessage($template);
            } else {
                $this->messages[$key] = new JiGuangMessage($template);
            }
        }
        return $this->messages[$key];
    }

    public function GetMessageCount()
    {
        echo count($this->messages);
    }
}

class User
{
    public $name;
    public function GetName()
    {
        return $this->name;
    }
}

class Template
{
    public $template;
    public function GetTemplate()
    {
        return $this->template;
    }
}

// 内部状态
$t1 = new Template();
$t1->template = &#39;模板1，不错哟！&#39;;

$t2 = new Template();
$t2->template = &#39;模板2，还好啦！&#39;;

// 外部状态
$u1 = new User();
$u1->name = &#39;张三&#39;;

$u2 = new User();
$u2->name = &#39;李四&#39;;

$u3 = new User();
$u3->name = &#39;王五&#39;;

$u4 = new User();
$u4->name = &#39;赵六&#39;;

$u5 = new User();
$u5->name = &#39;田七&#39;;

// 享元工厂
$factory = new MessageFactory();

// 阿里云发送
$m1 = $factory->GetMessage($t1);
$m1->send($u1);

$m2 = $factory->GetMessage($t1);
$m2->send($u2);

echo $factory->GetMessageCount(), PHP_EOL; // 1

$m3 = $factory->GetMessage($t2);
$m3->send($u2);

$m4 = $factory->GetMessage($t2);
$m4->send($u3);

echo $factory->GetMessageCount(), PHP_EOL; // 2

$m5 = $factory->GetMessage($t1);
$m5->send($u4);

$m6 = $factory->GetMessage($t2);
$m6->send($u5);

echo $factory->GetMessageCount(), PHP_EOL; // 2

// 加入极光
$m1 = $factory->GetMessage($t1, &#39;jg&#39;);
$m1->send($u1);

$m2 = $factory->GetMessage($t1);
$m2->send($u2);

echo $factory->GetMessageCount(), PHP_EOL; // 3

$m3 = $factory->GetMessage($t2);
$m3->send($u2);

$m4 = $factory->GetMessage($t2, &#39;jg&#39;);
$m4->send($u3);

echo $factory->GetMessageCount(), PHP_EOL; // 4

$m5 = $factory->GetMessage($t1, &#39;jg&#39;);
$m5->send($u4);

$m6 = $factory->GetMessage($t2, &#39;jg&#39;);
$m6->send($u5);

echo $factory->GetMessageCount(), PHP_EOL; // 4

Description

• The code is a bit much, but in fact there are There are two types of classes that generate four types of objects. Different objects of each class here are distinguished based on templates.
• Such a combination is more convenient. Combine it with other modes to optimize the factory. Well, the future is limitless. You can think about it. !
• Flyweight mode is suitable for scenarios where there are a large number of similar objects in the system and a buffer pool is required. It can reduce memory usage and improve efficiency, but it will increase complexity and require sharing of internal and external states
• The most important feature is that it has a unique identifier. When the object already exists in the memory, the object is returned directly without creating it.

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

Author: Hardcore Project Manager

Recommended learning: "PHP Video Tutorial"

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