【设计模式】访问者模式

最新推荐文章于 2023-04-27 22:04:22 发布
最新推荐文章于 2023-04-27 22:04:22 发布
阅读量315 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45654306/article/details/106738564
版权

访问者模式（Visitor）

本质：预留通路，回调实现

访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构则可以保持不变。

在这里插入图片描述

结构对象会遍历它自己所保存的聚集中的所有节点，在本系统中就是节点ConcreteElementA和节点ConcreteElementB。首先ConcreteElementA会被访问到，这个访问是由以下的操作组成的:

  • ConcreteElementA对象的Accept方法被调用，并将Visitor1对象本身传入;
  • ConcreteElementA对象反过来调用Visitor1对象的访问方法VisitConcreteElementA，并将ConcreteElementA对象本身传入;
  • 从而就完成了双重分派过程，接着，ConcreteElementB会被访问，这个访问的过程和ConcreteElementA被访问的过程是一样的。

具体访问者的数目与具体节点的数目没有任何联系

因此，结构对象对聚集元素的遍历过程就是对聚集中所有的节点进行委派的过程，也就是双重分派的过程。

访问者模式的目的是要把处理从数据结构分离出来
访问者模式仅应当在被访问的类结构非常稳定的情况下使用

换言之，系统很少出现需要加入新节点的情况。如果出现需要加入新节点的情况，那么就必须在每一个访问对象里加入一个对应于这个新节点的访问操作，而这是对一个系统的大规模修改，因而是违背“开一闭”原则的。

访问者模式提供了倾斜的可扩展性设计:方法集合的可扩展性和类集合的不可扩展性。换言之，如果系统的数据结构是频繁变化的，则不适合使用访问者模式。

示意性代码


    class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new ConcreteElementA());
            o.Attach(new ConcreteElementB());

            ConcreteVisitor1 v1 = new ConcreteVisitor1();
            ConcreteVisitor2 v2 = new ConcreteVisitor2();

            o.Accept(v1);
            o.Accept(v2);

            Console.Read();
        }
    }

    abstract class Visitor
    {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);

        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }

    class ConcreteVisitor1 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    class ConcreteVisitor2 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }

    class ConcreteElementA : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementA(this);
        }

        public void OperationA()
        { }
    }

    class ConcreteElementB : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementB(this);
        }

        public void OperationB()
        { }
    }

    class ObjectStructure
    {
        private IList<Element> elements = new List<Element>();

        public void Attach(Element element)
        {
            elements.Add(element);
        }

        public void Detach(Element element)
        {
            elements.Remove(element);
        }

        public void Accept(Visitor visitor)
        {
            foreach (Element e in elements)
            {
                e.Accept(visitor);
            }
        }
    }

例子——男人女人

人类的种类只有男女两类，后期不会再增加或更改了，而行为可能会增加或更改
即状态类支持扩展，人类不支持拓展，且男人成功失败、女人成功失败之间是同构互传对象实现的，也就是所谓的双重分派。
在这里插入图片描述

 class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new Man());
            o.Attach(new Woman());

            Success v1 = new Success();
            o.Display(v1);

            Failing v2 = new Failing();
            o.Display(v2);

            Amativeness v3 = new Amativeness();
            o.Display(v3);

            Marriage v4 = new Marriage();
            o.Display(v4);

            Console.Read();
        }
    }

    //状态
    abstract class Action
    {
        //得到男人结论或反应
        public abstract void GetManConclusion(Man concreteElementA);
        //得到女人结论或反应
        public abstract void GetWomanConclusion(Woman concreteElementB);
    }


    //成功
    class Success : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            Console.WriteLine("{0}{1}时，背后多半有一个伟大的女人。", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreteElementB)
        {
            Console.WriteLine("{0}{1}时，背后大多有一个不成功的男人。", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }
    //失败
    class Failing : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            Console.WriteLine("{0}{1}时，闷头喝酒，谁也不用劝。", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreteElementB)
        {
            Console.WriteLine("{0}{1}时，眼泪汪汪，谁也劝不了。", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }
    //恋爱
    class Amativeness : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            Console.WriteLine("{0}{1}时，凡事不懂也要装懂。", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreteElementB)
        {
            Console.WriteLine("{0}{1}时，遇事懂也装作不懂", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }
    //结婚
    class Marriage : Action
    {
        public override void GetManConclusion(Man concreteElementA)
        {
            Console.WriteLine("{0}{1}时，感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreteElementB)
        {
            Console.WriteLine("{0}{1}时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    //人
    abstract class Person
    {
        //接受
        public abstract void Accept(Action visitor);
    }

    //男人
    class Man : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetManConclusion(this);
        }
    }

    //女人
    class Woman : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetWomanConclusion(this);
        }
    }
    //对象结构
    class ObjectStructure
    {
        private IList<Person> elements = new List<Person>();

        //增加
        public void Attach(Person element)
        {
            elements.Add(element);
        }
        //移除
        public void Detach(Person element)
        {
            elements.Remove(element);
        }
        //查看显示
        public void Display(Action visitor)
        {
            foreach (Person e in elements)
            {
                e.Accept(visitor);
            }
        }
    }

优缺点

优点:

  • 访问者模式使得增加新的操作变得很容易。增加新的操作就意味着增加一个新的访问者类。
  • 访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。

缺点：

  • 增加新的节点类变得很困难。每增加一个新的节点都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作。
  • 破坏封装。访问者模式要求访问者对象访问并调用每一个节点对象的操作，这隐含了一个对所有节点对象的要求:它们必须暴露一些自己的操作和内部状态。

利用访问者模式模拟实现拓展客户管理系统（CRM）

涉及客户：
个人客户、企业用户
涉及服务：
提出服务申请、客户价值分析、客户对产品的偏好分析

package visitor;

public abstract class Analysis {

	public abstract void ManageIndividual(Individual i);

	public abstract void ManageEnterprise(Enterprise e);
}


package visitor;

public class PreferenceAnalysis extends Analysis{

	@Override
	public void ManageIndividual(Individual i) {
		// TODO Auto-generated method stub
		System.out.println("个人客户"+i.getName()+"对产品偏好分析");
	}

	@Override
	public void ManageEnterprise(Enterprise e) {
		// TODO Auto-generated method stub
		System.out.println("企业客户"+e.getName()+"对产品偏好分析");
	}

}


package visitor;

public class ServiceApplication extends Analysis{

	@Override
	public void ManageIndividual(Individual i) {
		// TODO Auto-generated method stub
		System.out.println("个人客户"+i.getName()+"提出服务申请");
	}

	@Override
	public void ManageEnterprise(Enterprise e) {
		// TODO Auto-generated method stub
		System.out.println("企业客户"+e.getName()+"提出服务申请");
	}

}


package visitor;

public class ValueAnalysis extends Analysis{

	@Override
	public void ManageIndividual(Individual i) {
		// TODO Auto-generated method stub
		System.out.println("个人客户"+i.getName()+"客户价值分析");
	}

	@Override
	public void ManageEnterprise(Enterprise e) {
		// TODO Auto-generated method stub
		System.out.println("企业客户"+e.getName()+"客户价值分析");
	}

}


package visitor;

public abstract class Customer {
	private String name;
	
	public Customer(String name) {
		
			this.name = name;
		}
	 
	public String getName() {
		return name;
	}
	 
	public void setName(String name) {
		this.name = name;
	}
	public abstract void Operate(Analysis a);
}


package visitor;

public class Enterprise extends Customer {

	public Enterprise(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void Operate(Analysis a) {
		// TODO Auto-generated method stub
		a.ManageEnterprise(this);
	}

}


package visitor;

public class Individual extends Customer{

	public Individual(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void Operate(Analysis a) {
		// TODO Auto-generated method stub
		a.ManageIndividual(this);
	}

}


package visitor;

import java.util.ArrayList;

public class ObjectStructure {
	private ArrayList<Customer> cl = new ArrayList<Customer>();

	public void Attach(Customer c) {
		cl.add(c);

	}

	public void Detach(Customer c) {
		cl.remove(c);
	}

	public void Display(Analysis a) {
		for (Customer c : cl)
			c.Operate(a);
	}

}


package visitor;

public class Main {
	public static void main(String args[]) {
		ObjectStructure os = new ObjectStructure();
		os.Attach(new Individual("CustomerA"));
		os.Attach(new Enterprise("CompanyB"));
		Analysis a1 = new ValueAnalysis();
		os.Display(a1);
		
		Analysis a2 = new PreferenceAnalysis();
		os.Display(a2);
		
		Analysis a3 = new ServiceApplication();
		os.Display(a3);

	}

}

UML图
在这里插入图片描述

SuperSources
关注
专栏目录
javascript设计模式----访问者模式
kitt15的博客
04-16 76
访问者模式：针对于对象结构中的元素，定义在不改变改对象的前提下访问结构中元素的新方法。
设计模式 访问者模式
11-16
**访问者模式**是一种行为设计模式，它允许在不修改对象结构的情况下添加新的操作。这种模式主要用于处理具有复杂对象结构的情况，使得我们可以对结构中的每个元素执行特定操作，而无需暴露其内部实现。 访问者模式...
JavaScript-访问者模式
qq_42372534的博客
06-29 280
访问者模式 在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 关键代码:在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。 // 接收者类,拥有accept方法 class Employee { constructor(name, salary) { this.nam
JavaScript中的访问者模式
最新发布
m0_75198698的博客
04-27 222
在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。4. 具体元素(ConcreteElement)角色：实现了元素角色中定义的接受访问者的方法，通常情况下，具体元素角色会调用访问者角色中的方法。2. 具体访问者(ConcreteVisitor)角色：实现了访问者角色中定义的方法，具体实现了对元素的操作。
访问者模式
颖墨的博客
04-15 117
定义 访问者模式(VisitorPattern)，封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。即主要将数据结构与数据操作分离，解决数据结构和操作耦合性问题。访问者模式的基本工作原理是在被访问的类里面加一个对外提供接待访问者的接口。访问者模式主要应用场景是当需要对一个对象结构中的对象进行很多不同操作(这些操作彼此没有关联)，同时需要避免让这...
JS设计模式之访问者模式定义与用法分析
10-18
访问者模式是JavaScript设计模式中的一种行为型模式，它允许在不改变元素类的前提下，向类结构中添加新的操作。该模式将数据结构与数据操作分离开，使得增加新的操作变得简单，同时对原有类的修改也变得不需要。 在...
学习php设计模式 php实现访问者模式(Visitor)
10-23
访问者模式是PHP设计模式中的一种，它是一种行为型设计模式，主要用于对一个对象结构中的各元素进行操作，而不是对这些元素自身进行操作。访问者模式允许在不修改被访问结构（即对象结构）的情况下，向结构中添加新...
设计模式C++学习之访问者模式（Visitor）
09-07
访问者模式（Visitor）是一种行为设计模式，它允许在不修改对象结构的前提下向对象结构中的元素添加新的操作。这种模式将算法与数据结构分离，使得算法可以独立于数据结构进行变化，增强了系统的可扩展性。 在C++中...
java设计模式-访问者模式
02-27
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...
javascript设计模式 – 访问者模式原理与用法实例分析
11-21
本文实例讲述了javascript设计模式 – 访问者模式原理与用法。分享给大家供大家参考，具体如下： 介绍：访问者模式比较复杂，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对他们进行不同的访问操作。访问者模式的主要目的是将数据结构与数据操作相分离。 定义：提供一个作用于某对象结构中的个元素的操作表示，它使得可以再不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式 场景：使用PC结构demo来解释下访问者模式 示例： var Keyboard = function(){ this.accept = fun
JavaScript设计模式——访问者模式
前端御书房
10-02 596
JavaScript设计模式，持续更新中……
JavaScript设计模式———访问者模式
纾与妤
05-12 485
定义 访问者模式，针对于对象结构中的元素，定义在不改变该对象的前提下访问其结构中元素的新方法。 // 访问者模式：DOM事件绑定 var bindEvent = function(dom, type, fn, data) { if (dom.addEventListener) { dom.addEventListener(type, fn, false); } else if (dom.attachEvent) { // dom.attachEvent('on
JavaScript设计模式(二十)【访问者模式】
极客神殿
08-05 253
/** * 访问者模式很好的使用了call这个东西 * 访问者模式是表示一个作用于某个对象结构中的各元素的操作。 * 它使可以在不改变各元素的类的前提下定义作用于这些元素的新操作 * * 通俗的说 * 访问者模式先把一些可复用的行为抽象到一个函数（对象）里，这个函数我们就称为访问者（Visitor） * 如果另外一些对象要调用这个函数，只需要把那些对象当作参数传给这个函数 * 在js里我们经常通过call或者apply的方式传递this对象给一个Visitor函数 * * 也就是说，可能A和B两个类都有一样
设计模式--访问者模式(Visitor)
TERRY的技术日志
05-27 887
访问者模式概述 表示一个作用于某对象结构中的各元素的操作。 它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。适用性 1.一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。 2.需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值