访问者模式进阶(三)

    这一篇讲述一下如何用反射改造访问者模式，使之在增加具体元素的时候也符合“开放-封闭”原则(OCP)。为了理解的连贯性继续采用之前的男人-女人的例子。
这是既定访问者的类图：





在(二)在介绍过，既定访问者模式增加具体元素之所以如此困难是因为访问者与具体元素(被访问者)的互相依赖，必须去除这这一层的依赖关系。
请看如何用反射来改变这一层依赖关系：

import java.lang.reflect.Method;

public abstract class ReflectionVisitor  {
	public void visit(Person person) {
		// 判断是否是null
		if (person == null) {
			throw new NullPointerException("大哥,Person不能为空啊!");
		}
		// 组装class数组，即调用动态方法的时候参数的类型
		Class[] classes = new Class[] { person.getClass() };
		// 组装与class数组相对应的值
		Object[] objects = new Object[] { person };
		try {
			// 查找方法
			Method m = getClass().getMethod("visit", classes);
			// 调用该方法
			m.invoke(this, objects);
		} catch (NoSuchMethodException e) {
			// 没有找到相应的方法
			System.out.println("在"+getClass().getName()+"中,你没有实现" + person.getClass().getName() + "的visit方法");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

现在抽象访问者不再是一个接口，而是一个抽象类，为了方便理解把它叫做ReflectionVisitor，里面退化到只有一个visit方法，参数是Person类型，也就是抽象访问者原来依赖于各个具体元素的关系被抽象成只依赖于具体元素的接口，这样当增加新的具体元素，抽象访问者就不需要因为增加对应新元素的visit方法而重新编译！

具体元素的接口与具体元素
基本没有变化，参数类型从Visitor变成ReflectionVisitor

public interface Person {     
     void accept(ReflectionVisitor visitor);
}

public class Man implements Person{

	public void accept(ReflectionVisitor visitor) {
		visitor.visit(this);
	}
}

public class Woman implements Person{

	public void accept(ReflectionVisitor visitor) {
		visitor.visit(this);
	}
}

具体访问者，也几乎没有变化，不过从实现Visitor接口变成继承ReflectionVisitor抽象类

//成功时Man与Woman的不同表现
public class Success extends ReflectionVisitor{

	public void visit(Man man) {
		System.out.println("当男人成功时，背后多半有一个伟大的女人");
	}

	public void visit(Woman girl) {
		System.out.println("当女人成功时，背后大多有一个不成功的男人");
	}
}

//恋爱时Man与Woman的不同表现
public class Love extends ReflectionVisitor{

	public void visit(Man man) {
		System.out.println("当男人恋爱时，凡事不懂也装懂");
	}

	public void visit(Woman girl) {
		System.out.println("当女人恋爱时，遇事懂也装不懂");
	}
}

ObjectStructure类与客户端测试代码

import java.util.*;

public class ObjectStructure {
    private List<Person> elements = new ArrayList<Person>();

    public void attach(Person element){
    	elements.add(element);
    }
    
    public void detach(Person element){
    	elements.remove(elements);
    }
    
    //遍历各种具体元素并执行他们的accept方法

    public void display(ReflectionVisitor visitor){
    	for(Person p:elements){
    		p.accept(visitor);
    	}
    }
}

public class Client {
      public static void main(String[] args) {
		ObjectStructure o = new ObjectStructure();  //依赖于ObjectStructure
		//实例化具体元素
		o.attach(new Man());  
		o.attach(new Woman());

		//当成功时不同元素的不同反映
		ReflectionVisitor success = new Success();          
		o.display(success);
		
		//当恋爱时的不同反映
		ReflectionVisitor amativeness = new Love();         
		o.display(amativeness);
		

	}
}

结果显示：
当男人成功时，背后多半有一个伟大的女人
当女人成功时，背后大多有一个不成功的男人
当男人恋爱时，凡事不懂也装懂
当女人恋爱时，遇事懂也装不懂


现在增加一个具体元素(被访问者)

public class Bruce implements Person {

	public void accept(ReflectionVisitor visitor) {
		visitor.visit(this);
	}
}

修改一下客户端测试代码：

public class Client {
      public static void main(String[] args) {
		ObjectStructure o = new ObjectStructure();  //依赖于ObjectStructure
		//实例化具体元素
		o.attach(new Man());  
		o.attach(new Woman());
//		o.attach(new Bruce());
		//当成功时不同元素的不同反映
		ReflectionVisitor success = new Success();          
		o.display(success);
		
		//当恋爱时的不同反映
		ReflectionVisitor amativeness = new Love();         
		o.display(amativeness);
		
		//当失败时的不同反映
//		ReflectionVisitor fail = new Fail_Reflection();
//		o.display(fail);
	}
}

结果显示：
当男人成功时，背后多半有一个伟大的女人
当女人成功时，背后大多有一个不成功的男人
在visitor.reflection4.Success中,你没有实现visitor.reflection4.Bruce的visit方法
当男人恋爱时，凡事不懂也装懂
当女人恋爱时，遇事懂也装不懂
在visitor.reflection4.Love中,你没有实现visitor.reflection4.Bruce的visit方法


其实抽象访问者中的visit方法就是通过反射去查找每一个具体访问者中所实现的对各个具体元素的visit方法，然后捕捉NoSuchMethodException的异常。这样的好处就是你可以自由选择某种具体访问者对某种具体元素(被访问者)visit方法的实现，增加了灵活性。而且增加一个新具体元素时，再也不需要重新编译抽象访问者与所有具体访问者。从而达到部分的“开放-封闭”。当然，你要增加某种具体访问者的visit方法时，还需要去修改具体访问者的类。但这比修改所有访问者and重新编译要好得多。缺点就是，从实现Visitor接口变成了继承ReflectionVisitor抽象类～～～～～～

反射用在这个例子上有点乏味，迟下结合组合模式讲可能会更加恰当。