PHP Closure Principle (OCP) use case analysis

This time I will bring you an analysis of PHP Closure Principle (OCP) use cases, what are the precautions when using PHP Closure Principle (OCP), the following is a practical case, let's take a look.

1. What is "open-closed"

As the scale of software systems continues to increase, the maintenance and modification of software systems The complexity continues to increase. This dilemma prompted French engineering academician Bertrand Meyer to propose the "Open-Close Principle (OCP)" principle in 1998. The basic idea of ​​this principle is:

Open ( Open for extension) The behavior of the module must be open and support extension, rather than rigid.

Close (Closed for modification) When extending the functionality of a module, it should not affect or affect existing modules on a large scale.

In other words, developers are required to expand the software functions of the application system without modifying the existing code (source code or binary code) in the system. To sum it up in one sentence: a module should be developed in terms of extensibility and closed in terms of changeability.

From life, the easiest example to think of is the computer. We can easily expand the functions of the computer and only need to connect different devices through the interface.

Open-closed can improve the scalability and maintainability of the system, but this is also relative. It is impossible for a computer to be completely open. Some equipment and functions must remain stable to reduce maintenance difficulties. To implement a new feature, you must upgrade your hardware or change to a higher-performance computer. Take the Multimedia playback software in the computer as an example. As a player, it should have some basic and universal functions, such as opening multimedia files, stopping playback, fast forwarding, volume adjustment, etc. But no matter what player it is, no matter what playback platform it is on, players designed according to this principle should have a unified style and operating habits. No matter which one is used, the author should be able to get started quickly.

Taking the player as an example, first define an abstract interface, the code is as follows.

interface process
{
  public function process();
}

Then, extend this interface to implement decoding and output functions, as shown below

class playerencode implements process
{
  public function process()
  {
    echo "encode",PHP_EOL;
  }
}
class playeroutput implements process
{
  public function process()
  {
    echo "ouput",PHP_EOL;
  }
}

For various functions of the player, this is open, as long as you follow the agreement and implement With the process interface, you can add new functional modules to the player. Only the decoding and output modules are implemented here, and more new modules can be added according to needs.

Next define the player's thread high scheduling manager. Once the player receives a notification (it can be an external click behavior or an internal notify behavior), it will call back the actual thread processing. The code is as follows

class playProcess
{
  private $message = null;
  public function construct() {}
  public function callback(event $event)
  {
    $this->message = $event->click();
    if($this->message instanceof process)
    {
      $this->message->process();
    }
  }
}

The specific product has come out. Here we define an MP4 class. This class is relatively closed and defines the event processing logic. The code is as follows

class mp4
{
  public function work()
  {
    $playProcess = new playProcess();
    $playProcess->callback(new event('encode'));
    $playProcess->callback(new event('output'));
  }
}

Finally, it is the processing of event sorting. Class, this class is responsible for sorting events and judging user or internal behavior to generate the correct "thread" for scheduling by the player's built-in purebred manager. The code is as follows

class event
{
  private $m;
  public function construct($me)
  {
    $this->m = $me;
  }
  public function click()
  {
    switch($this->m)
    {
      case 'encode';
        return new playerencode();
        break;
      case 'output':
        return new playeroutput();
        break;
    }
  }
}

Finally run Code

$mp4 = new mp4;
$mp4->work();

The running result is as follows:

encode ouput

2. How to comply with the open-closed principle

The core of realizing open-closed is to program abstractly rather than concretely, because abstraction is relatively stable. By letting a class depend on a fixed abstraction, such modifications are closed; through Object-oriented inheritance and the polymorphic mechanism, inheritance of the abstract body can be achieved, and the inherent behavior can be changed by overriding its methods. , implements new extension methods, so it is open to extensions.

1) Apply the ideas of "abstraction" and "encapsulation" in design.

On the one hand, it is necessary to find various possible "variable factors" in the software system and encapsulate them.

On the other hand, a variable factor should not be scattered across multiple different code modules, but should be encapsulated into an object.

2) Apply interface-oriented programming in the implementation of system function programming.

When the requirements change, a new implementation class of this interface can be provided to adapt to the change.

Interface-oriented programming requires functional classes to implement interfaces and objects to be declared as interface types. In Design Mode, the decoration mode clearly uses OCP.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Detailed explanation of PHP Richter replacement case

Bootstrap PHP detailed explanation of the steps to implement multiple image uploads

The above is the detailed content of PHP Closure Principle (OCP) use case analysis. For more information, please follow other related articles on the PHP Chinese website!