设计模式之19访问者模式（笔记）

1 定义：

1.1 定义：Represent an operation to be performed on the elements of an object structure. Vistor lets you define a new operation without changing the classes of the elements on which it operates.(封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。)

1.2 通用类图：

角色说明：

Visitor——抽象访问者：

抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是visit方法的参数定义哪些对象是可以被访问的。

ConcreteVisitor——具体访问者：

它影响访问者访问到一个类后该怎么干，要做什么事情。

Element——抽象元素：

接口或者抽象类，声明接受哪一类访问者访问，程序上是通过accept方法中的参数来定义的。

ConcreteElement——具体元素：

实现accept方法，通常是visitor.visit(this)，基本上都形成一种模式了。

ObjectStructure——结构对象：

元素产生者，一般容纳在多个不同类、不同接口的容器，如List、Set、Map等，在项目中，一般很少抽象出这个角色。

一个更易懂的类图：

1.3 通用代码：

注意Vistor.visit(elem)方法，此方法更多的时候是取出elem中成员，按所需处理显示。

public abstract class Element {
	// 定义业务逻辑
	public abstract void doSomething();

	// 允许谁来访问
	public abstract void accept(IVisitor visitor);
}

public class ConcreteElement1 extends Element {
	// 完善业务逻辑
	public void doSomething() {
		// 业务处理
	}

	// 允许那个访问者访问
	public void accept(IVisitor visitor) {
		visitor.visit(this);
	}
}

public class ConcreteElement2 extends Element {
	// 完善业务逻辑
	public void doSomething() {
		// 业务处理
	}

	// 允许那个访问者访问
	public void accept(IVisitor visitor) {
		visitor.visit(this);
	}
}

public interface IVisitor {
	// 可以访问哪些对象
	public void visit(ConcreteElement1 el1);

	public void visit(ConcreteElement2 el2);
}

public class Visitor implements IVisitor {
	// 访问el1元素
	public void visit(ConcreteElement1 el1) {
		el1.doSomething();
	}

	// 访问el2元素
	public void visit(ConcreteElement2 el2) {
		el2.doSomething();
	}
}

public class ObjectStruture {
	// 对象生成器，这里通过一个工厂方法模式模拟
	public static Element createElement() {
		Random rand = new Random();
		if (rand.nextInt(100) > 50) {
			return new ConcreteElement1();
		} else {
			return new ConcreteElement2();
		}
	}
}

public class Client {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			// 获得元素对象
			Element el = ObjectStruture.createElement();
			// 接受访问者访问
			el.accept(new Visitor());
		}
	}
}

2 优点

2.1 符合单一职责原则：具体元素角色负责数据的加载，而Visitor类则负责报表的展现，两个不同的职责非常明确地分离开来，各自演绎变化；

2.2 优秀的扩展性：数据不同的展示，直接在Vistor中增加方法实现；

2.3 灵活性高：对于不同的数据实体，不需要instanceof判断。

3 缺点

3.1 具体元素对访问者公布细节：违背了LOW原则；

3.2 具体元素变更比较困难：增、删、改都会导致Visitor的修改。

3.3 违背了依赖倒置原则：访问者依赖的是具体元素，而不是抽象元素，扩展比较困难。

4 应用场景

4.1 一个对象结构包含很多类对象，他们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作，也就是迭代器模式已经不能胜任的情况。

4.2 需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免这些操作“污染”这些对象的类。

总结：业务规则要求遍历多个不同的对象，这本身是访问者模式的出发点，迭代器模式只能访问同类或接口的数据（当然了，如果你使用instanceof，那么能访问所有的数据），而访问者是对迭代器模式的扩充，可以遍历不同的对象，然后针对不同的对象，执行不同的操作。

5 注意事项

暂无

6 扩展

6.1 统计功能；

6.2 多个访问者：如显示、汇总

6.3 双分派（Java是一个单分派语言：重载时，方法的实参类型源于定义，而方法的所属对象则是动态绑定。）：使用多态+访问者模式，可以看出java是一个支持双分派的单分派语言。

源码一：测试单分派：

public interface Role {
	// 演员要扮演的角色
}

public class IdiotRole implements Role {
	// 一个弱智角色
}

public class KungFuRole implements Role {
	// 武功天子第一的角色
}

public abstract class AbsActor {
	// 演员都能够演一个角色
	public void act(Role role) {
		System.out.println("演员可以扮演任何角色");
	}

	// 可以演功夫戏
	public void act(KungFuRole role) {
		System.out.println("演员都可以演功夫角色");
	}
}

public class YoungActor extends AbsActor {
	// 年轻演员最喜欢演功夫戏
	public void act(KungFuRole role) {
		System.out.println("最喜欢演功夫角色");
	}
}

public class OldActor extends AbsActor {
	// 不演功夫角色
	public void act(KungFuRole role) {
		System.out.println("年龄大了，不能演功夫角色");
	}
}

public class Client {
	public static void main(String[] args) {
		// 定义一个演员
		AbsActor actor = new OldActor();
		// 定义一个角色
		Role role = new KungFuRole();
		// 开始演戏
		actor.act(role);
		actor.act(new KungFuRole());
	}
}

源码二：实现双分派：（更改下列代码）

public interface Role {
	// 演员要扮演的角色
	public void accept(AbsActor actor);
}

public class KungFuRole implements Role {
	// 武功天子第一的角色
	public void accept(AbsActor actor) {
		actor.act(this);
	}
}

public class IdiotRole implements Role {
	// 一个弱智角色,然谁来扮演
	public void accept(AbsActor actor) {
		actor.act(this);
	}
}

public class Client {
	public static void main(String[] args) {
		// 定义一个演员
		AbsActor actor = new OldActor();
		// 定义一个角色
		Role role = new KungFuRole();
		// 开始演戏
		role.accept(actor);
	}
}

7 范例

暂无。通用源码即可。