在我的工作中，我们进行了调查，一项调查涉及多个步骤。我从事自动化工作，因此我围绕为这些调查创建的页面对象设计测试。我们将此特定调查称为“流程”调查，因为它有多个步骤。因此，您可以跳过第 1 步(调查 A)，然后完成或跳过第 2 步(调查 B)，然后完成或跳过第 3 步(调查 C)。天真地，我们可以编写一个只包含如下方法的测试:

public void completeSurveyA() {
    //...
}
public void skipSurveyB() {
    //...
}
public void completeSurveyB() {
    //...
}
public void skipSurveyC() { 
    //...
}
public void completeSurveyC() {
    //...
}

你会像这样使用它

completeSurveyA();
skipSurveyB();
completeSurveyC();

但是，这可能是个问题，因为我们可能会在调用 completeSurveyA() 之前调用 completeSurveyB()，调用 completeSurveyA 两次，等等. 并且测试会中断。为避免这种情况，我引入了一种不同的方法，即调用 surveyA 上的方法将返回一个 surveyB 对象，该对象将返回一个 surveyC 对象。

public class SurveyFlow() {
    public SurveyB completeSurveyA() {
        //...
        return new SurveyB();
    }
    private class SurveyB() {
        public SurveyC skipSurveyB() {
            //...
            return new SurveyC();
        }
        public SurveyC completeSurveyB() {
            //...
            return new SurveyC();
        }
        private class SurveyC() {
            public void skipSurveyC() {
                //...
            }
            public void completeSurveyC() {
                //...
            }
        }
    }
}

你会像这样使用它

new SurveyFlow().completeSurveyA().skipSurveryB().completeSurveyC();

该模式让我想起了状态机，因为在不同的状态下您只能使用特定的方法，但我想知道该模式是否有更具体的名称。

最佳答案

根据您示例的类，它是一个 FluentInterface :

Probably the most important thing to notice about this style is that the intent is to do something along the lines of an internal DomainSpecificLanguage. (...) The API is primarily designed to be readable and to flow.

这不是构建器模式，因为您没有构建任何东西(即您没有最终的 build() 方法，其中在前面的步骤中收集的数据用于创建实例)。

这也不是状态模式，因为操作(在本例中为 skip() 和 complete())不依赖于对象的状态(实际上步骤没有状态)。

如果整个调查被建模为一个对象，其实现取决于不同的状态(在这种情况下，状态将是步骤加上操作)，

它会是状态模式采取，即 surveyACompleted 、 surveyASkipped 、 surveyBCompleted 、 surveyBSkipped 等，而方法类似于 nextStep() ):

public class SurveyFlow {

    private SurveyState state; // this represents the current step

    public SurveyFlow(boolean skipFirst) {
        this.state = skipFirst ? new SurveyASkipped() : new SurveyACompleted();
    }

    void setState(SurveyState state) {
        this.state = state;
    }

    public void takeStep(boolean skipNext) { // takeStep operation delegated 
                                             // to the state (current step)
        this.state.takeStep(skipNext, this); // "this" passed to the step so 
                                             // that it can switch to the 
                                             // next step if needed
    }
}

状态将由 SurveyFlow 的每一步多态表示:

abstract class SurveyState {

    protected abstract void takeStep(boolean skipNext, SurveyFlow survey);
}

调查 A 状态如下:

class SurveyACompleted extends SurveyState {

    protected void takeStep(boolean skipNext, SurveyFlow survey) {
        // ...

        survey.setState(skipNext ? new SurveyBSkipped() : new SurveyBCompleted());
    }
}

class SurveyASkipped extends SurveyState {

    protected void takeStep(boolean skipNext, SurveyFlow survey) {
        // ...

        survey.setState(skipNext ? new SurveyBSkipped() : new SurveyBCompleted());
    }
}

调查 B 状态如下:

class SurveyBCompleted extends SurveyState {

    protected void takeStep(boolean skipNext, SurveyFlow survey) {
        // ...

        survey.setState(skipNext ? new SurveyCSkipped() : new SurveyCCompleted());
    }
}

class SurveyBSkipped extends SurveyState {

    protected void takeStep(boolean skipNext, SurveyFlow survey) {
        // ...

        survey.setState(skipNext ? new SurveyCSkipped() : new SurveyCCompleted());
    }
}

以你的例子为例:

1. 完成调查 A
2. 跳过调查 B
3. 完成调查 C

你可以这样做:

SurveyFlow survey = new SurveyFlow(false); // will complete survey A
survey.takeStep(true);                     // completed survey A and will skip survey B
survey.takeStep(false);                    // skipped survey A and will complete survey C
survey.takeStep(true);                     // completed survey C

如果调查 C 是最后一步，那么它可以忽略 boolean争论，不应设置进一步的步骤。

关于java - 这种基于 Java 状态的设计模式的名称是什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31733262/