命令设计模式示例

本文是我们名为“ Java设计模式 ”的学院课程的一部分。

在本课程中，您将深入研究大量的设计模式，并了解如何在Java中实现和利用它们。 您将了解模式如此重要的原因，并了解何时以及如何应用模式中的每一个。 在这里查看 ！

1.简介

命令设计模式是一种行为设计模式，有助于将调用者与请求的接收者解耦。

为了理解命令设计模式，我们创建一个示例来执行不同类型的作业。 作业可以是系统中的任何内容，例如，发送电子邮件，SMS，日志记录以及执行某些IO功能。

命令模式将有助于将调用者与接收者解耦，并有助于执行任何类型的作业，而无需了解其实现。 让我们通过创建线程来帮助并发执行这些作业，使该示例更加有趣。 由于这些作业彼此独立，因此这些作业的执行顺序并不是很重要。 我们将创建一个线程池以限制执行作业的线程数。 命令对象将封装作业，并将其从执行作业的池中移交给线程。

在实施示例之前，让我们进一步了解命令设计模式。

2.什么是命令设计模式

命令设计模式的目的是将请求封装为对象，从而使开发人员可以将具有不同请求，队列或日志请求的客户端参数化，并支持可撤销的操作。

通常，面向对象的应用程序由一组交互对象组成，每个对象都提供有限的集中功能。 响应于用户交互，应用程序执行某种处理。 为此，应用程序将不同对象的服务用于处理需求。

在实现方面，应用程序可能依赖于指定的对象，该对象通过将所需数据作为参数传递来调用这些对象上的方法。 这个指定的对象可以称为调用程序，因为它调用不同对象上的操作。 调用方可以视为客户端应用程序的一部分。 实际包含用于提供请求处理所需服务的实现的对象集可以称为Receiver对象。

使用“命令”模式，可以将代表客户端发出请求的调用程序和一组服务呈现Receiver对象分离。 命令模式建议为响应客户请求而执行的处理或要采取的动作创建一个抽象。 可以将这种抽象设计为声明要由称为Command对象的不同具体实现者实现的公共接口。 每个Command对象代表不同类型的客户端请求和相应的处理。

给定的Command对象负责提供处理它所代表的请求所需的功能，但不包含该功能的实际实现。 Command对象在提供此功能时利用了Receiver对象。

图1 –命令模式类图

命令

• 声明用于执行操作的接口。

具体命令

• 定义Receiver对象和操作之间的绑定。
• 通过在Receiver上调用相应的操作来实现Execute 。

客户

• 创建一个ConcreteCommand对象并设置其接收者。

召唤者

• 要求命令执行请求。

接收者

• 知道如何执行与执行请求相关的操作。 任何类都可以充当Receiver 。

3.实施命令设计模式

我们将使用命令对象来实现示例。 该命令对象将由一个公共接口引用，并将包含用于执行请求的方法。 具体的命令类将覆盖该方法，并将提供其自己的特定实现以执行请求。

package com.javacodegeeks.patterns.commandpattern;

public interface Job {

	public void run();
}

Job接口是命令接口，包含单个方法run ，该方法由线程执行。 我们命令的execute方法是run方法，该方法将由线程执行以完成工作。

可以执行其他类型的作业。 以下是不同的具体类，它们的实例将由不同的命令对象执行。

package com.javacodegeeks.patterns.commandpattern;

public class Email {

	public void sendEmail(){
		System.out.println("Sending email.......");
	}
}

package com.javacodegeeks.patterns.commandpattern;

public class FileIO {

	public void execute(){
		System.out.println("Executing File IO operations...");
	}
}

package com.javacodegeeks.patterns.commandpattern;

public class Logging {

	public void log(){
		System.out.println("Logging...");
	}
}

package com.javacodegeeks.patterns.commandpattern;

public class Sms {

	public void sendSms(){
		System.out.println("Sending SMS...");
	}
}

以下是封装上述类并实现Job接口的不同命令类。

package com.javacodegeeks.patterns.commandpattern;

public class EmailJob implements Job{

	private Email email;
	
	public void setEmail(Email email){
		this.email = email;
	}
	
	@Override
	public void run() {
		System.out.println("Job ID: "+Thread.currentThread().getId()+" executing email jobs.");
		if(email!=null){
			email.sendEmail();
		}
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
		}
		
	}

}

package com.javacodegeeks.patterns.commandpattern;

public class FileIOJob implements Job{

	private FileIO fileIO;
	
	public void setFileIO(FileIO fileIO){
		this.fileIO = fileIO;
	}
	
	@Override
	public void run() {
		System.out.println("Job ID: "+Thread.currentThread().getId()+" executing fileIO jobs.");
		if(fileIO!=null){
			fileIO.execute();
		}
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
		}
		
	}
}

package com.javacodegeeks.patterns.commandpattern;

public class LoggingJob implements Job{

	private Logging logging;
	
	public void setLogging(Logging logging){
		this.logging = logging;
	}
	
	@Override
	public void run() {
		System.out.println("Job ID: "+Thread.currentThread().getId()+" executing logging jobs.");
		if(logging!=null){
			logging.log();
		}
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
		}
		
	}
}

package com.javacodegeeks.patterns.commandpattern;

public class SmsJob implements Job{

	private Sms sms;
	
	public void setSms(Sms sms) {
		this.sms = sms;
	}


	@Override
	public void run() {
		System.out.println("Job ID: "+Thread.currentThread().getId()+" executing sms jobs.");
		if(sms!=null){
			sms.sendSms();
		}
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
		}
		
	}

}

上面的类对它们各自的类进行引用，这些类将用于完成工作。 这些类将覆盖run方法并执行请求的工作。 例如， SmsJob类用于发送短信，其运行方法调用Sms对象的sendSms方法以完成工作。

您可以将一个不同的对象一一设置到同一command对象。

下面是ThreadPool类，该类用于创建线程池并允许线程从作业队列中获取并执行作业。

package com.javacodegeeks.patterns.commandpattern;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ThreadPool {
	
	private final BlockingQueue<Job> jobQueue;
	private final Thread[] jobThreads;
	private volatile boolean shutdown;

	public ThreadPool(int n)
	{
		jobQueue = new LinkedBlockingQueue<>();
		jobThreads = new Thread[n];

		for (int i = 0; i < n; i++) {
			jobThreads[i] = new Worker("Pool Thread " + i);
			jobThreads[i].start();
		}
	}

	public void addJob(Job r)
	{
		try {
			jobQueue.put(r);
		} catch (InterruptedException e) {
			Thread.currentThread().interrupt();
		}
	}

	public void shutdownPool()
	{
		while (!jobQueue.isEmpty()) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		shutdown = true;
		for (Thread workerThread : jobThreads) {
			workerThread.interrupt();
		}
	}

	private class Worker extends Thread
	{
		public Worker(String name)
		{
			super(name);
		}

		public void run()
		{
			while (!shutdown) {
				try {
					Job r = jobQueue.take();
					r.run();
				} catch (InterruptedException e) {
				}
			}
		}
	}

}

上面的类用于创建n个线程（工作线程）。 每个工作线程将在队列中等待作业，然后执行该作业，并返回到等待状态。 该类包含一个作业队列； 当将新作业添加到队列中时，池中的工作线程将执行该作业。

我们还包括一个shutdownPool方法，该方法仅在作业队列为空时才通过中断所有工作线程来关闭池。 addJob方法用于将作业添加到队列。

现在，让我们测试代码。

package com.javacodegeeks.patterns.commandpattern;


public class TestCommandPattern {
	public static void main(String[] args)
    {
        init();
    }
 
    private static void init()
    {
        ThreadPool pool = new ThreadPool(10);
        
        Email email = null;
        EmailJob  emailJob = new EmailJob();
        
        Sms sms = null;
        SmsJob smsJob = new SmsJob();
        
        FileIO fileIO = null;;
        FileIOJob fileIOJob = new FileIOJob();
        
        Logging logging = null;
        LoggingJob logJob = new LoggingJob();
        
        for (int i = 0; i < 5; i++) {
        	email = new Email();
        	emailJob.setEmail(email);
        	
        	sms = new Sms();
        	smsJob.setSms(sms);
        	
        	fileIO = new FileIO();
        	fileIOJob.setFileIO(fileIO);
        	
        	logging = new Logging();
        	logJob.setLogging(logging);
        	
            pool.addJob(emailJob);
            pool.addJob(smsJob);
            pool.addJob(fileIOJob);
            pool.addJob(logJob);
        }
        pool.shutdownPool();
    }

}

上面的代码将导致以下输出：

Job ID: 9 executing email jobs.
Sending email.......
Job ID: 12 executing logging jobs.
Job ID: 17 executing email jobs.
Sending email.......
Job ID: 13 executing email jobs.
Sending email.......
Job ID: 10 executing sms jobs.
Sending SMS...
Job ID: 11 executing fileIO jobs.
Executing File IO operations...
Job ID: 18 executing sms jobs.
Sending SMS...
Logging...
Job ID: 16 executing logging jobs.
Logging...
Job ID: 15 executing fileIO jobs.
Executing File IO operations...
Job ID: 14 executing sms jobs.
Sending SMS...
Job ID: 12 executing fileIO jobs.
Executing File IO operations...
Job ID: 10 executing logging jobs.
Logging...
Job ID: 18 executing email jobs.
Sending email.......
Job ID: 16 executing sms jobs.
Sending SMS...
Job ID: 14 executing fileIO jobs.
Executing File IO operations...
Job ID: 9 executing logging jobs.
Logging...
Job ID: 17 executing email jobs.
Sending email.......
Job ID: 13 executing sms jobs.
Sending SMS...
Job ID: 15 executing fileIO jobs.
Executing File IO operations...
Job ID: 11 executing logging jobs.
Logging...

请注意，后续执行的输出可能会有所不同。

在上面的类中，我们创建了一个具有10个线程的线程池。 然后，我们使用不同的作业设置不同的命令对象，并使用ThreadPool类的addJob方法将这些作业添加到队列中。 作业插入队列后，线程就会执行该作业并将其从队列中删除。

我们设置了不同类型的作业，但是通过使用命令设计模式，我们将作业与调用程序线程解耦。 线程将执行实现Job接口的任何类型的对象。 不同的命令对象封装了不同的对象，并在这些对象上执行了请求的操作。

输出显示执行不同作业的不同线程。 通过查看输出中的作业ID，您可以清楚地看到单个线程正在执行多个作业。 这是因为执行作业后，线程将发送回池中。

命令设计模式的优点是您可以添加更多不同种类的作业，而无需更改现有类。 这样可以提高灵活性和可维护性，并减少代码中出现错误的机会。

4.何时使用命令设计模式

当您要执行以下操作时，请使用“命令”模式：

• 通过要执行的操作对对象进行参数化。
• 在不同的时间指定，排队和执行请求。 Command对象的生存期可以独立于原始请求。 如果可以以与地址空间无关的方式表示请求的接收者，则可以将请求的命令对象传输到其他进程，并在那里执行请求。
• 支持撤消。 命令的Execute操作可以在命令本身中存储用于反转其效果的状态。 Command接口必须具有添加的Un-execute操作，该操作可以逆转先前对Execute的调用的效果。 执行的命令存储在历史列表中。 无限级撤消和重做通过分别向后和向前遍历此列表来实现，分别调用Un-execute和Execute 。
• 支持日志记录更改，以便在系统崩溃时可以重新应用它们。 通过使用加载和存储操作扩展Command界面，您可以保留更改的持久日志。 从崩溃中恢复涉及从磁盘重新加载记录的命令，并使用Execute操作重新执行它们。
• 围绕基于原始操作的高级操作构建系统。 这种结构在支持交易的信息系统中很常见。 事务封装了一组数据更改。 命令模式提供了一种对事务进行建模的方法。 命令具有一个公共接口，可让您以相同的方式调用所有事务。 该模式还使通过新事务轻松扩展系统成为可能。

5. JDK中的命令设计模式

• java.lang.Runnable
• javax.swing.Action

6.下载源代码

这是有关命令设计模式的课程。 您可以在此处下载源代码： CommandPattern-Project

翻译自: https://www.javacodegeeks.com/2015/09/command-design-pattern.html