Les meilleures pratiques de gestion de l'entrée des composants en Java

Question

Considérez ceci 3 exemples d'entrée de manipulation:

/*EXAMPLE A*/ 
public class HandlingInputExampleA 
{ 
    private Label labelFromOtherClass; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 1; 

    private void init() 
    { 
     Button button = new Button(); 
     button.addClickListener(event -> labelFromOtherClass.setCaption(myText + myInt)); 
    } 
} 

public class HandlingInputExampleB 
{ 
    private ClickListener inputHandler; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 2; 

    private void init() 
    { 
     Button button = new Button(); 
     button.addClickListener(inputHandler); 
    } 
} 

/*EXAMPLE B*/ 
public class HandlingInputExampleB 
{ 
    private ClickListener inputHandler; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 2; 

    private void init() 
    { 
     Button button = new Button(); 
     button.addClickListener(inputHandler); 
    } 
} 

public class InputHandlerB implements ClickListener 
{ 
    private HandlingInputExampleB exampleB; //injected by setter 
    private Label label; //injected by setter/constructor 

    @Override 
    public void buttonClick(ClickEvent event) 
    { 
     Button button = event.getButton(); 
     if(button == exampleB.getButton()) 
     { 
      label.setCaption(exampleB.getMyText() + exampleB.getMyInt()); 
     } 
    } 
} 

/*EXAMPLE C*/ 
public class HandlingInputExampleC 
{ 
    private ClickListener inputHandler; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 2; 

    private void init() 
    { 
     Button button = new Button(); 
     button.setData(this); 
     button.addClickListener(inputHandler); 
    } 
} 

public class InputHandlerC implements ClickListener 
{ 
    private Label label; //injected by setter/constructor 

    @Override 
    public void buttonClick(ClickEvent event) 
    { 
     Button button = event.getButton(); 
     if(button.getData() instanceof HandlingInputExampleC) 
     { 
      HandlingInputExampleC exampleC = (HandlingInputExampleC)button.getData(); 
      label.setCaption(exampleC.getMyText() + exampleC.getMyInt()); 
     } 
    } 
} 

Je suppose que je devrais garder une façon de la gestion des entrées dans mon projet. La plupart du temps, je crée une classe pour gérer les entrées et j'y injecte tous les objets nécessaires pour que chaque action associée aux entrées utilisateur soit gérée en un seul endroit. Bien sûr, plus mon projet est grand, plus la classe de gestionnaire d'entrée est grande et commence à avoir l'air un peu brouillon. Peut-être qu'il me manque une meilleure solution? Veuillez me dire lequel de ces exemples dois-je éviter?

Answer 1

Cela dépend de la taille du projet et combien de gestionnaires semblables/différents dont vous aurez besoin. Pour certaines situations très simples, je pencherais pour l'option A, mais si vous avez quelques gestionnaires similaires, il est préférable d'extraire une nouvelle classe.

Par exemple, si le texte « exampleC.getMyText() + exampleC.getMyInt() » ne change pas pendant l'exécution je préfère:

public class HandlingInputExample { 
    private ClickListener inputHandler; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 2; 

    private void init() { 
     Button button = new Button(); 
     button.setData(this); 
     button.addClickListener(new SetCaptionClickListener(example.getMyText() + example.getMyInt())); 
    } 
} 

public class SetCaptionClickListener implements ClickListener { 
    private Label label; //injected by setter/constructor 
    private String caption; 

    public SetCaptionClickListener(String caption) { 
     this.caption = caption; 
    } 

    @Override 
    public void buttonClick(ClickEvent event) { 
      label.setCaption(caption); 
    } 
} 

Mais si les données peuvent changer, vous pouvez ajouter une autre couche qui ont la responsabilité de récupérer les informations nécessaires par le gestionnaire, quelque chose comme:

public class HandlingInputExample { 
    private ClickListener inputHandler; //injected by setter/constructor 
    private String myText = "hello "; 
    private int myInt = 2; 

    private void init() { 
     Button button = new Button(); 
     button.setData(this); 
     button.addClickListener(new SetCaptionClickListener(new Context(this))); 
    } 
} 

public class SetCaptionClickListener implements ClickListener { 
    private Label label; //injected by setter/constructor 
    private Context context; 

    public SetCaptionClickListener(Context context) { 
     this.context = context; 
    } 

    @Override 
    public void buttonClick(ClickEvent event) { 
     label.setCaption(context.getCaption()); 
    } 
} 

public class Context { 
    HandlingInputExample handlingInputExample; 

    public Context(handlingInputExample handlingInputExample) { 
     this.handlingInputExample = handlingInputExample; 
    } 

    public String getCaption() { 
     return handlingInputExample.getMyText() + handlingInputExample.getMyInt(); 
    } 
}