java - 如何在多个枚举名称中重用代码？

Question

我有下面的枚举，我根据传递的枚举类型(eventType)调用适当的execute方法。

public enum EventType {

  EventA {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      String itemId = holder.get("m_itemId");
      Map<String, String> clientInfoHolder = getClientInfo(itemId);
      holder.putAll(clientInfoHolder);
      return ImmutableMap.<String, Map<String, String>>builder().put(EventA.name(), holder)
          .build();
    }
  },
  EventB {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      return ImmutableMap.<String, Map<String, String>>builder().put(EventB.name(), holder)
          .build();
    }
  },
  EventC {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
      final Map<String, String> holder = parseStringToMap(eventMapHolder);
      if (holder.isEmpty() || Strings.isNullOrEmpty(holder.get("m_itemId"))) {
        return ImmutableMap.of();
      }
      String itemId = holder.get("m_itemId");
      Map<String, String> clientInfoHolder = getClientInfo(itemId);
      holder.putAll(clientInfoHolder);
      return ImmutableMap.<String, Map<String, String>>builder().put(EventC.name(), holder)
          .build();
    }
  };

  public abstract Map<String, Map<String, String>> execute(String eventMapHolder);

  public Map<String, String> parseStringToMap(String eventMapHolder) {
    // parse eventMapHolder String to Map
  }

  public Map<String, String> getClientInfo(final String clientId) {
    // code to populate the map and return it
  }
}

例如:如果我得到 "EventA"，那么我将调用它的 execute 方法。同样，如果我得到“EventB”，那么我将调用它的“execute”方法，依此类推。

String eventType = String.valueOf(payload.get("eventType"));
String eventMapHolder = String.valueOf(payload.get("eventMapHolder"));
Map<String, Map<String, String>> processedMap = EventType.valueOf(eventType).execute(eventMapHolder);

一般来说，我会在同一个枚举类中拥有更多的事件类型(大约 10-12 个)，并且大多数情况下它们会执行与 EventA、EventB 和 EventC 相同的操作。

问题:

现在如您所见，EventA 和 EventC 的 execute 方法中的代码完全相同，但唯一的区别是我输入的内容返回的不可变映射中的“key”(事件名称)。有什么方法可以删除重复的代码，但仍然在枚举中实现相同的功能。

例如，这片土地上的东西。通过并排编写多个枚举并用逗号分隔(如果执行方法功能相同)。我知道这不起作用，因为我有一个抽象方法，我需要在任何地方实现它，但是通过进行一些更改或任何其他更好的方法仍然可以实现吗？

public enum EventType {

  EventA,
  EventC {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
        // same code which is there in execute method for EventA and EventC
    }
  },
  EventB {
    @Override
    public Map<String, Map<String, String>> execute(String eventMapHolder) {
        // same code which is there in execute method of EventB
    }
  };

  // other methods which are there already
}

我知道一种方法是使用所有常见的东西创建一个方法，并通过传递适当的事件类型枚举名称来调用这些方法。除了使用枚举功能或任何其他更改之外，还有其他方法吗？

如果有任何其他更好的方法或任何其他设计模式来做到这一点，那么我也愿意寻求建议，这可以帮助我删除重复的代码。

想法是 - 根据传递的事件类型，我想调用其执行方法并尽可能避免重复。

Answer 1

有两种简单的机制(当然可以组合)。

第一个包括在基类中使用 execute()，委托(delegate)给每个子类中定义的特定代码(即模板方法模式):

enum Foo {
    A {
        @Override
        protected void specificCode() {
            //...
        }
    },
    B {
        @Override
        public void specificCode() {
            //...
        }
    };

    public void execute() {
        // ... common code
        specificCode();
        // ... common code
    }

    protected abstract void specificCode();
}

第二个方法是在每个子类中重写 execute() 但委托(delegate)给基类中定义的通用方法:

enum Foo {
    A {
        @Override
        public void execute() {
            //...
            commonCode();
            // ...
        }
    },
    B {
        @Override
        public void execute() {
            //...
            commonCode();
            // ...
        }
    };

    public abstract void execute();

    protected void commonCode() {
        // ...
    }
}