何时使用成员变量与按组成设计？

时间：2019-05-20 16:30:11

标签： java oop design-patterns

我正在全神贯注于如何最好地设计我正在使用的系统。

假设它是类似于典当行的应用程序。我已经将购买和转售流程限制为一种称为ExecutionStrategy的流程。此应用程序中有四个ExecutionStrategy实现：注册客户，投标和购买，定价以及过帐到商店。

每一项策略都遵循一个基本步骤，包括主要执行工作流程并记录我们在数据存储区中所做的工作。

除了这些投标，购买以及定价外，还需要专家咨询，然后我们才能在执行工作流中执行任何操作。

在这里，我对我想根据设计做出的决定感到有些困惑。似乎有三个选项可供选择，我不太确定哪个是最正确的。 1）使用带有ExecutionStrategyWithConsultation的ExecutionStrategy之类的东西来扩展执行策略，该策略将策略的执行工作流程包装为咨询阶段。 2）为ExecutionStrategy创建Decorator模式，并使用ConsultationServiceDecorator之类的方式扩展它。 3）在购买/投标和定价的实现中创建一个成员变量，以随时通过围绕该服务的接口调用咨询服务。

我将在下面概述设计。

一些注意事项：

  • ConsultationService非常非常慢。缓存并不是真正的选择，因为数据的格式非常松散，我们不希望为此创建文档数据存储。
  • ConsultationService返回与给定对象匹配的对象。因此，最终得到了一种看起来像T consultOn(T item)
    • 的方法
  • 在执行工作流中随时可能需要调用ConsultationService。当前唯一的用例是在主流之前调用服务，但这不一定是目前唯一的用例。

上述每种方法的优点/缺点：

  1. 直接扩展执行策略：

    • PRO：我们可以访问代码中受保护的ConsultationService变量
    • PRO：通过阅读PurchasingExecutionStrategy extends ExecutionStrategyWithConsultation这样的代码，我们有了一个了解，因此，我们从中了解到它只是一种什么样的工作流程。
    • CON：这似乎打破了“继承之上的构成”模式。我们正在使用继承来存储成员变量。
    • CON：服务返回一个全新的对象，因此在对服务进行调用的第一行代码之后，我们正在处理的对象与原始传递的对象完全不同。

  2. 创建装饰器：

    • PRO：我们与继承主体的组成更加一致。
    • PRO：我们可以强制首先调用该服务，然后将该新对象传递给主工作流程，因此它仅对传递的对象执行其主工作流程。
    • CON：我还没有找到一种设计方法来允许潜在的多次或任何时间的服务呼叫。
    • CON：在查看代码时，我们会失去从PurchasingExecutionStrategy extends ExecutionStrategyWithConsultation获得的知识，除非我们将PurchasingExecutionStrategy实际实例化为ConsultationServiceDecorator的构造函数arg的地方

  3. 使用接口创建成员变量：

    • PRO：与＃1相同。易于理解，无需深入挖掘代码在做什么。
    • CON：与＃1相同。无法执行订单。执行处理的对象与传递的对象本质上不同。
    • CON：如果我们需要在同一工作流程中进行多个调用，由于服务速度快且没有缓存，这将非常慢。

每个示例：

//Number 1
public interface ExecutionStrategy<T> {

    /**
    * Perform the main execution workflow
    */
    public T execute(T item);
}

public interface ConsultationService {

    public StoreItem consultOn (StoreItem item);
}

public abstract class ExecutionStrategyWithConsultation implements ExecutionStrategy<StoreItem> {

    protected ConsultationService consultationService;

}

public class ListingExecutionStrategy extends ExecutionStrategyWithConsultation {

    public StoreItem execute(StoreItem item) {
      if (item.hasDirectBuyer()) { //hasDirectBuyer is populated by ConsultationService
        item.sellTo = item.directBuyer.getId();
      } else {
        //no direct buyer
        SuggestedPriceRange priceRange = item.getConsultationPriceRange(); //consultationPriceRange is populated by ConsultationService
        item.priceRange = priceRange;
        item.listToWebsite = true;
      }
      return item;
    }
}

//Number 2
public interface ExecutionStrategy<T> {

    /**
    * Perform the main execution workflow
    */
    public T execute(T item);
}

public abstract class ExecutionStrategyDecorator<T> implements ExecutionStrategy<T>{

    protected final ExecutionStrategy<T> executionStrategy;
    public ExecutionStrategyDecorator(ExecutionStrategy<T> execStrategy) {
      executionStrategy = execStrategy;
    };
}

public class ExecutionStrategyWithConsultation extends ExecutionStrategyDecorator<StoreItem> {

    protected ConsultationService consultationService;

    public ExecutionStrategyWithConsultation(ExecutionStrategy<StoreItem> execStrat, ConsultationService service) {
      super(execStrat);
      consultationService = service;
    }

    public StoreItem execute(StoreItem item) {
      StoreItem itemAfterConsultation = consultationService.consultOn(item);
      return execStrategy.execute(itemAfterConsultation);
    }

}

public class ListingExecutionStrategy implements ExecutionStrategy<StoreItem> {

    public StoreItem execute(StoreItem item) {
      if (item.hasDirectBuyer()) { //hasDirectBuyer is populated by ConsultationService
        item.sellTo = buyer.getId();
      } else {
        //no direct buyer
        SuggestedPriceRange priceRange = item.getConsultationPriceRange(); //consultationPriceRange is populated by ConsultationService
        item.priceRange = priceRange;
        item.listToWebsite = true;
      }
      return item;
    }
}

public class ListingExecutionStrategyFactory {

    public ExecutionStrategy instantiate() {
      return new ExecutionStrategyWithConsultation(new ListingExecutionStrategy(), new ConsultationServiceImpl());
    }
}

//Number 3
public interface ExecutionStrategy<T> {

    /**
    * Perform the main execution workflow
    */
    public T execute(T item);
}

public interface ConsultationService {

    public DirectBuyer getDirectBuyerIfExists(StoreItemType itemType);
    public SuggestedPriceRange getSuggestedPriceRange(StoreItem item);
}

public class ListingExecutionStrategy implements ExecutionStrategy<StoreItem> {

    ConsultationService service;

    public PurchasingExecutionStrategy(ConsultationService consultService) {
        service = ConsultationService;
    }

    public StoreItem execute(StoreItem item) {
      DirectBuyer buyer = service.getDirectBuyerIfExists(item.getItemType())
      if (Optional.ofNullable(buyer).isPresent()) {
        item.sellTo = buyer.getId();
        return item;
      } else {
        //no direct buyer
        SuggestedPriceRange priceRange = service.getSuggestedPriceRange(item);
        item.priceRange = priceRange;
        item.listToWebsite = true;
        return item;
      }
    }
}

感谢您的输入。感谢帮助。

1 个答案:

答案 0 :(得分：1)

作为ConsultationService的替代方法，您可以考虑构建ExecutionService实例链以允许创建复杂的处理方案：

public interface ExecutionStrategy<T> {
    public T execute(T item);
}


public interface ExecutionStrategyChain<T> extends ExecutionStrategy<T> {
    public static <T> ExecutionStrategyChain<T> newInstance(ExecutionStrategy<T> executionStrategy) {
        return new ExecutionStrategyChainImpl<T>(executionStrategy); 
    }

    public ExecutionStrategyChain<C> chainTo(ExecutionStrategy<C> executionStrategy);
}


public abstract class AbstractExecutionStrategyChain<T> implements ExecutionStrategyChain<T> {
    protected AbstractExecutionStrategyChain() {
        this(null);
    }


    public abstract T execute(T item);


    public ExecutionStrategyChain<T> chainTo(ExecutionStrategy<T> executionStrategy) {
        return new ExecutionStrategyChainImpl<T>(this, executionStrategy);
    }
}


public final class ExecutionStrategyChainImpl<T> extends AbstractExecutionStrategyChain<T> {

    private final ExecutionStrategy<T> firstExecutionStrategy;
    private final Executionstrategy<T> secondExecutionStrategy;

    public ExecutionStrategyChainImpl(ExecutionStrategy<T> first, ExecutionStrategy<T> second) {
        if(first == null) throw new NullPointerException();
        this.firstExecutionStrategy = first;
        this.secondExecutionStrategy = second;
    }

    public ExecutionStrategyChainImpl(ExecutionStrategy<T> first) {
        this(first, null);
    }

    @Override
    public final T execute(T item) {
        if(item == null) {
            return null;
        }

        T result = firstExecutionStrategy.execute(item);
        if(result != null && secondExecutionStrategy != null) {
            result = secondExecutionStrategy.execute(result);
        }
        return result;
    }
}


public class PreProcessor<T> implements ExecutionStrategy<T> {

    public PreProcessor() {
    }

    @Override
    public T execute(T item) {
       //Do some pre-processing of item
       return item;
    }
}


public class PostProcessor<T> implements ExecutionStrategy<T> {

    public PostProcessor() {
    }

    @Override
    public T execute(T item) {
       //Do some post-processing of item
       return item;
    }
}


public class MyNormalProcessor<T> extends AbstractExecutionStrategyChain<T> {

    public MyNormalProcessor() {
    }

    @Override
    public T execute(T item) {
       //Do something normal with the item
       return item;
    }
}


public static final ExecutionStrategy<StoreItem> COMPLEX_EXECUTION_STRATEGY = 
    ExecutionStrategyChain<StoreItem>.newInstance(new PreProcessor<StoreItem>())
                                     .chainTo(new MyNormalProcessor<StoreItem>())
                                     .chainTo(new PostProcessor<StoreItem>());
相关问题
最新问题