访问者模式详解附有代码案例分析

最新推荐文章于 2023-08-22 15:19:52 发布

hyyyya

最新推荐文章于 2023-08-22 15:19:52 发布

阅读量711

点赞数

分类专栏：设计模式文章标签：数据结构设计模式 java 编程语言

本文链接：https://blog.csdn.net/hyyyya/article/details/109207620

版权

设计模式专栏收录该内容

23 篇文章 5 订阅

订阅专栏

访问者模式

一、访问者模式的概念与角色

（一）、访问者模式的概念

访问者模式是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。

访问者模式的基本思想是：针对系统中拥有固定类型数的对象结构，在其内提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同，使得相同的元素集合可以产生不同的数据结构。accept()方法可以接收不同的访问者对象，然后在内部将自己转发到访问者对象的visit()方法内。访问者内部对应类型的visit()方法就会得到回调执行，对元素进行操作。

也就是通过两次动态分发，最终将一个具体的元素传递到一个具体的访问者。如此依赖，就解耦了数据结构与操作，且数据操作不会改变元素状态。

访问者模式的核心是：解耦数据结构与数据操作，使得对元素的操作具备优秀的扩展性。可以通过扩展不同的数据操作类型（访问者）实现对相同元素集的不同的操作。

（二）、访问者模式的角色

1、抽象访问者（Visitor）：接口或抽象类，该类冠以了对每一个具体元素的访问行为visit()方法，其参数就是具体的元素对象。理论上说，Visitor的方法个数与元素个数是相等的。如果元素个数经常变动，会导致Visitor的方法也要进行变动，此时，并不适用访问者模式。

2、具体访问者（ConcreteVisitor）：实现对具体元素的操作。

3、抽象元素（Element）：接口或抽象类，定义了一个接受访问者访问的方法accept()，表示所有元素类型都支持被访问者访问。

4、具体元素（ConcreteElement）：具体元素类型，提供接受访问者的具体实现。通常的实现都为：visitor.visit(this)。

5、结构对象（ObjectStruture）：该类内部维护了元素集合，并提供方法接受访问者对该集合所有元素进行操作。

二、访问者模式的应用场景

1、数据结构稳定，作用于数据结构的操作经常变化的场景。

2、需要数据结构于数据操作分离的操作。

3、需要对不同数据类型进行操作，而不适用分支判断具体类型的场景。

三、访问者模式的通用写法

抽象元素：Element

public interface Element {

    void accept(Visitor visitor);
}

抽象访问者：Visitor

public interface Visitor {

    void visit(ConcreteElementA element);

    void visit(ConcreteElementB element);
}

具体元素：ConcreteElementA

public class ConcreteElementA implements Element{

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return this.getClass().getSimpleName();
    }

}

具体元素：ConcreteElementB

public class ConcreteElementB implements Element{

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public int operationB() {
        return new Random().nextInt(100);
    }
}

具体访问者：ConcreteVisitorA

public class ConcreteVisitorA implements Visitor{

    @Override
    public void visit(ConcreteElementA element) {
        String result = element.operationA();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }

    @Override
    public void visit(ConcreteElementB element) {
        int result = element.operationB();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }
}

具体访问者：ConcreteVisitorB

public class ConcreteVisitorB implements Visitor{

    @Override
    public void visit(ConcreteElementA element) {
        String result = element.operationA();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }


    @Override
    public void visit(ConcreteElementB element) {
        int result = element.operationB();
        System.out.println("result from " + element.getClass().getSimpleName() + ": " + result);
    }
}

结构对象：ObjectStructure

public class ObjectStructure {

    private List<Element> list = new ArrayList<Element>();

    {
        this.list.add(new ConcreteElementA());
        this.list.add(new ConcreteElementB());
    }

    public void accept(Visitor visitor) {
        for (Element element : this.list) {
            element.accept(visitor);
        }
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        ObjectStructure collection = new ObjectStructure();
        System.out.println("ConcreteVisitorA handle elements:");
        Visitor visitorA = new ConcreteVisitorA();
        collection.accept(visitorA);
        System.out.println("------------------------------------");
        System.out.println("ConcreteVisitorB handle elements:");
        Visitor visitorB = new ConcreteVisitorB();
        collection.accept(visitorB);
    }

}

四、访问者模式的KPI考核的代码示例

抽象元素：Employee

public abstract class Employee {

    public String name;
    public int kpi;  //员工KPI

    public Employee(String name) {
        this.name = name;
        kpi = new Random().nextInt(10);
    }

    //接收访问者的访问
    public abstract void accept(Visitor visitor);
}

抽象访问者：Visitor

public interface Visitor {

    void visit(Engineer engineer);

    void visit(Manager manager);

}

具体元素：Engineer

public class Engineer extends Employee {
    public Engineer(String name) {
        super(name);
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    //考核指标是每年的代码量
    public int getCodeLines() {
        return new Random().nextInt(10 * 10000);
    }
}

具体元素：Manager

public class Manager extends Employee {
    public Manager(String name) {
        super(name);
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    //考核的是每年新产品研发数量
    public int getProducts() {
        return new Random().nextInt(10);
    }
}

具体访问者：CEOVisitor

public class CEOVisitor implements Visitor {

    @Override
    public void visit(Engineer engineer) {
        System.out.println("工程师" + engineer.name + "，KIP：" + engineer.kpi);
    }

    @Override
    public void visit(Manager manager) {
        System.out.println("经理：" + manager.name + ",KPI:" + manager.kpi + "，产品数量：" + manager.getProducts());
    }
}

具体访问者：CTOVisitor

public class CTOVisitor implements Visitor {

    @Override
    public void visit(Engineer engineer) {
        System.out.println("工程师" + engineer.name + "，代码行数：" + engineer.getCodeLines());
    }

    @Override
    public void visit(Manager manager) {
        System.out.println("经理：" + manager.name + "，产品数量：" + manager.getProducts());
    }
}

结构对象：BusinessReport

public class BusinessReport {

    private List<Employee> employees = new LinkedList<Employee>();

    public BusinessReport() {
        employees.add(new Manager("产品经理A"));
        employees.add(new Engineer("程序员A"));
        employees.add(new Engineer("程序员B"));
        employees.add(new Engineer("程序员C"));
        employees.add(new Manager("产品经理B"));
        employees.add(new Engineer("程序员D"));
    }

    public void showReport(Visitor visitor) {
        for (Employee employee : employees) {
            employee.accept(visitor);
        }
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        BusinessReport report = new BusinessReport();
        System.out.println("==========CEO看报表===============");
        report.showReport(new CEOVisitor());
        System.out.println("==========CTO看报表===============");
        report.showReport(new CTOVisitor());
    }

}

五、访问者模式的优缺点

（一）、优点

1、解耦了数据结构与数据操作，使得操作集合可以独立变化。

2、扩展性好，可以通过扩展访问者角色，实现对数据集的不同操作。

3、元素具体类型并非单一，访问者均可操作。

4、各角色职责分离，符合单一职责原则。

（二）、缺点

1、无法增加元素类型：若系统数据结构对象易于变化，经常有新的数据对象增加进来，则访问者类必须增加对应元素类型的操作，违背了开闭原则。

2、具体元素变更困难：具体元素增加属性，删除属性等操作会导致对应的访问者类需要进行相应的修改，尤其当有大量访问者类时，修改范围太大。

3、违背依赖倒置原则：为了达到“区别对待”，访问者依赖的是具体元素类型，而不是抽象。

六、设计模式的相关博客文章链接

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
访问者模式详解附有代码案例分析

访问者模式一、访问者模式的概念与角色（一）、访问者模式的概念（二）、访问者模式的角色二、访问者模式的应用场景三、访问者模式的通用写法四、访问者模式的KPI考核的代码示例五、访问者模式的优缺点（一）、优点（二）、缺点一、访问者模式的概念与角色（一）、访问者模式的概念访问者模式是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。访问者模式的基本思想是：针对系统中拥有固定类型数的对
复制链接

扫一扫