Advanced object-oriented design patterns in PHP: Mediator pattern usage examples

What is the intermediary pattern?

The mediator pattern is used to develop an object that can transmit or mediate modifications to a collection of similar objects without directly interacting with each other. Generally, when dealing with uncoupled objects with similar properties that need to be kept synchronized, the best approach is the mediator pattern. A design pattern that is not particularly commonly used in PHP.

Mode motivation:

1. In the design scheme where users chat directly with users, there is a strong correlation between user objects, which will cause the system to appear as follows Problem:

The system structure is complex: there are a large number of interrelationships and calls between objects. If one object changes, all other objects associated with the object need to be tracked and processed appropriately.

　2. Poor object reusability: Since an object has a strong relationship with other objects, without the support of other objects, it is difficult for an object to be reused by another system or module. These objects behave more like An indivisible whole with confusing responsibilities.

　3. System scalability is low: adding a new object requires adding references to the original related objects, and adding new reference relationships also requires adjusting the original objects. The system coupling is very high, and object operations are very inflexible. , poor scalability.

　4. In the object-oriented software design and development process, according to the "single responsibility principle", we should try to refine the object so that it is only responsible for or presents a single responsibility.

　5. For a module, it may be composed of many objects, and there may be mutual references between these objects. In order to reduce the complex reference relationship between objects and make it a loosely coupled system, We need to use the mediator pattern, and this is the pattern motivation of the mediator pattern.

UML

This UML diagram illustrates a class design using the mediator design pattern

The following is Explanation of the above picture:

1. There are two similar classes in the picture: MyObjectA and MyObjectB. The appearance of both classes is the same. Their difference may be the identifier represented by the private variable identifier. Furthermore, all functions are similar.

2. During object creation, the instance of MyObjectMediator is stored internally. Subsequently, if a change is requested for an object by calling the public method cahngeIdentifier(), the parameter newID can be applied to the object by updating the private identifier string. Next, call the protected method notifyMediator() to apply mediation to other objects.

3.MyObjectMediator is the center of a series of objects. These objects are stored in the array MyObjectsToMediate. MyObjectsToMediate will execute the myObjectChanged() method when it receives the notification, which is responsible for parsing the array MyObjectsToMediate and applying the specified changes to all other objects.

Use an intermediary object to encapsulate a series of object interactions so that each object does not need to explicitly reference each other, thereby loosening the coupling, and the interaction between them can be changed independently

_mediator = $mediator;
}
public function send($message)
{
$this->_mediator->send($message,$this);
}
abstract public function notify($message);
}
class ConcreteMediator extends Mediator
{
private $_colleague1 = null;
private $_colleague2 = null;
public function send($message,$colleague)
{
if($colleague == $this->_colleague1)
{
$this->_colleague1->notify($message);
} else {
$this->_colleague2->notify($message);
}
}
public function set($colleague1,$colleague2)
{
$this->_colleague1 = $colleague1;
$this->_colleague2 = $colleague2;
}
}
class Colleague1 extends Colleague
{
public function notify($message)
{
echo "Colleague1 Message is :".$message."
";
}
}
class Colleague2 extends Colleague
{
public function notify($message)
{
echo "Colleague2 Message is :".$message."
";
}
}
//
$objMediator = new ConcreteMediator();
$objC1 = new Colleague1($objMediator);
$objC2 = new Colleague2($objMediator);
$objMediator->set($objC1,$objC2);
$objC1->send("to c2 from c1");
$objC2->send("to c1 from c2");

The above is the detailed content of Advanced object-oriented design patterns in PHP: Mediator pattern usage examples. For more information, please follow other related articles on the PHP Chinese website!