Composite

动机(Motivation)

• 客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构(而非抽象结构)的变化
  引起客户代码的频繁变化，带来了代码的维护性、扩展性等弊端。
• 如何将”客户代码与复杂的对象容器结构“解耦？让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象一样来处理复杂的对象容器？

模式定义

将对象组合成树形结构以表示”部分-整体“的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性(稳定)。
——《设计模式》GoF

要点总结

• Composite模式采用 树性结构 来实现普遍存在的对象容器，从而将一对多的关系转化为一对一的关系，使得客户代码可以一致地(复用)处理对象和对象容器，
  无需关心处理的是单个的对象，还是组合的对象容器。
• 客户代码与纯粹的抽象接口——而非对象容器的内部实现结构——发生依赖，从而更能”应对变化“。
• Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对象有频繁的遍历需求，可使用缓存技术来改善效率。

例子

# -*- coding:utf-8 -*-


class Component(object):
    def __init__(self, node_name):
        self.node_name = node_name

    def process(self):
        pass


class TreeNode(Component):

    def __init__(self, node_name):
        super(TreeNode, self).__init__(node_name)
        self.node_list = []

    def process(self):
        self._process_cur_node()
        self._process_sub_node()

    def add_node(self, node):
        self.node_list.append(node)

    def remove_node(self, node):
        self.node_list.pop(node)

    def _process_cur_node(self):
        print('process cur node:', self.node_name)

    def _process_sub_node(self):
        for sub_node in self.node_list:
            sub_node.process()


class LeafNode(Component):

    def process(self):
        print('process leaf node:', self.node_name)


if __name__ == '__main__':
    root_node = TreeNode('root')
    tree_node1 = TreeNode('tree_node1')
    tree_node2 = TreeNode('tree_node2')
    tree_node3 = TreeNode('tree_node3')
    leaf_node1 = LeafNode('leaf_node1')
    leaf_node2 = LeafNode('leaf_node2')

    root_node.add_node(tree_node1)
    root_node.add_node(tree_node2)
    tree_node1.add_node(tree_node3)
    tree_node3.add_node(leaf_node1)
    tree_node3.add_node(leaf_node2)

    root_node.process()

输出

('process cur node:', 'root')
('process cur node:', 'tree_node1')
('process cur node:', 'tree_node3')
('process leaf node:', 'leaf_node1')
('process leaf node:', 'leaf_node2')
('process cur node:', 'tree_node2')