访问者模式

    visitor定义  
    作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.
　　在Java 中,Visitor 模式实际上是分离了collection 结构中的元素和对这些元素进行操作的行为
   
    参考：http://smartfool.iteye.com/blog/207092 总觉得他的代码实现有些问题，每次执行的都是默认的业务方法，所以修改了下

    话说有一个银行，有三个窗口，但是每个窗口的智能都是一样的，即都能办理所有的业务。因此每位来银行办理业务的人只要排队就是了，排到你了，就向业务员说明你要办理的业务，然后业务员根据你的业务选择不同的单据，打开不同的账本。
    业务员此时典型的工作流程是：

Java代码  

1.     if (service instanceof Saving){  
2.     //存款  
3.    ......  
4. }else if (service instanceof Draw){  
5.     //提款  
6.    ......  
7. }else if (service instanceof Fund){  
8.     //基金  
9.    ......  
10. }   
11. ......  

于是每位业务员的桌面总是塞得满满的，更重要的是大量的时间都花在受理不同业务之间的切换，使得效率很低。

有没有方法能够使得业务员的工作效率提高呢？银行经理苦思冥想了半天，终于想出了一个好办法。他让每个窗口各负责一个业务，同时委任了一位访问者(Visitor)，负责在客户进门时，询问他要办理什么业务，告诉他应该去哪个窗口办理。这样，每个窗口的业务员就只负责一项业务，减少了在不同业务间切换的时间耗费 ，效率大大提高。更重要的是，当某一项业务的处理流程发生变更时，不需要同时麻烦三个窗口的业务员，而只需要让处理这项业务的业务员进行修改就可以了 。

下面就来定义Visitor类，这个Visitor类实际上还办含了不同窗口受理员的职责，可以认为是银行的受理反应机制吧。

Java代码  

1. package visitor;  
2.   
3. public class Visitor {  
4.     public void process(Service service){  
5.         // 基本业务  
6.         System.out.println("基本业务");  
7.     }  
8.     public void process(Saving service){  
9.         // 存款  
10.         System.out.println("存款");  
11.     }  
12.       
13.     public void process(Draw service){  
14.         // 提款  
15.         System.out.println("提款");  
16.     }  
17.       
18.     public void process(Fund service){  
19.         System.out.println("基金");  
20.         // 基金  
21.     }  
22. }   

服务接口类

Java代码  

1. package visitor;  
2.   
3. public interface Service {  
4.     public void accept(Visitor visitor);  
5. }  

具体的服务类
存款：

Java代码  

1.  package visitor;  
2.   
3. ublic class Saving implements Service {  
4.   
5. public void accept(Visitor visitor) {  
6.       
7.     visitor.process(this);  
8. }  

取款：

Java代码  

1. package visitor;  
2.   
3. public class Draw implements Service {  
4.   
5.     public void accept(Visitor visitor) {  
6.       
7.         visitor.process(this);  
8.     }  
9.   
10. }  

基金：

Java代码  

1. package visitor;  
2.   
3. public class Fund implements Service {  
4.   
5.     public void accept(Visitor visitor) {  
6.       
7.         visitor.process(this);  
8.     }  
9.   
10. }  

测试：被注释掉得部分是普通实现方式

Java代码  

1. package visitor;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7. public class Test {  
8.     //访问者模式实现方法  
9.     public static void main(String[] args) {    
10.         Service s1 = new Saving();    
11.         Service s2 = new Draw();    
12.         Service s3 = new Fund();    
13.             
14.         Visitor visitor = new Visitor();    
15.             
16.         s1.accept(visitor);    
17.         s2.accept(visitor);    
18.         s3.accept(visitor);    
19.     }    
20.       
21.       
22.     //普通实现方法  
23. //  public static void main(String[] args) {  
24. //      Service s1 = new Saving();    
25. //      Service s2 = new Draw();    
26. //      Service s3 = new Fund();   
27. //        
28. //      //要办理业务的三个客户队列  
29. //      List<Service> list = new ArrayList<Service>();  
30. //      list.add(s1);  
31. //      list.add(s2);  
32. //      list.add(s3);  
33. //        
34. //      Iterator<Service> it = list.iterator();  
35. //      while(it.hasNext()){  
36. //        Service s = it.next();  
37. //         if (s instanceof Saving){    
38. //              System.out.println("存款");  
39. //  
40. //          }else if (s instanceof Draw){    
41. //              System.out.println("取款");  
42. //  
43. //          }else if (s instanceof Fund){    
44. //              System.out.println("基金");  
45. //          }     
46. //          
47. //      }  
48. //        
49. //     
50. //  
51. //  }  
52.       
53. }  

Visitor模式实际上是利用的语言本身的特性，见Vistor类的各个函数，通过不同的参数来自动查找相应的处理函数。

采用Visitor的好处如上面说到的那样，当需要改变其中一项业务的处理时，不需要每个地方都进行修改，而只需要改动Visitor类中相应的处理函数就可以了。也就是说它适合于业务处理时常发生变动的情况。

当然，Visitor也有它自身的限制。它不适合于业务数量的经常变化，因为一旦新增或删除一些Service时，需要对visitor进行相应的增删。也就是说具体Service与Visitor是耦合的。