Java设计模式(二十三)：访问者设计模式

àì夳堔傛蜴生んèń 2022-03-29 10:09 348阅读 0赞

# 1. 应用场景 #

对于系统中的某些对象，它们存储在同一个集合中，且具有不同的类型，而且对于该集合中的对象，可以接受一类称为访问者的对象来访问，而且不同的访问者其访问方式有所不同，访问者模式为解决这类问题而诞生。

在实际使用时，对同一集合对象的操作并不是唯一的，对相同的元素对象可能存在多种不同的操作方式。而且这些操作方式并不稳定，可能还需要增加新的操作，以满足新的业务需求。此时，访问者模式就是一个值得考虑的解决方案。  
访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式，这就是访问者模式的模式动机。

# 2.概念 #

表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

# 3. Class Diagram #

*  Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作
 *  ConcreteVisitor：具体访问者，存储遍历过程中的累计结果
 *  ObjectStructure：对象结构，可以是组合结构，或者是一个集合。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMTI1MTgz_size_16_color_FFFFFF_t_70]

# 4. Implementation #

public interface Element { 
        void accept(Visitor visitor);
    }
    
    public class Item { 
        private String name;
    
        public Item(String name) { 
            this.name = name;
        }
    
        public String getName() { 
            return name;
        }
    
        public void accept(Visitor visitor) { 
            visitor.visit(this);
        }
    }
    
    public class Order implements Element{ 
        private String name;
        private List<Item> items = new ArrayList();
    
        public Order(String name) { 
            this.name = name;
        }
    
        public Order(String name, String itemName) { 
            this.name = name;
            this.addItem(new Item(itemName));
        }
    
        public String getName() { 
            return name;
        }
    
        public void addItem(Item item) { 
            items.add(item);
        }
    
        public void accept(Visitor visitor) { 
            visitor.visit(this);
    
            for (Item item : items) { 
                item.accept(visitor);
            }
        }
    }
    
    public class Customer implements Element{ 
        private String name;
        private List<Order> orders = new ArrayList<>();
    
        public Customer(String name) { 
            this.name = name;
        }
    
        public String getName() { 
            return name;
        }
    
        public void addOrder(Order order) { 
            orders.add(order);
        }
    
        public void accept(Visitor visitor) { 
            visitor.visit(this);
            for (Order order : orders) { 
                order.accept(visitor);
            }
        }
    }
    
    public class CustomerGroup implements Element{ 
        private List<Customer> customers = new ArrayList<>();
    
        public void accept(Visitor visitor) { 
            for (Customer customer : customers) { 
                customer.accept(visitor);
            }
        }
    
        public void addCustomer(Customer customer) { 
            customers.add(customer);
        }
    }
    
    public interface Visitor { 
        public void visit(Customer customer);
    
        public void visit(Order order);
    
        public void visit(Item item);
    }
    
    public class GeneralReport implements Visitor{ 
        private int customersNo;
        private int ordersNo;
        private int itemsNo;
    
        public void visit(Customer customer) { 
            System.out.println(customer.getName());
            customersNo++;
        }
    
        public void visit(Order order) { 
            System.out.println(order.getName());
            ordersNo++;
        }
    
        public void visit(Item item) { 
            System.out.println(item.getName());
            itemsNo++;
        }
    
        public void displayResults() { 
            System.out.println("Number of customers: " + customersNo);
            System.out.println("Number of orders: " + ordersNo);
            System.out.println("Number of items: " + itemsNo);
        }
    }
    
    public class Client { 
        public static void main(String[] args) { 
            Customer customer1 = new Customer("customer1");
            customer1.addOrder(new Order("order1", "item1"));
            customer1.addOrder(new Order("order2", "item1"));
            customer1.addOrder(new Order("order3", "item1"));
    
            Order order = new Order("order_a");
            order.addItem(new Item("item_a1"));
            order.addItem(new Item("item_a2"));
            order.addItem(new Item("item_a3"));
            Customer customer2 = new Customer("customer2");
            customer2.addOrder(order);
    
            CustomerGroup customers = new CustomerGroup();
            customers.addCustomer(customer1);
            customers.addCustomer(customer2);
    
            GeneralReport visitor = new GeneralReport();
            customers.accept(visitor);
    
            visitor.displayResults();
        }
    }
    
    运行结果：
    customer1
    order1
    item1
    order2
    item1
    order3
    item1
    customer2
    order_a
    item_a1
    item_a2
    item_a3
    Number of customers: 2
    Number of orders:    4
    Number of items:     6

# 5. 优点和缺点 #

## 5.1 优点 ##

*  允许你对组合结构加入新的操作，而无需改变结构本身。
 *  想要加入新的操作，想到容易
 *  访问者所进行的操作，其代码是集中在一起的。

## 5.2 用途和缺点 ##

*  当采用访问者模式的时候，就会打破组合类的封装
 *  因为游走的功能牵连其中，所以对组合结构的改变就更加困难

# 6. JDK #

*  javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
 *  javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMTI1MTgz_size_16_color_FFFFFF_t_70]: /images/20220329/9d5dfbce311441dc8c4043b05ea0bb3c.png