PHP design pattern-mediation pattern

We will introduce the mediation mode to you. the purpose of this mode is to encapsulate the interaction between a group of objects to prevent mutual interference between objects. the Mediator is on the colleaguate object) serves as an intermediate aggregation point. Colleague objects should be loosely coupled to avoid introducing the mediation mode. the purpose of this mode is to encapsulate the interaction between a group of objects and prevent mutual interference between objects, mediator acts as an intermediate aggregation point between colleagues and objects.

Colleagues' objects should be loosely coupled to avoid an object pointing to another object explicitly. In the mediation by mode, when the relationship and dependency between objects conflict, we can use the mediation to coordinate the workflow between the coupled objects. the dependency can be established from a colleague to the mediation or from the mediation to the colleague, the dependency in both directions can be interrupted using abstractcolleags or AbstractMediator.

498) this. style. width = 498; "border =" 0 "/>
Target of mediators and colleagues

Objects are not isolated and must collaborate with each other to complete the task. Although the mediation mode can restrict the interaction between objects, it will become very difficult to compile the aggregated classes if abuse occurs. For example, the service in Domain-Driven Design is the mediation between entities. For another PHP-related example, the Zend_Form decoration and filtering functions can be regarded as a simple mediation between Zend_Form_Decorator and Zend_Filter instances. they all use the Zend_Validate object for verification.

When the mediator must listen to the events of a colleague object, it is usually implemented as an Observer to generate a blackboard object, written by some colleagues, and read by others. Events from colleagues are pushed to the mediation staff and then forwarded to other subscribe colleagues. colleagues do not need to know each other. This architecture is successfully used for the Dojo JavaScript library released with the Zend Framework. Another advantage of this mode is that the changes of objects are included in the calculation method. you can configure different mediators to achieve this goal, but instantiating the objects will be a loose operation, the relationships between containers and factories are scattered. Participants:

◆ Collegou: it focuses on its responsibilities. it only communicates with one Mediator or AbstractMediator.

◆ Mediator: works with multiple Colleagues.

◆ AbstractMediator and AbstractColleague: an optional interface for real decoupling of these roles. There may be more than one role AbstractColleague.

The following code implements a form input filtering process, similar to the Zend_Form_Element function.

 
 

  
  
  
  
  
/** 
  
  
 * AbstractColleague. 
  
  
 */ 
  
  
interface Filter 
  
  
{ 
  
  
 public function filter($value); 
  
  
} 
  
  
 
  
  
/** 
  
  
 * Colleague. We decide in the implementation phase 
  
  
 * that Colleagues should not know the next Colleague 
  
  
 * in the chain, resorting to a Mediator to link them together. 
  
  
 * This choice succesfully avoids a base abstract class 
  
  
 * for Filters. 
  
  
 * Remember that this is an example: it is not only 
  
  
 * Chain of Responsibility that can be alternatively implemented 
  
  
 * as a Mediator. 
  
  
 */ 
  
  
class TrimFilter implements Filter 
  
  
{ 
  
  
 public function filter($value) 
  
  
 { 
  
  
 return trim($value); 
  
  
 } 
  
  
} 
 
 

 
 

  
  
/** 
  
  
 * Colleague. 
  
  
 */ 
  
  
class NullFilter implements Filter 
  
  
{ 
  
  
 public function filter($value) 
  
  
 { 
  
  
 return $value ? $value : ''; 
  
  
 } 
  
  
} 
  
  
 
  
  
/** 
  
  
 * Colleague. 
  
  
 */ 
  
  
class HtmlEntitiesFilter implements Filter 
  
  
{ 
  
  
 public function filter($value) 
  
  
 { 
  
  
 return htmlentities($value); 
  
  
 } 
  
  
} 
 
 

 
 

  
  
/**
  
  
* The Mediator. We avoid referencing it from ConcreteColleagues
  
  
* And so the need for an interface. We leave the implementation
  
  
* Of a bidirectional channel for the Observer pattern's example.
  
  
* This class responsibility is to store the value and coordinate
  
  
* Filters computation when they have to be applied to the value.
  
  
* Filtering responsibilities are obviusly a concern
  
  
* The Colleagues, which are Filter implementations.
  
  
*/
  
  
Class InputElement
  
  
{
  
  
Protected: We will introduce the mediation mode. the purpose of this mode is to encapsulate the interaction between a group of objects to prevent mutual interference between objects. the Mediator is on the colleaguate object) serves as an intermediate aggregation point.
Colleagues' objects should be loosely coupled to avoid an object pointing to another object explicitly. In the mediation by mode, when the relationship and dependency between objects conflict, we can use the mediation to coordinate the workflow between the coupled objects. the dependency can be established from a colleague to the mediation or from the mediation to the colleague, the dependency in both directions can be interrupted using abstractcolleags or AbstractMediator.
498) this. style. width = 498; "border =" 0 "/>
Target of mediators and colleagues
Objects are not isolated and must collaborate with each other to complete the task. Although the mediation mode can restrict the interaction between objects, it will become very difficult to compile the aggregated classes if abuse occurs. For example, the service in Domain-Driven Design is the mediation between entities. For another PHP-related example, the Zend_Form decoration and filtering functions can be regarded as a simple mediation between Zend_Form_Decorator and Zend_Filter instances. they all use the Zend_Validate object for verification.
When the mediator must listen to the events of a colleague object, it is usually implemented as an Observer to generate a blackboard object, written by some colleagues, and read by others. Events from colleagues are pushed to the mediation staff and then forwarded to other subscribe colleagues. colleagues do not need to know each other. This architecture is successfully used for the Dojo JavaScript library released with the Zend Framework. Another advantage of this mode is that the changes of objects are included in the calculation method. you can configure different mediators to achieve this goal, but instantiating the objects will be a loose operation, the relationships between containers and factories are scattered. Participants:
◆ Collegou: it focuses on its responsibilities. it only communicates with one Mediator or AbstractMediator.
◆ Mediator: works with multiple Colleagues.
◆ AbstractMediator and AbstractColleague: an optional interface for real decoupling of these roles. There may be more than one role AbstractColleague.
The following code implements a form input filtering process, similar to the Zend_Form_Element function.
     
     

      
      
  
      
      
/** 
      
      
 * AbstractColleague. 
      
      
 */ 
      
      
interface Filter 
      
      
{ 
      
      
 public function filter($value); 
      
      
} 
      
      
 
      
      
/** 
      
      
 * Colleague. We decide in the implementation phase 
      
      
 * that Colleagues should not know the next Colleague 
      
      
 * in the chain, resorting to a Mediator to link them together. 
      
      
 * This choice succesfully avoids a base abstract class 
      
      
 * for Filters. 
      
      
 * Remember that this is an example: it is not only 
      
      
 * Chain of Responsibility that can be alternatively implemented 
      
      
 * as a Mediator. 
      
      
 */ 
      
      
class TrimFilter implements Filter 
      
      
{ 
      
      
 public function filter($value) 
      
      
 { 
      
      
 return trim($value); 
      
      
 } 
      
      
} 
     
     
     
     

      
      
/** 
      
      
 * Colleague. 
      
      
 */ 
      
      
class NullFilter implements Filter 
      
      
{ 
      
      
 public function filter($value) 
      
      
 { 
      
      
 return $value ? $value : ''; 
      
      
 } 
      
      
} 
      
      
 
      
      
/** 
      
      
 * Colleague. 
      
      
 */ 
      
      
class HtmlEntitiesFilter implements Filter 
      
      
{ 
      
      
 public function filter($value) 
      
      
 { 
      
      
 return htmlentities($value); 
      
      
 } 
      
      
} 
     
     
___FCKpd___2
Original article name: Practical Php Patterns: Mediator author: Giorgio
Source: http://giorgiosironi.blogspot.com/search/label/practical%20php%20patterns
Filters;
  
  
Protected: We will introduce the mediation mode. the purpose of this mode is to encapsulate the interaction between a group of objects to prevent mutual interference between objects. the Mediator is on the colleaguate object) serves as an intermediate aggregation point.
Colleagues' objects should be loosely coupled to avoid an object pointing to another object explicitly. In the mediation by mode, when the relationship and dependency between objects conflict, we can use the mediation to coordinate the workflow between the coupled objects. the dependency can be established from a colleague to the mediation or from the mediation to the colleague, the dependency in both directions can be interrupted using abstractcolleags or AbstractMediator.
498) this. style. width = 498; "border =" 0 "/>
Target of mediators and colleagues
Objects are not isolated and must collaborate with each other to complete the task. Although the mediation mode can restrict the interaction between objects, it will become very difficult to compile the aggregated classes if abuse occurs. For example, the service in Domain-Driven Design is the mediation between entities. For another PHP-related example, the Zend_Form decoration and filtering functions can be regarded as a simple mediation between Zend_Form_Decorator and Zend_Filter instances. they all use the Zend_Validate object for verification.
When the mediator must listen to the events of a colleague object, it is usually implemented as an Observer to generate a blackboard object, written by some colleagues, and read by others. Events from colleagues are pushed to the mediation staff and then forwarded to other subscribe colleagues. colleagues do not need to know each other. This architecture is successfully used for the Dojo JavaScript library released with the Zend Framework. Another advantage of this mode is that the changes of objects are included in the calculation method. you can configure different mediators to achieve this goal, but instantiating the objects will be a loose operation, the relationships between containers and factories are scattered. Participants:
◆ Collegou: it focuses on its responsibilities. it only communicates with one Mediator or AbstractMediator.
◆ Mediator: works with multiple Colleagues.
◆ AbstractMediator and AbstractColleague: an optional interface for real decoupling of these roles. There may be more than one role AbstractColleague.
The following code implements a form input filtering process, similar to the Zend_Form_Element function.
      
      

       
       
  
       
       
/** 
       
       
 * AbstractColleague. 
       
       
 */ 
       
       
interface Filter 
       
       
{ 
       
       
 public function filter($value); 
       
       
} 
       
       
 
       
       
/** 
       
       
 * Colleague. We decide in the implementation phase 
       
       
 * that Colleagues should not know the next Colleague 
       
       
 * in the chain, resorting to a Mediator to link them together. 
       
       
 * This choice succesfully avoids a base abstract class 
       
       
 * for Filters. 
       
       
 * Remember that this is an example: it is not only 
       
       
 * Chain of Responsibility that can be alternatively implemented 
       
       
 * as a Mediator. 
       
       
 */ 
       
       
class TrimFilter implements Filter 
       
       
{ 
       
       
 public function filter($value) 
       
       
 { 
       
       
 return trim($value); 
       
       
 } 
       
       
} 
      
      
      
      

       
       
/** 
       
       
 * Colleague. 
       
       
 */ 
       
       
class NullFilter implements Filter 
       
       
{ 
       
       
 public function filter($value) 
       
       
 { 
       
       
 return $value ? $value : ''; 
       
       
 } 
       
       
} 
       
       
 
       
       
/** 
       
       
 * Colleague. 
       
       
 */ 
       
       
class HtmlEntitiesFilter implements Filter 
       
       
{ 
       
       
 public function filter($value) 
       
       
 { 
       
       
 return htmlentities($value); 
       
       
 } 
       
       
} 
      
      
___FCKpd___2
Original article name: Practical Php Patterns: Mediator author: Giorgio
Source: http://giorgiosironi.blogspot.com/search/label/practical%20php%20patterns
Value;
  
  
 
  
  
Public function addFilter (Filter $ filter)
  
  
{
  
  
$ This->_ Filters [] = $ filter;
  
  
Return $ this;
  
  
}
  
  
 
  
  
Public function setValue ($ value)
  
  
{
  
  
$ This->_ Value = $ this->_ Filter ($ value );
  
  
}
  
  
 
  
  
Protected function _ filter ($ value)
  
  
{
  
  
Foreach ($ this->_ Filters as $ filter ){
  
  
$ Value = $ filter->Filter ($ value );
  
  
}
  
  
Return $ value;
  
  
}
  
  
 
  
  
Public function getValue ()
  
  
{
  
  
Return $ this->_ Value;
  
  
}
  
  
}
  
  
 
  
  
$ Input = new InputElement ();
  
  
$ Input->AddFilter (new NullFilter ())
  
  
->AddFilter (new TrimFilter ())
  
  
->AddFilter (new HtmlEntitiesFilter ());
  
  
$ Input->SetValue ('you should use
-
Tags for your headings .');

  
  
Echo $ input->GetValue (), "\ n ";
 
 

Original article name: Practical Php Patterns: Mediator author: Giorgio

Source: http://giorgiosironi.blogspot.com/search/label/practical%20php%20patterns