版权声明：转载必须注明本文转自晓_晨的博客：http://blog.csdn.net/niunai112
目录
设计模式之六大设计原则
设计模式（一）单例模式
设计模式（二）工厂模式
设计模式（三）策略模式
设计模式（四）适配器模式
设计模式（五）享元模式
设计模式（六）建造者模式
设计模式（七）原型模式
设计模式（八）桥接模式
设计模式（九）外观模式
设计模式（十）组合模式
设计模式（十一）装饰器模式
设计模式（十二）代理模式
设计模式（十三）迭代器模式
设计模式（十四）观察者模式
设计模式（十五）中介者模式
设计模式（十六）命令模式
设计模式（十七）状态模式
设计模式（十八）访问者模式
设计模式（十九）责任链模式
设计模式（二十）解释器模式
设计模式（二十一）备忘录模式
设计模式（二十二）模板模式
设计模式总结篇（为什么要学习设计模式，学习设计模式的好处）
当类与类之间的依赖关系非常复杂，犹如一张错综复杂的网络时，我们可以用中介者模式来解耦其中错综复杂的关系。
UML图
中介者模式通用代码
/
*
*@Author ChenjunWang
*@Description:中介者抽象类
*@Date: Created in 10:51 2018/4/12
*@Modified By:
*
*/
public abstract class Mediator {
protected Colleague colleagueA;
protected Colleague colleagueB;
public Mediator(Colleague colleagueA, Colleague colleagueB) {
this.colleagueA = colleagueA;
this.colleagueB = colleagueB;
}
public abstract void notifyColleagueA();
public abstract void notifyColleagueB();
}
/***
*
*@Author ChenjunWang
*@Description:同事抽象类
*@Date: Created in 10:54 2018/4/12
*@Modified By:
*
*/
public abstract class Colleague {
protected Mediator mediator;
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
public abstract void operation();
}
/***
*
*@Author ChenjunWang
*@Description:同事A实现类
*@Date: Created in 10:56 2018/4/12
*@Modified By:
*
*/
public class ConcreteColleagueA extends Colleague {
public void notifyColleagueB() {
mediator.notifyColleagueB();
}
@Override
public void operation() {
System.out.println("同事A的操作");
}
}
/***
*
*@Author ChenjunWang
*@Description:同事B实现类
*@Date: Created in 10:56 2018/4/12
*@Modified By:
*
*/
public class ConcreteColleagueB extends Colleague {
public void notifyColleagueA() {
mediator.notifyColleagueA();
}
@Override
public void operation() {
System.out.println("同事B的操作");
}
}
/***
*
*@Author ChenjunWang
*@Description:中介者具体实现类
*@Date: Created in 10:57 2018/4/12
*@Modified By:
*
*/
public class ConcreteMediator extends Mediator {
public ConcreteMediator(Colleague colleagueA, Colleague colleagueB) {
super(colleagueA, colleagueB);
}
@Override
public void notifyColleagueA() {
if (colleagueA != null) {
colleagueA.operation();
}
}
@Override
public void notifyColleagueB() {
if (colleagueB != null) {
colleagueB.operation();
}
}
}
/***
*
*@Author ChenjunWang
*@Description:
*@Date: Created in 10:59 2018/4/12
*@Modified By:
*
*/
public class Test {
public static void main(String[] args) {
ConcreteColleagueA concreteColleagueA = new ConcreteColleagueA();
ConcreteColleagueB concreteColleagueB = new ConcreteColleagueB();
ConcreteMediator concreteMediator = new ConcreteMediator(concreteColleagueA, concreteColleagueB);
concreteMediator.notifyColleagueA();
concreteMediator.notifyColleagueB();
}
}
运行结果如下
------------------------------------------
同事A的操作
同事B的操作虽然运行结果非常简单，但是他们在调用的时候，不是直接调用的，而是通过ConcreteMediator来调用了。
其实我觉得通用的这个列子不能很好的表达出我对中介者模式的理解，我觉得还是用类似某企鹅的聊天工具来解释会比较好理解。若没有某企鹅，我们之间的聊天
每增加一个人，都要加好几条线来确保正常沟通，关系非常复杂。
而当有某企鹅后，我们之间的关系变得简单了，耦合度大大降低了
/***
*
*@Author ChenjunWang
*@Description:中介者抽象类
*@Date: Created in 13:34 2018/4/12
*@Modified By:
*
*/
public abstract class Mediator {
List<User> list = new ArrayList<>();//所有在聊天室里的人存这
abstract void sendToAll(String msg);//群发
abstract void senToPerson(String msg, String name);//给某个人发送消息
abstract void join(User user);//用户加入聊天室
abstract void leave(User user);//用户离开聊天室
}
/***
*
*@Author ChenjunWang
*@Description:聊天平台
*@Date: Created in 13:39 2018/4/12
*@Modified By:
*
*/
public class ChatPlatform extends Mediator {
@Override
void sendToAll(String msg) {
for (User u : list){
u.accept(msg);
}
}
@Override
void senToPerson(String msg, String name) {
for (User u : list){
if (u.name.equals(name))
u.accept(msg);
}
}
@Override
void join(User user) {
list.add(user);
}
@Override
void leave(User user) {
list.remove(user);
}
}
/***
*
*@Author ChenjunWang
*@Description:用户抽象类
*@Date: Created in 13:35 2018/4/12
*@Modified By:
*
*/
public abstract class User {
protected Mediator mediator;
String name;
//在创建对象的时候就把他的中间者传入，他要发送都是通过这个中介者来做的。
public User(String name, Mediator mediator){
this.name = name;
this.mediator = mediator;
}
abstract void sendToAll(String msg);//给所有人发消息
abstract void senToPerson(String msg, String name);//给某个人发送消息
abstract void accept(String msg);//接受消息
abstract void join();//加入聊天室
abstract void leave();//离开聊天室
}
/***
*
*@Author ChenjunWang
*@Description:普通用户
*@Date: Created in 13:42 2018/4/12
*@Modified By:
*
*/
public class NormalUser extends User {
public NormalUser(String name, Mediator mediator) {
super(name, mediator);
}
@Override
void sendToAll(String msg) {
mediator.sendToAll(msg);
}
@Override
void senToPerson(String msg, String name) {
mediator.senToPerson(msg, name);
}
@Override
void accept(String msg) {
System.out.println(this.name + "收到消息：" + msg );
}
@Override
void join() {
mediator.join(this);
}
@Override
void leave() {
mediator.leave(this);
}
}
/***
*
*@Author ChenjunWang
*@Description:
*@Date: Created in 13:42 2018/4/12
*@Modified By:
*
*/
public class Test {
public static void main(String[] args) {
Mediator chatPlatform = new ChatPlatform();
NormalUser a = new NormalUser("A", chatPlatform);
NormalUser b = new NormalUser("B", chatPlatform);
NormalUser c = new NormalUser("C", chatPlatform);
a.join();
b.join();
c.join();
System.out.println("-----------------A群发送消息------------------");
a.sendToAll("A：大家听得到吗?");
System.out.println("-----------------A给B私发消息------------------");
a.senToPerson("A：B,我只想和你说", "B");
System.out.println("-----------------B给A私发消息------------------");
b.senToPerson("B:可以，请说", "A");
System.out.println("-----------------A离开聊天室------------------");
a.leave();
System.out.println("-----------------B群发送消息------------------");
b.sendToAll("B:A能听到吗");
}
}
运行结果如下
-------------------------------------------------------------------------------
-----------------A群发送消息------------------
A收到消息：A：大家听得到吗?
B收到消息：A：大家听得到吗?
C收到消息：A：大家听得到吗?
-----------------A给B私发消息------------------
B收到消息：A：B,我只想和你说
-----------------B给A私发消息------------------
A收到消息：B:可以，请说
-----------------A离开聊天室------------------
-----------------B群发送消息------------------
B收到消息：B:A能听到吗
C收到消息：B:A能听到吗以上便是LZ使用中介者模式实现了简单的群聊和单聊的模型。相信各位看官能理解中介者模式到底是干嘛的了。所有用户不再私下对话，全部交流都通过中介来完成，各个用户关系解耦，依赖关系从之前的网状变成星型。
像LZ日常用来开发的MVC 框架就是使用了中介者模式，其中Controller就是 Model和 View的中介者。
（1）解耦了类与类之间的关系
（2）将对象间多对多的关联转变为一对多的关联，使对象间的关系易于理解和维护。
（1）中介者的逻辑会变得很庞大，变得复杂难以维护.
（2）这是一个中心化的模式，若中介者出现了问题，毫无疑问，整个系统将直接崩溃。
本篇实例Github地址：https://github.com/stackisok/Design-Pattern/tree/master/src/mediator
有什么不懂或者不对的地方，欢迎留言。
喜欢LZ文章的小伙伴们，可以关注一波，也可以留言，LZ会回你们的。
觉得写得不错的小伙伴，欢迎转载，但请附上原文地址，谢谢^_^!