组合模式详解

古城微笑少年丶 2024-03-17 17:35 8阅读 0赞

### 简介 ###

组合模式(Composite)是针对由多个节点对象（部分）组成的树形结构的对象（整体）而发展出的一种结构型设计模式，它能够使客户端在操作整体对象或者其下的每个节点对象时做出统一的响应，保证树形结构对象使用方法的一致性，使客户端不必关注对象的整体或部分，最终达到对象复杂的层次结构与客户端解耦的目的。

组合模式的核心思想是将对象看作是一个树形结构，其中每个节点可以是一个单独的对象（叶子节点）或者一个包含其他节点的容器（组合节点）。叶子节点和组合节点都实现了相同的接口，这样客户端就可以对它们进行一致的操作，而不需要关心它们的具体类型。

组合模式有以下几个角色：

![453399cad9ec52277c8870741a8e52e4.jpeg][]

*  Component（组件接口）：所有复合节点与叶节点的高层抽象，定义出需要对组件操作的接口标准。对应本章例程中的抽象节点类，具体使用接口还是抽象类需根据具体场景而定。
 *  Composite（复合组件）：包含多个子组件对象（可以是复合组件或叶端组件）的复合型组件，并实现组件接口中定义的操作方法。对应本章例程中作为“根节点/枝节点”的文件夹类。
 *  Leaf（叶端组件）：不包含子组件的终端组件，同样实现组件接口中定义的操作方法。对应本章例程中作为“叶节点”的文件类  
    。
 *  Client（客户端）：按所需的层级关系部署相关对象并操作组件接口所定义的接口，即可遍历树结构上的所有组件。

### 好处和坏处 ###

组合模式的好处有：

*  可以将对象组合成树形结构，表示**整体-部分**的层次关系，符合人们的直觉。
 *  可以统一处理单个对象和对象组合，简化了客户端的代码逻辑，提高了系统的可复用性。
 *  可以遵循开闭原则，扩展性高，增加新的节点类型时不需要修改原有代码。

组合模式的坏处有：

*  可以使设计变得过于抽象，不利于理解和维护。
 *  可以违反单一职责原则，让叶子节点和组合节点具有相同的接口，导致叶子节点出现不必要的方法。
 *  可以导致递归调用过深，影响系统的性能。

### 应用场景 ###

组合模式是一种将对象组合成树形结构的设计模式，它可以表示**整体-部分**的层次关系，并且提供了一致的接口来操作单个对象和对象组合。应用场景有：

*  当需要表示一个对象整体与部分的层次结构时，可以使用组合模式来实现树形结构。例如，文件系统中的文件与文件夹、组织机构中的部门与员工、商品分类中的类别与商品等。
 *  当需要统一处理单个对象和对象组合时，可以使用组合模式来实现多态性。例如，图形界面中的简单控件与容器控件、菜单系统中的菜单项与子菜单、报表系统中的单元格与表格等。
 *  当需要将对象的创建和使用分离时，可以使用组合模式来实现依赖注入。例如，Spring框架中的Bean对象与BeanFactory对象、测试框架中的测试用例与测试套件等。

### Java 代码示例 ###

假设我们有一个文件系统，其中有两种类型的文件：文本文件和文件夹。文本文件是叶子节点，文件夹是组合节点，可以包含其他文件。我们想要使用组合模式来实现文件系统的层次结构，并且提供一个打印文件路径的方法。代码如下：

定义抽象组件

public interface File {
        // 获取文件名称
        String getName();
        // 添加子文件
        void add(File file);
        // 删除子文件
        void remove(File file);
        // 获取子文件
        List<File> getChildren();
        // 打印文件路径
        void printPath(int space);
    }

定义叶子节点

public class TextFile implements File {
        private String name;
    
        public TextFile(String name) {
            this.name = name;
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void add(File file) {
            throw new UnsupportedOperationException("Text file cannot add child file");
        }
    
        @Override
        public void remove(File file) {
            throw new UnsupportedOperationException("Text file cannot remove child file");
        }
    
        @Override
        public List<File> getChildren() {
            throw new UnsupportedOperationException("Text file has no child file");
        }
    
        @Override
        public void printPath(int space) {
            StringBuilder sp = new StringBuilder();
            for (int i = 0; i < space; i++) {
                sp.append(" ");
            }
            System.out.println(sp + name);
        }
    }

定义组合节点

public class Folder implements File {
        private String name;
        private List<File> children;
    
        public Folder(String name) {
            this.name = name;
            children = new ArrayList<>();
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void add(File file) {
            children.add(file);
        }
    
        @Override
        public void remove(File file) {
            children.remove(file);
        }
    
        @Override
        public List<File> getChildren() {
            return children;
        }
    
        @Override
        public void printPath(int space) {
            StringBuilder sp = new StringBuilder();
            for (int i = 0; i < space; i++) {
                sp.append(" ");
            }
            System.out.println(sp + name);
            space += 2;
            for (File child : children) {
                child.printPath(space);
            }
        }
    }

客户端代码

public class Client {
        public static void main(String[] args) {
            // 创建一个根文件夹，并添加两个文本文件和一个子文件夹
            File root = new Folder("root");
            root.add(new TextFile("a.txt"));
            root.add(new TextFile("b.txt"));
            File subFolder = new Folder("subFolder");
            root.add(subFolder);
    
            // 在子文件夹中添加两个文本文件
            subFolder.add(new TextFile("c.txt"));
            subFolder.add(new TextFile("d.txt"));
    
            // 打印根文件夹的路径
            root.printPath(0);
        }
    }

输出结果：

root
      a.txt
      b.txt
      subFolder
        c.txt
        d.txt

### Go 代码示例 ###

package main
    
    // importing fmt package
    import (
    	"fmt"
    )
    
    // IComposite interface
    type IComposite interface {
    	perform()
    }
    
    // Leaflet struct
    type Leaflet struct {
    	name string
    }
    
    // Leaflet class method perform
    func (leaf *Leaflet) perform() {
    
    	fmt.Println("Leaflet " + leaf.name)
    }
    
    // Branch struct
    type Branch struct {
    	leafs    []Leaflet
    	name     string
    	branches []Branch
    }
    
    // Branch class method perform
    func (branch *Branch) perform() {
    
    	fmt.Println("Branch: " + branch.name)
    	for _, leaf := range branch.leafs {
    		leaf.perform()
    	}
    
    	for _, branch := range branch.branches {
    		branch.perform()
    	}
    }
    
    // Branch class method add leaflet
    func (branch *Branch) add(leaf Leaflet) {
    	branch.leafs = append(branch.leafs, leaf)
    
    }
    
    //Branch class method addBranch branch
    func (branch *Branch) addBranch(newBranch Branch) {
    
    	branch.branches = append(branch.branches, newBranch)
    }
    
    //Branch class  method getLeaflets
    func (branch *Branch) getLeaflets() []Leaflet {
    	return branch.leafs
    }
    
    // main method
    func main() {
    
    	var branch = &Branch{name: "branch 1"}
    
    	var leaf1 = Leaflet{name: "leaf 1"}
    	var leaf2 = Leaflet{name: "leaf 2"}
    
    	var branch2 = Branch{name: "branch 2"}
    
    	branch.add(leaf1)
    	branch.add(leaf2)
    	branch.addBranch(branch2)
    
    	branch.perform()
    
    }

输出结果：

G:\GoLang\examples>go run composite.go
    Branch: branch 1
    Leaflet leaf 1
    Leaflet leaf 2
    Branch: branch 2

### Spring 代码示例 ###

Spring 框架也可以使用组合模式来实现对象的层次结构，它提供了一个注解叫做 `@Component`，它可以用来标注一个类是一个组件，即一个可被Spring管理的Bean对象。`@Component` 注解有一个属性叫做value，它可以用来指定组件的名称。我们可以使用 `@Component` 注解来标注我们的文件类，然后在配置文件或注解中声明这些组件，Spring 就会自动创建和管理这些组件对象。

假设我们有一个文件系统，其中有两种类型的文件：文本文件和文件夹。文本文件是叶子节点，文件夹是组合节点，可以包含其他文件。我们想要使用组合模式来实现文件系统的层次结构，并且提供一个打印文件路径的方法。我们可以使用 `@Component` 注解来实现，代码如下：

抽象组件不用改造

叶子节点添加 `@Component("a.txt")` 注解

@Component("a.txt")
    public class TextFile implements File {
        private String name;
    
        public TextFile() {
            this.name = "a.txt";
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void add(File file) {
            throw new UnsupportedOperationException("Text file cannot add child file");
        }
    
        @Override
        public void remove(File file) {
            throw new UnsupportedOperationException("Text file cannot remove child file");
        }
    
        @Override
        public List<File> getChildren() {
            throw new UnsupportedOperationException("Text file has no child file");
        }
    
        @Override
        public void printPath() {
            System.out.println(name);
        }
    }

组合节点添加 `@Component("root")` 注解

@Component("root")
    public class Folder implements File {
        private String name;
        private List<File> children;
    
        // 通过@Autowired注解自动注入所有类型为File的Bean对象到children集合中
        @Autowired
        public Folder(List<File> children) {
            this.name = "root";
            this.children = children;
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        @Override
        public void add(File file) {
            children.add(file);
        }
    
        @Override
        public void remove(File file) {
            children.remove(file);
        }
    
        @Override
        public List<File> getChildren() {
            return children;
        }
    
        @Override
        public void printPath() {
            System.out.println(name);
            for (File child : children) {
                child.printPath();
            }
        }
    }

SpringBoot 测试代码

@Slf4j
    @SpringBootTest
    class SpringBootTest {
    
        @Autowired
        private Folder folder;
    
        @Test
        void test() {
            folder.printPath();
        }
    }

输出结果：

root
    a.txt

### 总结 ###

组合模式是一种常用的结构型设计模式，它可以将对象组合成树形结构，并且提供了一致的接口来操作单个对象和对象组合，是一种值得学习和掌握的设计模式。

[453399cad9ec52277c8870741a8e52e4.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/8287d1596f234d888006f94ef117a616.png