设计模式篇---命令模式(结合spring+动态代理实现开闭)

概念

命令模式：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。
现实生活中，我们用开关来控制一些电器的打开和关闭，比如电灯和电视。购买开关时，我们也不知道它未来用来控制哪些电器，也就是说开关和电灯、电视之间没有直接关系。安装开关可能用来控制电灯，也可能用来控制其他电器，取决于控制哪些电器的是电线，相同的开关可以通过不同的电线来控制不同的电器。
上面的例子中，开关可以理解为调用者，电线为命令类，电器为接收者。开关和电器之间并不存在耦合，想控制哪个电器，更换一根电线就可以了。

结构

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();
    }
  }

调用结果：

总结

命令模式可以降低系统的耦合度，让请求者和接收者完全解耦，并且如果有新的命令加进来，也不用修改之前的代码，符合开闭原则。
命令模式和外观模式有些类似，都是通过中间一个对象进行解耦。命令模式更适合操作的切换，比如开关用来开灯，也可以用来开电视，开关作为调用者，可以调用开灯的命令，也可以调用开电视的命令，让调用者和接收者解耦。
外观模式更类似一组操作的集合，比如到家后，先换拖鞋，再开电视，最后坐在沙发上，这一系列的操作，可以放在外观层实现，让调用者和具体的子系统解耦。