Question

基本上我需要灵活的设计来处理。我在想这样的事情：

拥有一个界面DataProcessor，然后拥有不同类型的具体类，如CSVDataProcessor，FTPDataProcessor，CloudDataProcessor。
所有DataProcessor类都将实现process()接口

DataProcessor

我的问题是：

如果每个具体类需要不同的参数来执行process()方法，那么最佳设计应该是什么。例如，FTPDataProcessor需要参数，如文件，主机，端口 - CSVDataProcessor将需要文件位置，架构 - CloudDataProcessor将需要端点服务，用户，密码？？

我的第一个想法是，使用构造函数将特定需求传递给每个具体类，但是如果需要很多参数会怎样？

将来会增加更多DataProcessor具体实现，这就是为什么我希望从一开始就有一个非常灵活的设计来实现它。

Answer 1

工厂设计模式

是你问题的答案。

DataProcessor p = ProcessorsFactory.getProcessor(yourParametersHere);

你应该重载你的工厂 getProcessor（）。最后，您的对象将只知道DataProcessor接口和Factory，而不是实现。这就是其中一项领导技术的工作原理： Spring Bean Factory示例 http://javajadhav.blogspot.bg/2013/07/03-understanding-spring-bean-factory.html 所以你可以创建这样的东西。在ProcessorsFactory中，您可以从应用程序加载一些配置文件，具体取决于写入的属性，以实例化相应的处理器实现。最后，您将只使用interface.process +配置文件。

Answer 2

一种可能的解决方案是：

interface DataProcessorParameters {}

class FtpParams implements DataProcessorParameters {/* connection params come here*/}

interface DataProcessor<T extends DataProcessorParameters> {
    void process(T params);
}

class FtpProcessor implements DataProcessor<FtpParams> {
    void process(FtpParams params) {
       //...do stuff
    }
}

虽然这有效，但您必须首先询问为什么要使用接口，因为调用者必须知道传递正确参数的实际类型。

FtpProcessor proc = new FtpProcessor();
proc.process(new FtpParams()); // this works

DataProcessor proc = ... //let's say this came from somewhere else, and all we know about it is that it's a data processor
proc.process(???); //this doesn't

您还提到在构造函数中传递参数，您可以这样做，但这在语义上是不同的：在这种情况下，处理器实例必须在其整个生命周期中使用相同的参数，基本上它们是＆＃39将是＃34;一次拍摄＆＃34;。如果您使用process()方法传递参数，您的处理器将可以重复使用＆＃34;。

一个人不一定比另一个好，所以根据你的设计更适合你的选择，只要注意差异。

Answer 3

首先，我要感谢所有到目前为止花时间回答我的人。我想出了一个可能的选项，我想分享并征求意见，看看是否可以选择。

如果我有这样的主界面怎么办：

public interface DataProcessor {
    public void process();
}

那么如果我有特定类型的DataProcessors的另一个接口，如下所示：

public interface FTPDataProcessor extends DataProcessor {

    //add all parameters getter and setters but also 'with' methods

    public String getHost();
    public void setHost(String host);
    public FTPDataProcessor withHost(String host);

    public String getUsername();
    public void setUsername(String username);
    public FTPDataProcessor withUsername(String username);

}

然后我可以在Abstract类中初始化所有get'ters，set'ters和with'ters方法，如下所示：

public abstract class AbstractFTPDataProcessor implements FTPDataProcessor {

    private String host;
    private String username;

    public String getHost() {
        return this.host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public FTPDataProcessor withHost(String host) {
        setHost(host);
        return this;
    }

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public FTPDataProcessor withUsername(String username) {
        setUsername(username);
        return this;
    }

}

然后我的具体类只能实现方法process()，如下所示：

public class SimpleFTPDataProcessor extends AbstractFTPDataProcessor {

    @Override
    public void process() {
        //do some stuff
    }

}

最后我可以在我的应用中使用它，如下所示：

public class Application {

    public static void main(String[] args) {

        DataProcessor processor = new SimpleFTPDataProcessor()
                .withHost('host')
                .withUsername('username');

        processor.process();

    }

}

其他人对这种可能的选择有何看法？这是一个很好的做法吗？什么可以成为prons和/或cons？

感谢大家的反馈。

Java最佳设计可以是一个不同的对象，但也可以这样做

3 个答案:

工厂设计模式