首页 > 编程语言 >【访问者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

【访问者设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

时间：2023-05-04 11:11:49浏览次数：45  
标签：Java name Python Visitor 元素 Element 设计模式 public 访问者

简介

访问者模式（Visitor Pattern）是一种行为型模式。它封装一个访问者类，把各元素类的操作集合起来，目的是将数据结构与数据操作分离。在不改变原有元素类数据结构的前提下，改变了元素类的执行算法。

当某些较为稳定的东西（数据结构或算法），不想直接被改变但又想扩展功能，这时候适合用访问者模式。访问者模式的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。

访问者模式有以下几个角色：

  • 结构对象(ObjectStructure)：结构对象角色，这是访问者模式的基础角色，包含多个类或者接口.
  • 抽象元素(Element)：定义一个接受访问操作accept()，以一个访问者Visitor作为参数。
  • 具体元素(ConcreteElement)：实现抽象节点的accept()方法和处理操作，调用Vistor的访问方法实现具体功能。
  • 抽象访问者(Visitor)：定义一个抽象接口，声明一个或多个访问操作，使得所有具体访问者都必须实现。
  • 具体访问者(ConcreteVisitor)：具体访问者角色，实现Visitor声明的接口。

作用

  1. 在数据基础类里面有一个方法接受访问者，将自身引用传入访问者，从而把不变的固定起来，把变化的开放出去。
  2. 通过隔离类中变化的东西，固定不变的东西，符合单一职责原则，同时具备较好的扩展性和灵活性。

实现步骤

  1. 先创建基本元素抽象类Element，确定accept()抽象方法。
  2. 分别创建几个具体的元素类，实现抽象元素的accept方法。
  3. 在创建Visitor抽象接口，定义visit方法，调用具体元素。
  4. 创建1个或多个Visitor类，继承抽象接口，客户将以此去访问具体元素。
  5. 再创建对象结构类，这是核心入口类，负责组合各种元素，以及传递访问者Visitor。
  6. 客户调用时先创建对象结构类，再指定访问者类，通过访问这类调用具体元素类

UML

 

Java代码

结构对象

// ObjectStructure.java 结构对象(ObjectStructure)
public class ObjectStructure {

  // 可以想象为一台电脑，聚合了各种设备元素
  private String name = "Computer Structure";
  private List<Element> elements = new ArrayList<Element>();

  // 结构对象初始化聚合了其他元素
  public ObjectStructure() {
    addElement(new ConcreteElementA());
    addElement(new ConcreteElementB());
  }

  public void addElement(Element element) {
    elements.add(element);
  }

  // 传入访问者分发给其他元素
  public void accept(Visitor visitor) {
    System.out
        .println("ObjectStructure::accept() [visitor.class = " + visitor.getClass().getSimpleName() + " visitor.name = "
            + visitor.getName() + "]");
    for (Element element : elements) {
      element.accept(visitor);
    }
  }

  public String getName() {
    return this.name;
  }

}

抽象访问者类

// Visitor.java 访问者Visitor抽象接口，定义不同的visit方法
public interface Visitor {
  public void visit(ConcreteElementA concreteElementA);

  public void visit(ConcreteElementB concreteElementB);

  public String getName();
}

具体访问者

// ConcreteVisitorA.java 具体访问者A
public class ConcreteVisitorA implements Visitor {

  // 假如由不同厂商是程序的访问者
  private String name = "Google Visitor";

  @Override
  public void visit(ConcreteElementA concreteElementA) {
    System.out.println(
        "ConcreteVisitorA::visit() [Element.class = " + concreteElementA.getClass().getSimpleName()
            + " Element.name = "
            + concreteElementA.getName() + "]");
    concreteElementA.operate();
  }

  @Override
  public void visit(ConcreteElementB concreteElementB) {
    System.out.println("ConcreteVisitorA::visit() [Element.class = " + concreteElementB.getClass().getSimpleName()
        + " Element.name = "
        + concreteElementB.getName() + "]");
    concreteElementB.operate();
  }

  public String getName() {
    return this.name;
  }
}

// ConcreteVisitorB.java 具体访问者B
public class ConcreteVisitorB implements Visitor {

  // 假如由不同厂商是程序的访问者
  private String name = "Apple Visitor";

  @Override
  public void visit(ConcreteElementA concreteElementA) {
    System.out.println(
        "ConcreteVisitorB::visit() [Element.class = " + concreteElementA.getClass().getSimpleName()
            + " Element.name = "
            + concreteElementA.getName() + "]");
    concreteElementA.operate();
  }

  @Override
  public void visit(ConcreteElementB concreteElementB) {
    System.out.println(
        "ConcreteVisitorB::visit() [Element.class = " + concreteElementB.getClass().getSimpleName()
            + " Element.name = "
            + concreteElementB.getName() + "]");
    concreteElementB.operate();
  }

  public String getName() {
    return this.name;

  }
}

抽象元素类

// Element.java 抽象元素(Element)，定义accept方法，传入抽象访问者
abstract class Element {
  public abstract void accept(Visitor visitor);
}

具体元素实现类

// ConcreteElementA.java 具体的元素实现者A
public class ConcreteElementA extends Element {
  // 可以设想为显示器
  private String name = "Monitor Element";

  @Override
  public void accept(Visitor visitor) {
    System.out
        .println(
            "ConcreteElementA::accept() [visitor.class = " + visitor.getClass().getSimpleName() + " visitor.name = "
                + visitor.getName() + "]");
    visitor.visit(this);
  }

  public void operate() {
    System.out.println("ConcreteElementA::operate() [" + this.getName() + "]");
  }

  public String getName() {
    return this.name;
  }
}

// ConcreteElementB.java 具体的元素实现者B
public class ConcreteElementB extends Element {
  private String name = "Keyboard Element";

  @Override
  public void accept(Visitor visitor) {
    System.out.println(
        "ConcreteElementB::accept() [visitor.class = " + visitor.getClass().getSimpleName() + " visitor.name = "
            + visitor.getName() + "]");
    visitor.visit(this);
  }

  public void operate() {
    System.out.println("ConcreteElementB::operate() [" + this.getName() + "]");
  }

  public String getName() {
    return this.name;
  }
}

测试调用

  /**
   * 访问者模式是当客户需要访问具体各元素Element时，先建立一个访问者Visitor作为媒介
   * 客户基于对象结构ObjectStructure，调用accept()，接受传入的访问者
   * 对象结构向其他元素负责分发访问者，元素对象接受之后会将自己回传给访问者，从而访问者可以访问具体元素
   */
    ObjectStructure structure = new ObjectStructure();
    // 接受访问者A，把访问者传递给具体元素
    structure.accept(new ConcreteVisitorA());

    System.out.println("====");
    // 接受访问者B，把访问者传递给具体元素
    structure.accept(new ConcreteVisitorB());

Go代码

结构对象

// ObjectStructure.go 结构对象(ObjectStructure)
type ObjectStructure struct {
  name     string
  elements []Element
}

func (o *ObjectStructure) AddElement(e Element) {
  o.elements = append(o.elements, e)
}

// 传入访问者分发给其他元素
func (o *ObjectStructure) Accept(v Visitor) {
  fmt.Println(
    "ObjectStructure::Accept() [Visitor.name = " +
      v.GetName() + "]")

  // 通知全部元素成员接受访问者
  for i := 0; i < len(o.elements); i++ {
    o.elements[i].Accept(v)
  }

  // for _, ele := range o.elements {
  //   ele.Accept(v)
  // }
}

func (o *ObjectStructure) GetName() string {
  o.name = "Computer Structure"
  return o.name
}

// 结构对象的初始化函数
func (o *ObjectStructure) Init() {
  // 可以想象为一台电脑，聚合了各种设备元素
  fmt.Println("ObjectStructure::Init() ", o.GetName())
  // 定义一个对象数组，长度可选
  o.elements = make([]Element, 0, 100)

  // 结构对象初始化聚合了其他元素
  o.AddElement(&ConcreteElementA{})
  o.AddElement(&ConcreteElementB{})
}

抽象访问者类

// Visitor.go 访问者Visitor抽象接口，定义不同的visit方法
type Visitor interface {
  VisitA(e *ConcreteElementA)
  VisitB(e *ConcreteElementB)
  GetName() string
}

具体访问者

// ConcreteVisitorA.go 具体访问者A
type ConcreteVisitorA struct {
  name string
}

func (v *ConcreteVisitorA) GetName() string {
  v.name = "Google Visitor(struct=ConcreteVisitorA)"
  return v.name
}

func (v *ConcreteVisitorA) VisitA(e *ConcreteElementA) {
  fmt.Println(
    "ConcreteVisitorA::VisitA() [Element.name = " + e.GetName() + "]")
  e.Operate()
}

func (v *ConcreteVisitorA) VisitB(e *ConcreteElementB) {
  fmt.Println(
    "ConcreteVisitorA::VisitB() [Element.name = " + e.GetName() + "]")
  e.Operate()
}

// ConcreteVisitorB.go 具体访问者B
type ConcreteVisitorB struct {
  name string
}

func (v *ConcreteVisitorB) GetName() string {
  v.name = "Apple Visitor(struct=ConcreteVisitorB)"
  return v.name
}

func (v *ConcreteVisitorB) VisitB(e *ConcreteElementB) {
  fmt.Println(
    "ConcreteVisitorB::VisitB() [Element.name = " + e.GetName() + "]")
  e.Operate()
}

func (v *ConcreteVisitorB) VisitA(e *ConcreteElementA) {
  fmt.Println(
    "ConcreteVisitorB::VisitA() [Element.name = " + e.GetName() + "]")
  e.Operate()
}

抽象元素类

// Element.go 抽象元素(Element)，定义accept方法，传入抽象访问者
// go无抽象类，用interface替代
type Element interface {
  Accept(v Visitor)
  Operate()
  GetName() string
}

具体元素实现类

// ConcreteElementA.go 具体的元素实现者A
type ConcreteElementA struct {
  name string
}

func (c *ConcreteElementA) GetName() string {
  c.name = `Monitor Element(struct=ConcreteElementA)`
  return c.name
}

func (e *ConcreteElementA) Accept(v Visitor) {
  fmt.Println(
    "ConcreteElementA::Accept() [Visitor.name = " + v.GetName() + "]")
  v.VisitA(e)
}

func (e *ConcreteElementA) Operate() {
  fmt.Println("ConcreteElementA::Operate() [" + e.GetName() + "]")
}

// ConcreteElementB.go 具体的元素实现者B
type ConcreteElementB struct {
  name string
}

func (c *ConcreteElementB) GetName() string {
  c.name = "Keyboard Element(struct=ConcreteElementB)"
  return c.name
}

func (e *ConcreteElementB) Accept(v Visitor) {
  fmt.Println(
    "ConcreteElementB::Accept() [Visitor.name = " + v.GetName() + "]")
  v.VisitB(e)
}

func (e *ConcreteElementB) Operate() {
  fmt.Println("ConcreteElementB::Operate() [" + e.GetName() + "]")
}

测试调用

func main() {
  fmt.Println("test start:")

  /**
   * 访问者模式是当客户需要访问具体各元素Element时，先建立一个访问者Visitor作为媒介
   * 客户基于对象结构ObjectStructure，调用Accept()，接受传入的访问者
   * 对象结构向其他元素负责分发访问者，元素对象接受之后会将自己回传给访问者，从而访问者可以访问具体元素
   */
  structure := src.ObjectStructure{}
  structure.Init()
  // 接受访问者A，把访问者传递给具体元素
  structure.Accept(&src.ConcreteVisitorA{})

  fmt.Println("====")
  // 接受访问者B，把访问者传递给具体元素
  structure.Accept(&src.ConcreteVisitorB{})
}

更多语言版本

不同语言设计模式源码：https://github.com/microwind/design-pattern

标签：Java,name,Python,Visitor,元素,Element,设计模式,public,访问者
From： https://www.cnblogs.com/letjs/p/17370512.html

相关文章

  • Python网络爬虫原理及实践 | 京东云技术团队
    作者：京东物流田禹1网络爬虫网络爬虫：是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。网络爬虫相关技术和框架繁多，针对场景的不同可以选择不同的网络爬虫技术。2Scrapy框架（Python）2.1.Scrapy架构2.1.1.系统架构2.1.2.执行流程总结爬虫开发过程，简化爬虫执行流程如下图......
  • 毕业生进入社会，JAVA工程师面试经验汇总
    Java工程师是高度需求的技术岗位之一，面试过程非常重要。以下是一些Java工程师面试经验：基础知识：面试官可能会问关于Java基础知识的问题，例如Java语言特性、集合框架、多线程等。在准备面试时，应该学习这些内容，并确保自己能回答相关问题。经验和项目：面试官通常会问你参与的项目和你遇......
  • Java中 HTTP下载 常用的需要设置的MIME类型
    .docapplication/msword.dotapplication/msword.docxapplication/vnd.openxmlformats-officedocument.wordprocessingml.document.dotxapplication/vnd.openxmlformats-officedocument.wordprocessingml.template.docmapplication/vnd.ms-wo......
  • python pandas 生成excle
    首先需要导包需要两个包分别是pandas和openpyxlpipinstall-i https://pypi.doubanio.com/simple/ --trusted-host pypi.doubanio.com pandaspipinstallopenpyxl 创建Python开始写入#使用pandas生成xlsx的excel文件importpandasaspdimportpandasaspddata=......
  • python+playwright 学习-60 在打开的多个标签页窗口灵活切换
    前言当页面打开了多个标签页后，如何切换到自己需要的标签页上呢？使用场景以百度首页为例，当打开多个标签页后，如何切换到自己想要的页面上操作。通过context.pages可以获取到所有的page对象，每一个page对象就代表一个标签页实例fromplaywright.sync_apiimportsync_playwrigh......
  • Java中进行高精准度坐标数据计算使用BigDecimal（计算距离、开平方）
    场景Java中使用java.awt.geom.Point2D进行坐标相关的计算(距离、平方等)：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/126072919Java中使用JTS对空间几何计算(读取WKT、距离、点在面内、长度、面积、相交等)：https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article......
  • java 数组操作
    去重List<PolicySalaryVO>policySalaryVO=policySalaryDTOList.stream().map(PolicySalaryVO::new).collect(Collectors.collectingAndThen(Collectors.toCollection(()->newTreeSet<>(Comparator.comparing(PolicySalaryVO::getType))),ArrayList::new))......
  • java-高精确处理常用的数学运算
     用于高精确处理常用的数学运算packagecom.vivo.ars.util;importjava.math.BigDecimal;/***用于高精确处理常用的数学运算*/publicclassArithmeticUtils{//默认除法运算精度privatestaticfinalintDEF_DIV_SCALE=10;/***提供精确的......
  • 学习python太枯燥？一招让你爱上学python！
    如果你认为学习编程需要看枯燥乏味的教科书，那么你就大错特错了！现在，有一种全新的学习方式，让你在欣赏流行漫画的同时轻松掌握Python编程的技巧！![image-20230504071523860](http://pic.lovelifelovedream.com/typora/image-20230504071523860.png)《看漫画学Python》是一本独特而又......
  • 通过Python进行MySQL表信息统计
    在上一篇文章中简单的介绍了使用python-mysql-replication来解析MySQLbinlog来完成实时统计的业务，当然，在现实的业务中不可能用的那么简单的。啰哩八说今天的目的不是介绍真实的业务场景如何使用python-mysql-replication，而是推出一枚<MySQL表信息统计>小工具(笔者通过......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99