【趣味设计模式系列】之【组合模式】

2022年1月21日 19点热度 0条评论 来源: 小猪爸爸

1. 简介

组合模式(Composite Pattern):将对象组合成树形结构以表示部分-整体的层次关系。

2. 示例

假设要设计一个文件系统的目录,需要灵活的在某个目录下添加、删除目录或文件,统计指定目录下的文件个数,计算指定目录下的文件大小。

设计类图如下:

抽象类Node

package com.wzj.composite;

/**
 * @Author: wzj
 * @Date: 2020/9/23 15:33
 * @Desc:
 */
public abstract class Node {

    //文件路径
    protected String path;

    public Node(String path) {
        this.path = path;
    }

    public String getPath() {
        return path;
    }

    // 统计目录下文件数目
    public abstract int countNumOfFiles();

    // 统计目录下文件大小
    public abstract long countSizeOfFiles();

    // 打印路径
    public abstract void print();

}

文件类FileNode

package com.wzj.composite;

import java.io.File;

/**
 * @Author: wzj
 * @Date: 2020/9/23 16:38
 * @Desc:
 */
public class FileNode extends Node {
    public FileNode(String path) {
        super(path);
    }

    @Override
    public String getPath() {
        return super.getPath();
    }

    @Override
    public int countNumOfFiles() {
        return 1;
    }

    @Override
    public long countSizeOfFiles() {
        File file = new File(path);
        if (!file.exists()) return 0;
        return file.length();
    }


    @Override
    public void print() {
        System.out.println(path);
    }
}

目录类DirectorNode

package com.wzj.composite;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: wzj
 * @Date: 2020/9/23 16:48
 * @Desc:
 */
public class DirectoryNode extends Node{
    public List<Node> list = new ArrayList<>();
    public DirectoryNode(String path) {
        super(path);
    }

    @Override
    public String getPath() {
        return super.getPath();
    }

    @Override
    public int countNumOfFiles() {
        int num = 0;
        for (Node node : list) {
            num += node.countNumOfFiles();
        }
        return num;
    }

    @Override
    public long countSizeOfFiles() {
        long size = 0;
        for (Node node : list) {
            size += node.countSizeOfFiles();
        }
        return size;
    }

    @Override
    public void print() {
        System.out.println(path);
    }

    public void addSubNode(Node node) {
        list.add(node);
    }

    public void removeSubNode(Node node) {
        int size = list.size();
        int i = 0;
        for (; i < size; ++i) {
            if (list.get(i).getPath().equalsIgnoreCase(node.getPath())) {
                break;
            }
        }

        if (i < size) {
            list.remove(i);
        }
    }

}

客户端Client

package com.wzj.composite;

/**
 * @Author: wzj
 * @Date: 2020/9/23 20:44
 * @Desc:
 */
public class Client {
    public static void main(String[] args) {
        DirectoryNode root = new DirectoryNode("root");
        DirectoryNode chapter1 = new DirectoryNode("chapter1");
        DirectoryNode chapter2 = new DirectoryNode("chapter2");

        Node r1 = new FileNode("r1.txt");
        Node c11 = new FileNode("c11.txt");
        Node c12 = new FileNode("c12.txt");

        DirectoryNode b21 = new DirectoryNode("section21");

        Node c211 = new FileNode("c211.txt");
        Node c212 = new FileNode("c212.txt");

        root.addSubNode(chapter1);
        root.addSubNode(chapter2);
        root.addSubNode(r1);

        chapter1.addSubNode(c11);
        chapter1.addSubNode(c12);
        chapter2.addSubNode(b21);

        b21.addSubNode(c211);
        b21.addSubNode(c212);

        printTree(root, 0);

        System.out.println("root files num:" + root.countNumOfFiles());
        System.out.println("/root/chapter1/ files num:" + chapter2.countNumOfFiles());

    }

    // 打印树状结构
    public static void printTree(Node root, int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("--");
        }
        root.print();
        if(root instanceof DirectoryNode) {
            for (Node n : ((DirectoryNode)root).list) {
                printTree(n, depth + 1);
            }
        }
    }
}

结果

root
--chapter1
----c11.txt
----c12.txt
--chapter2
----section21
------c211.txt
------c212.txt
--r1.txt
root files num:5
/root/chapter1/ files num:2

3. 源码分析

SpringMVC中对参数的解析使用的是HandlerMethodArgumentResolver接口,该类有一个实现类为HandlerMethodArgumentResolverComposite,为组合类,又持有其他HandlerMethodArgumentResolver对象,在它的实现方法中是对其他组合模式中的节点进行循环处理,从而选择最适合的一个。

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {

        // 对参数解析器的引用
	private final List<HandlerMethodArgumentResolver> argumentResolvers =
			new LinkedList<HandlerMethodArgumentResolver>();

        // 对其所拥有的对象循环,找到最适合的参数解析器
        private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
			for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
				if (logger.isTraceEnabled()) {
					logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
							parameter.getGenericParameterType() + "]");
				}
				if (methodArgumentResolver.supportsParameter(parameter)) {
					result = methodArgumentResolver;
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}

4. 总结

4.1 优点

  • 高层调用简单
    一棵树形机构中的所有节点都是Component,局部和整体对调用者来说没有任何区别,也就是说,高层模块不必关心自己处理的是单个对象还是整个组合结构,简化了高层模块的代码。
  • 节点自由增加
    使用了组合模式后,我们可以看看,如果想增加一个树枝节点、树叶节点是不是都很容易,只要找到它的父节点就成,非常容易扩展,符合开闭原则,对以后的维护非常有利。

4.2 缺点

组合模式不容易限制组合中的构件。

    原文作者:小猪爸爸
    原文地址: https://www.cnblogs.com/father-of-little-pig/p/13792325.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。