访问者模式以及代码应用

先看一个最小化的表述
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 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中的不同规则，实现不同的计算逻辑。