Java架构设计：状态机模式连接适配器调度复杂任务

假设现在系统架构中定义了一批状态机关键值，每一个状态机关键值对应一个任务的某些执行调度模块（函数），而这些执行调度模块又要执行相应的逻辑回调（接口）。设计目标：支持扩展和高度解耦。

现在以Java设计模式中的状态机模式为主体，各模块之间尽可能解耦，在用适配器把状态机关键值与任务的执行调度，已经相应的逻辑回调连接起来。

为此架构设计建立抽象模型：

状态机的状态值：

/**
 * 状态机的状态值。
 * 
 * @author fly
 *
 */
public class State {
	public final static String START = "start";
	public final static String STOP = "stop";
}

 

一个任务的抽象模型，任务由各个生命周期组成，start()表示任务开始：

/**
 * 任务的抽象。任务有不同的生命周期函数。
 * 
 * @author fly
 *
 */
public abstract class Task {
	public abstract void start();
}

 

 

任何的调度、装配管理器：

import java.util.ArrayList;
/**
 * 状态机的核心任务调度器抽象模型。
 * 
 * @author fly
 *
 */
public abstract class TaskController {
	private Task task;
	private String state;
	private TaskLifecycle lifecycle;

	private ArrayList<Adapter> adapters;

	public TaskController(Task task) {
		this.task = task;
		this.adapters = new ArrayList();
	}

	public void setTask(Task task) {
		this.task = task;
	}

	public Task getTask() {
		return task;
	}

	public void execute() {
		for (Adapter adapter : adapters) {
			if (adapter.getState().equals(getState())) {
				if (getTaskLifecycle() != null) {
					adapter.callTaskLifecycle();
				}

				adapter.callTask();
			}
		}
	}

	public void setState(String state) {
		this.state = state;
	}

	public String getState() {
		return state;
	}

	public void setTaskLifecycle(TaskLifecycle lifecycle) {
		this.lifecycle = lifecycle;
	}

	public TaskLifecycle getTaskLifecycle() {
		return lifecycle;
	}

	public void addAdapter(Adapter adapter) {
		this.adapters.add(adapter);
	}

	public ArrayList<Adapter> getAdapter() {
		return adapters;
	}

	public void removeAdapter(Adapter adapter) {
		for (Adapter a : adapters) {
			if (a == adapter) {
				adapters.remove(adapter);
				break;
			}
		}
	}
}

 

任何的生命周期回调，便于第三方开发者感知一个任务的生命周期变化，onStart()对应Task中的start()：

/*
 * 生命周期的回调函数抽象接口。
 * 
 */
public interface TaskLifecycle {
	void onStart();
}

 

 

连接适配器，关键。此连接适配器负责把状态机状态值——Task的生命周期功能函数——任务的生命周期回调函数，这三者组装连接在一起，驱动这套系统架构的运转：

/**
 * 连接适配器。该适配器把状态机的每一个状态值、生命周期函数、生命周期函数回调适配连接在一起。
 * 
 * @author fly
 *
 */
public interface Adapter {
	String getState();

	void callTask();

	void callTaskLifecycle();
}

 

 

抽象模型的具体实例实现，以一个下载任务为例，一个下载任务的生命周期包含有开始（start）、停止（stop），其中stop函数为系统架构至少的扩展：

public class DownloadTask extends Task {

	@Override
	public void start() {
		System.out.println("start");
	}

	// 假设父类中没有定义stop()函数，在这里扩展一个。
	public void stop() {
		System.out.println("stop");
	}

}

 

下载任务的生命周期回调实例，第三方使用，其中onStop为体系架构之上的扩展：

public class DownloadTaskLifecycle implements TaskLifecycle {

	@Override
	public void onStart() {
		System.out.println("onStart");
	}

	/**
	 * 抽象模型中没有onStop，在此新增一个，演示如何回调该函数。
	 * 
	 */
	public void onStop() {
		System.out.println("onStop");
	}
}

 

下载任务的控制器：

public class DownloadTaskController extends TaskController {

	public DownloadTaskController(Task task) {
		super(task);

		make();
	}

	private void make() {
		DownloadTaskLifecycle lifecycle = new DownloadTaskLifecycle();
		this.setTaskLifecycle(lifecycle);

		// 连接适配器。
		this.addAdapter(new Adapter() {

			@Override
			public String getState() {
				return State.START;
			}

			@Override
			public void callTaskLifecycle() {
				if (getTaskLifecycle() != null) {
					getTaskLifecycle().onStart();
				}
			}

			@Override
			public void callTask() {
				getTask().start();
			}
		});

		this.addAdapter(new Adapter() {

			@Override
			public String getState() {
				return State.STOP;
			}

			@Override
			public void callTaskLifecycle() {
				if (getTaskLifecycle() != null) {
					((DownloadTaskLifecycle) getTaskLifecycle()).onStop();
				}
			}

			@Override
			public void callTask() {
				((DownloadTask) getTask()).stop();
			}
		});
	}
}

 

测试例程：

/**
 * 测试。以一个下载任务为例。 测试通过状态机控制器设置不同的状态值，调度执行不同的任务生命周期函数， 同时触发不同生命周期的回调函数。
 * 
 * @author fly
 *
 */
public class Main {
	public static void main(String[] args) {
		new Main().test();
	}

	private void test() {
		Task task = new DownloadTask();
		TaskController controller = new DownloadTaskController(task);

		controller.setState(State.START);
		controller.execute();

		controller.setState(State.STOP);
		controller.execute();
	}
}

 

 

输出：

onStart
start
onStop
stop