访问者模式

最新推荐文章于 2021-05-31 06:10:45 发布

快乐的小三菊

最新推荐文章于 2021-05-31 06:10:45 发布

阅读量337

点赞数

分类专栏： java 设计模式

本文链接：https://blog.csdn.net/xhf852963/article/details/103664033

版权

java 设计模式专栏收录该内容

24 篇文章 0 订阅

订阅专栏

背景：

在现实生活中，有些集合对象中存在多种不同的元素，且每种元素也存在多种不同的访问者和处理方式。例如，公园中存在多个景点，也存在多个游客，不同的游客对同一个景点的评价可能不同；医院医生开的处方单中包含多种药元素，査看它的划价员和药房工作人员对它的处理方式也不同，划价员根据处方单上面的药品名和数量进行划价，药房工作人员根据处方单的内容进行抓药。
这样的例子还有很多，例如，电影或电视剧中的人物角色，不同的观众对他们的评价也不同；还有顾客在商场购物时放在“购物车”中的商品，顾客主要关心所选商品的性价比，而收银员关心的是商品的价格和数量。
这些被处理的数据元素相对稳定而访问方式多种多样的数据结构，如果用“访问者模式”来处理比较方便。访问者模式能把处理方法从数据结构中分离出来，并可以根据需要增加新的处理方法，且不用修改原来的程序代码与数据结构，这提高了程序的扩展性和灵活性。

定义：

将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素新的操作，为数据结构中的每一个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为模式在最复杂的一种模式。

适用场景：

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）模式中的“元素对象”可能是叶子对象或者是容器对象，如果元素对象包含容器对象，就必须用到组合模式。