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

Question

我有下面的枚举我打电话适当execute方法基础什么类型的枚举（eventType）传递。

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和EventCexecute方法的代码相同且相似，但唯一不同的是我把为"key" (event name)在返回不可变的映射。有什么办法删除重复的代码，但仍然在枚举中实现相同的功能。

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

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 
} 

我知道一种方法是制作一个方法，包含所有常见事物，并通过传递适当的Event类型枚举名来调用这些方法。除此之外，还有其他方法使用枚举特性或其他更改吗？

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

想法是 - 什么类型的事件通过的基础上，我想调用它的执行方法，并尽可能避免重复。

Answer 1

有两个简单的机制（当然可以组合）。

第一个包括在具有​​在基类，委托给在每个子类中定义的特定的代码（即，模板方法模式）：

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

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

    protected abstract void specificCode(); 
} 

第二个由具有在覆盖了​​每个子类，但委托到在基类中定义的常见方法：

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

    public abstract void execute(); 

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

Answer 2

这样的事情？

package enumCodeReuse; 

import java.util.Map; 

import com.google.common.collect.ImmutableMap; 

public enum EventType2 { 

    EventA 
    , EventB 
    , EventC 
    ; 

    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(this.name(), holder) 
       .build(); 
    }; 

    public Map<String, String> parseStringToMap(String eventMapHolder) { 
     // parse eventMapHolder String to Map 
     return null; // FIXME 
    } 

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