java（11）
运用java中介者模式的一个小程序
* @author Administrator
public abstract class Mediator {
//Mediator定义对SchoolRole的一个交互行为
public abstract void action(SchoolRole role);
//加入SchoolRole对象
public abstract void addRole(SchoolRole role);
import java.util.ArrayL
import java.util.L
* @author Administrator
public class ConcreteMediator extends Mediator{
private List&SchoolRole& roles=new ArrayList&SchoolRole&(0);
public void action(SchoolRole act){
String msg=act.getMessage();
for(SchoolRole role:roles){
if(role.equals(act)){
role.sendMsg();
for(SchoolRole role:roles){
if(role.equals(act))
role.receMsg(msg);
public void addRole(SchoolRole role){
roles.add(role);
* @author Administrator
public abstract class SchoolRole {
public Mediator getMediator(){
SchoolRole(Mediator mediator){
this.mediator=
public String getMessage(){
//需要子类实现的抽象方法
//发送消息
public abstract void sendMsg();
//收到消息
public abstract void receMsg(String msg);
public abstract void setName(String name);
public abstract String getName();
//发送消息
public void sendMsg(String msg){
this.message=
mediator.action(this);
* @author Administrator
public class Office extends SchoolRole{
public Office(Mediator m){
//发送消息
public void sendMsg(){
System.out.println(name+&发送的消息是'&+getMessage()+&'&);
//收到消息
public void receMsg(String msg){
System.out.println(name+&接受的消息是'&+msg+&'&);
public void setName(String name){
this.name=
public String getName(){
* @author Administrator
public class Student extends SchoolRole{
public Student(Mediator m){
//发送消息
public void sendMsg(){
System.out.println(name+&发送的消息是'&+getMessage()+&'&);
//收到消息
public void receMsg(String msg){
System.out.println(name+&接受的消息是'&+msg+&'&);
public void setName(String name){
this.name=
public String getName(){
* @author Administrator
public class Teacher extends SchoolRole{
public Teacher(Mediator m){
//发送消息
public void sendMsg(){
System.out.println(name+&发送的消息是'&+getMessage()+&'&);
//收到消息
public void receMsg(String msg){
System.out.println(name+&接受的消息是'&+msg+&'&);
public void setName(String name){
this.name=
public String getName(){
* @author Administrator
public class MediatorText {
* @param args
public static void main(String[] args) {
// TODO Auto-generated method stub
Mediator mediator=new ConcreteMediator();
SchoolRole Office=new Office(mediator);
SchoolRole Student=new Student(mediator);
SchoolRole Teacher=new Teacher(mediator);
Office.setName(&办公室人员&);
Student.setName(&学生&);
Teacher.setName(&老师&);
//注册对象到中介者
mediator.addRole(Office);
mediator.addRole(Student);
mediator.addRole(Teacher);
//Office 的行为
Office.sendMsg(&今天下午两点开会！&);
System.out.println();
//Student 的行为
Student.sendMsg(&我们今天下午有课&);
System.out.println();
//Teacher 的行为
Teacher.sendMsg(&咱们可以把课调一下&);
System.out.println();
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：14755次
排名：千里之外
原创：15篇
(1)(1)(3)(11)中介者模式 - lovebeauty - 博客园
随笔 - 273, 文章 - 0, 评论 - 41, 引用 - 0
在生活中，当电脑缺少了一块主板，那会怎么样？如果有人这样问我的话，我就会马上跳出来说&这电脑肯定报废了&，当然这不是重点。假如少了主板电脑还可以用的话，想想，里面的
在软件的开发过程中，势必会碰到这样一种情况，多个类或多个子系统相互交互，而且交互很繁琐，导致每个类都必须知道他需要交互的类，这样它们的耦合会显得异常厉害。牵一发而动全身又不木有啊！(严重违反低耦合)
好了，既然问题提出来了，那有请我们这期的主角&&中介者模式出场吧！
具体过程如下：
1.首先光驱读取光盘上的数据，然后告诉主板，它的状态已经改变了。
2.主板得到光驱的数据，将数据交给CPU进行分析处理。
3.CPU处理完，将数据分成了视频数据和音频数据，通知主板，已将处理好了。
4.主板得到数据，将数据交给显卡和声卡进行输出。
先用几句话说下这些代码，colleague是一个抽象类，是光驱、cpu等的父类，有对中介者mediator的引用，
然后mediator是一个接口，ConcreteMediator实现了它的change方法，有对光驱、cpu等的引用，每当光驱、cpu等自己工作完的时候就去调用中介者的change方法，
然后中介者的change就去做一些调兵遣将的工作比如派显卡和声卡工作，用户就能看到东西了，而这个过程，光驱、cpu等的操作都是隔离开的，没有在内部相互引用，
而都是放在中介者里面引用的！实现了模块间的低耦合！
一句话是：光驱、cpu有对接口中介者mediator的引用，接口中介者mediator的实现类又有对光驱、cpu等类的引用！
package designMode.mediator2;
public interface Mediator {
void change(Colleague colleague);
package designMode.mediator2;
public abstract class Colleague {
public Colleague(Mediator mediator){
this.mediator =
public Mediator getMediator() {
package designMode.mediator2;
public class CPU extends Colleague {
public CPU(Mediator mediator) {
super(mediator);
private String videioData = null;
private String soundData = null;
public String getVideioData() {
return this.videioD
public String getSoundData() {
return this.soundD
public void executeData(String data) {
String[] ss = data.split(",");
this.videioData = ss[0];
this.soundData = ss[1];
// 通知主板，CPU工作已完成
this.getMediator().change(this);
package designMode.mediator2;
public class CDDriver extends Colleague {
public CDDriver(Mediator mediator) {
super(mediator);
private String data = null;
public String getData()
return this.
public void readCD()
//逗号前是视频数据，逗号后是声音数据
this.data = "这是视频数据,这是声音数据";
//通知主板，自己的状态反生了改变
this.getMediator().change(this);
package designMode.mediator2;
public class VideoCard extends Colleague {
public VideoCard(Mediator mediator) {
super(mediator);
// TODO Auto-generated constructor stub
public void showData(String data) {
System.out.println("您正在看：" + data);
package designMode.mediator2;
public class SoundCard extends Colleague {
public SoundCard(Mediator mediator) {
super(mediator);
// TODO Auto-generated constructor stub
public void showData(String data) {
System.out.println("您正在听：" + data);
ConcreteMediator
package designMode.mediator2;
public class ConcreteMediator implements Mediator {
private CDDriver cdD
private CPU
private VideoC
private SoundC
public void setCDDriver(CDDriver cdDriver) {
this.cdDriver = cdD
public void setCPU(CPU cpu) {
this.cpu =
public void setVideoCard(VideoCard video) {
this.video =
public void setSoundCard(SoundCard sound) {
this.sound =
public void change(Colleague colleague) {
if (colleague == cdDriver) {
openCDAndReadData((CDDriver) colleague);
} else if (colleague == cpu) {
openCPU((CPU) colleague);
private void openCDAndReadData(CDDriver cs) {
// 获取光驱读取的数据
String data = cdDriver.getData();
// 把这些数据传递给CPU进行处理
this.cpu.executeData(data);
private void openCPU(CPU cpu) {
// 获取数据
String videoData = cpu.getVideioData();
String soundData = cpu.getSoundData();
// cpu通知声卡显卡工作,用户就可以看到影像了
this.video.showData(videoData);
this.sound.showData(soundData);
测试类MainTest：
package designMode.mediator2;
import java.io.IOE
public class MainTest {
public static void main(String[] args) throws IOException {
//1.创建中介者&&主板对象
ConcreteMediator mediator = new ConcreteMediator();
//2.创建同事类
CDDriver cd = new CDDriver(mediator);
CPU cpu = new CPU(mediator);
VideoCard videocard = new VideoCard(mediator);
SoundCard soundcard = new SoundCard(mediator);
//3.让中介知道所有的同事
mediator.setCDDriver(cd);
mediator.setCPU(cpu);
mediator.setVideoCard(videocard);
mediator.setSoundCard(soundcard);
//4.开始看电影
cd.readCD();
System.out.println();博客访问： 382754
博文数量： 163
博客积分： 4040
博客等级： 上校
技术积分： 1618
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： 项目管理
1、mediator.h#ifndef MEDIATOR_H
#define MEDIATOR_H
#include &iostream&
#include &iostream&
#include &map&
using namespace std;
class User;
class Room //Mediator,中介基类
&&&&Room();
&&&&virtual ~Room();
&&&&virtual void Register(User*) = 0;
&&&&virtual void Send(char* pFrom, char* pTo, char* pMsg) = 0;
class Chatroom : public Room //ConcreteMediator,中介具体类
&&&&Chatroom();
&&&&virtual ~Chatroom();
&&&&void Register(User*);
&&&&void Send(char* pFrom, char* pTo, char* pMsg);
&&&&map&char*, User*& m_mapUsers;
class User //用户基类
&&&&User(char*);
&&&&virtual ~User();
&&&&void Send(char* pTo, char* pMsg);
&&&&virtual void Receive(char* pFrom, char* pMsg);
&&&&void SetChatroom(Chatroom*);
&&&&friend class Chatroom;
&&&&char* m_pName;
&&&&Chatroom* m_pChatroom;
class UserInGroupA : public User //具体组用户类A，与B交互通过ConcreteMediator来实现
&&&&UserInGroupA(char*);
&&&&virtual ~UserInGroupA();
&&&&virtual void Receive(char* pFrom, char* pMsg);
class UserInGroupB : public User //具体组用户类B，与A交互通过ConcreteMediator来实现
&&&&UserInGroupB(char*);
&&&&virtual ~UserInGroupB();
&&&&virtual void Receive(char* pFrom, char* pMsg);
#endif // MEDIATOR_H
2、mediator.cpp#include "mediator.h"
Room::Room(){}
Room::~Room(){}
Chatroom::Chatroom(){}
Chatroom::~Chatroom(){}
void Chatroom::Register(User* pUser)
&&&&if(m_mapUsers[pUser-&m_pName] == NULL)
&&&&&&&&m_mapUsers[pUser-&m_pName] = pUser;
&&&&pUser-&SetChatroom(this);
void Chatroom::Send(char* pFrom, char* pTo, char* pMsg)
&&&&User* pUserTo = (User*)m_mapUsers[pTo];
&&&&if(pUserTo != NULL)
&&&&&&&&pUserTo-&Receive(pFrom, pMsg);
User::User(char* pName)
&&&&m_pName = pName;
User::~User()
&&&&if(m_pChatroom != NULL)
&&&&&&&&delete m_pChatroom;
&&&&&&&&m_pChatroom = NULL;
void User::Send(char* pTo, char* pMsg)
&&&&m_pChatroom-&Send(m_pName, pTo, pMsg);
void User::SetChatroom(Chatroom* pChatroom)
&&&&m_pChatroom = pChatroom;
void User::Receive(char* pFrom, char* pMsg)
&&&&cout && pFrom && " to " && this-&m_pName && " said:'" && pMsg &&"'"&& endl;
UserInGroupA::UserInGroupA(char* pName) : User(pName){}
UserInGroupA::~UserInGroupA(){}
void UserInGroupA::Receive(char* pFrom, char* pMsg)
&&&&cout && "UserInGroupA receive-&:";
&&&&User::Receive(pFrom, pMsg);
UserInGroupB::UserInGroupB(char* pName) : User(pName){}
UserInGroupB::~UserInGroupB(){}
void UserInGroupB::Receive(char* pFrom, char* pMsg)
&&&&cout && "UserInGroupB receive-&:";
&&&&User::Receive(pFrom, pMsg);
3、main.cpp/*
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：/
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互作用，从而使其耦合松散，
而且可以独立地改变他们之间的交互。
面向对象设计，鼓励将行为分布在各个对象中，这种分布可能导致对象间有很多链接，在最坏的情况下，每个对象都要知道基他的所有对象，
这样，如果有N个对象，则将会有N*(N-1)/2种情况。
1.Mediator中介者模式，在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，
&&如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。使用一个中介对象来管理对象间的关联关系，
&&避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化。
2.将多个对象间复杂的关联关系解耦，mediator模式将多个对象间的控制逻辑进行集中管理，变多个对象互相关联为多个对象和
&&一个中介者关联，简化了系统的维护，抵御了可能的变化。随着控制逻辑的复杂化，mediator具体对象的实现可能相当复杂。
&&这时候可以对mediator对象进行分解处理。Façade模式是解耦系统外到系统内（单向）的对象关联关系；
&&mediator模式是解耦系统内各个对象之间（双向）的关联关系。
1.将系统按功能分割成更小的对象，符合类的最小设计原则.
2.对关联对象的集中控制.
3.减小类的耦合程度，明确类之间的相互关系：当类之间的关系过于复杂时，其中任何一个类的修改都会影响到其他类，
&&不符合类的设计的开闭原则,而Mediator模式将原来相互依存的多对多的类之间的关系简化为Mediator控制类与其他关联类的一对多的关系，
&&当其中一个类修改时，可以对其他关联类不产生影响（即使有修改，也集中在Mediator控制类）。
4.有利于提高类的重用性.
1.一组对象以定义良好但是复杂的方式进行通信,产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。
以聊天室的例子说明如下，一个聊天室可以很多成员，成员可以加入不同的讨论组，聊天室就是一个中介，讨论组中的成员通过聊天室发送消息。
以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
#include &QtCore/QCoreApplication&
#include "mediator.h"
int main(int argc, char *argv[])
&&&&cout && "=== jhluroom start ========" && endl;
&&&&Chatroom* pChatroom = new Chatroom();
&&&&User* pUserA1 = new UserInGroupA("UserA1");
&&&&User* pUserA2 = new UserInGroupA("UserA2");
&&&&User* pUserB1 = new UserInGroupB("UserB1");
&&&&pChatroom-&Register(pUserA1);
&&&&pChatroom-&Register(pUserA2);
&&&&pChatroom-&Register(pUserB1);
&&&&pUserA1-&Send("UserA2", "hello，UserA2");
&&&&pUserA2-&Send("UserB1", "hello，UserB1");
&&&&pUserB1-&Send("UserA1", "hello，UserA1");
&&&&cout && "=== jhluroom finish _^_ ===" && endl;
&&&&return 0;
运行结果：
=== jhluroom start ========
UserInGroupA receive-&:UserA1 to UserA2 said:'hello，UserA2'
UserInGroupB receive-&:UserA2 to UserB1 said:'hello，UserB1'
UserInGroupA receive-&:UserB1 to UserA1 said:'hello，UserA1'
=== jhluroom finish _^_ ===
阅读(306) | 评论(0) | 转发(0) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。1104人阅读
设计模式（21）
JAVA（145）
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
二、适用性
1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
2.一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。
三、参与者
1.Mediator 中介者定义一个接口用于与各同事（Colleague）对象通信。
2.ConcreteMediator 具体中介者通过协调各同事对象实现协作行为。 了解并维护它的各个同事。
3.Colleagueclass 每一个同事类都知道它的中介者对象。 每一个同事对象在需与其他的同事通信的时候，与它的中介者通信
package com.lyz.design.
* Mediator
* @author liuyazhuang
public abstract class Mediator {
public abstract void notice(String content);
ConcreteMediator
package com.lyz.design.
* ConcreteMediator
* @author liuyazhuang
public class ConcreteMediator extends Mediator {
private ColleagueA
private ColleagueB
public ConcreteMediator() {
ca = new ColleagueA();
cb = new ColleagueB();
public void notice(String content) {
if (content.equals(&boss&)) {
//老板来了, 通知员工A
ca.action();
if (content.equals(&client&)) {
//客户来了, 通知前台B
cb.action();
Colleagueclass
package com.lyz.design.
* Colleagueclass
* @author liuyazhuang
public class ColleagueA extends Colleague {
public void action() {
System.out.println(&普通员工努力工作&);
package com.lyz.design.
* Colleagueclass
* @author liuyazhuang
public class ColleagueB extends Colleague {
public void action() {
System.out.println(&前台注意了!&);
package com.lyz.design.
* @author liuyazhuang
public class Test {
public static void main(String[] args) {
Mediator med = new ConcreteMediator();
//老板来了
med.notice(&boss&);
//客户来了
med.notice(&client&);
普通员工努力工作
前台注意了!
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1106110次
积分：17802
积分：17802
排名：第513名
原创：668篇
评论：205条
文章：20篇
阅读：12557
文章：13篇
阅读：4017
文章：18篇
阅读：47873
阅读：22156
文章：22篇
阅读：31725
阅读：6394
文章：22篇
阅读：47398
文章：67篇
阅读：119771
文章：15篇
阅读：31782
文章：72篇
阅读：160835
文章：147篇
阅读：265558
文章：83篇
阅读：109433
文章：119篇
阅读：135642
(11)(6)(37)(26)(13)(6)(8)(14)(12)(18)(19)(18)(11)(9)(23)(19)(12)(5)(8)(6)(22)(21)(41)(39)(49)(49)(72)(11)(20)(7)(4)(8)(15)(11)(2)(1)(3)(7)(15)下次自動登錄
現在的位置:
& 綜合 & 正文
Java設計模式（十一）訪問者模式 中介者模式
（二十一）訪問者模式
對已存在的類進行擴展，通常需要增加方法，但是如果需要的行為與現有的對象模型不一致，或者無法修改現有。在這種情況下，不更改類的層次結構，就無法擴展該層次結構的行為。如果運用了訪問者模式，就可以支持開發人員擴展該類層次結構的行為。
和解釋器模式一樣，訪問者模式通常是基於合成模式的。
訪問者模式在不改變類層次結構的前提下，對該層次結構進行擴展。
interface Visitor{
public void visit(VisiSubject sub);
interface VisiSubject{
public void accept(Visitor visitor);
public String getSubject();
class MyVisitor implements Visitor{
public void visit(VisiSubject sub){
System.out.println("visitor MyVisitor:"+sub.getSubject()+"");
class MyVisitor2 implements Visitor{
public void visit(VisiSubject sub){
System.out.println("visitor MyVisitor2:"+sub.getSubject()+"");
class MyVisiSubject implements VisiSubject{
public void accept(Visitor visitor) {
visitor.visit(this);
public String getSubject() {
return "MyVisiSubject";
class MyVisiSubject2 implements VisiSubject{
public void accept(Visitor visitor) {
visitor.visit(this);
public String getSubject() {
return "MyVisiSubject2";
public class VisitorTest {
public static void main(String[] args){
Visitor visitor = new MyVisitor2();
VisiSubject sub = new MyVisiSubject2();
sub.accept(visitor);
訪問者模式是否是一個好的選擇，取決於系統變化的特徵：如果層次結構穩定，變化的是行為那麼就是一個好的選擇。如果行為穩定，層次結構總是變化，就不是一個好的選擇了。因為你需要更新現有的訪問者類，使得他們可以支持新的節點類型。
與任何模式一樣，訪問者模式不是必須的：如果需要使用該模式，就應該物盡其用。判斷是否使用訪問者模式，最好滿足以下條件：
節點類型的集合是穩定的。
共同發生的變化是為不同的節點添加新的功能。
新功能必須適用於所有節點類型。小結：
訪問者模式使你可以在不改變類層次結構的前提下，為該結構增加新的行為。該模式的機制包括為訪問者定義一個接口，為層次關係中的所有訪問者增加一個accept()方法。accept()方法使用雙重委派技術，將其調用委派給訪問者。類層次結構中的對象可以根據其類型調用核實的visit()方法。
（二十二）中介者模式
面對對象開發要求儘可能恰當的分配職責，要求對象能夠獨立的完成自己的任務。觀察者模式通過最小化對象與對象之間的職責交互，從而支持職責的合理分配。當對象間的交互趨向複雜，而每個對象都需要知道其他對象的情況時，提供一個集中地控制權是很有用的。當相關對象的交互邏輯獨立於對象的其他行為時，職責的集中同樣有用。
中介者模式的意圖是定義一個對象，封裝一組對象的交互，從而降低對象間的耦合度，避免了對象間的顯式引用，並且可以獨立地改變對象的行為。
interface Mediator{
public void createMediator();
public void workAll();
abstract class MUser{
public Mediator getMediator(){
public MUser(Mediator mediator){
this.mediator =
public abstract void work();
class User1 extends MUser{
public User1(Mediator m){
public void work(){
System.out.println("User1");
class User2 extends MUser{
public User2(Mediator m){
public void work(){
System.out.println("User2");
class MyMediator implements Mediator{
private MUser user1;
private MUser user2;
public MUser getUser1() {
return user1;
public MUser getUser2() {
return user2;
public void createMediator() {
user1 = new User1(this);
user2 = new User2(this);
public void workAll() {
user1.work();
user2.work();
public class MediatorTest {
public static void main(String[] args){
Mediator m = new MyMediator();
m.createMediator();
m.workAll();
MUser類統一接口，User1和User2分別是不同的對象，兩者之間有關聯，如果不採用中介者模式，則需要兩者相互持有引用，為了解耦引入中介者模式，Mediator為接口，MyMediator為實現類，持有user1跟user2，這兩個類相互獨立，只需要維持和Mediator之間的聯繫，剩下的由MyMediator維護。
&&&&推薦文章:
【上篇】【下篇】