Texte intégral 3564 Mots, durée estimée de l'étude 11 Procès-verbaux
Qui est meilleur que le constructeur ou le modèle d'observateur? Ça dépend de la situation.
Qui appartient à qui?
Habituellement, nous utilisons le paramètre constructeur pour connecter deux composants. Par exemple, ce processus peut être vu très clairement lors de la construction de surfaces graphiques. Par exemple, le code source suivant:
public classSubView {
privé MainView mainView;
SubView publique (MainView mainView) {
this.mainView = mainView;
}
public void buttonClicked (entrée de chaîne) {
mainView.setInputValue (entrée);
}
}
Ce sous-composant obtient le composant principal environnant via un constructeur. L'instance de ce composant n'est nécessaire que pour la transmission de valeurs. Cette valeur est le résultat de l'interaction de l'utilisateur au sein des sous-composants et de la consommation interne des éléments environnants.
Ce processus sera confronté à divers défis, mais ces défis peuvent être évités. Premièrement, ce sous-composant est lié de façon rigide au composant principal. Mais ce type de couplage dur n'a aucun sens, car cette combinaison est purement basée sur l'utilisation des valeurs générées.
De plus, le test des sous-composants est plus difficile, car l'instance de composant principal ou le MOCK correspondant doit être utilisé. Encore une fois, il s'agit d'une exigence supplémentaire qui ajoute de la complexité et empêche l'extraction de composants individuels. Alors, comment l'ajouter au projet en ce moment sans compter sur d'autres frameworks?
Source: pexels
Méthode classique: mode Observateur (Observateur)
Il existe un modèle de conception simple qui peut vous aider. C'est le mode observateur.
public classObservable < VALEUR CLÉ > {
Carte finale privée < CLÉ, Consommateur < VALEUR > > listeners = new ConcurrentHashMap < > ();
registre des vides public (clé KEY, Consumer < VALEUR > auditeur) {
listeners.put (clé, écouteur);
}
public void unregister (clé KEY) {
listeners.remove (clé);
}
public void sentEvent (VALUE événement) {
listeners.values ()
.forEach (auditeur- > listener.accept (événement));
}
}
Le principe de base comprend trois processus interactifs. Dans une carte, les informations (consommateur) sont stockées pour une clé donnée. Le consommateur est l'unité d'utilisation de l'événement ou le type d'entrée défini par la deuxième définition de type de la carte. Vous pouvez utiliser la clé pour vous inscrire et, si nécessaire, vous pouvez à nouveau supprimer le consommateur associé de cette carte.
Les paquets de données en attente seront envoyés à tous les consommateurs enregistrés (consommateurs) à ce moment en utilisant les événements post. En fait, tous les consommateurs existants dans la carte traiteront les valeurs dans un ordre non défini. L'événement envoyé doit lui-même être immuable.
S'inscrire
Pour simplifier le processus d'inscription et de désinscription, le modèle de conception de l'observateur peut être légèrement modifié.
interfaceRegistration publique {
void remove ();
}
public classRegistry < VALEUR CLÉ > {
Carte finale privée < CLÉ, Consommateur < VALEUR > > listeners = new ConcurrentHashMap < > ();
statique publique < K, V > Enregistrement < K, V > exemple () {
retourner un nouveau registre < > ();
}
registre d'enregistrement public (clé KEY, Consumer < VALEUR > auditeur) {
listeners.put (clé, écouteur);
revenir ()- > listeners.remove (clé);
}
public void sentEvent (VALUE événement) {
listeners.values ()
.forEach (auditeur- > listener.accept (événement));
}
}
À cette fin, une interface de fonction nommée Registration est définie, qui ne peut être supprimée que du registre. Il en va de même pour le processus de déconnexion correspondant. L'inscription est la valeur de retour du processus d'inscription lui-même.
Le traitement des données d'événement est le même que celui d'Observable. L'utilisation réelle des tests JUnit5 est la suivante:
Registre final < String, Event > eventBus = Registry.instance ();
finalString attendu = "message 001";
compteur AtomicInteger final = nouveau AtomicInteger (0);
finalString key01 = "Consumer-01";
finalString key02 = "Consumer-02";
Registre d'enregistrement final01 = eventBus.register (key01, (event) - > {
assertEquals (attendu, event.getMessage ());
counter.incrementAndGet ();
});
Registre d'enregistrement final02 = eventBus.register (key02, (event) - > {
assertEquals (attendu, event.getMessage ());
counter.incrementAndGet ();
});
eventBus.sentEvent (nouvel événement (attendu, ""));
Assertions.assertEquals (2, counter.get ());
register01.remove ();
eventBus.sentEvent (nouvel événement (attendu, ""));
Assertions.assertEquals (3, counter.get ());
Couplage de composants
Commençons par les sous-composants. Le composant ne sera plus lié à l'assemblage principal. Cet exemple utilise le bus d'événements statique régulier de la classe Registry. Bien sûr, vous pouvez également utiliser le bus d'événements pour chaque composant, ce qui séparera davantage les composants.
public classSubView {
public void buttonClicked (entrée de chaîne) {
EVENT_BUS.sentEvent (nouvel événement (entrée));
}
registre d'enregistrement public (clé de chaîne, consommateur < un événement > auditeur) {
return EVENT_BUS.register (clé, écouteur);
}
}
Si un autre composant doit utiliser la valeur de l'interaction utilisateur virtuel, il peut être enregistré dans l'instance du sous-composant.
classe statique publique MainView {
// pour démo publique
public SubView subView = new SubView ();
enregistrement d'enregistrement privé = subView.register ("keyXYZ",
e- > inputValue = e.getValue ());
private String inputValue;
public String getInputValue () {
return inputValue;
}
annulation publique () {
registration.remove ();
}
}
Le test JUnit5 correspondant est illustré ci-dessous.
final MainView mainView = new MainView ();
finalString inputValue = "inputValue";
// subview est public pour la démo
mainView.subView.buttonClicked (inputValue);
Assertions.assertEquals (inputValue, mainView.getInputValue ());
Source: pexels
Résumé
Avec quelques lignes de code source, non seulement le couplage des composants est meilleur, mais également le test des différents composants est simplifié, de sorte que la maquette n'est plus nécessaire. L'abstraction ajoutée permet d'enregistrer plus d'un composant sur les sous-composants présentés ici. Bien sûr, vous ne devez pas oublier de vous déconnecter du registre à ce stade pour que le garbage collector fonctionne correctement.
Je vous souhaite à tous un bon codage!
laissez un commentaire
Partageons ensemble les produits de base de l'apprentissage et du développement de l'IA
Si réimprimé, veuillez laisser un message en arrière-plan et suivre les spécifications de réimpression
