在不同 "output levels" 上执行请求的设计模式

Question

我正在解析如下字符串：

\read(customer) hello world


~> \method(arg, arg, ...)

进入一个复合数据结构，它持续存在 1 到 n 个参数，它们是requestLeaf 对象，参数可以是 requestLeaf 对象（如果只是纯文本，应该像上面那样 returned（"hello world")) 或另一个 requestComposite 对象（如果正在进行一些计算（如读取->客户），直到它再次成为纯文本。

requestComposite Object
(
  [requests:protected] => Array
      (
          [0] => commandRequest Object
              (
                  [methodName:protected] => read
                  [arguments:protected] => Array
                      (
                        [0] => commandRequest Object
                          (
                            [methodName:protected] => text
                            [arguments:protected] => customer
                          )
                      )
              )
          [1] => commandRequest Object
              (
                  [methodName:protected] => text
                  [arguments:protected] =>  hello world
              )
      )
)

我想要实现的是循环遍历整个合成，以便呈现某种文档。

第一个 composite 的参数或 leafs 代表 root 或 Level 0 用于打印到文档。
我想为此使用图书馆。这个库可以处理打印文本、图像等，但不能评估任何东西！

一切> 0 级 应在另一个 库中计算。
这个库可以读取成员值，做一些数学运算等，并且 return 它的最终值（不包括字符串）到 root 被打印出来。
其他所有内容都通过例如显式打印\img() 或 \text()

可能会有一个

\read(x)

用于查找成员值 X 的令牌，
whichs value should be printed implicitly, (不将其包装到另一个 \text())!

可能有一个 \list() 标记通过指定的成员列表循环其参数，例如：

\list(\read(x)))

X 可能是另一个 Y

\list(\read(\read(y))).

换句话说：我不知道结构有多深。

碰巧我对设计模式尤其是 OO 还很陌生。
我现在正在为 "executing" 摆弄 责任链 模式，其中 rendering/output 库和计算库正在构建处理程序链。
但我有点好奇 CoR 是否真的能满足我的需求：

你会如何解决这样的问题？

编辑：我现在的方法

遍历复合材料。
传递一个 Mediator Object
其中包含 输出库 和 计算库 。
如果当前叶是文本
检查当前是否是根
如果没有访问计算库以评估实际值并将其传递给它可能关注的人（例如 \read(), \varput(), ...）
如果是访问输出库打印出来

我想到的是我必须在两个库中实现每个requestMethod才能实现自动根打印。即
output 中的 \read() 应该将文本打印到文档，
计算库中的 \read() 应该查找一个成员值。

我是不是把事情复杂化了？

Answer 1

从评论继续，假设您已经根据输入构建了复合树，您需要什么不能像这样完成：

import java.util.ArrayList;
import java.util.List;
interface Component {
    void add(Component component);
    List<Component> children();
}
class Composite implements Component {
    @Override public void add(Component component) {
        children.add(component);
    }
    @Override public List<Component> children() {
        return children;
    }
    List<Component> children=new ArrayList<>();
}
class Leaf implements Component {
    @Override public void add(Component component) {
        throw new UnsupportedOperationException();
    }
    @Override public List<Component> children() {
        return null;
    }
}
public class So34886186 {
    static String indent(int n) {
        String s="";
        for(int i=0;i<n;i++)
            s+=" ";
        return s;
    }
    static void print(Component root,Component component,int indent) {
        if(component instanceof Leaf)
            if(component.equals(root))
                System.out.println(indent(indent)+"    root: leaf: "+component);
            else System.out.println(indent(indent)+"not root: leaf: "+component);
        else {
            if(component.equals(root)) {
                System.out.println(indent(indent)+"    root: composite: "+component+": (");
                for(Component component2:((Composite)component).children)
                    print(root,component2,indent+4);
                System.out.println(indent(indent)+")");
            } else {
                System.out.println(indent(indent)+"not root: composite: "+component+": (");
                for(Component component2:((Composite)component).children)
                    print(root,component2,indent+4);
                System.out.println(indent(indent)+")");
            }
        }
    }
    public static void main(String[] args) {
        Component root=new Composite();
        root.add(new Leaf());
        Component one=new Composite();
        root.add(one);
        one.add(new Leaf());
        Component two=new Composite();
        root.add(two);
        print(root,root,0);
    }
}

在不同 "output levels" 上执行请求的设计模式

Design Pattern for executing requests on different "output levels"

oop

design-patterns

composite

multi-level

chain-of-responsibility