访问者模式以及代码应用

缺乏、安全感 2021-08-11 11:52 237阅读 0赞

![5057999-cc2693ed042bc2c6.png][]

先看一个最小化的表述  
**vistor 访问者 通过不同element作为参数，实现不同的方法**  
**Element 被访问者 其模式是固定的,都是accept(vistor)中，以自己为参数，回调vistor中对应的方法。其重点就在于element本身的传递.**

**我认为，当element多样化 且适合作为封闭的个体时 需要单独维护时候 适合用访问者模式。**

/**
         * 最小化的表述
         * vistor 访问者 通过不同element作为参数，实现不同的方法
         * Element 被访问者 其模式是固定的,都是accept(vistor)中，以自己为参数，回调vistor中对应的方法。其重点就在于element本身的传递.
         * 当element多样化 且适合作为封闭的个体时 需要单独维护时候 适合用访问者模式。
         */
      class VisitorA {
            public void visit(){
                System.out.println("我是A");
            }
    
            public void visit(ElementB b){
                System.out.println("我是B");
            }
            public void visit(ElementC c){
                System.out.println("我是C");
            }
        }
    
        class ElementB {
            public void accept(VisitorA vistor){
                vistor.visit(this);
            }
        }
    
        class ElementC {
            public void accept(VisitorA vistor){
                vistor.visit(this);
            }
        }
    
        @Test
        public void testMin(){
            VisitorA visitor = new VisitorA();
            ElementB b = new ElementB();
            b.accept(visitor);
            ElementC c = new ElementC();
            c.accept(visitor);
        }

下面是一个更为具体的实现  
比如车 简单分为 车轮，引擎，车身 这些属于不同element，被访问者  
当我们需要单独维护这些组件时候，比如说他们有一些仅属于自己的特性时候，可以通过访问者模式来实现需要的功能  
比如下文举例中，金额的计算，类型的打印  
通过对每一个不同的element，以vistor入参执行accept方法，在element的accept方法中，将自己本身作为入参，回调对应vistor接口中的实现方法，达到不同效果的实现

public class VisitorPattern {
    
        interface Visitor {
            void visit(Wheel wheel);
    
            void visit(Engine engine);
    
            void visit(Body body);
        }
    
        class Wheel extends Element {
            void accept(Visitor visitor) {
                visitor.visit(this);
            }
        }
    
        abstract class Element {
            int price;
    
            void accept(Visitor visitor) {
            }
        }
    
        class Engine extends Element {
            void accept(Visitor visitor) {
                visitor.visit(this);
            }
        }
    
        class Body extends Element {
            void accept(Visitor visitor) {
                visitor.visit(this);
            }
        }
    
        class PrintVisitor implements Visitor {
            public void visit(Wheel wheel) {
                System.out.println("Visiting wheel");
            }
    
            public void visit(Engine engine) {
                System.out.println("Visiting engine");
            }
    
            public void visit(Body body) {
                System.out.println("Visiting body");
            }
        }
    
        /**
         * 计算金额访问者，实现金额设置计算的功能
         */
        class CalcVisitor implements Visitor {
            public void visit(Wheel wheel) {
                wheel.price = 100;
            }
    
            public void visit(Engine engine) {
                engine.price =200;
            }
    
            public void visit(Body body) {
                body.price = 300;
            }
        }
    
    
    
        @Test
        public void test() {
            PrintVisitor visitor = new PrintVisitor();
            Enforcer enforcer = new Enforcer(new Wheel(), new Engine(), new Body());
            enforcer.visitAll(visitor);
        }
    
        @Test
        public void testCalMoney() {
            CalcVisitor visitor = new CalcVisitor();
            Enforcer enforcer = new Enforcer(new Wheel(), new Engine(), new Body());
            enforcer.visitAll(visitor);
            enforcer.calcalateAll();
        }
    
        /**
         * 执行者
         */
        class Enforcer {
            private List<Element> elementList = new ArrayList<>();
    
            Enforcer(Wheel wheel, Engine engine, Body body) {
                elementList.add(wheel);
                elementList.add(engine);
                elementList.add(body);
            }
    
            /**
             * 通过以vistor为入参，遍历组件的accept方法，来实现访问所有的组件
             *
             * @param visitor
             */
            public void visitAll(Visitor visitor) {
                for (Element element : elementList) {
                    element.accept(visitor);
                }
            }
    
            public void calcalateAll(){
                int price= 0;
                for(Element e : elementList){
                    price  += e.price;
                }
                System.out.println(price);
            }
        }
        
    }

我认为的使用场景：

1.  每一个被访者都有需要单独维护的地方，需要进行封装
2.  对于每个被访问者，都可以抽象出对应的计算规则/逻辑

项目中的应用：  
在一些财务的结算项目中，有收入、利润、总利润等等很多不同的方面，同时每个的方面又有很多不同的计算规则需要保存。这个时候可以用访问者模式，将这些不同方面作为element，在vistor实现中，再取element中的不同规则，实现不同的计算逻辑。

[5057999-cc2693ed042bc2c6.png]: /images/20210811/fbfb1eeccfe24220b1570d16ccfe7bf5.png