具有不同参数的策略模式

Question

我在使用策略模式时遇到了一个问题.我正在实现创建任务的服务.此服务还解决了此任务的负责人员.解决职员是通过使用策略模式来完成的,因为有不同的方法可以做到这一点.关键是每个策略都需要不同的参数来解决职员.

例如:

interface ClerkResolver {
    String resolveClerk(String department);
}

class DefaultClerkResolver implements ClerkResolver {

    public String resolveClerk(String department) {
        // some stuff
    }
}

class CountryClerkResolver implements ClerkResolver {

    public String resolveClerk(String department) {
        // I do not need the department name here. What I need is the country.
    }

}

问题是每个解析器可能依赖于不同的参数来解决负责的职员.对我来说,这听起来像是我的代码中的设计问题.我还尝试将一个类作为参数来保留策略可能需要的所有值,例如:

class StrategyParameter {

   private String department;
   private String country;

   public String getDepartment() ...
}

interface ClerkResolver {
    String resolveClerk(StrategyParameter strategyParameter);
}

但说实话,我对这个解决方案并不满意,因为每当策略需要一个新的/不同的参数时我就必须更改参数类.其次,策略的调用者必须设置所有参数,因为他不知道哪个策略将解析职员,因此他必须提供所有参数(但这并不是那么糟糕).

同样,对我而言,这听起来像我的代码中的设计问题,但我找不到更好的解决方案.

---编辑

此解决方案的主要问题是创建任务时.任务服务如下所示:

class TaskService {

    private List<ClerkResolver> clerkResolvers;

    Task createTask(StrategyParamter ...) {

        // some stuff

       for(ClerkResolver clerkResolver : clerkResolvers) {
          String clerk = clerkResolver.resolveClerk(StrategyParameter...)
          ...
       }

       // some other stuff
    }

}

正如您在使用TaskService时所看到的那样,调用者必须提供必要的信息来解析职员,即部门名称和/或国家/地区,因为TaskService本身没有这些信息.

当必须创建任务时,调用者必须提供StrategyParameter,因为它们是解析职员所必需的.同样,问题是,呼叫者没有所有信息,即他不了解该国家.他只能设置部门名称.这就是我为界面添加第二种方法以确保策略可以处理职员解析的原因:

interface ClerkResolver {
    String resolveClerk(StrategyParameter strategyParameter);
    boolean canHandle(StrategyParameter strategyParameter);
}

冒着重复我的风险,这个解决方案对我来说听起来不对.

所以,如果有人有更好的解决方案来解决这个问题,我将不胜感激.

感谢您的意见!

Answer 1

我认为这个任务实际上有些混乱.在我看来,任务是由职员完成的.因此,您可以在不知道职员的情况下自行创建任务.

根据该任务,您可以为其选择合适的职员.将任务分配给职员本身可以包含在其他任务中.因此,选择职员的通用界面是:

interface ClerkResolver {
    String resolveClerk(Task task);
}

为了实现这种职员解析器,您可以使用基于任务的实际类型的策略模式.

Answer 2

恭喜，你发现了策略模式的缺点之一：

策略模式可用于托管不同的算法，这些算法要么没有参数，要么每个算法的参数集相同。但是，如果要使用具有不同参数集的各种算法，则达不到要求。

幸运的是，本文提出了一个优雅的解决方案：

将其应用于您的特定情况：

public abstract class ClerkResolver {  // Role: Algorithm 

    protected Parameter[] parameters;

    public Parameter[] getParameters() {
        return parameters.clone();
    }

    abstract String resolveClerk();

}

class CountryClerkResolver extends ClerkResolver {

    public CountryClerkResolver() {
        parameters = new Parameter[1];
        parameters[0] = new StringParameter("country", "Denmark"); // Default value is 'Denmark'
    }

    private String country;

    @Override
    String resolveClerk() {
        country = ((StringParameter) parameters[0]).getValue();

        // CountryClerkResolver specific code

        return country;
    }

}

class DefaultClerkResolver extends ClerkResolver { // Role: ConcreteAlgorithm

    public DefaultClerkResolver() {
        parameters = new Parameter[1];
        parameters[0] = new StringParameter("department", "someName");
    }

    private String department;

    @Override
    public String resolveClerk() {
        department = ((StringParameter) parameters[0]).getValue();

        // DefaultClerkResolver specific code

        return department;
    }

}

public abstract class Parameter { // Role: Parameter

    private String name;

    public String getName() {
        return name;
    }

    public Parameter(String name) {
        this.name = name;
    }

}

public class StringParameter extends Parameter { // Role: ConcreteParameter

    private String value;

    public StringParameter(String name, String value) {
        super(name);
        this.value = value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getValue() {
        return value;
    }
}

使用示例：

public class Main {
    public static void main(String... args) {  // Role: client
        ClerkResolver clerk_1 = new CountryClerkResolver();

        Parameter[] parameters = clerk_1.getParameters();

        StringParameter country = (StringParameter) parameters[0];  // [¤]
        country.setValue("USA"); // Overwriting default value

        clerk_1.resolveClerk();
    }
}

如果您想CountryClerkResolver采用例如三个参数（其中一个是整数），您将执行以下操作：

首先介绍一个IntegerParameter.

public class IntegerParameter extends Parameter {

    private int value;

    public IntegerParameter(String name, int value) {
        super(name);
        this.value = value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

现在改变构造函数和策略的方法：

class CountryClerkResolver extends ClerkResolver {

    public CountryClerkResolver() {
        parameters = new Parameter[1];
        parameters[0] = new StringParameter( "country",         "Denmark"   ); // Default value is 'Denmark'
        parameters[1] = new StringParameter( "newStringParam",  "defaultVal");
        parameters[2] = new IntegerParameter("newIntegerParam", 9999        );
    }

    private String country;
    private String newStringParam;
    private int    newIntegerParam;

    @Override
    String resolveClerk() {
        country         = ((StringParameter)  parameters[0]).getValue();
        newStringParam  = ((StringParameter)  parameters[1]).getValue();
        newIntegerParam = ((IntegerParameter) parameters[2]).getValue();

        // CountryClerkResolver specific code

        return country;
    }

}

有关模式的更详细说明，请参阅论文。

好处：

• [灵活] 每当您想添加新的混凝土Algorithm或Parameter.
• 您不必处理算法（策略）的公共方法的签名，因为它不带任何参数；在调用方法之前，参数将被放置。

负债：

• [稳定性] 在获取参数时（请参阅 参考资料[¤]），程序员可能会混淆parameters数组的索引。（例如，如果parameters[0]不是country但是，比如说，continent）

• • 解决稳定性问题的可能解决方案是：

public class Main {
    public static void main(String... args) {  // Role: client
        ClerkResolver clerk_1 = new CountryClerkResolver();

        Parameter[] parameters = clerk_1.getParameters();
                         
                   // Analyzability suffers because of ugly casting: 
        StringParameter country = (StringParameter) getParameterWithName("country", parameters);
        country.setValue("USA"); // Overwriting default value

        clerk_1.resolveClerk();
    }

    private static Parameter getParameterWithName(String paramName, Parameter[] parameters) {
        for (Parameter param : parameters) 
            if (param.getName().equals(paramName))
                return param;
        throw new RuntimeException();  
    }

}

• • • 为了提高可读性，Parameter[]可以引入对 的抽象：

import java.util.ArrayList;
import java.util.List;

public class ParameterList {

    private final List<Parameter> parameters;

    public ParameterList(int length) {
        this.parameters = new ArrayList<>(length);
    }
    
    public void add(Parameter p) {
        parameters.add(p);
    }
    
    private Parameter getParameterOf(String name) {
        return parameters.stream()
                            .filter(p -> p.getName().equals(name))
                            .findFirst()
                            .orElse(null);
    }



    // =================================================== ~~~~~~~~~~~~~~~~~~~~~~~~
    // The liability of ParameterList is that we have to write a lot of boilerplate getter methods.
    // However, because most parameter to any strategy class is a primitive type (or String), we don't
    // have to continiously add new methods; this is thus acceptable.

    // === A getter for each type of {@code Parameter} is needed ~~~~~~~~~~~~~~~~~~~~~~~~
    public StringParameter getStringParameterOf(String name) {
        return (StringParameter) getParameterOf(name);
    }

    public IntegerParameter getIntegerParameterOf(String name) {
        return (IntegerParameter) getParameterOf(name);
    }

    // === A value of each type of {@code Parameter} is needed ~~~~~~~~~~~~~~~~~~~~~~~~
    public String getValueOfStringParameter(String name) {
        return ((StringParameter) getParameterOf(name)).getValue();
    }

    public int getValueOfIntegerParameter(String name) {
        return ((IntegerParameter) getParameterOf(name)).getValue();
    }

    // =================================================== ~~~~~~~~~~~~~~~~~~~~~~~~


    public ParameterList clone() throws CloneNotSupportedException {
        return (ParameterList) super.clone();
    }
    
}

GitHub：所有代码