• 通常访问者模式会结合组合模式一起来用。组合模式对我们的建议是：使用递归而非迭代去操作复杂的数据结构。访问者模式侧重将具体的操作逻辑与复杂数据结构分离出来。把操作逻辑放到访问者里面去。
    • 重构一下部门树，将之前的remove()等逻辑抽象为操作访问者的逻辑。
    1.     public static class Department {
    3.         private String name;
    4.         private List<Department> children = new ArrayList<Department>();
    6.         public Department(String name) {
    7.             super();
    8.             this.name = name;
    9.         }
    11.         public String getName() {
    12.             return name;
    13.         }
    14.         public void setName(String name) {
    15.             this.name = name;
    16.         }
    17.         public List<Department> getChildren() {
    18.             return children;
    19.         }
    20.         public void setChildren(List<Department> children) {
    21.             this.children = children;
    22.         }
    24.         //这里接客,可以观光
    25.         public void accept(Visitor visitor) {
    26.             visitor.visit(this);
    27.         }
    29.     }
    • 构造访问者接口，它专门处理对Department这种复杂数据结构的操作。
    1.     public interface Visitor {        
    2.         void visit(Department dept);        
    3.     }
    • 实现访问者接口，构造删除部门和更新部门两种访问操作。
    1.     public static class RemoveVisitor implements Visitor {
    3.         public void visit(Department dept) {
    4.             if(dept.getChildren().size() > 0) {
    5.                 for(Department child : dept.getChildren()) {  
    6.                     //在这里实现递归遍历
    7.                     child.accept(this);  
    8.                 }
    9.             }
    10.             System.out.println("删除部门【" + dept.getName() + "】");  
    11.         }        
    12.     }    
    14.     public static class UpdateStatusVisitor implements Visitor {
    16.         private String status;
    18.         public void visit(Department dept) {
    19.             if(dept.getChildren().size() > 0) {
    20.                 for(Department child : dept.getChildren()) {  
    21.                     //在这里实现递归遍历
    22.                     child.accept(this);  
    23.                 }
    24.             }
    25.             System.out.println("将部门【" + dept.getName() + "】的状态修改为：" + status);  
    26.         }
    28.         public UpdateStatusVisitor(String status) {
    29.             this.status = status;
    30.         }    
    31.     }
    • 测试
    1.     public static void main(String[] args) {
    2.         Department leafDept1 = new Department("叶子部门1"); 
    3.         Department leafDept2 = new Department("叶子部门2");
    4.         Department leafDept3 = new Department("叶子部门3"); 
    6.         Department subDept1 = new Department("子部门1");
    7.         subDept1.getChildren().add(leafDept1);
    8.         subDept1.getChildren().add(leafDept2);
    10.         Department subDept2 = new Department("子部门2"); 
    11.         subDept2.getChildren().add(leafDept3);
    13.         Department parentDept = new Department("父部门");
    14.         parentDept.getChildren().add(subDept1);
    15.         parentDept.getChildren().add(subDept2);
    17.         Visitor removeVisitor = new RemoveVisitor();
    18.         parentDept.accept(removeVisitor);
    20.         Visitor updateStatusVisitor = new UpdateStatusVisitor("禁用");  
    21.         parentDept.accept(updateStatusVisitor);
    22.     }