Question

我正在尝试使用存储过程来构建键值存储，并且我发现枚举可方便地定义事物。我希望数据库成为表的枚举，并且表与操作的枚举和区域的枚举关联。问题是枚举不能扩展抽象类，因此我必须使用接口。因此，我有很多枚举，每个枚举都必须实现相同的代码（定义相同的字段，编写相同的构造函数以填充这些字段，并覆盖使用这些字段的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还是很陌生，并担心这可能是反模式。它还公开了一个我不想成为接口一部分的变量，并增加了可能会影响性能的额外级别的函数调用。我想到的一种用于保持公共接口整洁的解决方案是，将字段对象保持在静态的WeakHashMap中，该静态WeakHashMap在接口实例上的键之间：

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）它并没有完全消除公共接口的污染，只是对其进行了模糊处理。

2）它可能会导致更大的性能损失。

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

是否有更好的方法？以上两种解决方案是否比我已经指出的问题（性能问题和不干净的代码）更严重？我正在尝试遵守Demeter定律，但这似乎可能会在以后引起一些耦合问题。

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

编辑2：对开头的段落进行了澄清，并对示例进行了一些清理

Answer 1

为此使用父类有什么问题？除了接口Operation之外，还有：

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

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

...然后从那里拿走。

与接口不同，类可以具有状态。在上面的示例中，getCode将使用所述的实现，但是可以根据需要覆盖它（可以添加final作为关键字来停止该实现），以及方法example 必须由子类实现。它类似于接口中的普通void example();（在接口中，默认情况下，所有方法声明都是公共的和抽象的，在类中必须添加这些关键字）。

如果不能成为超类，这不是一个好主意；一般的观念是接口实际上不应该具有状态。如果您坚持要使用有状态的接口，那么您或多或少会致力于肮脏的黑客攻击。

Answer 2

您是否正在设计一个无所不知且能够执行任何内容的上帝课程？
The visitor pattern可以将任务分为多个部分，然后将它们组合起来执行。

避免使用Java接口中的样板

2 个答案: