peter_luy
8/9/2017 - 11:14 AM

外观、组合模式

外观、组合模式

#外观模式 ##一、UML图

关键词:增加Facade层。

##二、概念

外观模式:为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

##三、说明

Q:外观模式在什么时候使用呢?

A:分为三个阶段:

(1)首先,在设计初期阶段,应该要有意识的将不同的两个层分离。

(2)第二,在开发阶段,子系统往往因为不断的重构演化而变得越来越复杂,大多数的模式使用时也会产生很多很小的类,这本是好事儿,但是也给外部调用他们的用户程序带来了使用上的困难,增加外观Facade可以提供一个简单的接口,减少他们之间的依赖。

(3)第三,在维护一个遗留的大型系统时,可能这个系统已经非常难以维护和扩展了,但因为它包含非常重要的功能,新的需求开发必须要依赖于它。此时用外观模式Facade也是非常合适的。

具体而言:为新系统开发一个外观Facade类,来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口,让新系统与Facade对象交互,Facade与遗留代码交互所有复杂的工作。

好处是显而易见的,如下图所示:
##四、C++实现

(1)Facade.h

//SubSystem Class,实现子系统的功能,处理Facade对象指派的任务。注意子类中没有Facade任何信息,即没有对Facade对象的引用。
//下面是四个子系统的类
class SubSystemOne
{
public:
void MethodOne()
{
std::cout<<"子系统方法一"<<std::endl;
}
};

class SubSystemTwo
{
public:
void MethodTwo()
{
std::cout<<"子系统方法二"<<std::endl;
}
};

class SubSystemThree
{
public:
void MethodThree()
{
std::cout<<"子系统方法三"<<std::endl;
}
};

class SubSystemFour
{
public:
void MethodFour()
{
std::cout<<"子系统方法四"<<std::endl;
}
};

//Facade Class,外观类,知道有哪些子系统类,负责处理请求,将客户的请求代理给适当的子系统对象。
class Facade
{
private:
SubSystemOne* one;
SubSystemTwo* two;
SubSystemThree* three;
SubSystemFour* four;

public:
Facade()
{
one=new SubSystemOne();
two=new SubSystemTwo();
three=new SubSystemThree();
four=new SubSystemFour();
}
~Facade()
{
delete one;
delete two;
delete three;
delete four;
}
void MethodA()
{
std::cout<<"方法组A()------"<<std::endl;
one->MethodOne();
two->MethodTwo();
four->MethodFour();
std::cout<<std::endl;
}
void MethodB()
{
std::cout<<"方法组B()------"<<std::endl;
two->MethodTwo();
three->MethodThree();
std::cout<<std::endl;
}
};
(2).client.cpp

//Client
void main()
{
Facade* facade=new Facade();
facade->MethodA();
facade->MethodB();
delete facade;
system("pause");

}

(3).运行结果


来自另一篇blog:
外观模式应该是用的很多的一种模式,特别是当一个系统很复杂时,系统提供给客户的是一个简单的对外接口,而把里面复杂的结构都封装了起来。客户只需使用这些简单接口就能使用这个系统,而不需要关注内部复杂的结构。DP一书的定义:为子系统中的一组接口提供一个一致的界面, 外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。举个编译器的例子,假设编译一个程序需要经过四个步骤:词法分析、语法分析、中间代码生成、机器码生成。学过编译都知道,每一步都很复杂。对于编译器这个系统,就可以使用外观模式。可以定义一个高层接口,比如名为Compiler的类,里面有一个名为Run的函数。客户只需调用这个函数就可以编译程序,至于Run函数内部的具体操作,客户无需知道。下面给出UML图,以编译器为实例。

相应的代码实现:

class Scanner
{
public:
void Scan() { cout<<"词法分析"<<endl; }
};
class Parser
{
public:
void Parse() { cout<<"语法分析"<<endl; }
};
class GenMidCode
{
public:
void GenCode() { cout<<"产生中间代码"<<endl; }
};
class GenMachineCode
{
public:
void GenCode() { cout<<"产生机器码"<<endl;}
};
//高层接口
class Compiler
{
public:
void Run()
{
Scanner scanner;
Parser parser;
GenMidCode genMidCode;
GenMachineCode genMacCode;
scanner.Scan();
parser.Parse();
genMidCode.GenCode();
genMacCode.GenCode();
}
};
客户端的使用方式:
int main()
{
Compiler compiler;
compiler.Run();
return 0;
}

这就是外观模式,它有几个特点(摘自DP一书):

-(1)它对客户屏蔽子系统组件,因而减少了客户处理的对象的数目并使得子系统使用起来更加方便。
-(2)它实现了子系统与客户之间的松耦合关系,而子系统内部的功能组件往往是紧耦合的。
-(3)如果应用需要,它并不限制它们使用子系统类。
结合上面编译器这个例子,进一步说明。对于(1),编译器类对客户屏蔽了子系统组件,客户只需处理编译器的对象就可以方便的使用子系统。对于(2),子系统的变化,不会影响到客户的使用,体现了子系统与客户的松耦合关系。对于(3),如果客户希望使用词法分析器,只需定义词法分析的类对象即可,并不受到限制。


##组合模式

外观模式在构建大型系统时非常有用。接下来介绍另一种模式,称为组合模式。感觉有点像外观模式,刚才我们实现外观模式时,在Compiler这个类中包含了多个类的对象,就像把这些类组合在了一起。组合模式是不是这个意思,有点相似,其实不然。
DP书上给出的定义:将对象组合成树形结构以表示“部分-整体”的层次结构。组合使得用户对单个对象和组合对象的使用具有一致性。注意两个字“树形”。这种树形结构在现实生活中随处可见,比如一个集团公司,它有一个母公司,下设很多家子公司。不管是母公司还是子公司,都有各自直属的财务部、人力资源部、销售部等。对于母公司来说,不论是子公司,还是直属的财务部、人力资源部,都是它的部门。整个公司的部门拓扑图就是一个树形结构。
下面给出组合模式的UML图。从图中可以看到,FinanceDepartment、HRDepartment两个类作为叶结点,因此没有定义添加函数。而ConcreteCompany类可以作为中间结点,所以可以有添加函数。那么怎么添加呢?这个类中定义了一个链表,用来放添加的元素。


相应的代码实现为:

class Company
{
public:
Company(string name) { m_name = name; }
virtual ~Company(){}
virtual void Add(Company *pCom){}
virtual void Show(int depth) {}
protected:
string m_name;
};
//具体公司
class ConcreteCompany : public Company
{
public:
ConcreteCompany(string name): Company(name) {}
virtual ~ConcreteCompany() {}
void Add(Company *pCom) { m_listCompany.push_back(pCom); } //位于树的中间,可以增加子树
void Show(int depth)
{
for(int i = 0;i < depth; i)
cout<<"-";
cout<<m_name<<endl;
list<Company *>::iterator iter=m_listCompany.begin();
for(; iter != m_listCompany.end(); iter) //显示下层结点
(*iter)->Show(depth + 2);
}
private:
list<Company *> m_listCompany;
};
//具体的部门,财务部
class FinanceDepartment : public Company
{
public:
FinanceDepartment(string name):Company(name){}
virtual ~FinanceDepartment() {}
virtual void Show(int depth) //只需显示,无限添加函数,因为已是叶结点
{
for(int i = 0; i < depth; i)
cout<<"-";
cout<<m_name<<endl;
}
};
//具体的部门,人力资源部
class HRDepartment :public Company
{
public:
HRDepartment(string name):Company(name){}
virtual ~HRDepartment() {}
virtual void Show(int depth) //只需显示,无限添加函数,因为已是叶结点
{
for(int i = 0; i < depth; i)
cout<<"-";
cout<<m_name<<endl;
}
};

客户端的调用方式:

int main()
{
Company *root = new ConcreteCompany("总公司");
Company *leaf1=new FinanceDepartment("财务部");
Company *leaf2=new HRDepartment("人力资源部");
root->Add(leaf1);
root->Add(leaf2);
//分公司A
Company *mid1 = new ConcreteCompany("分公司A");
Company *leaf3=new FinanceDepartment("财务部");
Company *leaf4=new HRDepartment("人力资源部");
mid1->Add(leaf3);
mid1->Add(leaf4);
root->Add(mid1);
//分公司B
Company *mid2=new ConcreteCompany("分公司B");
FinanceDepartment *leaf5=new FinanceDepartment("财务部");
HRDepartment *leaf6=new HRDepartment("人力资源部");
mid2->Add(leaf5);
mid2->Add(leaf6);
root->Add(mid2);
root->Show(0);
delete leaf1; delete leaf2;
delete leaf3; delete leaf4;
delete leaf5; delete leaf6;
delete mid1; delete mid2;
delete root;
return 0;
}

上面的实现方式有缺点,就是内存的释放不好,需要客户自己动手,非常不方便。有待改进,比较好的做法是让ConcreteCompany类来释放。因为所有的指针都是存在ConcreteCompany类的链表中。C++的麻烦,没有垃圾回收机制。


###一、UML图
关键词:Leaf是叶子,Composite是非叶子节点,Composite包含Leaf。

##二、概念

组合模式(Composite):将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

##三、说明

角色:

(1)Component:为组合中的对象声明接口,在适当情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component 的子部件。

(2)Leaf:在组合中白哦是叶节点对象,叶节点没有子节点。

(3)Composite:定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关的操作,比如增加Add和删除Remove。

什么时候使用组合模式?
当你发现需求中是体现部分与整体层次的结构时,以及你希望用户可以忽略组合对象与单个对象的不同,统一地使用组合结构中的所有对象时,就应该考虑用组合模式了。

使用组合模式的好处?
(1)组合模式定义了包含基本对象(Leaf)和组合对象(Composite)的类层次结构。基本对象可以被组合成更复杂的组合对象,而这个组合对象又可以被组合,这样不断地地柜下去,客户代码中,任何用到基本对象的地方都可以使用组合对象了。

(2)用户不用关心到底是处理一个叶子节点还是处理一个组合组件,也就不用为定义组合而写一些判断语句了。

(3)简而言之,组合模式让客户可以一致的使用组合结构和单个对象。

##四、C++实现

(1)Composite.h

//Component:此处为抽象公司类
class Company
{
protected:
std::string name;
public:
Company(std::string name)
{
this->name=name;
}
//增加节点
virtual void Add(Company* c)=0;
//删除节点
virtual void Remove(Company* c)=0;
//展示
virtual void Display(int depth)=0;
//职责
virtual void LineOfDuty()=0;
//运算符重载
inline bool operator(const Company &company) const
{
return this->namecompany.name;
}
};

//Composite:具体公司类
class ConcreteCompany:public Company
{
private:
std::list<Company> children;
public:
ConcreteCompany(std::string name):Company(name)
{
children=new std::list<Company
>;
}
~ConcreteCompany()
{
for(std::list<Company
>::iterator it=children->begin();it!=children->end();it)
delete it;
delete children;
}
//增加叶子节点
void Add(Company
c)
{
children->push_back(c);
}
//删除叶子节点
void Remove(Company* c)
{
for(std::list<Company*>::iterator it=children->begin();it!=children->end();it)
{
if(it==c)
{
children->erase(it);
break;
}
}
}
//打印
void Display(int depth)
{
for(int i=0;i<depth;i++)
std::cout<<"-";
std::cout<<name<<std::endl;
for(std::list<Company
>::iterator it=children->begin();it!=children->end();it)
(it)->Display(depth+4);
}
//职责
void LineOfDuty()
{
for(std::list<Company
>::iterator it=children->begin();it!=children->end();it)
(*it)->LineOfDuty();
}
};

//Leaf:人力资源部
class HRDepartment:public Company
{
public:
HRDepartment(std::string name):Company(name){}
void Add(Company* c){}
void Remove(Company* c){}
void Display(int depth)
{
for(int i=0;i<depth;i++)
std::cout<<"-";
std::cout<<name<<std::endl;
}
void LineOfDuty()
{
std::cout<<name<<" 员工招聘培训管理"<<std::endl;
}
};

//Leaf:财务部
class FinanceDepartment:public Company
{
public:
FinanceDepartment(std::string name):Company(name){}
void Add(Company* c){}
void Remove(Company* c){}
void Display(int depth)
{
for(int i=0;i<depth;i++)
std::cout<<"-";
std::cout<<name<<std::endl;
}
void LineOfDuty()
{
std::cout<<name<<" 公司财务收支管理"<<std::endl;
}
};

(2).Client.cpp

//Client,客户端
void main()
{
Company* root=new ConcreteCompany("北京总公司");
root->Add(new HRDepartment("总公司人力资源部"));
root->Add(new FinanceDepartment("总公司财务处"));
Company* comp=new ConcreteCompany("上海华东分公司");
comp->Add(new HRDepartment("华东分公司人力资源部"));
comp->Add(new FinanceDepartment("华东分公司财务处"));
root->Add(comp);
Company* comp1=new ConcreteCompany("南京办事处");
comp1->Add(new HRDepartment("南京办事处人力资源部"));
comp1->Add(new FinanceDepartment("南京办事处财务处"));
comp->Add(comp1);
Company* comp2=new ConcreteCompany("杭州办事处");
comp2->Add(new HRDepartment("杭州办事处人力资源部"));
comp2->Add(new FinanceDepartment("杭州办事处财务处"));
comp->Add(comp2);
std::cout<<"结构图:"<<std::endl<<std::endl;
root->Display(1);
std::cout<<std::endl<<"职责:"<<std::endl<<std::endl;
root->LineOfDuty();
delete root;
system("pause");
}

(3).运行结果