计划模式-中介者（调停者）模式（行为型）

中介者模式

中介者模式是一种行为型模式，又叫调停者模式，它是为了办理多个对象之间，多个类之间通信的复杂性，定义一个中介者对象来封装一些列对象之间的交互，使各个对象之间不同持有对方的引用就可以实现交互，降低耦合度；实际开发中，消息队列、服务注册中心、MVC框架中的controller都是中介者；
图解

脚色

   

• 同事对象：定义抽象接口，用于与中介者举行通信，一般是一个发送消息的接口，一个接收消息的接口
  
• 详细同事对象：实现同事对象抽象接口，详细发送、接收消息的逻辑
  
• 中介者：定义要给抽象接口用于与同事对象举行通信
  
• 详细中介者：实现同事之间通信的逻辑
  

  案例1-中介者持有同事对象的引用

中介者

1. public interface Mediator {
2.     void execute();
3. }
4. /** 实现1*/
5. public class AllPersonMediator implements Mediator {
6.     private List<Person> personList;
7.     public AllPersonMediator(List<Person> personList) {
8.         this.personList = personList;
9.     }
10.     @Override
11.     public void execute() {
12.         System.out.println("开家长会啦：");
13.         personList.forEach(item -> System.out.println(item.getName()));
15.     }
16. }
17. /** 实现2*/
18. public class TeacherByTeacherMediator implements Mediator {
19.     private Person p1;
20.     private Person p2;
21.     public TeacherByTeacherMediator(Teacher p1, Teacher p2) {
22.         this.p1 = p1;
23.         this.p2 = p2;
24.     }
25.     @Override
26.     public void execute() {
27.         System.out.println(p1.getName()+"和" + p2.getName() + "两个老师之间的协同的任务");
28.     }
29. }
30. /** 实现3*/
31. public class TeacherAndStudentAndParentsMediator implements Mediator {
32.     private Person p1;
33.     private Person p2;
34.     private Person p3;
36.     public TeacherAndStudentAndParentsMediator(Teacher p1, Student p2, Parents p3) {
37.         this.p1 = p1;
38.         this.p2 = p2;
39.         this.p3 = p3;
40.     }
41.     @Override
42.     public void execute() {
43.         System.out.println("老师"+p1.getName()+"通知家长"+p3.getName() +"学生" +p2.getName()+ "成绩不及格！");
44.     }
45. }

复制代码

同事类：

1. public abstract class Person {
2.    private String name;
4.    public Person(String name) {
5.       this.name = name;
6.    }
8.    public String getName() {
9.       return name;
10.    }
11. }
13. public class Student extends Person {
14.     public Student(String name) {
15.         super(name);
16.     }
17. }
19. public class Student extends Person {
20.     public Student(String name) {
21.         super(name);
22.     }
23. }
25. public class Parents extends Person {
26.     public Parents(String name) {
27.         super(name);
28.     }
29. }

复制代码

测试类：

1. public class Test01 {
2.     public static void main(String[] args) {
3.         Teacher t1 = new Teacher("王老师");
4.         Teacher t2 = new Teacher("刘老师");
5.         Student s1 = new Student("小明");
6.         Parents p1 = new Parents("小明爸爸");
8.         TeacherByStudentMediator teacherByTeacherMediator = new TeacherByStudentMediator(t1, s1);
9.         teacherByTeacherMediator.execute();
11.         TeacherAndStudentAndParentsMediator teacherAndStudentAndParentsMediator = new TeacherAndStudentAndParentsMediator(t1, s1, p1);
12.         teacherAndStudentAndParentsMediator.execute();
14.         List<Person> list = new ArrayList<>();
15.         list.add(t1);
16.         list.add(t2);
17.         list.add(s1);
18.         list.add(p1);
20.         AllPersonMediator allPersonMediator = new AllPersonMediator(list);
21.         allPersonMediator.execute();
22.     }
23. }

复制代码

案例2-同事类持有中介者的引用

中介者

1. public interface SimpleMediator {
2.     Queue<Client> queue = new ConcurrentLinkedQueue<>();
3.     void add(Client c);
4.     Client get();
5. }
6. /** 实现*/
7. public class MessageSimpleMediator implements SimpleMediator{
8.     @Override
9.     public void add(Client c) {
10.         queue.add(c);
11.     }
12.     @Override
13.     public Client get() {
14.         return queue.poll();
15.     }
16. }

复制代码

同事类

1. public abstract class Client<T> {
2.     protected String name;
3.     protected T message;
4.     protected SimpleMediator simpleMediator;
6.     public Client(String name, T message, SimpleMediator simpleMediator) {
7.         this.name = name;
8.         this.message = message;
9.         this.simpleMediator = simpleMediator;
10.     }
12.     public Client(String name, SimpleMediator simpleMediator) {
13.         this.name = name;
14.         this.simpleMediator = simpleMediator;
15.     }
17.     /** 发送消息*/
18.     abstract void sent();
20.     /** 获取消息*/
21.     abstract void get();
23.     public String getName() {
24.         return name;
25.     }
27.     public void setName(String name) {
28.         this.name = name;
29.     }
31.     public T getMessage() {
32.         return message;
33.     }
35.     public void setMessage(T message) {
36.         this.message = message;
37.     }
38. }
40. public class ReceiverClient extends Client<String>{
42.     public ReceiverClient(String name, SimpleMediator simpleMediator) {
43.         super(name, simpleMediator);
44.     }
46.     @Override
47.     void sent() {
48.         new RuntimeException("这是接收消息的客户端");
49.     }
51.     @Override
52.     void get() {
53.         Client client = simpleMediator.get();
54.         System.out.println("发送人：" + client.getName());
55.         System.out.println("发送内容：" + client.getMessage());
56.     }
57. }
59. public class SenderClient extends Client<String>{
61.     public SenderClient(String name, String message, SimpleMediator simpleMediator) {
62.         super(name, message, simpleMediator);
63.     }
65.     @Override
66.     void sent() {
67.         simpleMediator.add(this);
68.         System.out.println("消息发送成功！");    }
71.     @Override
72.     void get() {
73.         new RuntimeException("这是接收消息的客户端");
74.     }
75. }

复制代码

测试类：

1. public class Test02 {
2.     public static void main(String[] args) {
3.         MessageSimpleMediator messageSimpleMediator = new MessageSimpleMediator();
4.         SenderClient C1 = new SenderClient("发送消息的客户端1", "发送的内容", messageSimpleMediator);
5.         SenderClient C2 = new SenderClient("发送消息的客户端2", "发送的内容", messageSimpleMediator);
6.         SenderClient C3 = new SenderClient("发送消息的客户端3", "发送的内容", messageSimpleMediator);
7.         ReceiverClient R3 = new ReceiverClient("接收消息的客户端",  messageSimpleMediator);
9.         C1.sent();
10.         C2.sent();
11.         C3.sent();
13.         while (messageSimpleMediator.queue.size() > 0){
14.             R3.get();
15.         }
16.     }
17. }

复制代码

总结

在学习中介者模式的时候一直迷惑，为什么要有中介者接口？
学习完后感悟：计划模式是一种思想，不应该去套公式。中介者模式的核心思想就是通过对象引用的方式实现多个同事类通过一个中介者建立接洽，可以中介者中引用同事类，也可以同时类引用中介者，甚至可以用一个不用中介者接口，直接定义详细中介者实现。详细怎么实现要根据详细环境而论。
计划模式是一种思想，而不是一种公式模板。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。