十六、命令模式

1，基本介绍

2，使用样例

// 电灯
public class Light {

  public void turnOn() {
    System.out.println("打开电灯");
  }

  public void turnOff() {
    System.out.println("关闭电灯");
  }
}

（2）然后我们定义一个 Command 接口，该接口有一个 execute() 方法，用于执行命令。

// 命令接口
public interface Command {
  void execute();
}

（3）接着我们定义了两个实现了命令接口的具体命令类：TurnOnLightCommand 和 TurnOffLightCommand，分别用于打开和关闭电灯。

// 开灯命令
public class TurnOnLightCommand implements Command {

  private Light light;

  public TurnOnLightCommand(Light light) {
    this.light = light;
  }

  @Override
  public void execute() {
    light.turnOn();
  }
}


// 关灯命令
public class TurnOffLightCommand implements Command {

  private Light light;

  public TurnOffLightCommand(Light light) {
    this.light = light;
  }

  @Override
  public void execute() {
    light.turnOff();
  }
}

（4）接下来我们定义了 RemoteControl 类，该类表示遥控器（即调用者 Invoker），并提供了 setCommand() 方法用于设置命令，以及 pressButton() 方法用于执行命令。

// 遥控器
public class RemoteControl {

  private Command command;

  public void setCommand(Command command) {
    this.command = command;
  }

  public void pressButton() {
    command.execute();
  }
}

（5）最后在应用程序的 main() 方法中（该类即为客户端 Client），我们创建了一个电灯对象，然后创建了打开和关闭电灯命令的实例。接着我们创建了遥控器对象，并使用 setCommand() 方法设置打开电灯命令，然后调用 pressButton() 方法执行命令。最后，我们再次使用 setCommand() 方法设置关闭电灯命令，并再次调用 pressButton() 方法执行命令。

public class Test {
  public static void main(String[] args) {
    // 创建一个电灯对象
    Light light = new Light();
    // 创建打开和关闭电灯命令的实例
    Command turnOnCommand = new TurnOnLightCommand(light);
    Command turnOffCommand = new TurnOffLightCommand(light);
    // 创建遥控器对象
    RemoteControl remoteControl = new RemoteControl();
    // 设置打开电灯命令
    remoteControl.setCommand(turnOnCommand);
    // 执行命令
    remoteControl.pressButton();
    // 设置关闭电灯命令
    remoteControl.setCommand(turnOffCommand);
    // 执行命令
    remoteControl.pressButton();
  }
}

附一：JDK 中的命令模式

public class Test {
  public static void main(String[] args) {
    // 创建一个窗口
    JFrame frame = new JFrame("My Window");
    frame.setLayout(new BorderLayout());
    frame.setSize(400, 300);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    // 创建一个文本字段
    JTextField textField = new JTextField();
    frame.add(textField, BorderLayout.CENTER);

    // 创建一个按钮
    JButton button = new JButton("点击按钮");
    frame.add(button,BorderLayout.NORTH);

    // 创建一个命令，当用户点击按钮时，将会执行这个命令
    Action command = new AbstractAction() {
      @Override
      public void actionPerformed(ActionEvent e) {
        textField.setText("按钮被点击!");
      }
    };

    // 将命令附加到按钮上
    button.addActionListener(command);

    // 显示窗口
    frame.setVisible(true);
  }
}

附二：Spring 中的命令模式

1，Spring 中的事务管理

public interface PlatformTransactionManager {
  TransactionStatus getTransaction(TransactionDefinition var1)
          throws TransactionException;

  void commit(TransactionStatus var1) throws TransactionException;

  void rollback(TransactionStatus var1) throws TransactionException;
}

（3）下面是一个示例代码，展示了如何使用 Spring 中的事务管理。UserService 类使用 @Transactional 注解标注了 addUser() 方法，表示该方法需要进行事务管理。在执行 addUser() 方法时，Spring 会自动调用 PlatformTransactionManager 接口的实现类进行事务操作，实现事务的开启、提交、回滚等功能。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private PlatformTransactionManager transactionManager;

    @Transactional
    public void addUser(User user) {
        userDao.addUser(user);
    }
}

2，Spring 中的异步处理

public interface TaskExecutor {
    void execute(Runnable var1);

    void execute(Runnable var1, long var2);
}

（3）下面是一个示例代码，展示了如何使用 Spring 中的异步处理。UserService 类的 asyncAddUser() 方法使用了 @Async 注解，表示该方法可以被异步执行。当调用 asyncAddUser() 方法时，Spring 会自动将方法封装为 Runnable 接口的实现类，然后交给 TaskExecutor 接口的实现类进行处理。

@Service
public class UserService {
    @Async
    public void asyncAddUser(User user) {
        // 进行用户添加操作
    }
}

3，Spring 中的定时调度任务

public interface TaskScheduler {
    ScheduledFuture schedule(Runnable var1, Trigger var2);

    ScheduledFuture schedule(Runnable var1, Date var2);

    ScheduledFuture scheduleAtFixedRate(Runnable var1, Date var2, long var3);

    ScheduledFuture scheduleAtFixedRate(Runnable var1, long var2);

    ScheduledFuture scheduleWithFixedDelay(Runnable var1, Date var2, long var3);

    ScheduledFuture scheduleWithFixedDelay(Runnable var1, long var2);
}

（3）下面是一个示例代码，展示了如何使用 Spring 中的调度任务。ScheduledTask 类的 executeTask() 方法使用了 @Scheduled 注解，表示该方法可以被定时执行。当调度器启动时，Spring 会自动将 executeTask() 方法封装为 Runnable 接口的实现类，然后交给 TaskScheduler 接口的实现类进行处理，按照 cron 表达式规定的时间周期执行 executeTask() 方法。

@Component
public class ScheduledTask {
    @Scheduled(cron = "0 0/1 * * * *")
    public void executeTask() {
        // 进行定时任务处理
    }
}

4，Spring 中的 JdbcTemplate 类

（1）Spring 中的 JdbcTemplate 类使用了命令模式，将 SQL 操作封装为命令对象，然后交给 JdbcTemplate 执行。

@Repository
public class UserDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    // 获取多条数据
    public List<User> getAllUsers() {
        return jdbcTemplate.query("SELECT * FROM users",
                new BeanPropertyRowMapper<>(User.class));
    }
}

（3）而 query() 方法内容如下，可以看到这里面有个内部类 QueryStatementCallback 实现了 StatementCallback 接口，该接口只有唯一的 doInStatement 方法。最后就是创建了这个内部类的实例传给 execute 方法并放回结构。从源码可以发现：