我可以称其为复合模式的实现吗

Question

我有自己自称为复合模式的设计，尽管我不完全确定。因此，我正在为您提供有关此的声明。

这是一个界面，共同描述了所有这些界面，

public interface DomainResourceBuilder<T extends DomainResource> {

    T buildInsertion(T persistence, EntityManager entityManager) throws Exception;

    T buildUpdate(T model, T persistence, EntityManager entityManger);

    <E extends T> DomainResourceBuilder<E> and(DomainResourceBuilder<E> next);

}

该界面描述了 domainResourceBuilder 作为配对

public abstract class AbstractDomainResourceBuilder<D extends 
    DomainResource> implements DomainResourceBuilder<D> {

    @Override
    public <E extends D> DomainResourceBuilder<E> 
        and(DomainResourceBuilder<E> next) {
        return new CompositeDomainResourceBuilder<>(this, next);
    }

    private class CompositeDomainResourceBuilder<T extends D> 
        extends AbstractDomainResourceBuilder<T> {

        private final DomainResourceBuilder<D> parentBuilder;
        private final DomainResourceBuilder<T> childBuilder;

        public 
           CompositeDomainResourceBuilder(DomainResourceBuilder<D> 
           parentBuilder,
           DomainResourceBuilder<T> childBuilder) {
            super();
            this.parentBuilder = parentBuilder;
            this.childBuilder = childBuilder;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T buildInsertion(T model, EntityManager 
            entityManager) throws Exception {
            return childBuilder.buildInsertion((T) 
            parentBuilder.buildInsertion(model, entityManager), 
                entityManager);
        }

        @SuppressWarnings("unchecked")
        @Override
        public T buildUpdate(T model, T persistence, 
            EntityManager entityManger) {
            return childBuilder.buildUpdate(model, (T) 
                parentBuilder.buildUpdate(model, persistence, 
                    entityManger), entityManger);
        }
    }
}

具体类扮演 leaf> leaf 角色

public class CustomerBuilder extends AbstractDomainResourceBuilder<Customer> {

    @Override
    public
        Customer buildInsertion(Customer persistence, EntityManager entityManager) throws Exception {
        return persistence;
    }

    @Override
    public
        Customer buildUpdate(Customer model, Customer persistence, EntityManager entityManger) {
        return persistence;
    }

}

我可以称其为复合模式吗？

这就是我的使用方式。屁股我有以下层次结构。

AbstractEntity
|___User
    |___Customer

现在，我想在每个类上实现不同的逻辑，因此，使用设计，我将为这些班级创建特定的逻辑，然后最终将它们组成一个，这仍然是其中之一。这样的东西。

// group of objects
DomainResourceBuilder<AbstractEntity> abstractEntityBuilder = new AbstractEntityBuilder<>();
DomainResourceBuilder<User> userBuilder = new UserBuilder<>();
DomainResourceBuilder<Customer> customerBuilder = new CustomerBuilder<>();
// treat them as a whole (unify them all)
DomainResourceBuilder<Customer> compositeCustomerBuilder = 
    abstractEntityBuilder
    .and(userBuilder)
    .and(customerBuilder);

Answer 1

我认为它看起来不像复合模式为：

• 没有一个地方一组对象与相同类型对象的单个实例相同的对象。

在我看来，看起来它使用 builder> builder 与可以处理实体结构的通用物质。

更新：

在我的视图中，它不是对象组：

// group of objects
DomainResourceBuilder<AbstractEntity> abstractEntityBuilder = new AbstractEntityBuilder<>();
DomainResourceBuilder<User> userBuilder = new UserBuilder<>();
DomainResourceBuilder<Customer> customerBuilder = new CustomerBuilder<>();

如果将上述对象放入集合中，则可以将其称为一组对象。以我的荣誉意见，这只是对象变量。

在以下几行中， fluent interface 可以将设计模式视为可以被视为可以链接的：

// treat them as a whole (unify them all)
DomainResourceBuilder<Customer> compositeCustomerBuilder = 
    abstractEntityBuilder
    .and(userBuilder)
    .and(customerBuilder);

让我展示一个示例，其中可以将对象组作为一个整体对待。

以下文献有很好的例子和解释：

• 埃里克·弗里曼（Eric Freeman）的有趣书
• 有关 Wiki的复合模式
• 有关 CodeMaze的复合模式

想象您正在构建浏览器您想显示控件。您的任务是显示在DOM浏览器中放置的所有控件的值。

因此，示例代码看起来像这样。

我们需要一些用于控件的基类：

public abstract class ControlBase
{
    protected string name;
    protected string value;

    public ControlBase(string name, string value)
    {
        this.name = name;
        this.value = value;
    }

    public abstract string ShowValue();
}

及其操作：

public interface IControlOperations
{
    void Add(ControlBase gift);
    void Remove(ControlBase gift);
}

然后，我们创建一个复合控件，可以在其中拥有对象组：

public class CompositeControl : ControlBase, IControlOperations
{
    // group of objects
    private List<ControlBase> _controls;

    public CompositeControl(string name, string value)
        : base(name, value)
    {
        _controls = new List<ControlBase>();
    }

    public void Add(ControlBase gift)
    {
        _controls.Add(gift);
    }

    public void Remove(ControlBase gift)
    {
        _controls.Remove(gift);
    }

    // group of objects can be treat as a whole
    public override string ShowValue()
    {
        StringBuilder allValues = new StringBuilder();

        Console.WriteLine($"{name} has the following values:");

        foreach (var gift in _controls)
        {
            allValues.AppendLine(gift.ShowValue());
        }

        return allValues.ToString();
    }
}

我们的UI控件：

public class TextBox : ControlBase
{
    public TextBox(string name, string value)
        : base(name, value)
    {
    }

    public override string ShowValue()
    {
        Console.WriteLine($"{name} has {value}");

        return value;
    }
}

public class CheckBox : ControlBase
{
    public CheckBox(string name, string value)
        : base(name, value)
    {
    }

    public override string ShowValue()
    {
        Console.WriteLine($"{name} with value {value}");

        return value;
    }
}   

然后我们可以这样调用代码：

var textBox_Phone = new TextBox("textBox_Phone", "1");
textBox_Phone.ShowValue();
Console.WriteLine();
//composite control
var divContainer = new CompositeControl("divContainer", string.Empty);
var textBox_Name = new TextBox("textBox_Name", "Joseph");
var textBox_Surname = new TextBox("textBox_Surname", "Albahari");
divContainer.Add(textBox_Name);
divContainer.Add(textBox_Surname);
Console.WriteLine($"Total values of this composite control " +
    $"is: {divContainer.ShowValue()}");