中介者模式

转载：https://blog.csdn.net/qq_20143059/article/details/102752773

定义：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。。

优点：1.灵活性高，因为将同事类进行了解耦，使其不必有关联性；

           2.降低了类的复杂度，将一对多转化成了一对一；

缺点：1.中介者使用过多，中介者类太过负责，会使系统变得复杂难以维护；

使用场景：多个对象耦合改成只关联一个中介者 如 聊天室   ,房屋中介，淘宝，相当于一个平台连接各使用者  

原理：将原来各个类的相互调用，转换成调用一个中间类，而中间类去调用每个成员对象，这样可以去掉各个成员类的耦合关系，如果要增加或改变成员对象，直接修改中间成员就可以了。

类图:

Mediator 中介者接口 

ConcreteMediator 中介者实现 ，放入具体成员类对象，可以让别的成员类通过自己调用其他成员类

Colleague 成员类的接口

ConcreteColleague 成员类实现 放入中介者类的实例，通过中介者类去调用中介者类里面的成员1(个人理解eureka的感觉 ，将成员都放于服务端，然后需要调用时从服务端取会，如果eureka是通过服务端去调用 那么就完全是中介者模式了)

 

代码：

中介者接口

public abstract class Mediator {
 
    //放入需要联系的成员类
    protected ConcreteColleague1 colleague1;
    protected ConcreteColleague2 colleague2;
 
    //成员类的get set
    public ConcreteColleague1 getColleague1() {
        return colleague1;
    }
 
    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }
 
    public ConcreteColleague2 getColleague2() {
        return colleague2;
    }
 
    public void setColleague2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }
 
    //通过这些方法去调用成员类
    public abstract void sendMessageToColleague1(String message);
    //
    public abstract void sendMessageToColleague2(String message);
 
 
}

 

中介者实现类

public class ConcreteMediator extends  Mediator{  
    
    //与1成员建立连接
    @Override
    public void sendMessageToColleague1(String message) {
        super.colleague1.receiveMessage(message);
    }
 
    //与2成员建立连接
    @Override
    public void sendMessageToColleague2(String message) {
        super.colleague2.receiveMessage(message);
    }
}

Colleague 成员类的接口

public abstract class Colleague {
    protected Mediator mediator;
 
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

ConcreteColleague 成员类实现

public class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }
 
  
    public void selfMethod(){
        System.out.println("成员1：我是成员1");
    }
 
    public void receiveMessage(String message){
        System.out.println("成员1收到了 "+message);
    }
 
    //成员1和成员2进行沟通1，但是都调用中介者类
    public void sendMessageToColleague2(String message){ 
        super.mediator.sendMessageToColleague2(message);
    }
}

public class ConcreteColleague2 extends Colleague {
 
    //放入中介者类 以便调用
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }
 
  
    public void selfMethod(){
        System.out.println("成员2：我是成员1");
    }
 
    public void receiveMessage(String message){
        System.out.println("成员2收到了 "+message);
    }
 
    //成员1和成员2进行沟通1，但是都调用中介者类
    public void sendMessageToColleague1(String message){ 
        super.mediator.sendMessageToColleague1(message);
    }
 
}

调用

public class Client {
 
    public static void main(String[] args) {
        Mediator mediator=new ConcreteMediator();
 
        ConcreteColleague1 colleague1=new ConcreteColleague1(mediator);
        ConcreteColleague2 colleague2=new ConcreteColleague2(mediator);
 
 
        mediator.setColleague1(colleague1);
        mediator.setColleague2(colleague2);
 
 
        colleague1.selfMethod();
        colleague1.sendMessageToColleague2("来自成员1");
 
        colleague2.selfMethod();
        colleague2.sendMessageToColleague1("来自成员2");
 
 
    }
 
}
 

附上两个经典的代码场景

https://blog.csdn.net/wwwdc1012/article/details/83389158

https://www.2cto.com/kf/201805/750094.html