Pourquoi devrais-je utiliser la commande de conception de modèle, je peux facilement appeler des méthodes requises?
J'étudie la commande de modèle de conception, et je suis tout à fait confondue avec la manière de l'employer. L'exemple que j'ai est liée à une télécommande classe qui est utilisée pour allumer et éteindre les lumières.
Pourquoi devrais-je pas utiliser le switchOn() /terminé() les méthodes de Lumière classe, plutôt que d'avoir plusieurs classes et de méthodes qui appellent finalement switchOn /terminé méthodes?
Je sais que mon exemple est assez simple, mais c'est le point. Je ne pouvais pas trouver tout problème complexe n'importe où sur l'Internet pour voir exactement l'utilisation de la commande à modèle de conception.
Si vous êtes conscient de la complexité du monde réel problème que vous avez résolu qui peut être résolu à l'aide de ce modèle merci de partager cela avec moi. Il m'aide et les futurs lecteurs de ce post pour mieux comprendre l'utilisation de ce modèle de conception. Grâce
//Command
public interface Command {
public void execute();
}
//Concrete Command
public class LightOnCommand implements Command {
//Reference to the light
Light light;
public LightOnCommand(Light light) {
this.light = light;
}
public void execute() {
light.switchOn(); //Explicit call of selected class's method
}
}
//Concrete Command
public class LightOffCommand implements Command {
//Reference to the light
Light light;
public LightOffCommand(Light light) {
this.light = light;
}
public void execute() {
light.switchOff();
}
}
//Receiver
public class Light {
private boolean on;
public void switchOn() {
on = true;
}
public void switchOff() {
on = false;
}
}
//Invoker
public class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
}
//Client
public class Client {
public static void main(String[] args) {
RemoteControl control = new RemoteControl();
Light light = new Light();
Command lightsOn = new LightsOnCommand(light);
Command lightsOff = new LightsOffCommand(light);
//Switch on
control.setCommand(lightsOn);
control.pressButton();
//Switch off
control.setCommand(lightsOff);
control.pressButton();
}
}
Pourquoi ne devrais-je pas facilement utiliser le code suivant?
Light light = new Light();
switch(light.command) {
case 1:
light.switchOn();
break;
case 2:
light.switchOff();
break;
}
- À l'aide de la
Command
interface, il est plus facile de brancher vos commandes pour de nouveaux Boutons, des Menus, des Raccourcis. - pourriez-vous svp me donner un exemple. À la fin, j'ai besoin d'appeler explicitement la méthode de la classe sélectionnée ainsi quel est la différence?
- Vous êtes à la recherche à partir d'un point de vue très simple problème. Pour des problèmes simples, des solutions simples et toujours gagner. C'est comme lorsque vous apprenez au sujet de la programmation orientée objet pour la première fois. Au début, je parie que vous étiez comme des "mais pourquoi je ne peux pas il suffit d'écrire tout mon code dans une classe?" (au moins, j'étais).
- vous avez raison, ma question est comment serait-il être utilisé pour des problèmes complexes. J'ai besoin d'un exemple pour clarifier sur ce.
- Je trouve que le design de type à ce genre de questions sont difficiles à illustrer en un petit exemple; c'est exactement quand vous avez un complexe d'application qui leur utilité commence à l'emporter sur leur complexité, et il faut de l'expérience pour construire une intuition à ce sujet. Je vous suggère de conserver le motif dans le dos de votre esprit, mais allez-y avec ce qui est plus simple pour l'instant. Si et quand vous avez besoin le modèle plus complexe, refactoriser. Voir aussi: YAGNI.
- J'ai juste appris et je peux l'utiliser, mais j'ai juste posté la question pour voir si quelqu'un a déjà utilisé pour résoudre tout problème complexe. Qui pourraient les aider à apprendre mieux. Qu'entendez-vous par YAGNI?
- en.m.wikipedia.org/wiki/You_ain%27t_gonna_need_it
- Pour un monde réel exemple de modèle de commande d'utilisation, reportez-vous à Or. Or est un très puissant moteur de workflow. Il est fortement basé sur le modèle de commande. Comme il est open source, vous pouvez télécharger le code et de donner un coup d'œil.
- Fondamentalement, vous pouvez faire plus de choses avec les objets de commande. Vous pouvez stocker dans une liste par exemple; vous ne pouvez pas stocker les appels de méthode dans une liste. Si vous n'allez pas faire ces choses, alors vous avez raison, c'est ridicule d'utiliser des objets ici.
Vous devez vous connecter pour publier un commentaire.
La principale motivation pour l'utilisation de la Commande modèle est que l'exécuteur de la commande n'a pas besoin de savoir quelque chose au sujet de ce que le commandement est, à ce que les informations de contexte dont il a besoin ou ce qu'il fait. Tout cela est encapsulé dans la commande.
Cela vous permet de faire des choses comme avoir une liste de commandes qui sont exécutées dans l'ordre, qui dépendent d'autres éléments, qui sont affectés à certains événement de déclenchement etc.
Dans votre exemple, vous pourriez avoir d'autres classes (par exemple,
Air Conditioner
) qui ont leurs propres commandes (par exemple,Turn Thermostat Up
,Turn Thermostat Down
). L'une de ces commandes peut être assigné à un bouton ou déclenchée lorsqu'une condition est remplie, sans avoir besoin d'aucune connaissance de la commande.Donc, en résumé, le modèle encapsule tout ce qui est nécessaire pour prendre une action et permet l'exécution de l'action complètement indépendamment de tout contexte. Si ce n'est pas une obligation pour vous, alors le modèle n'est probablement pas utile pour votre problème de l'espace.
Voici un cas simple d'utilisation:
Ensuite, vous pouvez faire des choses comme
Comme vous pouvez le voir le
Button
etScheduler
n'avez pas besoin de connaître quoi que ce soit sur les commandes.Scheduler
est un exemple d'une classe qui peut contenir un ensemble de commandes.Notez également que dans Java 8 interfaces fonctionnelles et de la méthode références ont fait de ce type de code encore plus net:
Maintenant les méthodes qui sont transformés en commandes n'ont même pas besoin de savoir à propos des commandes - tant qu'ils ont la bonne signature que vous pouvez tranquillement créer un anonyme de l'objet de commande en référence à la méthode.
Command
objet non plus précis, et fait appel à sonexecute
méthode)Concentrons-nous sur la non-mise en œuvre des aspects de la commande de design, et quelques raisons principales pour l'utilisation de la Commande de design pattern regroupés en deux grandes catégories: les
Masquer la mise en œuvre
Dans la plupart des programmes, vous aurez envie de se cacher loin de la mise en œuvre, de sorte que lorsque l'on regarde le premier problème, il se compose d'une compréhensible sous-ensemble de commandes/code. I. e. Vous n'avez pas besoin/envie de connaître les détails sanglants de la façon dont une lumière est allumée, ou une voiture est démarrée. Si votre objectif est d'obtenir la voiture a commencé, vous n'avez pas besoin de comprendre comment le moteur fonctionne, et comment il a besoin de carburant dans le moteur, comment les vannes de travail, ...
Indiquant l'action, et non pas comment il est fait
Une commande vous donne ce genre de vue. Vous allez tout de suite comprendre que le
TurnLightOn
de commande, ouStartCar
. À l'aide d'une commande que vous allez cacher les détails de la façon de faire quelque chose, tout en indiquant clairement l'action qui doit être exécutée.Permettent de changer des détails intérieurs
En outre, permet de dire que vous plus tard sur la reconstruction de l'ensemble de votre
Light
classe, ou d'unCar
classe, ce qui nécessite d'instancier plusieurs objets différents, et, éventuellement, vous avez besoin de quelque chose d'autre avant de faire votre voulais opération. Dans ce cas, si vous avait mis en œuvre la méthode d'accès direct, dans beaucoup d'endroits, vous devez le modifier dans tous les endroits où vous avez codé à l'avance. L'aide d'une commande, vous pouvez changer l'intérieur les détails de la façon de faire des trucs sans modifier l'appel de la commande.De commande possibles extensions
À l'aide d'une interface de Commande vous donne une couche supplémentaire entre le code à l'aide de la commande, et le code d'effectuer l'action de la commande. Cela peut permettre plusieurs bons scénarios.
Extension de sécurité, ou de l'interface de l'exposition
À l'aide d'une interface de commande, vous pouvez également limiter l'accès à vos objets, vous permettant de définir un niveau de sécurité supplémentaire. Il pourrait être intéressant d'avoir un module/bibliothèque avec une assez ouvert l'accès de sorte que vous pouvez traiter des cas spéciaux facilement.
De l'extérieur, cependant, vous pouvez restreindre l'accès à la lumière alors qu'il est allumé ou éteint. À l'aide de commandes vous donne la possibilité de limiter l'interface vers une classe.
En plus si vous le souhaitez, vous pouvez créer un utilisateur dédié système d'accès autour des commandes. Cela laisserait tout de la logique d'entreprise ouverte et accessible, et sans restriction, mais encore vous pouvez facilement restreindre l'accès au niveau de la commande à appliquer accès approprié.
Interface commune pour l'exécution de trucs
Lors de la construction d'un suffisamment grand système, les commandes donne un moyen sympa de pont entre les différents modules/bibliothèques. Au lieu de vous avoir à examiner chaque détail de l'implémentation d'une classe, vous pouvez regarder dans les commandes qui accèdent à la classe.
Et puisque vous êtes en laissant de côté les détails de l'implémentation de la commande elle-même, vous pouvez utiliser une méthode commune pour instancier la commande, de l'exécuter et de revoir le résultat. Cela facilite le codage, au lieu d'avoir besoin de lire sur la façon d'instancier cette
Light
ouCar
classe, et de déterminer le résultat.Séquençage de commandes
À l'aide de commandes, vous pouvez également faire des trucs comme le séquençage de commandes. C'est puisque vous n'avez pas vraiment d'importance si vous êtes l'exécution de la
TurnOnLight
ouStartCar
de commande, vous pouvez exécuter des séquences de thèses comme ils sont exécutés de la même manière. Qui à son tour peut permettre pour les chaînes de commandes à exécuter, ce qui pourrait être utile dans de multiples situations.Vous pouvez créer des macros, exécuter des ensembles de commandes que vous croyez sont regroupés. I. e. la séquence de commande:
UnlockDoor
,EnterHouse
,TurnOnLight
. Une séquence naturelle de commandes, mais probablement pas en fait une méthode qu'il utilise différents objets et les actions.De la sérialisation de commandes
Commandes étant plutôt petite dans la nature, permet également de sérialisation tout à fait bien. Ceci est utile dans le client-serveur de contexte, ou le programme microservice contexte.
Le serveur (ou le programme) pourrait déclencher une commande, puis serialises la commande, l'envoie au-dessus de certaines protocole de communication (c'est à dire des événements de la file d'attente, file d'attente de messages, http, ... ) à quelqu'un qui fait de la manipulation de la commande. Pas nécessaire de d'abord instancier l'objet sur le serveur, c'est à dire un
Light
qui pourrait être la lumière-poids (pun intended), ou unCar
qui pourrait être d'une très grande structure. Vous avez juste besoin de la commande, et éventuellement un peu de paramètres.Cela pourrait être un bon endroit pour se présenter à la CQRS - Commande de Requête de la Responsabilité de modèle de Séparation pour la poursuite des études.
Suivi des commandes
À l'aide de la couche supplémentaire de commandes dans votre système pourrait également permettre d'exploitation forestière ou de suivi des commandes, si c'est un besoin de l'entreprise. Au lieu de faire tout cela sur la place, vous pouvez recueillir de suivi de l'exploitation forestière dans le module de commande.
Cela facilite les changements de système de journalisation, ou plus de trucs comme timeing, ou de l'activation/la désactivation de la journalisation. Et tout est facilement maintenue à l'intérieur du module de commande.
De suivi de commandes permet également de permettre d'annuler les actions, vous pouvez choisir de ré-itérer les commandes à partir d'un état donné. Besoin d'un peu d'installation supplémentaire, mais plutôt facilement faisable.
En bref, les commandes peuvent être vraiment utiles car ils permettent la connexion entre les différentes parties de votre bientôt-à-être-grand programme, car ils sont légers et facilement mémorisable/documenté et masque les détails de mise en œuvre lorsque nécessaire. En outre, les commandes de plusieurs extensions utiles, qui lors de la construction d'un système plus vaste, s'avèreront très utiles, à savoir: interface commune, le séquençage, la sérialisation, le suivi, l'exploitation forestière, de la sécurité.
Les possibilités sont nombreuses, mais ce serait généralement être quelque chose comme:
opts.register("--on", new LightOnCommand())
.on(Event.ENTER_ROOM, new LightOnCommand())
Le schéma général est ici que vous avez un morceau de code responsable pour comprendre que certains des mesures doivent être prises sans savoir ce que l'action, et un autre morceau de code sait comment faire une action, mais pas quand le faire.
Par exemple, dans le premier exemple, le
opts
instance sait que quand il voit une option de ligne de commande --, il doit allumer les lumières. Mais il le sait, sans vraiment savoir ce que "éteindre les lumières sur les" moyens. En fait, il se pourrait bien que le choisit l'exemple est venu d'un tiers de la bibliothèque, de sorte qu'il ne peut pas savoir sur les lumières. Tous les il sait à ce sujet est de savoir comment accociate actions (commandes) avec les options de ligne de commande qu'il analyse.Command
objet et appelle saexecute
méthode sans savoir ce que cela fait. De cette façon, quelqu'un d'autre peut décider, ce qui devrait arriver dans cette situation, juste par l'inscription d'un objet d'une sous-classe spécifique deCommand
.on
méthode a été déclarée très générale de la classe, comme le Bouton ou UserInput, où d'autres instances de cette classe peuvent effectuer d'autres options. Peut-être pour un immeuble de bureau, vous aussi vous voulezon(Event.ENTER_ROOM, new TriggerAlarm())
.Command
interface a unundo()
méthode ainsi que laexecute()
méthode, et les classes concrètes de mettre en œuvreundo()
de telle manière qu'ils ont parfaitement inverser les effets de laexecute()
, alors vous pouvez pousser les commandes sur une pile comme ils sont exécutés, et de la pop etundo()
pour annuler un nombre arbitraire de fois.Vous n'avez pas à. Les modèles de conception sont tout simplement lignes directrices que des gens dans le passé ont trouvé utile lors de l'écriture d'applications de grande complexité.
Dans votre cas, si ce que vous avez à faire est de tourner l'interrupteur de lumière sur et en dehors, et pas grand-chose, la deuxième option est une évidence.
Moins de code est presque toujours mieux que plus de code.
L'exemple
ICommand
vous donner est plutôt limitée et n'est de l'utilisation réelle dans un langage de programmation qui n'ont pas les expressions lambda. Sprinter couvre très bien dans ses réponses montrant l'utilisation de la commande des usines.La plupart des cas, le modèle de commande d'inclure d'autres méthodes, par exemple,
CanRun
et/ouUndo
. Ces permet un bouton pour mettre à jour son état d'activation en fonction de l'état de la commande, ou une application à mettre en œuvre une pile d'annulation.Comme la plupart des modèles de conception, le Modèle de Commande est là où les choses deviennent un peu plus complexes. Il est également le savez bien, ce qui permet de rendre votre code clairement à la plupart des programmeurs.
Vous pouvez faire ce que vous pensez, mais il est bon de suivre la tendance pour
usability
demanageability
de code.Dans la vraie vie, exemple,
Light
serait une interface. Vous avez différentes implémentations deLight
commeLEDLight
,TubeLight
Si vous exécutez le béton de commande à travers
Inovker
(RemoteControl
), vous ne devez pas vous soucier des changements dans le nom de la méthode dansReceiver
.switchOn() in Light can be changed to switchOnDevice() in future
. Mais il n'a pas d'effet Invocateur depuisConcreteCommand
(LightsOnCommand
) permettra d'apporter les modifications nécessaires.Assumer le scénario, où vous publiez vos interfaces à un service (Un Service) et la mise en œuvre dans d'autres services (Service B).
Maintenant Un Service ne devrait pas connaître de changements dans
Receiver
.Invoker
permet le couplage entre l'Expéditeur & Récepteur du message.Ont un coup d'oeil à certains plus liés SE questions:
L'aide de la Commande modèle de Conception
Modèle de commande semble inutilement complexe (ce que je suis ne pas comprendre?)
Il y a quelques avantages du modèle de Commande que j'ai vécu. Mais tout d'abord, je tiens à rappeler que, comme tous les autres modèles de ce modèle est également d'accroître la lisibilité du code et d'apporter de la compréhension commune de votre (probablement) le partage de la base de code.
- Je utiliser ce modèle pour la transition à partir d'une méthode orientée d'une interface de commande de l'interface. Cela signifie que, je suis de l'encapsulation des appels de méthode dans le béton des commandes avec les données nécessaires. Elle rend le code plus lisible, oui, mais plus important encore, je peux traiter des méthodes comme des objets, ce qui vous permet de facilement ajouter/supprimer/modifier des commandes sans augmenter la complexité du code. De sorte qu'il est facile de gérer ainsi facile à lire.
Deuxièmement, puisque vous avez vos méthodes comme des objets, vous pouvez enregistrer/mettre en file d'attente pour les exécuter plus tard. Ou de les annuler, même après que vous avez exécuté entre eux. C'est là que ce modèle vous aide à mettre en œuvre "Annuler".
Enfin, le modèle de commande également utilisé pour découpler l'exécution d'une commande et les commandes elles-mêmes. Il est comme un garçon ne sais pas comment cuisiner les ordres qu'il a reçu. Il ne se soucie pas. Il ne doit pas savoir. Si il l'aurait su qu'il allait travailler comme cuisinier ainsi. Et si le propriétaire d'un restaurant veut incendie le garçon, il/elle se retrouve avec ayant pas de cuire ainsi. Bien sûr, cette définition n'est pas particulière ou liés à la commande modèle seulement. Cela explique pourquoi nous avons besoin de découplage ou de gestion de la dépendance en général.
Modèles de conception sont essentiellement développés pour résoudre un problème complexe ou, en d'autres termes, nous pouvons dire qu'ils sont utilisés pour éviter que votre solution pour devenir complexe. Ils nous offrent la possibilité d'ajouter de nouvelles fonctionnalités à l'avenir sans faire beaucoup de changements dans notre code existant. Ouvert pour l'extension, fermées pour la modification.
Modèle de commande fondamentalement encapsule une demande comme un objet, et ainsi vous permettant de paramétrer d'autres objets avec différentes demandes et opérations annulables.
Lorsque nous voyons une télécommande qui est un meilleur exemple de modèle de commande. Dans ce cas, nous avons associé un béton de commande pour chaque bouton et que la commande a une information du syndic pour agir.
Dans votre exemple de commutateur cas, supposons que si vous souhaitez associer un bouton sur la télécommande pour ventilateur au lieu de la lumière puis à nouveau, vous devrez modifier le code existant, car vous devez l'associer à un bouton avec une commande. C'est l'essence même du modèle de commande où il vous offre une souplesse d'associer n'importe quelle commande avec un bouton de sorte que, au moment de l'exécution, vous pouvez modifier la fonctionnalité. Bien qu'en général, TÉLÉVISION à télécommande, vous n'avez pas cette faisabilité c'est à dire que vous ne pouvez pas prendre de volume, bouton de travailler en tant que volume. Mais si vous utilisez une application pour contrôler votre TV, alors vous pouvez assigner n'importe quel bouton de la commande disponible.
De plus, à l'aide de modèle de commande vous pouvez avoir un ensemble de commandes pour une fonctionnalité particulière à atteindre, c'est à dire de macro-commande. Donc si vous pensez à un niveau plus large, puis, ce modèle peut vous obtenir la flexibilité d'étendre les fonctionnalités.
Modèle de commande de nous aider dans le découplage de l'appelant(contrôle à distance) et le Récepteur (lampe,un Ventilateur,etc) avec l'aide de l'objet de commande(LightOnCommand, FanOffCommand, etc).