领略设计模式的魅力,谈谈组合模式搭配访问者模式

组合模式+访问者模式 实现商品多级目录分类 商城有很多商品目录,且层级很多。为了对层级目录进行管理,需要满足对层级目录的增删。 阅读详情

组合模式(composite)

我们都知道文件和文件夹的概念,并且文件是可以存放在文件夹中,文件夹中也可以存放其他文件夹。需要设计一个简单的程序来实现文件夹和文件的关系。

实现思路

  1. 文件夹需要存放文件夹和文件,首先想到的是在文件夹中设计两个集合分别来存放文件夹和文件。
  2. 有展示文件路径需求时,不清楚在最里层是文件夹还是文件,所以需要把文件夹和文件当做一个对象来处理会更好,都是条目。所以需要创建一个他们共同的父类。
  3. 对文件夹的设计优化,创建一个集合容器,容器类型是父类,即解决了既要存放文件夹又要存放文件的问题。

有时,将容器和内容作为同一种东西看待,可以很好地帮助我们处理问题,在容器中既可以存放内容,也可以存放小容器,然后在小容器中,又可以继续放入更小的容器。这样,这样就形成了容器结构、递归结构。

创造出这样结构的模式就是组合模式(Composite),能够使容器和内存具有一致性,创造出递归结构的模式。

代码实现

Composite:文件和文件夹的父类

public abstract class Component {

    public Component(String name) {
        this.name = name;
    }

    /**
     * 名称
     */
    protected String name;

    /**
     * 展示方法
     * @param prefix
     */
    public abstract void show(String prefix);

    /**
     * 添加方法
     * @param component
     */
    public void add(Component component){

    }

Folder:文件夹类

public class Folder extends Component {

    /**
     * 存放composite的集合
     */
    private List<Component> componentList = new ArrayList<>(16);

    public Folder(String name) {
        super(name);
    }

    @Override
    public void show(String prefix) {
        prefix += "/"+name;
        String finalPrefix = prefix;
        System.out.println(finalPrefix);
        componentList.forEach(component -> component.show(finalPrefix));
    }

    @Override
    public void add(Component component) {
        componentList.add(component);
    }
}

file:文件类

public class File extends Component {

    public File(String name) {
        super(name);
    }

    @Override
    public void show(String prefix) {

        System.out.println(prefix+"/"+this.name);
    }

}

main方法测试

 public static void main(String[] args) {
        Folder folder = new Folder("根文件夹");
        Folder folder1 = new Folder("文件夹1");
        folder.add(folder1);
        File file1 = new File("文件1");
        folder1.add(file1);
        File file2 = new File("文件2");
        folder1.add(file2);
        Folder folder2 = new Folder("文件夹2");
        folder.add(folder2);
        File file3 = new File("文件3");
        folder2.add(file3);
        File file4 = new File("文件4");
        folder2.add(file4);
        File file5 = new File("文件5");
        folder2.add(file5);
        File file6 = new File("文件6");
        folder.add(file6);

        folder.show("");
        System.out.println("----------------");
        folder1.show("");
    }

输出结果:

领略设计模式的魅力,谈谈组合模式搭配访问者模式

类图

领略设计模式的魅力,谈谈组合模式搭配访问者模式

访问者模式

我们在对类中数据结构执行操作A时,一般会在该类中声明一个方法来完成操作A。但是当需要增加另一种操作B时,就需要再增加一个方法。那么在后续不断增加需求过程中,我们就需要不断地去修改这个类,这样就很不符合开闭原则。

那么我们能不能把数据结构和操作分开,当需要增加操作需求时,只需修改操作类呢?

访问模式就可以实现这样的需求。在该模式中,数据结构与处理被分离开来。编写一个表示“访问者”的类来访问数据 中的元素,并把对各元素的处理交给访问者类。这样,当需要增加新的处理时,我们只需要编 的访问者,然后让数据结构可以接受访问者的访问即可。

代码实现

ELement:数据结构接口

public interface Element {

    void accept(Visitor visitor);

}

Visitor:访问者接口

public interface Visitor {

    void visit(Element element);
}

ConcreteElement:具体数据结构实现类

public class ConcreteElement implements Element{

    private String name;

    private Integer age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "ConcreteElement{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

NameVisitor:修改名称属性的访问者

public class NameVisitor implements Visitor {

    @Override
    public void visit(Element element) {
        ConcreteElement concreteElement  = (ConcreteElement) element;
        concreteElement.setName("测试");
    }
}

AgeVisitor:修改年龄属性的访问者

public class AgeVisitor implements Visitor {
    @Override
    public void visit(Element element) {
        ConcreteElement concreteElement  = (ConcreteElement) element;
        concreteElement.setAge(1);
    }
}

main方法:

 public static void main(String[] args) {

        Element element = new ConcreteElement();
        System.out.println(" 没有被访问结果输出: "+element);
        Visitor visitor = new NameVisitor();
        element.accept(visitor);
        System.out.println(" 被NameVisitor访问结果输出: "+element);
        visitor = new AgeVisitor();
        element.accept(visitor);
        System.out.println(" 被AgeVisitor访问结果输出: "+element);
    }

数据结果:

领略设计模式的魅力,谈谈组合模式搭配访问者模式

通过上面的代码实现,可以看到ConcreteElement通过accept实现了对访问者动态变更,通过传入不同的访问者实现类不同的操作需求,后期因需求的增加只需增加不同的访问者。

类图

领略设计模式的魅力,谈谈组合模式搭配访问者模式

俩个模式搭配干活

浅尝

需求

在组合模式中,完成了一个文件夹的设计。现在需要增加一个需求:对当前文件夹中的文件做名称修改。

这个需求其实很简单,首先想到应该就是遍历文件夹修改里面的文件名称。

那么有没有更优雅的方式呢?试试访问者模式

代码实现

下面贴入的代码已省略在组合模式已有的代码。

文件相关代码:

public interface Element {
    void accept(Visitor visitor);
}

public abstract class Component implements Element{}

public class File extends Component {

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

}

public class Folder extends Component {

    @Override
    public void accept(Visitor visitor) {
        componentList.stream().forEach(component -> visitor.visit(component));
    }
}

访问者相关代码:

public interface Visitor {

    void visit(Element element);
}

public class UpdateFileNameVisitor implements Visitor {
    @Override
    public void visit(Element element) {
        if(element instanceof Folder){
            element.accept(this);
        }else{
            File file = (File) element;
            file.setName("visitor update-"+file.getName());
        }

    }
}

main方法

public static void main(String[] args) {
        // 省略已有代码
        folder.show("");
        System.out.println("----------------");

        Visitor visitor = new UpdateFileNameVisitor();
        folder.accept(visitor);
        folder.show("");

    }

结果:

image.png

深入

在我们日常业务代码中,经常会出现树型结构数据。比商品分类,权限等,一般涉及到这样的数据结构可以考虑使用组合模式+访问模式来处理需求。

需求

在商品分类处理中

  1. 实现商品分类树的查询 。
  2. 实现商品分类的删除,并删除他的子类。

代码实现

商品分类数据结构

public class CommodityClass  {

    /**
     * 标识
     */
    private Long  id;
    /**
     * 名称
     */
    private String  name;
    /**
     * 父分类ID
     */
    private Long parentId;
    /**
     * 商品分类子集
     */
    private List<CommodityClass> Children;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<CommodityClass> getChildren() {
        return Children;
    }

    public void setChildren(List<CommodityClass> children) {
        Children = children;
    }

    public Long getParentId() {
        return parentId;
    }

    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }

    public <T> T execute(CommodityClassOperation<T> commodityClassOperation){
        return commodityClassOperation.doExecute(this);
    }

    @Override
    public String toString() {
        return "CommodityClass{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", parentId=" + parentId +
                ", Children=" + Children +
                '}';
    }
}

service层处理类

public interface CommodityClassService {

    /**
     * 查询商品分类结构树
     * @param commodityClassId 商品分类ID
     * @return 商品分类结构树
     */
    CommodityClass getAllCommodityClassServiceById(Long commodityClassId);

    /**
     * 删除商品分类
     * @param commodityClassId 商品分类ID
     * @return true 成功 false 失败
     */
    Boolean deleteAllCommodityClassServiceById(Long commodityClassId);
}
@Service
public class CommodityClassServiceImpl implements CommodityClassService {

    @Autowired
    private QueryCommodityClassOperation queryCommodityClassOperation;

    @Autowired
    private DeleteCommodityClassOperation deleteCommodityClassOperation;

    @Autowired
    private CommodityClassDAO commodityClassDAO;

    /**
     * 查询商品分类结构树
     * @param commodityClassId 商品分类ID
     * @return 商品分类结构树
     */
    @Override
    public CommodityClass getAllCommodityClassServiceById(Long commodityClassId){
        CommodityClass commodityClassServiceById = 	   commodityClassDAO.getCommodityClassServiceById(commodityClassId);
        queryCommodityClassOperation.doExecute(commodityClassServiceById);
        return commodityClassServiceById;

    }

    /**
     * 删除商品分类
     * @param commodityClassId 商品分类ID
     * @return true 成功 false 失败
     */
    @Override
    public Boolean deleteAllCommodityClassServiceById(Long commodityClassId){
        CommodityClass commodityClassServiceById = commodityClassDAO.getCommodityClassServiceById(commodityClassId);
        return deleteCommodityClassOperation.doExecute(commodityClassServiceById);
    }

}

访问者类

public interface CommodityClassOperation<T> {

    T doExecute(CommodityClass commodityClass);
}

@Component
public class QueryCommodityClassOperation implements CommodityClassOperation<Boolean> {

    @Autowired
    private CommodityClassDAO commodityClassDAO;

    @Override
    public Boolean doExecute(CommodityClass commodityClass) {
        List<CommodityClass>  children = 
                commodityClassDAO.listCommodityClassServiceByParentId(commodityClass.getId());
        if(!CollectionUtils.isEmpty(children)){
            children.stream().forEach(commodityClass1 ->
                    commodityClass1.execute(this));
        }
        commodityClass.setChildren(children);
        return true;
    }
}
@Component
public class DeleteCommodityClassOperation implements CommodityClassOperation<Boolean> {

    @Autowired
    private CommodityClassDAO commodityClassDAO;

    @Override
    public Boolean doExecute(CommodityClass commodityClass) {
        List<CommodityClass> children = 
                commodityClassDAO.listCommodityClassServiceByParentId(commodityClass.getId());
        if(!CollectionUtils.isEmpty(children)){
            children.stream().forEach(commodityClass1 ->
                    commodityClass1.execute(this));

        }
        commodityClassDAO.deletCommodityClassServiceById(commodityClass.getId());
        return true;
    }
}

DAO层查询数据库已省略可以自行实现。

组合模式 + 访问者模式:树形结构与复杂操作的最佳拍档 模式组合的价值: 解耦数据与操作:访问者封装各种处理逻辑 保持结构稳定:组合模式维护树形结构不变 无限扩展能力:新增操作只需添加访问者 阅读详情

相关推荐

建造者模式组合模式访问者模式java学习源码

建造者模式组合模式访问者模式 abstract class Bulider{ public abstract void BuildPartA() ; public abstract void BuildPartB() ; public abstract Product GetResult() ; }

设计模式 - 组合模式与访问者模式

组合模式通常是与访问者模式一起使用,在处理树形结构数据时会,会展现出独特的奇效。组合模式注重树形结构数据的包装,访问者模式注重对不同层次数据的操作(添加、删除等)。除此之外,两者还有一个很大的相似点:两者的UML类图有部分的重叠,具体的可以看接下来的内容。本期将实现从建表开始到控制层的完整流程,所有代码均为本人验证过且正确的代码,一起来学习吧。链接:组合模式组合模式旨在将对象组合成树形结构以表示“部分-整体”的层次结构。类似于二叉树的结构。

m0_73478445的博客 843

从零搭建IoT数据中台:STM32+WebSocket实现边缘设备与Web端实时双向通信

本文详细介绍了如何从零搭建基于STM32和WebSocket协议的IoT数据中台,实现边缘设备与Web端的实时双向通信。通过硬件选型、协议设计、服务器搭建及安全优化,提供了一套低延迟、高并发的企业级解决方案,适用于智能农业和工业监控等场景。

tea88的博客 750

设计模式之访问者模式+组合模式

访问者模式Visitor CRM 客户关系管理 类型:企业客户,个人客户 功能:提出服务申请、客户偏好分析、客户价值分析 定义: 表示一个作用于某对象结构中的各元素的操作。 它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作 Visitor: 访问者接口,为所有的访问者对象声明一个visit方法, 用来代表为对象添加的功能,理论

chuyouyinghe的专栏 2074

华为HCIA-Datacom实战:200人企业园区网从规划到部署全流程解析

本文详细解析了华为HCIA-Datacom认证实战中200人企业园区网的规划与部署全流程。从需求分析、组网架构设计到设备选型、VLAN划分及安全策略实施,全面覆盖园区网建设的关键环节,特别针对部门隔离、无线覆盖和基础安全防护等典型场景提供可落地的解决方案。

f0g1h2的博客 717

Android应用开发从零到一:基于Kotlin与Jetpack Compose的完整实践指南

移动应用开发的核心在于构建一个架构清晰、可维护且可扩展的应用基础。理解应用架构的原理,如关注点分离和数据驱动UI,是实现高质量应用的关键技术价值。在现代Android开发中,Kotlin语言凭借其空安全特性和协程,能有效提升代码的健壮性与开发效率。Jetpack Compose作为声明式UI框架,代表了UI开发的未来方向,与Kotlin协程深度集成,简化了复杂交互界面的构建。这些技术共同服务于个人任务管理、企业工具等多种应用场景。本文以构建一个完整的个人任务管理应用为例,系统阐述从环境搭建、UI构建、数据持

weixin_32667955的博客 313

设计模式之:访问者模式

业务场景 (1)组合模式,我们现在想象一下,我们之前做的是说递归删除部门自己本身 (2)但是我们现在要对他改造一下,将组合模式和访问者模式结合起来,就是说,我们可以让那颗树执行我们想要他做的任何事情 访问者模式,是对目标对象,动态的执行某个功能,而不对目标对象有任何的改动 import java.util.ArrayList; import java.util.List; public clas...

Fireworks 289

用 Python 和 uiautomation 实现微信批量发送

思路是这样,将要发送的人员名单(包括称呼)以及发送内容都维护到Excel里,程序运行时读取Excel里内容,自动搜索人员姓名(微信昵称或备注名),填入要发送的内容,拼接上称呼(如果需要的话)自动点击发送,这样轮巡直至名单人员全部发送完成。、

jankingdom的专栏 1471

在组合模式中实现访问者(VISITOR)模式

本文从一个给定的实现了组合(Composite)模式的例子开始,说明怎么在这个数据结构上实现业务逻辑代码。依次介绍了非面向对象的方式、在组合结构中加入方法、使用访问者(Visitor)模式以及用改进后的访问者(Visitor)模式来实现相同的业务逻辑代码,并且对于每种实现分别给出了优缺点。   读者定位于具有Java程序开发和设计模式经验的开发人员。   读者通过本文可以学到如何在组合

happyrabbit456的专栏 859

MFC+Modbus-Tcp协议实现温湿度传感器采集

本文简单介绍MFC使用-Tcp通信实现系列MODBUSTCP型温湿度传感器采集数据。

zhigang_zhao的博客 2832

数据分享:中国历年省、市、县行政区划shp(1949~2023年共计75年)

中华人民共和国县级以上行政区沿革》(三册,1949-1983年)“The Atlas of Changes of Administrative Regions of China”;《中华人民共和国行政区划沿革地图集》The yearly publications of “The Administrative Regions”, 1985-2014;每年的出版行政区划简册(1985-2014年)行政区划网:www.xzqh.org。行政区划网:www.xzqh.org。

J_Giser的博客 3697

在组合(Composite)模式中实现访问者(Visitor)模式

参考ibm文章:http://www-128.ibm.com/developerworks/cn/java/j-jinfh/index.html?ca=dwcn-newsletter-java

汪翰翔的Blog 1140

QT Android开发之Android端usb调试模式设置与问题解决

QT Android开发之Android端usb调试模式设置与问题解决 一.QT android开发android端usb调试模式设置 QT android开发环境搭建完成后,android设备需要打开usb调试模式才能正常连接,下面以小米ipad为例进行设置(其他手机和ipad设置方法类似) 二.小米ipad打开usb调试模式 1.设置----我的设备-----全部参数信息-----OS版本---点击这里6次以上就进入开发者模式。

热土程序园,利他愉己~ 1135

利用组合模式与访问者模式实现Android树形控件(多层级,可拖拽)

先上图

u010755087的博客 611

Android USB串口通信详解与实例

在Android开发中,USB串口通信是一个常见的需求,尤其是在与硬件设备进行交互时。通过USB串口,我们可以轻松地实现数据的发送与接收。本文将详细介绍如何使用库来实现Android设备与USB串口设备的通信。

m0_62153576的博客 680

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

操作复杂对象结构——访问者模式

转:http://blog.youkuaiyun.com/lovelion/article/details/7433523

lynchyo——得失只在刹那间 1211

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

JAVA设计模式之访问者模式

访问者(Visitor)模式的定义:将作用于某种数据结构中的各元素的操作分离出来封装成独立的类,使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作,为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离,是行为类模式中最复杂的一种模式。 访问者(Visitor)模式是一种对象行为型模式,其主要优点如下。 扩展性好。能够在不修改对象结构中的元素的情况下,为对象结构中的元素添加新的功能。 复用性好。可以通过访问者来定义整个对象结构通用的功能,从而提高系统的复用程度。 灵活性好

DAIHUINKZX的博客 216

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

操作复杂对象结构——访问者模式(四)

26.4 访问者模式与组合模式联用       在访问者模式中,包含一个用于存储元素对象集合的对象结构,我们通常可以使用迭代器来遍历对象结构,同时具体元素之间可以存在整体与部分关系,有些元素作为容器对象,有些元素作为成员对象,可以使用组合模式来组织元素。引入组合模式后的访问者模式结构图如图26-4所示:          需要注意的是,在图26-4所示结构中,由于叶子元素的遍历操作已经

刘伟技术博客 1万+

组合模式和命令模式的联用实例

练习http://blog.youkuaiyun.com/lovelion/article/details/8806677 Sunny软件公司欲开发一个基于Windows平台的公告板系统。该系统提供了一个主菜单(Menu),在主菜单中包含了一些菜单项(MenuItem),可以通过Menu类的addMenuItem()方法增加菜单项。菜单项的主要方法是click(),每一个菜单项包含一个抽象命令类,具体命

一叶子的博客哦 2533

在组合模式中实现访问者(Visitor)模式

 本文从一个给定的实现了组合(Composite)模式的例子开始,说明怎么在这个数据结构上实现业务逻辑代码。依次介绍了非面向对象的方式、在组合结构中加入方法、使用访问者(Visitor)模式以及用改进后的访问者(Visitor)模式来实现相同的业务逻辑代码,并且对于每种实现分别给出了优缺点。  读者定位于具有Java程序开发和设计模式经验的开发人员。  读者通过本文可以学到

kinglino520的专栏 514

访问者模式——java设计模式(二十五)

简介 结构和实现 实例 联用组合模式 优缺点和适用范围 jdk中的应用 简介 访问者模式(Visitor Pattern):表示一个用于作用于某对象结构中的各个元素的操作。让用户在不改变各元素的类的前提下定义作用于这些元素的新操作。 为了以不同的方式操作复杂对象结构中的不同类型元素。 结构和实现 角色包括: 抽象访问者:为对象结构中的每一个具体元素...

qq_40369829的博客 1133

参观者与组合模式

Demo背景 实现类似于gwt框架的功能,通过java代码来编写界面组件,在将界面组件转换成浏览器可识别的UI元素 设计思路: 代码要实现两部分功能: 1.编写界面组件代码,用java类定义出所需要的界面元素(Button、Label、Panel等) 2.将java类组件进行语义转换,转换成界面引擎可识别的语法(json、html,js等) 接口设计: 界面组件的设计参考awt采

JavaMan_chen的专栏 3517

42 访问者模式(Visitor模式)详解

行为型模式: 模板方法(Template Method)模式、策略(Strategy)模式、命令(Command)模式、职责链(Chain of Responsibility)模式、状态(State)模式、观察者(Observer)模式、中介者(Mediator)模式、迭代器(Iterator)模式、访问者(Visitor)模式、备忘录(Memento)模式、解释器(Interpreter)模式 在现实生活中,有些集合对象存在多种不同的元素,且每种元素也存在多种不同的访问者和处理方式。例如,公园中存在多

天道·乾坤 的博客 2141
上一篇: 前方高能预警!阿里大佬出品“Spring实战学习笔记”震撼来袭!
下一篇: 关于Spring Cloud Gateway与下游服务器的连接分析
JavaCaiy
博客等级 码龄6年 1万+粉丝 95原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值