Java设计模式（17）：访问者模式

古城微笑少年丶 2022-12-29 02:12 91阅读 0赞

# 17，访问者模式（Visitor） #

## 17.1，问题引入\_账本查看 ##

*  财务系统是存在财务账本，财务账本有很多分类，而其中大体可以分为两种：支出和收入
 *  查看账本的人也分为好几种：老板，注会等等，每一个人查看账本的目的也是不相同的
 *  这时候对有多个固定元素的账本和多个角色的访问者，可以考虑使用访问者模式

## 17.2，基本介绍 ##

*  访问者模式（Visitor Pattern）：封装一些作用于某种数据结构的各元素操作，可以在不改变数据结构的前提下定义作用与这些元素的新的操作
 *  主要是将数据结构（元素）与数据操作（访问者）分离，解决数据结构与数据操作耦合性的问题
 *  访问者模式的基本工作原理是：在被访问的类里面加一个对外提供接待访问者的接口
 *  访问者模式主要应用场景是：需要一个对象结构中的对象进行不同的操作（这些操作之间彼此没有关联），同时需要避免让这些操作污染这些对象的类，可以选用访问者模式解决
 *  在问题引入的例子中，账本分类就是不同的元素，查看账本的人是不同的访问者，元素对外提供访问方式，多个元素组装成一个对象结构，由不同的访问者进行自定义访问

## 17.3，类图 ##

![在这里插入图片描述][20201219140252431.png]

*  `IElement`：元素顶级接口，用于构造对象结构，内部提供访问者访问方式
 *  `ElementA`：具体元素，实现自元素顶级接口，重写访问方式方法，提供对元素的进行访问
 *  `ElementStructure`：数据结构，即元素集合，对固定元素进行统一管理，由访问者进行访问
 *  `IVisitor`：访问者顶级接口，定义访问者的访问操作，对多个固定元素进行操作
 *  `Visitor`：具体访问者，实现自访问者顶级接口，重写访问操作，自定义该访问者的元素操作方式
 *  `Client`：客户端操作

## 17.4，代码实现 ##

*  `IElement`：元素顶级接口
    
        package com.self.designmode.visitor;
        
        /** * 访问者模式_元素顶层接口, 用于提供给访问者进行访问 * @author PJ_ZHANG * @create 2020-12-10 17:17 **/
        public interface IElement { 
        
            /** * 接受访问者访问 * @param visitor */
            void accept(IVisitor visitor);
        
            String getName();
        
        }
 *  `ElementA`：具体元素A
    
        package com.self.designmode.visitor;
        
        /** * 具体元素类, 用于访问者访问 * @author PJ_ZHANG * @create 2020-12-10 17:20 **/
        public class ElementA implements IElement { 
        
            private String name;
        
            public ElementA(String name) { 
                this.name = name;
            }
        
            /** * 接受访问者访问自己 * @param visitor */
            @Override
            public void accept(IVisitor visitor) { 
                visitor.viewElementA(this);
            }
        
            @Override
            public String getName() { 
                return name;
            }
        }
 *  `ElementB`：具体元素B
    
        package com.self.designmode.visitor;
        
        /** * 具体元素类, 用于访问者访问 * @author PJ_ZHANG * @create 2020-12-10 17:20 **/
        public class ElementB implements IElement { 
        
            private String name;
        
            public ElementB(String name) { 
                this.name = name;
            }
        
            /** * 接受访问者访问自己 * @param visitor */
            @Override
            public void accept(IVisitor visitor) { 
                visitor.viewElementB(this);
            }
        
            @Override
            public String getName() { 
                return name;
            }
        
        }
 *  `IVisitor`：访问者顶级接口
    
        package com.self.designmode.visitor;
        
        /** * 访问者模式_访问者顶层接口. * @author PJ_ZHANG * @create 2020-12-10 17:18 **/
        public interface IVisitor { 
            
            // 元素访问可以根据实际情况通过反射进行分发
            
            /** * 访问元素A * @param elementA */
            void viewElementA(ElementA elementA);
        
            /** * 访问元素B * @param elementB */
            void viewElementB(ElementB elementB);
        
        }
 *  `VisitorA`：访问者具体角色A
    
        package com.self.designmode.visitor;
        
        /** * 具体访问者类, 用于访问元素 * @author PJ_ZHANG * @create 2020-12-10 17:22 **/
        public class VisitorA implements  IVisitor{ 
        
            @Override
            public void viewElementA(ElementA elementA) { 
                System.out.println("A访问者 访问 A元素: " + elementA.getName());
            }
        
            @Override
            public void viewElementB(ElementB elementB) { 
                System.out.println("A访问者 访问 B元素: " + elementB.getName());
            }
        }
 *  `VisitorB`：访问者具体角色B
    
        package com.self.designmode.visitor;
        
        /** * 具体访问者类, 用于访问元素 * @author PJ_ZHANG * @create 2020-12-10 17:22 **/
        public class VisitorB implements  IVisitor{ 
        
            @Override
            public void viewElementA(ElementA elementA) { 
                System.out.println("B访问者 访问 A元素: " + elementA.getName());
            }
        
            @Override
            public void viewElementB(ElementB elementB) { 
                System.out.println("B访问者 访问 B元素: " + elementB.getName());
            }
        
        }
 *  `ElementStructure`：元素数据结构集，暴露统一的访问者访问接口
    
        package com.self.designmode.visitor;
        
        import java.util.ArrayList;
        import java.util.List;
        
        /** * 元素对象结构集合 * @author PJ_ZHANG * @create 2020-12-10 17:27 **/
        public class ElementStructure { 
        
            List<IElement> lstElement = new ArrayList<>(10);
        
            public void addElement(IElement element) { 
                lstElement.add(element);
            }
        
            public void show(IVisitor visitor) { 
                for (IElement element : lstElement) { 
                    element.accept(visitor);
                }
            }
        
        }
 *  `Client`：客户端，进行访问
    
        package com.self.designmode.visitor;
        
        /** * 客户端 * @author PJ_ZHANG * @create 2020-12-10 17:29 **/
        public class Client { 
        
            public static void main(String[] args) { 
                // 创建元素集合类
                ElementStructure elementStructure = new ElementStructure();
                // 添加元素
                elementStructure.addElement(new ElementA("AAAAA"));
                elementStructure.addElement(new ElementB("BBBBB"));
        
                // 创建两个访问者
                IVisitor visitorA = new VisitorA();
                IVisitor visitorB = new VisitorB();
        
                // 访问元素
                elementStructure.show(visitorA);
                elementStructure.show(visitorB);
            }
        
        }

## 17.5，访问者模式注意事项和细节 ##

*  访问者模式符合单一职责原则，让程序具有优秀的扩展性，灵活性比较高
 *  访问者模式可以对功能进行统一，可以做报表，UI，拦截器适配器等，使用与数据结构相对稳定的系统
 *  具体元素对访问者公布细节，也就是访问者类关注了其他类的内部细节，不符合迪米特法则，造成具体元素修改困难
 *  违背了依赖倒转原则，访问者依赖的是具体元素，而不是抽象接口
 *  初次之外，如果系统中有比较稳定的数据结构，又有经常变化的功能需求，访问者模式是比较适合的，但是确实用的不多

[20201219140252431.png]: /images/20221120/90b50dbc451e4b768f3caf8fee17eda2.png