中介模式和创作 [英] Mediator pattern and creation

问题描述

我有几个小部件涉及到需要彼此交互的演示文稿，但交互已经变得足够复杂，以保证一个新的对象来处理这些交互。

在尝试通过中介者作为该对象时，我很困惑，因为如何有效地构建参与者。调解员必须知道这些小部件，小部件必须知道调解员。

使用下面的玩具类可以让我看到构造函数的外观以及通常会以什么顺序创建？

干杯，

Berryl

  class WidgetOne {
 Mediator _mediator; 
} 
 
 class WidgetTwo {
 Mediator _mediator; 
} 
 
 class Mediator {
 WidgetOne _widgetOne; 
 WidgetTwo _widgetTwo; 
} 
  

解决方案

这真的取决于一个数字在其他情况下，但我可能会这样做：

  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）; 
  

当然，如果没有其他需要知道的小部件，那么我会摆脱setter只需这样：

  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 
} 
} 
  

其他几个简短的简要形式：

  //工厂：
 
 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（我）; 
 
 
 
 //集中式模型（工厂变量）
 class Mediator {
 W1 w1; 
 
 static Mediator getInstance（）{return inst; } //参见Singleton 
 
 void registerW1（W1 w）{w1 = w; w.setMediator（this）;} 
} 
  

I have several "widgets" involved in a presentation that need to interact with each other, but the interactions have gotten complex enough to warrant a new object to handle the interactions.

In trying to work through a Mediator as that object, I am confused as how to construct the participants effectively. The mediator has to know about the widgets, and the widgets have to know about the mediator.

Using the toy classes below can someone show me how the constructors would look and in what order they would typically be created?

Cheers,
Berryl

class WidgetOne {       
    Mediator _mediator;
} 

class WidgetTwo {       
    Mediator _mediator;
} 

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;               
}

解决方案

That really depends on a number of other circumstances, but I would probably do this:

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);

Of course, if nothing else needs to know about the widgets, then I would get rid of the setters and just have this:

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
    }
}

A couple of others in brief... brief form:

// 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);}
}

这篇关于中介模式和创作的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！