设计模式之访问者模式(Visitor)

访问者模式：在不改变一个已存在的类的层次结构的情况下，为这个层次结构中的某些类定义一个新的操作，这个新的操作作用于(操作)已存在的类对象，也即新的操作需要访问被作用的对象。

一句话: 为一个稳定的类结构增加操作. 也即把易变化的类的行为搬到访问者中.

特点：

1 访问者角色(Visitor)作用于具体的元素执行相关的操作;

2 元素角色(Element)定义了accept方法接受一个访问者,并通过调用Visitor的方法执行操作;

3 对象结构角色(Object structure)容许访问者访问每个元素。

个人认为访问者模式是最复杂最难理解的模式。

基本代码：

//访问者接口package designpattern.visitor;public interface IVisitor {public void visitElement1(ConcreteElement1 e);public void visitElement2(ConcreteElement2 e);}//具体访问者1package designpattern.visitor;public class ConcreteVisitor1 implements IVisitor{public void visitElement1(ConcreteElement1 e) {System.out.println("ConcreteVisitor1 visit ConcreteElement1.");}public void visitElement2(ConcreteElement2 e) {System.out.println("ConcreteVisitor1 visit ConcreteElement2.");}}//具体访问者2package designpattern.visitor;public class ConcreteVisitor2 implements IVisitor{public void visitElement1(ConcreteElement1 e) {System.out.println("ConcreteVisitor2 visit ConcreteElement1.");}public void visitElement2(ConcreteElement2 e) {System.out.println("ConcreteVisitor2 visit ConcreteElement2.");}}//类结构借口 package designpattern.visitor;public interface Element {public void accept(IVisitor v);}//实体类1package designpattern.visitor;public class ConcreteElement1 implements Element{public void accept(IVisitor v) {v.visitElement1(this);}}//实体类2package designpattern.visitor;public class ConcreteElement2 implements Element{public void accept(IVisitor v) {v.visitElement2(this);}}//对象结构package designpattern.visitor;import java.util.*;public class ObjectsStructure {List<Element> list = new ArrayList();public ObjectsStructure(){list.add(new ConcreteElement1());list.add(new ConcreteElement2());}public void process(IVisitor v){for(Element e : list){e.accept(v);}}public static void main(String[] args){ObjectsStructure o = new ObjectsStructure();o.process(new ConcreteVisitor1());o.process(new ConcreteVisitor2());}}

再举一个例子，例子的来源于《大话设计模式》，作者试图从如下的几句话中抽象几个角色：

当男人成功时，背后多半有一个伟大的女人

当女人成功时，背后大多有一个不成功的男人

当男人失败时，闷头喝酒，谁也不用劝

当女人失败时，眼泪汪汪，谁劝也没用

当男人恋爱时，凡事不懂也装懂

当女人恋爱时，遇事懂也装不懂

。。。。

我们很容易写出这样的代码:

public class Woman {public void getBehavior(String status){if("成功".equals(status)){System.out.println("背后大多有一个不成功的男人");}else if("失败".equals(status)){System.out.println("眼泪汪汪，谁劝也没用");}else if("恋爱".equals(status)){System.out.println("遇事懂也装不懂");}else if("结婚".equals(status)){//......}}}//public class Man {public void getBehavior(String status){if("成功".equals(status)){System.out.println("背后多半有一个伟大的女人");}else if("失败".equals(status)){System.out.println("闷头喝酒，谁也不用劝");}else if("恋爱".equals(status)){System.out.println("凡事不懂也装懂");}else if("结婚".equals(status)){//......}}}

但是这样写出现了两个问题:

1 代码中有坏味道, if else充斥着整个方法体;

2 外部状态(成功,失败,恋爱,结婚....)是非稳定的因素, 他们可能随时会改变, 可能随时会增加, 如果增加了新的状态, 比如生病,升迁,当官等, 我们就得修改代码, 这就违背了开放封闭原则(关于开放封闭原则, 将在后面写blog解释).

 

因为人分两种, 男人, 女人, 这种类结构几乎不会发生变化, 而外在的状态(成功,失败,恋爱,结婚....)却可以随时改变, 所以我们用访问者模式来改进上面的代码:

//package designpattern.visitor;public interface Person {public void accept(Visitor v);}//package designpattern.visitor;public class Man implements Person{public void accept(Visitor v) {v.visit(this);}}//package designpattern.visitor;public class Woman implements Person{public void accept(Visitor v) {v.visit(this);}}//package designpattern.visitor;public interface Visitor {public void visit(Man m);public void visit (Woman w);}//package designpattern.visitor;public class Success implements Visitor {public void visit(Man m) {System.out.println("当男人成功时，背后多半有一个伟大的女人");}public void visit(Woman w) {System.out.println("当女人成功时，背后大多有一个不成功的男人");}}//package designpattern.visitor;public class Love implements Visitor{public void visit(Man m) {System.out.println("当男人恋爱时，凡事不懂也装懂");}public void visit(Woman w) {System.out.println("当女人恋爱时，遇事懂也装不懂");}}//package designpattern.visitor;public class Failure implements Visitor{public void visit(Man m) {System.out.println("当男人失败时，闷头喝酒，谁也不用劝");}public void visit(Woman w) {System.out.println("当女人失败时，眼泪汪汪，谁劝也没用");}}

再举一例，我们假设银行只有两种经典业务：存款，取款，这两种业务种类自从有银行开始都没有变过, 所以他们是稳定因素,然而随着时代的变迁，银行的客户却在逐渐细分，增加。过去有普通存款，取款类型， 公司存款取款类型，现在有了一些新的客户群，比如股票第三方存取款客户，代理基金业务客户等。而且银行在不断的开辟新的客户。 可以认为，银行的服务结构没有变，变的是外在的客户，可以用访问者模式。

//服务接口package designpattern.visitor.bank;public abstract class Service {public abstract void accept(Visitor v);public int getCounterNum(){//得到可用的服务柜台，现实中的算法可以是通过看哪个柜台空闲就到哪个柜台，或者是按照一定的规则排序。//这里为了简化，就用随机数。return (int) Math.floor((Math.random()*4));}}//访问者接口package designpattern.visitor.bank;public interface Visitor {public void visit(DrawService s);public void visit(SavingService s);}//package designpattern.visitor.bank;public class DrawService extends Service {public void accept(Visitor v) {v.visit(this);}}//package designpattern.visitor.bank;public class SavingService extends Service {public void accept(Visitor v) {v.visit(this);}}////普通存款取款访问者package designpattern.visitor.bank;public class CommonVisitor implements Visitor {public void visit(DrawService s) {System.out.println("您办理的是普通取款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}public void visit(SavingService s) {System.out.println("您办理的是普通存款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}}////公司业务办理者package designpattern.visitor.bank;public class CompanyVisitor implements Visitor{public void visit(DrawService s) {System.out.println("您办理的是公司取款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}public void visit(SavingService s) {System.out.println("您办理的是公司存款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}}////股票第三方存款业务办理者package designpattern.visitor.bank;public class StockVisitor implements Visitor {public void visit(DrawService s) {System.out.println("您办理的是股票交易第三方取款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}public void visit(SavingService s) {System.out.println("您办理的是股票交易第三方存款业务。" + "请到 " + s.getCounterNum() + " 窗口。");}}////基金买卖委托业务办理者package designpattern.visitor.bank;public class FundVisitor implements Visitor {public void visit(DrawService s) {System.out.println("您办理的是基金委托买入业务。" + "请到 " + s.getCounterNum() + " 窗口。");}public void visit(SavingService s) {System.out.println("您办理的是基金委托卖出业务。" + "请到 " + s.getCounterNum() + " 窗口。");}}

优点：

对类结构增加新的操作很容易，只需要增加一个新的访问者。

缺点：

1 复杂

2 当数据结构或类发生变化的时候改动太大。

经典案例：

找ing。。。