Marque code plus générique en Java

Question

J'ai un Gestionnaire de scénarios Trigger où je délégué le déclenche (dans d'autres mots déclencheurs souscrivent) aux différents gestionnaires .

Pour l'instant j'ai trois types gestionnaire, j'utiliser un interrupteur cas avec ENUM (ENUM est ici le type de gestionnaire) pour rediriger pour corriger gestionnaire.

Mais mon code ne semble pas extensible, ce n'est pas générique et il ne suit pas le principe SOLID . Imaginez si je dois avoir plus gestionnaire

Je vais finalement venir et éditer mon code de cas de commutation et je vais avoir plus de cas où il affecte la complexité cyclomatique de mon code

Ci-dessous mon extrait de code exact

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); 

    } 

} 

que quelqu'un peut me aider à améliorer ce code en ce que je peux le rendre plus générique et d'éviter la complexité cyclomatique et suivre SOLID Principe avec un certain modèle de conception .

Answer 1

Je pense que vous voulez dire "code rendre plus dynamique", et votre problème vient d'utiliser des objets comme primitives.

Plutôt que de passer sur l'objet ENUM, vos objets ENUM doivent contenir le type à instancier:

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

    abstract TriggerHandler create(); 
} 

getTriggerContext peut alors appeler create() instancier le gestionnaire:

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

Answer 2

Je ne suis pas sûr de la structure de conception globale, mais le commutateur peut être remplacé par une méthode newHandler() sur l'énumération.

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

Dans le ENUM vous would implement la méthode pour chaque type ENUM

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

Answer 3

Vous pouvez utiliser une carte des configurations pour cela:

// 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()); 
}