使Java中的代码更通用

我有一个触发器管理器场景，其中我将触发器（换句话说，订阅触发器）委托给不同的处理程序

现在我有三种处理程序类型，我使用带有enum（这里的enum是处理程序类型）的开关大小写来重定向到正确的处理程序

但是我的代码似乎不可扩展，它不是通用的，而且它不遵循可靠的原则。想象一下如果我需要更多的处理器

我最终会来编辑我的切换案例代码，我会有更多的案例影响代码的圈复杂度

下面是我的代码片段

private static TriggerContext getTriggerContext(TriggerHandlerType triggerHandlerType) throws TriggerHandlerException {
    switch (triggerHandlerType) {
        case DASHBOARD_HANDLER:
            triggerContext = new TriggerContext(new DashboardTriggerHandler());
            return triggerContext;
        case COMPONENT_HANDLER:
            triggerContext = new TriggerContext(new ComponentTriggerHandler());
            return triggerContext;
        case WIDGET_HANDLER:
            triggerContext = new TriggerContext(new WidgetTriggerHandler());
            return triggerContext;
        default:
            LOGGER.error(MIS_CONFIGURED_REQUEST_IS_PROVIDED);
            throw new TriggerHandlerException(TRIGGER_HANDLER_TYPE_GIVEN_IS_NOT_CONFIGURED_IN_THE_LIST_OF_TRIGGER_HANDLERS);

    }

}

---

有人能帮我增强这段代码吗？在这段代码中，我可以使它更通用，避免圈复杂度，并遵循SOLID原则以及一些设计模式

我不确定总体设计结构，但可以使用枚举上的

newHandler（）

方法替换开关

private static TriggerContext getTriggerContext(TriggerHandlerType triggerHandlerType)
    throws TriggerHandlerException
{
    return new TriggerContext(triggerHandlerType.newHandler());
}

在枚举中，您可以将每种类型的方法枚举为

enum TriggerHandlerType {
    DASHBOARD_HANDLER
    {
        Handler newHandler() { return new DashboardHandler(); }
    },
    ...;
    abstract Handler newHandler();
}

我认为您的意思是“使代码更具动态性”，而您的问题来自将对象用作原语

您的枚举对象应该包含要实例化的类型，而不是打开枚举对象：

enum TriggerHandlerType {
    DASHBOARD {
        @Override
        TriggerHandler create() {
            return new DashboardTriggerHandler();
        }
    },
    COMPONENT_HANDLER {
        //...
    };

    abstract TriggerHandler create();
}

getTriggerContext

然后可以调用

create（）

来实例化处理程序：

private static TriggerContext getTriggerContext(TriggerHandlerType triggerHandlerType) throws TriggerHandlerException {
    return new TriggerContext(triggerHandlerType.create());
}

---

您可以为此使用配置图：

// All your triggers classes should implement this interface
interface TriggerHandler {}

// For example:
public static class DashboardTriggerHandler implements TriggerHandler {
}

// Create your configuration
static Map<TriggerHandlerType, Class> contexts;
static {
    contexts = new HashMap<>();
    contexts.put(TriggerHandlerType.DASHBOARD_HANDLER, DashboardTriggerHandler.class);
    contexts.put(TriggerHandlerType.COMPONENT_HANDLER, ComponentTriggerHandler.class);
    contexts.put(TriggerHandlerType.WIDGET_HANDLER, WidgetTriggerHandler.class);
}

// Return your instance through reflection
public static TriggerContext getTriggerContext(TriggerHandlerType triggerHandlerType) throws TriggerHandlerException, IllegalAccessException, InstantiationException {

    Class className = contexts.get(triggerHandlerType);

    if (className == null) {
        throw new TriggerHandlerException();
    }

    return new TriggerContext((TriggerHandler)className.newInstance());
}

//所有触发器类都应该实现此接口
接口触发器处理程序{}
//例如：
公共静态类DashboardTriggerHandler实现TriggerHandler{
}
//创建您的配置
静态地图上下文；
静止的{
contexts=newhashmap（）；
put（TriggerHandlerType.DASHBOARD\u处理程序，DashboardTriggerHandler.class）；
put（TriggerHandlerType.COMPONENT\u处理程序，ComponentTriggerHandler.class）；
put（TriggerHandlerType.WIDGET\u HANDLER，WidgetTriggerHandler.class）；
}
//通过反射返回您的实例
公共静态TriggerContext getTriggerContext（TriggerHandlerType TriggerHandlerType）引发TriggerHandlerException、IllegaAccessException、InstanceionException{
Class className=contexts.get（triggerHandlerType）；
if（className==null）{
抛出新的TriggerHandlerException（）；
}
返回新的TriggerContext（（TriggerHandler）className.newInstance（））；
}

这是一个关于堆栈交换代码的问题，请查看策略模式。您可以在枚举实例上添加一个

createTrigger（）

工厂方法，并像

triggerHandlerType.createTrigger（）

那样调用它。或者更正式的一步：您可以创建一个

TriggerFactory

接口，使用枚举实现，并尽可能使用该类型。这太宽泛了。有很多方法可以使这段代码更具可扩展性。也许你可以看看《四人帮》中的一本好书，比如《设计模式》？我认为你应该为每种需要处理的数据类型配备一个TriggerManager。创建子类来处理每个特定的数据类型。（然后看看蹦床上的图案，找到相反的想法：）谢谢你的回答，它指引了我正确的方向！