Question

我试图定义一个通用的抽象类来处理实现类的处理/重试逻辑。我希望所有实现的类都传递由抽象类执行的“过程”和“失败”功能。抽象类还包含重试尝试逻辑和其他一些我想重用的通用样板代码。

具体来说，我有以下抽象类：

public abstract class EnvelopeDispatcher<T> {

    protected Consumer<T> processFn;
    protected Consumer<T> failFn;

    private MetricsRegistry metricsRegistry;


    public EnvelopeDispatcher(MetricsRegistry metricsRegistry, Consumer<T> processFn, Consumer<T> failFn) {
        this.metricsRegistry = metricsRegistry;
        this.processFn = processFn;
        this.failFn = failFn;
    }

    protected void process(T envelope) { 
        //abstract processing logic calling processFn and failFn
    }
}

以及以下实现类：

public class ActionEnvelopeDispatcher extends EnvelopeDispatcher<ActionEnvelope> implements Consumer<ActionEnvelope> {
        public ActionEnvelopeDispatcher(MetricsRegistry metricsRegistry ) {
                super(metricsRegistry, this::processEnvelope, this::failEnvelope)
        }

        @Override
        public void accept(@NonNull ActionEnvelope envelopeToProcess) {
            super.process(envelopeToProcess);
        }

        private void processEnvelope( ... ) {
            //processing logic
        }

        private void failEnvelope( ... ) {
            //failure case logic
        }   
    }

当我尝试在引用this :: processEnvelope和this :: failEnvelope的同时调用super时，我得到“无法在调用超类型构造函数之前引用它”。

我知道为什么会这样，但是我不确定其他选择。有谁知道如何解决这个问题或更好的实施模式？

Answer 1

您可以做的是不要使调度程序抽象化，而不要使用工厂方法来创建它。

类似这样的东西：

class EnvelopeDispatchers {

    // factory method
    public static EnvelopeDispatcher<ActionEnvelope> actionEnvelopeDispatcher(MetricsRegistry metricsRegistry) {
        return new EnvelopeDispatcher(metricsRegistry,
                                      EnvelopeDispatchers::processEnvelope,
                                      EnvelopeDispatchers::failEnvelope);
    }

    private static void processEnvelope(ActionEnvelope env) {
        //processing logic
    }

    private static void failEnvelope(ActionEnvelope env) {
        //failure case logic
    }   
}

在超类型构造函数被调用之前，不能引用此函数

1 个答案: