枚举加策略模式，消除分支判断 if....else..

定义枚举类

```
package com.easygeneratorcode.model;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;


public enum EventTypeEnum {
    CREATED("游戏创建", "game.created", new Class[]{MeetingUpdateEventService.class}),
    UPDATED("游戏更新", "game.updated", new Class[]{MeetingUpdateEventService.class}),
    CANCELED("游戏取消", "game.canceled", new Class[]{MeetingStatusChangeEventService.class}),
    STARTED("游戏开始", "game.started", new Class[]{MeetingStatusChangeEventService.class});

    private String name;
    private String type;
    private Class<? extends AbstractTencentWebhookEvent>[] executionClass;

    EventTypeEnum(String name, String type, Class<? extends AbstractTencentWebhookEvent>[] executionClass) {
        this.name = name;
        this.type = type;
        this.executionClass = executionClass;
    }

    public static Map<String, EventTypeEnum> getEventMap() {
        Map<String, EventTypeEnum> eventTypeEnumMap = new HashMap<>();
        Arrays.asList(EventTypeEnum.values()).forEach(item -> eventTypeEnumMap.put(item.getType(), item));
        return eventTypeEnumMap;
    }

    public String getName() {
        return name;
    }

    public String getType() {
        return type;
    }

    public Class<? extends AbstractTencentWebhookEvent>[] getExecutionClass() {
        return executionClass;
    }
}
```
```
### 定义接口
```
public interface  AbstractTencentWebhookEvent {
    /**
     * 执行方法
     *
     * @param testEvent
     */
    void invoke(String content);
}
```
### 编写分配具体实现代码
```
import cn.comein.common.util.SpringContextUtils;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
@Service
public class TencentEventService {

    public void eventSubscriptionExecution(String event,String content) {
        try {
            Map<String, EventTypeEnum> eventTypeEnumMap = EventTypeEnum.getEventMap();
            if (Objects.isNull(event) || !eventTypeEnumMap.containsKey(event)) {
                return;
            }
            //判断是否编写了对应实现类
            EventTypeEnum eventTypeEnum = eventTypeEnumMap.get(event);
            if (eventTypeEnum == null || eventTypeEnum.getExecutionClass() == null) {
                return;
            }
            //根据枚举后面设置的实现类，调转到对应的实现
            Arrays.stream(eventTypeEnum.getExecutionClass()).forEach(executionClass -> {
                AbstractTencentWebhookEvent abstractTencentWebhookEvent = SpringContextUtils.getBean(executionClass);
                abstractTencentWebhookEvent.invoke(content);
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
```
### 编写实现类
```
public class CreateEventService implements AbstractTencentWebhookEvent {
    @Override
    public void invoke(String content) {
        System.out.println("游戏创建");
    }
}


public class UpdateEventService implements AbstractTencentWebhookEvent {
    @Override
    public void invoke(String content) {
        System.out.println("游戏更新");
    }
}

public class CanceledEventService implements AbstractTencentWebhookEvent {
    @Override
    public void invoke(String content) {
        System.out.println("游戏取消");
    }
}
```
后面要是新增了场景，只需要维护枚举中的配置即可