java - 避免 Java 接口(interface)中的样板文件

Question

我正在尝试使用存储过程构建一个键值存储，并且我发现枚举在定义事物时非常有用。我希望数据库成为表的枚举，并且表与操作的枚举和区域的枚举相关联。问题是枚举不能扩展抽象类，所以我必须使用接口(interface)。因此，我有很多枚举，每个枚举都必须实现相同的代码(定义相同的字段，编写相同的构造函数来填充这些字段，并覆盖使用这些字段的 getter 和方法)。这是此类枚举的示例:

interface Operation<VAL, PARAM>
{
    int code();
    Serdes<PARAM> pSerdes();
    VAL apply(VAL val, byte[] pbytes);
}

...

// Job, Param, & Ticket are protobuf classes
public enum JobOp implements Operation<Job, Param>
{
    AddTicket(0, (job, param) -> ...),
    RemoveTicket(1, (job, param) -> ...),
    CompleteTicket(2, (job, param) -> ...);

    private final int code;
    private final Serdes<Param> pSerdes = new ProtoSerdes<>(Param.PARSER);
    private final BiFunction<Job, Param, Job> proc;
    JobOp(int code, BiFunction<Job, Param, Job> proc)
    {
        this.code = code
        this.proc = proc
    }

    @Override
    public int code() { return code; }
    @Override
    public Serdes<Param> pSerdes() { return pSerdes; }
    @Override
    public Job apply(Job val, byte[] pbytes)
    {
        final Param param = pSerdes.fromBytes(pbytes);
        return proc.apply(val, param);
    }
}

我想避免所有重复的样板文件并尽可能尊重 DRY，因此我开始使用内部类来表示字段:

interface Operation<VAL, PARAM>
{
    default int code() { return imp().code; }
    default Serdes<PARAM> pSerdes() { return imp().pSerdes; }
    default VAL apply(VAL val, byte[] pbytes) { return imp().apply(val, pbytes); }
    // Reduce the number of fields and getters to implement to one: imp
    Imp<VAL, PARAM> imp();

    class Imp<VAL, PARAM>
    {
        public final int code;
        public final Serdes<PARAM> pSerdes;
        private final BiFunction<V, P, V> proc;

        Imp(int code, Serdes<PARAM> pSerdes, BiFunction<V, P, V> proc)
        {
            this.code = code;
            this.pSerdes = pSerdes;
            this.proc = proc;
        }

        VAL apply(VAL val, byte[] pbytes)
        {
            PARAM param = pSerdes.fromBytes(pbytes);
            return proc.apply(val, param);
        }
    }
}

...

// Job, Param, & Ticket are protobuf classes
public enum JobOp implements Operation<Job, Param>
{
    AddTicket(0, (job, param) -> ...),
    RemoveTicket(1, (job, param) -> ...),
    CompleteTicket(2, (job, param) -> ...);

    private final Serdes<Param> pSerdes = new ProtoSerdes<(Param.PARSER);
    private final Operation.Imp<Job, Param> imp;
    JobOp(int code, BiFunction<Job, Param, Job> proc)
    {
        imp = new Imp(code, pSerdes, proc);
    }

    @Override
    public Imp<Job, Param> imp() { return imp; }
}

这有助于减少样板文件，但我对 Java 相当陌生，担心这可能是一种反模式。它还公开了一个我不想成为接口(interface)一部分的变量，并添加了可能会损害性能的额外级别的函数调用。我想到的保持公共(public)接口(interface)干净的一种解决方案是将字段对象保留在静态 WeakHashMap 中，并在接口(interface)实例上进行键控:

interface Operation<VAL, PARAM>
{
    default int code() { return imp(this).code; }
    default Serdes<PARAM> pSerdes() { return imp(this).pSerdes; }
    default VAL apply(VAL val, byte[] pbytes) { return imp(this).apply(val, pbytes); }
    final Map<Operation, Imp> imps = new WeakHashMap<>();
    @SuppressWarnings("unchecked")
    static <V, P> Imp<V, P> imp(Operation<V, P> op) { return imps.get(op); }
    static <V, P> void bind(Operation<V, P> op, Imp<V, P> imp) { imps.put(op, imp); }

    class Imp<VAL, PARAM>
    {
        public final int code;
        public final Serdes<PARAM> pSerdes;
        private final BiFunction<V, P, V> proc;

        Imp(int code, Serdes<PARAM> pSerdes, BiFunction<V, P, V> proc)
        {
            this.code = code;
            this.pSerdes = pSerdes;
            this.proc = proc;
        }

        VAL apply(VAL val, byte[] pbytes)
        {
            PARAM param = pSerdes.fromBytes(pbytes);
            return proc.apply(val, param);
        }
    }
}

...

// Job, Param, & Ticket are protobuf classes
public enum JobOp implements Operation<Job, Param>
{
    AddTicket(0, (job, param) -> ...),
    RemoveTicket(1, (job, param) -> ...),
    CompleteTicket(2, (job, param) -> ...);

    private final Serdes<Param> pSerdes = new ProtoSerdes<(Param.PARSER);
    JobOp(int code, BiFunction<Job, Param, Job> proc)
    {
        Operation.bind(this, new Imp(code, pSerdes, proc));
    }
}

这个想法受到Python特性的启发，但它有一些问题:

1)它并没有完全摆脱公共(public)接口(interface)的污染，只是稍微混淆了一点。

2)它可能会带来更大的性能损失。

3) 它隐式要求实现者在构造函数中绑定(bind) Fields 对象。

有更好的方法吗？上述两个解决方案是否比我指出的问题更严重(性能影响和不干净的代码)？我试图遵守德墨忒尔定律，但这感觉可能会在以后引起一些耦合问题。

编辑:在适当的地方添加“最终”

编辑 2:添加了对开头段落的说明并稍微清理了示例

Answer 1

为此使用父类有什么问题吗？代替接口(interface)操作，有:

public abstract class Operation<VAL, PARAM> {
    private int code;

    public int getCode() { return code; }
    public abstract void example();
}

...然后从那里获取它。

与接口(interface)不同，类可以拥有状态。在上面的示例中，getCode 将使用指定的实现，但如果您愿意，您可以覆盖它(您可以添加 final 作为关键字来停止它)，并且方法 example 必须由子类实现。它类似于接口(interface)中的普通 void example();(在接口(interface)中，默认情况下所有方法声明都是公共(public)和抽象的，在类中您必须添加这些关键字)。

如果它不能是父类(super class)，这不是一个好主意；一般概念是接口(interface)确实不应该有状态。如果您坚持拥有有状态接口(interface)，那么您或多或少会犯下肮脏的黑客行为。