先看一个最小化的表述
vistor 访问者 通过不同element作为参数，实现不同的方法
Element 被访问者 其模式是固定的,都是accept(vistor)中，以自己为参数，回调vistor中对应的方法。其重点就在于element本身的传递.
我认为，当element多样化 且适合作为封闭的个体时 需要单独维护时候 适合用访问者模式。
/**
* 最小化的表述
* vistor 访问者 通过不同element作为参数，实现不同的方法
* Element 被访问者 其模式是固定的,都是accept(vistor)中，以自己为参数，回调vistor中对应的方法。其重点就在于element本身的传递.
* 当element多样化 且适合作为封闭的个体时 需要单独维护时候 适合用访问者模式。
*/
class VisitorA {
public void visit(){
System.out.println("我是A");
}
public void visit(ElementB b){
System.out.println("我是B");
}
public void visit(ElementC c){
System.out.println("我是C");
}
}
class ElementB {
public void accept(VisitorA vistor){
vistor.visit(this);
}
}
class ElementC {
public void accept(VisitorA vistor){
vistor.visit(this);
}
}
@Test
public void testMin(){
VisitorA visitor = new VisitorA();
ElementB b = new ElementB();
b.accept(visitor);
ElementC c = new ElementC();
c.accept(visitor);
}
下面是一个更为具体的实现
比如车 简单分为 车轮，引擎，车身 这些属于不同element，被访问者
当我们需要单独维护这些组件时候，比如说他们有一些仅属于自己的特性时候，可以通过访问者模式来实现需要的功能
比如下文举例中，金额的计算，类型的打印
通过对每一个不同的element，以vistor入参执行accept方法，在element的accept方法中，将自己本身作为入参，回调对应vistor接口中的实现方法，达到不同效果的实现
public class VisitorPattern {
interface Visitor {
void visit(Wheel wheel);
void visit(Engine engine);
void visit(Body body);
}
class Wheel extends Element {
void accept(Visitor visitor) {
visitor.visit(this);
}
}
abstract class Element {
int price;
void accept(Visitor visitor) {
}
}
class Engine extends Element {
void accept(Visitor visitor) {
visitor.visit(this);
}
}
class Body extends Element {
void accept(Visitor visitor) {
visitor.visit(this);
}
}
class PrintVisitor implements Visitor {
public void visit(Wheel wheel) {
System.out.println("Visiting wheel");
}
public void visit(Engine engine) {
System.out.println("Visiting engine");
}
public void visit(Body body) {
System.out.println("Visiting body");
}
}
/**
* 计算金额访问者，实现金额设置计算的功能
*/
class CalcVisitor implements Visitor {
public void visit(Wheel wheel) {
wheel.price = 100;
}
public void visit(Engine engine) {
engine.price =200;
}
public void visit(Body body) {
body.price = 300;
}
}
@Test
public void test() {
PrintVisitor visitor = new PrintVisitor();
Enforcer enforcer = new Enforcer(new Wheel(), new Engine(), new Body());
enforcer.visitAll(visitor);
}
@Test
public void testCalMoney() {
CalcVisitor visitor = new CalcVisitor();
Enforcer enforcer = new Enforcer(new Wheel(), new Engine(), new Body());
enforcer.visitAll(visitor);
enforcer.calcalateAll();
}
/**
* 执行者
*/
class Enforcer {
private List<Element> elementList = new ArrayList<>();
Enforcer(Wheel wheel, Engine engine, Body body) {
elementList.add(wheel);
elementList.add(engine);
elementList.add(body);
}
/**
* 通过以vistor为入参，遍历组件的accept方法，来实现访问所有的组件
*
* @param visitor
*/
public void visitAll(Visitor visitor) {
for (Element element : elementList) {
element.accept(visitor);
}
}
public void calcalateAll(){
int price= 0;
for(Element e : elementList){
price += e.price;
}
System.out.println(price);
}
}
}
我认为的使用场景：
- 每一个被访者都有需要单独维护的地方，需要进行封装
- 对于每个被访问者，都可以抽象出对应的计算规则/逻辑
项目中的应用：
在一些财务的结算项目中，有收入、利润、总利润等等很多不同的方面，同时每个的方面又有很多不同的计算规则需要保存。这个时候可以用访问者模式，将这些不同方面作为element，在vistor实现中，再取element中的不同规则，实现不同的计算逻辑。
