中介者模式:有很多相互依赖的类,将他们的依赖关系集中到中介者中。中介者抽象的是它们之间的依赖关系,这种依赖关系并不会消失,只是集中到了中介者身上。比如:很多同事一起办公,但是工作需要,经常要相互沟通,而我们直接找到对方代价很大,而通过发送微信转达对方是很快的,微信就扮演者中介者。中介者和外观模式,两者相同在于都是很多类相互协作,然而前者强调内部之间的沟通,后者强掉它们与外部沟通。
#include <iostream>
using namespace std;
//没有用中介者模式
namespace unMediator {
class ColleagueA;
class ColleagueB;
class ColleagueC;
class ColleagueA {
public:
void foob(ColleagueB *b) { cout << "a 调用 b" << endl; }
void fooc(ColleagueC *c) { cout << "a 调用 c" << endl; }
};
class ColleagueB {
public:
void fooa(ColleagueA *a) { cout << "b 调用 a" << endl; }
void fooc(ColleagueC *c) { cout << "b 调用 c" << endl; }
};
class ColleagueC {
public:
void fooa(ColleagueA *a) { cout << "c 调用 a" << endl; }
void foob(ColleagueB *b) { cout << "c 调用 b" << endl; }
};
}
//使用中介者模式
namespace Mediator {
class Colleague {
public:
virtual ~Colleague() = default;
};
class Mediator {
public:
Mediator(Colleague *src, Colleague *dst) : src(src), dst(dst) {}
virtual void foo() = 0;
virtual ~Mediator() = default;
protected:
Colleague *src;
Colleague *dst;
};
class ColleagueA : public Colleague {
public:
void foo(Mediator &m) {
m.foo();
}
};
class ColleagueB : public Colleague {
public:
void foo(Mediator &m) {
m.foo();
}
};
class ColleagueC : public Colleague {
public:
void foo(Mediator &m) {
m.foo();
}
};
class MediatorAB : public Mediator {
public:
MediatorAB(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "a 调用 b" << endl;
}
};
class MediatorAC : public Mediator {
public:
MediatorAC(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "a 调用 c" << endl;
}
};
class MediatorBA : public Mediator {
public:
MediatorBA(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "b 调用 a" << endl;
}
};
class MediatorBC : public Mediator {
public:
MediatorBC(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "b 调用 c" << endl;
}
};
class MediatorCA : public Mediator {
public:
MediatorCA(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "c 调用 a" << endl;
}
};
class MediatorCB : public Mediator {
public:
MediatorCB(Colleague *src, Colleague *dst) : Mediator(src, dst) {}
void foo() override {
cout << "c 调用 b" << endl;
}
};
}
int main()
{
//非中介者模式
unMediator::ColleagueA ua;
unMediator::ColleagueB ub;
unMediator::ColleagueC uc;
ua.foob(&ub);
ua.fooc(&uc);
ub.fooa(&ua);
//中介者模式
Mediator::ColleagueA a;
Mediator::ColleagueB b;
Mediator::ColleagueB c;
Mediator::MediatorAB atob (&a, &b);
Mediator::MediatorAC atoc (&a, &c);
Mediator::MediatorBA btoa (&b, &a);
a.foo(atob);
a.foo(atoc);
b.foo(btoa);
return 0;
}
中介者模式稳定部分是它们之间的相互依赖关系Mediator
和协作关系Colleague
,易变的部分是同事类可能进一步增加,关系也会进一步增加。