Mediator:中介者模式,当多个对象彼此间都有联系的时候,我们就可以应用Mediator将对象间的多对多关系转换为
一对多的关系,这样做,可以使各个对象间的耦合松散。统一管理对象间的通信协议。但也可能使得Mediator对象
成为一个系统中的庞然大物,难以维护。
好,我们现在来看一个实例。下面有三个对象:A,B,C。他们之间的关系是相互的,每个对象都知道其余的两个对象,都可以和其余的对象打交道。
我们先看看不使用Mediator模式的代码,这样的代码可能会产生混乱。
// A.H 类A 的头文件,下面的类B和类C的结构相同,只是为了演示出三个类之间“纠缠不清”的关系
#ifndef _A_H
#define _A_H
class B;
class C;
class A
...{
public:
void SetColleage(B *b, C *c); // 设置同事(协助者),也就是需要打交道的对象
void ACallB(); // 调用协助者B的服务
void ACallC(); // 调用协助者C的服务
void Function(); // 自己本身的服务
private:
B *_b;
C *_c;
};
#endif
#define _A_H
class B;
class C;
class A
...{
public:
void SetColleage(B *b, C *c); // 设置同事(协助者),也就是需要打交道的对象
void ACallB(); // 调用协助者B的服务
void ACallC(); // 调用协助者C的服务
void Function(); // 自己本身的服务
private:
B *_b;
C *_c;
};
#endif
// A.CPP
#include "a.h"
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void A::SetColleage(B *b, C *c)
...{
_b = b;
_c = c;
}
void A::ACallB()
...{
cout << "A call ";
_b->Function();
}
void A::ACallC()
...{
cout << "A call ";
_c->Function();
}
void A::Function()
...{
cout << "A's Func!" << endl;
}
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void A::SetColleage(B *b, C *c)
...{
_b = b;
_c = c;
}
void A::ACallB()
...{
cout << "A call ";
_b->Function();
}
void A::ACallC()
...{
cout << "A call ";
_c->Function();
}
void A::Function()
...{
cout << "A's Func!" << endl;
}
下面的B.H、B.CPP、C.H、C.CPP都和上面两个文件相似,下面给出这4个文件的完整内容
// B.H
#ifndef _B_H
#define _B_H
class A;
class C;
class B
...{
public:
void SetColleage(A *a, C *c);
void BCallA();
void BCallC();
void Function();
private:
A *_a;
C *_c;
};
#endif
#define _B_H
class A;
class C;
class B
...{
public:
void SetColleage(A *a, C *c);
void BCallA();
void BCallC();
void Function();
private:
A *_a;
C *_c;
};
#endif
// B.CPP
#include "a.h"
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void B::SetColleage(A *a, C *c)
...{
_a = a;
_c = c;
}
void B::BCallA()
...{
cout << "B call ";
_a->Function();
}
void B::BCallC()
...{
cout << "B call ";
_c->Function();
}
void B::Function()
...{
cout << "B's Func!" << endl;
}
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void B::SetColleage(A *a, C *c)
...{
_a = a;
_c = c;
}
void B::BCallA()
...{
cout << "B call ";
_a->Function();
}
void B::BCallC()
...{
cout << "B call ";
_c->Function();
}
void B::Function()
...{
cout << "B's Func!" << endl;
}
// C.H
#ifndef _C_H
#define _C_H
class A;
class B;
class C
...{
public:
void SetColleage(A *a, B *b);
void CCallA();
void CCallB();
void Function();
private:
A *_a;
B *_b;
};
#endif
#define _C_H
class A;
class B;
class C
...{
public:
void SetColleage(A *a, B *b);
void CCallA();
void CCallB();
void Function();
private:
A *_a;
B *_b;
};
#endif
// C.CPP
#include "a.h"
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void C::SetColleage(A *a, B *b)
...{
_a = a;
_b = b;
}
void C::CCallA()
...{
cout << "C call ";
_a->Function();
}
void C::CCallB()
...{
cout << "C call ";
_b->Function();
}
void C::Function()
...{
cout << "C's Func!" << endl;
}
#include "b.h"
#include "c.h"
#include <iostream>
using namespace std;
void C::SetColleage(A *a, B *b)
...{
_a = a;
_b = b;
}
void C::CCallA()
...{
cout << "C call ";
_a->Function();
}
void C::CCallB()
...{
cout << "C call ";
_b->Function();
}
void C::Function()
...{
cout << "C's Func!" << endl;
}
从上面三个类可以看出来,他们之间彼此都有关系,都可以和另外两个类对象打交道。在现实的软件系统中也可能会出现这种情况,整个系统的类间都有耦合性,最终导致整个系统变成一个耦合性很强的系统,完全没有重用可言。由于这种弊端,我们可以运用Mediator模式来解耦,这属于下篇文章的内容,现在我们先来看看怎么调用上面的这些类。
// main.CPP
#include <iostream>
using namespace std;
#include "a.h"
#include "b.h"
#include "c.h"
void main()
...{
A a;
B b;
C c;
a.SetColleage(&b, &c);
b.SetColleage(&a, &c);
c.SetColleage(&a, &b);
a.ACallB();
a.ACallC();
b.BCallA();
b.BCallC();
c.CCallA();
c.CCallB();
}
using namespace std;
#include "a.h"
#include "b.h"
#include "c.h"
void main()
...{
A a;
B b;
C c;
a.SetColleage(&b, &c);
b.SetColleage(&a, &c);
c.SetColleage(&a, &b);
a.ACallB();
a.ACallC();
b.BCallA();
b.BCallC();
c.CCallA();
c.CCallB();
}
好了,从这个调用可以看出来,他们之间的耦合性非常强,这里只是三个对象,而且调用的方式比较统一(因为是例子程序),我们还能把他们的关系给搞清楚,但在现实的软件开发中,往往类间的关系比这里的复杂多了,这个时候我们就要“剪”断这些错乱的关系,而“剪刀”就是Mediator模式。 (未完代续)