中介者模式

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

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

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

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

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

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

类图:

Mediator 中介者接口 

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

Colleague 成员类的接口

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

代码：

中介者接口

1. public abstract class Mediator {
2. 
3. //放入需要联系的成员类
4. protected ConcreteColleague1 colleague1;
5. protected ConcreteColleague2 colleague2;
6. 
7. //成员类的get set
8. public ConcreteColleague1 getColleague1() {
9. return colleague1;
10.     }
11. 
12. public void setColleague1(ConcreteColleague1 colleague1) {
13. this.colleague1 = colleague1;
14.     }
15. 
16. public ConcreteColleague2 getColleague2() {
17. return colleague2;
18.     }
19. 
20. public void setColleague2(ConcreteColleague2 colleague2) {
21. this.colleague2 = colleague2;
22.     }
23. 
24. //通过这些方法去调用成员类
25. public abstract void sendMessageToColleague1(String message);
26. //
27. public abstract void sendMessageToColleague2(String message);
28. 
29. 
30. }      

中介者实现类

1. public class ConcreteMediator extends  Mediator{  
2. 
3. //与1成员建立连接
4. @Override
5.     public void sendMessageToColleague1(String message) {
6. super.colleague1.receiveMessage(message);
7.     }
8. 
9. //与2成员建立连接
10. @Override
11.     public void sendMessageToColleague2(String message) {
12. super.colleague2.receiveMessage(message);
13.     }
14. }      

1. public abstract class Colleague {
2. protected Mediator mediator;
3. 
4. public Colleague(Mediator mediator) {
5. this.mediator = mediator;
6.     }
7. }      

ConcreteColleague 成员类实现      

1. public class ConcreteColleague1 extends Colleague {
2. 
3. 
4. public ConcreteColleague1(Mediator mediator) {
5. super(mediator);
6.     }
7. 
8. 
9. public void selfMethod(){
10. System.out.println("成员1：我是成员1");
11.     }
12. 
13. public void receiveMessage(String message){
14. System.out.println("成员1收到了 "+message);
15.     }
16. 
17. //成员1和成员2进行沟通1，但是都调用中介者类
18. public void sendMessageToColleague2(String message){ 
19. super.mediator.sendMessageToColleague2(message);
20.     }
21. 
22. }      

1. public class ConcreteColleague2 extends Colleague {
2. 
3. //放入中介者类 以便调用
4. public ConcreteColleague2(Mediator mediator) {
5. super(mediator);
6.     }
7. 
8. 
9. public void selfMethod(){
10. System.out.println("成员2：我是成员1");
11.     }
12. 
13. public void receiveMessage(String message){
14. System.out.println("成员2收到了 "+message);
15.     }
16. 
17. //成员1和成员2进行沟通1，但是都调用中介者类
18. public void sendMessageToColleague1(String message){ 
19. super.mediator.sendMessageToColleague1(message);
20.     }
21. 
22. }      

调用

1. public class Client {
2. 
3. public static void main(String[] args) {
4. Mediator mediator=new ConcreteMediator();
5. 
6. ConcreteColleague1 colleague1=new ConcreteColleague1(mediator);
7. ConcreteColleague2 colleague2=new ConcreteColleague2(mediator);
8. 
9. 
10.         mediator.setColleague1(colleague1);
11.         mediator.setColleague2(colleague2);
12. 
13. 
14.         colleague1.selfMethod();
15.         colleague1.sendMessageToColleague2("来自成员1");
16. 
17.         colleague2.selfMethod();
18.         colleague2.sendMessageToColleague1("来自成员2");
19. 
20. 
21.     }
22. 
23. }      

附上两个经典的代码场景

https://blog.csdn.net/wwwdc1012/article/details/83389158 https://www.2cto.com/kf/201805/750094.html