标签: strategy-pattern

这是一个与设计相关的问题。

假设我们有一个名为 ClientAPI 的公共 API，其中包含一些 Web 方法，例如 CreateAccount、GetAccount。根据客户的不同，我们使用许多不同的提供商来满足这些请求。

假设我们有 ProviderA、ProviderB 和 ProviderC。

ProviderA 具有 CreateAccount 的方法签名/实现，仅需要（名字，姓氏）并使用 ProviderA 创建帐户。

ProviderB 具有 CreateAccount 的方法签名/实现，需要（名字、姓氏、电子邮件、出生日期）并使用 ProviderB 创建帐户。

ProviderC 具有 CreateAccount 的方法签名/实现，需要（昵称、CompanyKey、电子邮件）并使用 ProviderC 创建帐户。

客户端不需要知道或关心它们是哪个提供者。当调用客户端 API 方法 CreateAccount 时，客户端 api 将计算出需要调用的提供程序并调用该提供程序方法。

我这里有两个问题。

1）该模型的最佳设计/模式是什么？另请记住，提供程序的数量将会增加 \xe2\x80\x93，我们将添加更多提供程序。

2）关于传递参数\xe2\x80\x93，目前ClientAPI CreateAccount方法签名是一大行变量，如果新的提供者需要新值，方法签名会添加另一个变量，这显然破坏了旧的实现等等。将方法签名中的参数数组/列表/字典传递到下面的提供程序中是否是一个好习惯，或者是否有更好的方法？

我有以下具有多种情况的代码：

def _extract_property_value(selector: Selector) -> str:
    raw_value = selector.xpath("span[2]")

    default_value = raw_value.xpath("./text()").get().strip()
    value_with_a = ', '.join([value.strip() for value in raw_value.xpath("./a /text()").getall()])
    value_with_div_and_a = ', '.join([value.strip() for value in raw_value.xpath("./div /a /text()").getall()])

    if value_with_a:
        return value_with_a
    elif value_with_div_and_a:
        return value_with_div_and_a
    elif default_value:
        return default_value

我想摆脱 if 语句并尽可能简化此代码。我不是优秀的 Pyton 开发者。我知道有模式“策略”，下面我试图实现它：

def _extract_property_value(selector: Selector) -> str:
    raw_value = selector.xpath("span[2]")
    values_dict = {
        'default value': raw_value.xpath("./text()").get().strip(),
        'value with a': ', '.join([value.strip() for value in raw_value.xpath("./a /text()").getall()]),
        'value with div and a': ', '.join([value.strip() for …

有人可以一劳永逸地向我解释这两者之间的区别,并尝试给出一种何时使用它们的指导方针？例子真的很棒.

我试图将策略模式应用于特定情况,但是我遇到了如何避免将每个具体策略与为其提供数据的上下文对象耦合的问题.以下是以几种不同方式发生的模式的简化情况,但应以类似的方式处理.

我们有一个对象Acquisition提供与特定时间相关的数据 - 基本上是使用不同硬件收集的一堆外部数据.它已经太大了,因为它包含了大量的数据,所以我不想给它任何进一步的责任.我们现在需要采取一些这样的数据,并根据一些配置向一块硬件发送相应的电压.

所以,想象下面的(简化的)类:

class Acquisition
{
    public Int32 IntegrationTime { get; set; }
    public Double Battery { get; set; }
    public Double Signal { get; set; }
}

interface IAnalogOutputter
{
    double getVoltage(Acquisition acq);
}

class BatteryAnalogOutputter : IAnalogOutputter
{
    double getVoltage(Acquisition acq)
    {
        return acq.Battery;
    }
}

现在,每个具体的策略类都必须耦合到我的Acquisition类,它也是最可能被修改的类之一,因为它是我们应用程序的核心.这仍然是对旧设计的改进,旧设计是课堂内的一个巨大的开关声明Acquisition.每种类型的数据都可能有不同的转换方法(虽然电池是一个简单的传递,其他类型根本不是那么简单),所以我觉得战略模式或类似应该是要走的路.

我还要注意,在最终实现中,IAnalogOutputter将是一个抽象类而不是接口.这些类将位于可由用户配置并序列化为XML文件的列表中.该列表必须在运行时可编辑并记住,因此Serializable必须是我们最终解决方案的一部分.如果它有所作为.

如何确保每个实现类获取它需要工作的数据,而不将其绑定到我最重要的类之一？还是我以完全错误的方式处理这类问题？

我目前正在开发一个项目,我们必须在3D环境中表示一组向量.我们有几种不同的可视化实现.

我想到了我可以将所有可视化类型捆绑在枚举中.我已经定义了一个Interface VectorVisualization和几个实现这个接口的实现.

现在我已经在Interface类中添加了以下枚举:

public interface VectorVisualization {

    public enum VectorVisualizationType {
       CYLINDER(new VectorVisualizationCylinder(), "Cylinder"),
       CONES(new VectorVisualizationCones(), "Cones"),
       FATCONES(new VectorVisualizationFatCones(), "Fat cones"),
       ARROWS(new VectorVisualizationArrows(), "Arrows");

       private final String label;
       private final VectorVisualization vis;

       VectorVisualizationType(VectorVisualization vis, String label) {
           this.vis = vis;
           this.label = label;
       }

       public VectorVisualization getVisualization() {
           return this.vis;
       }

       public String getLabel() {
           return this.label;
       }
   }

   void prepareVBO(GL gl, ArrayList<VectorData> vectors, VectorField field);
   void render(GL gl);
   void clearOldVBOS(GL gl);
}

该标签适用于Gui中的JComboBox.所以我现在可以迭代枚举并获得不同类型的标签.另外要设置一个实现,我可以像这样使用枚举:

VectorVisualizationType.CYLINDER.getVisualization()

但这是一个很好的方式吗？或者这种方法有什么问题吗？当然,现在当你创建一个新的实现时,你必须将它添加到枚举中.

感谢您的意见!

好的,所以我被赋予了一项任务,要求我同时使用策略和工厂设计模式.这是问题所在:

您正在为银行开发一个用于处理贷款的申请.有Loan一个方法的类capital().该capital()方法包含一个丑陋的if-then-else条件,它检查一些Loan对象实例属性,并根据属性使用正确的贷款类型策略.这是该capital()方法的伪代码:

capital() {
    if (expiry == null && maturity != null) {
        // Find capital for term loan
        return commitment * duration * riskFactor;
    }
    if (expiry != null && maturity == null) {
        if (getUnusedPercentage() != 1.0) {
            // Find capital for revolving loan
            return commitment * unusedPercentage * duration * riskFactor;
        } else {
            // Find capital for complex loan
            return (outstandingRiskAmount * duration * riskFactor) + (unusedRiskAmount * …

我目前正试图了解所有不同的设计模式,我已经设置了IQueryable基于不同列排序的任务,这是当前实现的方式:

if (choice == 1)
{ 
    return from Animals in ctx.Animals orderby Animals.AnimalID descending select Animals; 
}
else if (choice == 2)
{ 
    return from Animals in ctx.Animals orderby Animals.Name descending select Animals; 
}
else if (choice == 3)
{ 
    return from Animals in ctx.Animals orderby Animals.Age descending select Animals; 
}

然而,这似乎是一个糟糕的代码味道,它没有能力轻松添加不同的字段或排序选项,我的导师告诉我,实施策略模式并使用a Dictionary选择策略实现我们会更好但是,我不确定战略模式将如何应用于这种情况,任何有用的提示将非常感激,如果需要更多信息,请问.

如何在运行中切换服务并将所有组件(依赖服务)自动绑定到新策略上的数据？

我有一个Storage服务和两个存储策略,StorageStrategyA和StorageStrategyB.Storage为控制器和其他组件提供公共接口以与之交互:

angular.module('app').factory('Storage', function ($injector) {
    var storage;
    var setStrategy = function (name) {
        storage = $injector.get(name);
    };

    setStrategy('StorageStrategyB');

    return {
        getItems: function () {
            return storage.getItems();    
        }
        // [...]
    };
});

但是当策略发生变化时,双向绑定会中断,并且视图不会使用getItems()新策略中的项目进行更新.

我创建了一个Plunker来说明问题.

有没有办法将策略模式与AngularJS结合起来并保持双向绑定？

请注意,在我的实际应用程序中,我不能Storage.getItems()在策略更改后再次调用,因为依赖于多个组件(视图,控制器,范围)Storage并且服务更改会自动发生.

编辑:
我已经分叉了Plunker以突出问题.如您所见,上部的数据仅更新,因为我Storage.getItems()在策略更改后再次手动调用.但我不能这样做,因为其他组件 - 例如OtherController- 也在访问数据,Storage并且还需要自动从新策略中获取数据.相反,他们仍然坚持初始战略.

我无法理解为什么在策略设计模式中使用Context模块(我们将在下面的代码中看到),它的功能是什么？让我们看一下战略设计模式的一部分.

public interface Strategy {
    public int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    @Override 
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationSubstract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

从上面的代码中,我们可以通过这种方式调用不同的算法: …

在战略设计模式中,我们所做的是

• 创建一个通用接口.
• 使用具有重写方法的接口实现一组类.
• 让运行时选择与该公共接口具有相同类型的对象的实际类,并调用将根据类正确解析的重写方法.

我的问题是,这不是我们学习的多态和方法重写的基本例子吗？

除了使用抽象类的可能性之外,替换公共接口.