文章目录
- 概念
- 结构
- 实例
- 总结
概念
命令模式：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。
现实生活中，我们用开关来控制一些电器的打开和关闭，比如电灯和电视。购买开关时，我们也不知道它未来用来控制哪些电器，也就是说开关和电灯、电视之间没有直接关系。安装开关可能用来控制电灯，也可能用来控制其他电器，取决于控制哪些电器的是电线，相同的开关可以通过不同的电线来控制不同的电器。
上面的例子中，开关可以理解为调用者，电线为命令类，电器为接收者。开关和电器之间并不存在耦合，想控制哪个电器，更换一根电线就可以了。
结构
Command(抽象命令类)：其中声明了用于执行请求的execute()等方法，这些方法可以调用请求接收者的相关操作。
ConcreteCommand(具体命令类)：抽象命令类的子类，它对应具体的接收者对象，将具体接收者对象绑定其中，当实现execute()方法时，将调用接收者对象的相关操作。
Invoker(调用者)：它用来发送请求，关联抽象命令对象。
Receiver(接收者)：接收者执行与请求相关的操作，具体实现对请求的业务处理。
实例
某系统实现一个功能，用一个按钮控制不同的功能。可以通过按钮退出系统，也可以通过按钮来显示帮助文档。
抽象命令类
public interface Command {
public void execute();
}
请求发送者
public class FunctionButton {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void click() {
System.out.println("点击功能键：");
command.execute();
}
}
退出命令类，充当具体命令类
public class ExitCommand implements Command {
private SystemExitClass seObj;
public ExitCommand() {
seObj = new SystemExitClass();
}
@Override
public void execute() {
seObj.exit();
}
}
帮助命令类，充当具体命令类
public class HelpCommand implements Command {
private DisplayHelpClass hcObj;
public HelpCommand() {
hcObj = new DisplayHelpClass();
}
@Override
public void execute() {
hcObj.display();
}
}
退出系统模拟实现类，充当请求接收者
public class SystemExitClass {
public void exit() {
System.out.println("退出系统");
}
}
显示帮助文档模拟实现类，充当请求接受者
public class DisplayHelpClass {
public void display() {
System.out.println("显示帮助文档");
}
}
客户端
public class Client {
public static void main(String[] args) {
FunctionButton button = new FunctionButton();
button.setCommand(new ExitCommand());
button.click();
System.out.println("------------------");
button.setCommand(new HelpCommand());
button.click();
}
}
运行结果
当我们在项目开发中，更多的是结合Spring使用，当客户端调用时，具体命令类发生改变时，我们尽量不去改动客户端代码，实现的方式有很多，上一篇刚写完代理模式，这里可以结合动态代理来实现bean的切换。
简单写一个config类，不足的地方的大家可自行扩展。
@Configuration
public class BeanConfig {
@Resource
private ExitCommand exitCommand;
@Resource
private HelpCommand helpCommand;
private SwitcherInvocationHandler switcherInvocationHandler = new SwitcherInvocationHandler();
class SwitcherInvocationHandler implements InvocationHandler {
private final Set<String> methodsOnObjectClass = Arrays.stream(Object.class.getMethods()).map(Method::getName).collect(Collectors.toSet());
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (methodsOnObjectClass.contains(method.getName())) {
return method.invoke(this, args);
}
if (useExitCommand()) {
return method.invoke(exitCommand, args);
} else {
return method.invoke(helpCommand, args);
}
}
//需要变动的地方是这里
private boolean useExitCommand() {
return true;
}
}
//通过反射创建名字为"command"的bean
@Bean(name = "command")
public Command getCommand() {
return Reflection.newProxy(Command.class, switcherInvocationHandler);
}
}
然后给各个类加上spring的注解
FunctionButton类，去掉set注入，改用Resource注解，拿取名为“command” 的bean。
@Service
public class FunctionButton {
@Resource
private Command command;
public void click() {
System.out.println("点击功能键：");
command.execute();
}
}
ExitCommand 类
@Service
public class ExitCommand implements Command {
private SystemExitClass seObj;
public ExitCommand() {
seObj = new SystemExitClass();
}
@Override
public void execute() {
seObj.exit();
}
}
HelpCommand类
@Service
public class HelpCommand implements Command {
private DisplayHelpClass hcObj;
public HelpCommand() {
hcObj = new DisplayHelpClass();
}
@Override
public void execute() {
hcObj.display();
}
}
客户端直接注入发送者即可
@Service("commandClient")
public class CommandClient {
@Autowired
private FunctionButton button;
public void invoke() {
button.click();
}
}
写个单元测试调用一下
public class TestDemo {
@Autowired
private CommandClient commandClient;
@Test
public void test() throws InterruptedException {
commandClient.invoke();
}
}
调用结果：
总结
命令模式可以降低系统的耦合度，让请求者和接收者完全解耦，并且如果有新的命令加进来，也不用修改之前的代码，符合开闭原则。
命令模式和外观模式有些类似，都是通过中间一个对象进行解耦。命令模式更适合操作的切换，比如开关用来开灯，也可以用来开电视，开关作为调用者，可以调用开灯的命令，也可以调用开电视的命令，让调用者和接收者解耦。
外观模式更类似一组操作的集合，比如到家后，先换拖鞋，再开电视，最后坐在沙发上，这一系列的操作，可以放在外观层实现，让调用者和具体的子系统解耦。
