Modèle et création de médiateur

Question

J'ai plusieurs "widgets" impliqués dans une présentation qui ont besoin d'interagir entre eux, mais les interactions sont devenues suffisamment complexes pour justifier un nouvel objet pour gérer les interactions.

En essayant de travailler à travers un médiateur comme cet objet, je suis confus comme comment construire les participants efficacement. Le médiateur doit connaître les widgets, et les widgets doivent connaître le médiateur. En utilisant les classes de jouets ci-dessous, quelqu'un peut-il me montrer à quoi ressembleront les constructeurs et dans quel ordre ils seront typiquement créés?

Cheers,
Berryl

class WidgetOne {  
    Mediator _mediator; 
} 

class WidgetTwo {  
    Mediator _mediator; 
} 

class Mediator {  
    WidgetOne _widgetOne; 
    WidgetTwo _widgetTwo;    
} 

Answer 1

Cela dépend vraiment sur un certain nombre d'autres circonstances, mais je serais probablement faire:

class Mediator {  
    WidgetOne _widgetOne; 
    WidgetTwo _widgetTwo; 

    void setWidgetOne(WidgetOne one){_widgetOne = one;} 
    void setWidgetTwo(WidgetTwo one){_widgetTwo = one;}    
} 

class WidgetOne { 
    Mediator me 
    void WidgetOne(Mediator me){ 
     this.me = me 
     me.setWidgetOne(this); 
    } 
} 

class WidgetTwo { 
    Mediator me 
    void WidgetTwo(Mediator me){ 
     this.me = me 
     me.setWidgetTwo(this); 
    } 
} 

Mediator me = new Mediator(); 
WidgetOne one = new WidgetOne(me); 
WidgetTwo two = new WidgetTwo(me); 

Bien sûr, si rien d'autre a besoin de savoir sur les widgets, je supprimerais des setters et il suffit d'avoir ceci:

class Mediator {  
    WidgetOne _widgetOne; 
    WidgetTwo _widgetTwo; 

    void Mediator(){ 
     _widgetOne = new WidgetOne(this); 
     _widgetTwo = new WidgetTwo(this); 
    }    
} 

class WidgetOne { 
    Mediator me 
    void WidgetOne(Mediator me){ 
     this.me = me 
    } 
} 

class WidgetTwo { 
    Mediator me 
    void WidgetTwo(Mediator me){ 
     this.me = me 
    } 
} 

Un couple d'autres en bref ...forme brève:

// Factory: 

class Mediator {  
    WidgetOne _widgetOne; 
    WidgetTwo _widgetTwo; 

    void Mediator(){ 
     _widgetOne = WidgetFactory.getW1(this); 
     _widgetTwo = WidgetFactory.getW2(this); 
    }    
} 

class W1 { 
    Mediator me 
    void W1(){ 
    } 
    void setMediator(Mediator med){me = med} 
} 

class WidgetFactory { 
    W1 getW1(Mediator me){ W1 w = new W1(); w.setMediator(me); return me} 
} 


// Centralized "model" (variant of factory) 
class Mediator { 
    W1 w1; 

    static Mediator getInstance(){ return inst; }// See Singleton 

    void registerW1(W1 w){w1 = w; w.setMediator(this);} 
} 

Answer 2

vous ne spécifiez pas une langue si je vais le garder aussi générique que possible.

abstract class Participant { 
    public string Notify(string message); 
} 

---

class WidgetOne extends Participant {  
    Mediator _mediator; 
    public WidgetOne(Mediator theMediator){ 
     _mediator = theMediator; 
    } 
    public string Notify(string message){ 
     #do whatever 
    } 
    public string Talk(string message){ 
     return _mediator.Talk(message, this); 
    } 
} 

---

class WidgetTwo extends Participant {  
    Mediator _mediator; 
    public WidgetOne(Mediator theMediator){ 
     _mediator = theMediator; 
    } 
    public string Notify(string message){ 
     #do whatever 
    } 
    public string Talk(string message){ 
     return _mediator.Talk(message, this); 
    } 
} 

---

class Mediator {  
    WidgetOne _widgetOne; 
    WidgetTwo _widgetTwo; 
    public void setWidgetOne(WidgetOne theWidget){ 
     _wiidgetOne = theWidget; 
    } 
    public void setWidgetTwo(WidgetTwo theWidget){ 
     _wiidgetTwo = theWidget; 
    } 
    public string Talk(string message, Participant p){ 
      #make sure you do the correct ==/equals/etc. 
      if(p == _widgetOne){ 
       response = _widgetTwo.Notify(message);  
      }else if (p == _widgetTwo){ 
       response = _widgetOne.Notify(message); 
      } 
      return response; 
    } 

} 

---

class Main { 
    public void run(){ 
     Mediator theMediator = new Mediator(); 
     WidgetOne one = new WidgetOne(theMediator); 
     WidgetTwo two = new WidgetTwo(theMediator); 
     theMediator.setWidgetOne(one); 
     theMediator.setWidgetTwo(two); 
     one.Talk("hi there"); 
    } 
} 

donc à un haut niveau, vous avez 2 participants e à vouloir parler, vous devez configurer une interface commune pour le faire.

1. Nous créons un appel de méthode Notify (message); C'est essentiellement votre canal de communication. Pour régler les choses, nous instancions un médiateur, puis instancions les deux participants en leur passant le médiateur. La dernière étape, insetup, consiste à injecter/définir les participants médiateurs. Dans notre cas, nous utilisons simplement des setters simples. Au moment de communiquer, chaque participant appelle simplement le médiateur, transmet le message et le soi en tant que paramètre.

2. Médiateur voir qui les a contactés, puis appelle le contraire.

S'il vous plaît laissez-moi savoir si vous avez des questions, il y a évidemment de nombreuses variations de ce modèle, alors laissez-moi savoir s'il y a quelque chose que vous aimeriez voir.

Faites attention.