背景:
在现实生活中,有些集合对象中存在多种不同的元素,且每种元素也存在多种不同的访问者和处理方式。例如,公园中存在多个景点,也存在多个游客,不同的游客对同一个景点的评价可能不同;医院医生开的处方单中包含多种药元素,査看它的划价员和药房工作人员对它的处理方式也不同,划价员根据处方单上面的药品名和数量进行划价,药房工作人员根据处方单的内容进行抓药。
这样的例子还有很多,例如,电影或电视剧中的人物角色,不同的观众对他们的评价也不同;还有顾客在商场购物时放在“购物车”中的商品,顾客主要关心所选商品的性价比,而收银员关心的是商品的价格和数量。
这些被处理的数据元素相对稳定而访问方式多种多样的数据结构,如果用“访问者模式”来处理比较方便。访问者模式能把处理方法从数据结构中分离出来,并可以根据需要增加新的处理方法,且不用修改原来的程序代码与数据结构,这提高了程序的扩展性和灵活性。
定义:
将作用于某种数据结构中的各元素的操作分离出来封装成独立的类,使其在不改变数据结构的前提下可以添加作用于这些元素新的操作,为数据结构中的每一个元素提供多种访问方式。它将对数据的操作与数据结构进行分离,是行为模式在最复杂的一种模式。
适用场景:
1、对象结构相对稳定,但其操作算法经常变化的程序。
2、对象结构中的对象需要提供多种不同且不相关的操作,而且要避免让这些操作的变化影响对象的结构。
3、对象结构包含很多类型的对象,希望对这些对象实施一些依赖于其具体类型的操作。
优点:
1、扩展性好。能够在不修改对象结构中的元素的情况下,为对象结构中的元素添加新的功能。
2、复用性好。可以通过访问者来定义整个对象结构通用的功能,从而提高系统的复用程度。
3、灵活性好。访问者模式将数据结构与作用于结构上的操作解耦,使得操作集合可相对自由地演化而不影响系统的数据结构。
4、符合单一职责原则。访问者模式把相关的行为封装在一起,构成一个访问者,使每一个访问者的功能都比较单一。
缺点:
1、增加新的元素类很困难。在访问者模式中,每增加一个新的元素类,都要在每一个具体访问者类中增加相应的具体操作,这违背了“开闭原则”。
2、破坏封装。访问者模式中具体元素对访问者公布细节,这破坏了对象的封装性。
3、违反了依赖倒置原则。访问者模式依赖了具体类,而没有依赖抽象类。
组成元素:
1、抽象访问者角色(Visitor):定义一个访问具体元素的接口,为每个具体元素类对应一个访问操作 visit() ,该操作中的参数类型标识了被访问的具体元素。
2、具体访问者角色(ConcreteVisitor):实现抽象访问者角色中声明的各个访问操作,确定访问者访问一个元素时该做什么。
3、抽象元素角色(Element):声明一个包含接受操作 accept() 的接口,被接受的访问者对象作为 accept() 方法的参数。
4、具体元素角色(ConcreteElement):实现抽象元素角色提供的 accept() 操作,其方法体通常都是 visitor.visit(this) ,另外具体元素中可能还包含本身业务逻辑的相关操作。
5、对象结构角色(ObjectStructure):是一个包含元素角色的容器,提供让访问者对象遍历容器中的所有元素的方法,通常由 List、Set、Map 等聚合类实现。
类图如下:
抽象代码如下:
1、定义抽象访问者角色Visitor:
/*
抽象出一个访问者的接口
*/
public interface Visitor {
/*定义一个访问元素A时采用的方法*/
public void visit(ConcreteElementA element);
/*定义一个访问元素B时采用的方法*/
public void visit(ConcreteElementB element);
}
2、定义具体访问者角色ConcreteVisitorA和ConcreteVisitorB:
/*实例化一个具体访问者A*/
public class ConcreteVisitorA implements Visitor{
/*当访问具体元素A时,具体访问者A该做些什么*/
@Override
public void visit(ConcreteElementA element) {
System.out.println("具体访问者A访问-->"+element.operationA());
}
/*当访问具体元素B时,具体访问者B该做些什么*/
@Override
public void visit(ConcreteElementB element) {
System.out.println("具体访问者A访问-->"+element.operationB());
}
}
/*实例化一个具体访问者B*/
public class ConcreteVisitorB implements Visitor{
/*当访问具体元素A时,具体访问者B该做些什么*/
@Override
public void visit(ConcreteElementA element) {
System.out.println("具体访问者B访问-->"+element.operationA());
}
/*当访问具体元素B时,具体访问者B该做些什么*/
@Override
public void visit(ConcreteElementB element) {
System.out.println("具体访问者B访问-->"+element.operationB());
}
}
3、定义抽象元素角色Element:
/*定义一个抽象的元素接口*/
public interface Element {
/*定义一个元素接受访问者访问的方法*/
public void accept(Visitor visitor);
}
4、定义具体元素角色ConcreteElementA和ConcreteElementB:
/*具体元素A*/
public class ConcreteElementA implements Element{
/*表示访问者可以访问具体元素A*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/*具体元素A的其他操作*/
public String operationA() {
return "具体元素A的操作!";
}
}
/*具体元素B*/
public class ConcreteElementB implements Element{
/*表示访问者可以访问具体元素B*/
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
/*具体元素B的其他操作*/
public String operationB() {
return "具体元素B的操作!";
}
}
5、定义对象结构角色ObjectStructure:
/*一个包含元素角色的容器*/
public class ObjectStructure {
private List<Element> list = new ArrayList<Element>();
/*提供一个让访问者对象遍历容器中所有元素的方法*/
public void accept(Visitor visitor) {
Iterator<Element> i=list.iterator();
while(i.hasNext()){
((Element) i.next()).accept(visitor);
}
}
/*增加元素*/
public void add(Element element) {
list.add(element);
}
/*移除元素*/
public void remove(Element element) {
list.remove(element);
}
}
6:测试代码如下:
public class VisitorPattern {
public static void main(String[] args) {
ObjectStructure os=new ObjectStructure();
os.add(new ConcreteElementA());
os.add(new ConcreteElementB());
Visitor visitorA=new ConcreteVisitorA();
/*所有数据接受访问者A的访问*/
os.accept(visitorA);
System.out.println("------------------------");
/*所有数据接受访问者B的访问*/
Visitor visitorB=new ConcreteVisitorB();
os.accept(visitorB);
}
}
7:输出结果如下:
示例代码如下:
铜是一种金属材料,如果它在造币公司,它就会被制成纪念币;如果它在艺术品公司,就会被制成工艺品。同理,纸如果在造币公司,它就会被制成钞票;如果在艺术品公司,就会被制成画,我们使用访问者模式来实现下这个过程。
1、定义抽象访问者Company:
public interface Company {
public void visit(Paper paper);
public void visit(Cuprum cuprum);
}
2、定义具体访问者艺术品公司ArtCompany和造币公司MintCompany:
public class ArtCompany implements Company{
@Override
public void visit(Paper paper) {
System.out.println("艺术品公司需要"+paper.supportPaper()+"来造画");
}
@Override
public void visit(Cuprum cuprum) {
System.out.println("艺术品公司需要"+cuprum.supportCuprum()+"来造铜像");
}
}
public class MintCompany implements Company{
@Override
public void visit(Paper paper) {
System.out.println("造币公司需要"+paper.supportPaper()+"来造钱");
}
@Override
public void visit(Cuprum cuprum) {
System.out.println("造币公司需要"+cuprum.supportCuprum()+"来造硬币");
}
}
3、定义抽象元素材料Matreials:
public interface Matreials {
public void accept(Company company);
}
4、定义具体元素铜Cuprum和纸Paper:
public class Cuprum implements Matreials{
@Override
public void accept(Company company) {
company.visit(this);
}
public String supportCuprum() {
return "铜";
}
}
public class Paper implements Matreials{
@Override
public void accept(Company company) {
company.visit(this);
}
public String supportPaper() {
return "纸";
}
}
5、定义对象结构角色MatreialsStructure:
public class MatreialsStructure {
private List<Matreials> list = new ArrayList<Matreials>();
public void accept(Company company) {
Iterator<Matreials> i=list.iterator();
while(i.hasNext()){
((Matreials) i.next()).accept(company);
}
}
public void add(Matreials matreials) {
list.add(matreials);
}
public void remove(Matreials matreials) {
list.remove(matreials);
}
}
6:测试代码如下:
public class VisitorPattern {
public static void main(String[] args) {
MatreialsStructure os=new MatreialsStructure();
os.add(new Cuprum());
os.add(new Paper());
Company visitorA=new ArtCompany();
os.accept(visitorA);
System.out.println("------------------------");
Company visitorB=new MintCompany();
os.accept(visitorB);
}
}
7、输出结果如下:
模式拓展:
访问者(Visitor)模式是使用频率较高的一种设计模式,它常常同以下两种设计模式联用。
1、与迭代器模式联用。因为访问者模式中的“对象结构”是一个包含元素角色的容器,当访问者遍历容器中的所有元素时,常常要用迭代器。如刚才例子中的对象结构是用 List 实现的,它通过 List 对象的 Itemtor() 方法获取迭代器。如果对象结构中的聚合类没有提供迭代器,也可以用迭代器模式自定义一个。
2、与组合模式联用。因为访问者(Visitor)模式中的“元素对象”可能是叶子对象或者是容器对象,如果元素对象包含容器对象,就必须用到组合模式。