Command, callback and observer patterns have different semantics: callback – notifies a single caller that some operation finished with some result observer – notifies zero to n interested parties that some event (for example a finished operation) happened command – encapsulates a operation call in an object thus making it transferable over a wire or … Read more
I don’t have Design Patterns: Elements of Reusable Object-Oriented Software in front of me at the moment, but I’m pretty sure the authors even say that the design patterns they present are a model that can be modified to fit a specific situation. This question cuts to the core of what a design pattern is … Read more
The main motivation for using the Command pattern is that the executor of the command does not need to know anything at all about what the command is, what context information it needs on or what it does. All of that is encapsulated in the command. This allows you to do things such as have … Read more
Having Commands gives you the benefits of the good old Command pattern: you can parameterize an object, e.g. a UI element, with a Command to perform you can store a Command and execute it later, e.g. in a queue or a transaction log you can track which Commands you executed, giving you a foundation for … Read more
You’ll need to associate the parameters with the command object, either by constructor or setter injection (or equivalent). Perhaps something like this: public class DeletePersonCommand: ICommand { private Person personToDelete; public DeletePersonCommand(Person personToDelete) { this.personToDelete = personToDelete; } public void Execute() { doSomethingWith(personToDelete); } }
Disclaimer: Since there aren’t any great answers yet, I decided to post a part from a great blog post I read a while ago, copied almost verbatim. You can find the full blog post here. So here it is: We can define the following two interfaces: public interface IQuery<TResult> { } public interface IQueryHandler<TQuery, TResult> … Read more
using Command pattern: public interface Command { void exec(); } public class CommandA() implements Command { void exec() { // … } } // etc etc then build a Map<String,Command> object and populate it with Command instances: commandMap.put(“A”, new CommandA()); commandMap.put(“B”, new CommandB()); then you can replace your if/else if chain with: commandMap.get(value).exec(); EDIT you … Read more
Following the advice in Tackling Complexity in CQRS by Vladik Khononov suggests command handling can return information relating to its outcome. Without violating any [CQRS] principles, a command can safely return the following data: Execution result: success or failure; Error messages or validation errors, in case of a failure; The aggregate’s new version number, in … Read more
Typically the Command pattern is used to make an object out of what needs to be done — to take an operation and its arguments and wrap them up in an object to be logged, held for undo, sent to a remote site, etc. There will tend to be a large number of distinct Command … Read more
I’m including an encapsulation hierarchy table of several of the GoF design patterns to help explain the differences between these two patterns. Hopefully it better illustrates what each encapsulates so my explanation makes more sense. First off, the hierarchy lists the scope for which a given pattern is applicable, or the appropriate pattern to use … Read more