一、Client层总体介绍
在正式介绍Client层源码前，我们先来看一下如何在client端与server端通信，demo代码如下：
TaskClient taskClient = new TaskClient();
taskClient.setRootURI("http://localhost:8080/api/"); //Point this to the server API
int threadCount = 2; //number of threads used to execute workers. To avoid starvation, should be same or more than number of workers
Worker worker1 = new OrderWorker("order");
Worker worker2 = new PaymentWorker("payment");
//Create WorkflowTaskCoordinator
WorkflowTaskCoordinator.Builder builder = new WorkflowTaskCoordinator.Builder();
WorkflowTaskCoordinator coordinator = builder.withWorkers(worker1, worker2).withThreadCount(threadCount).withTaskClient(taskClient).build();
//Start for polling and execution of the tasks
coordinator.init();
代码说明：
1、第一步需要创建TaskClient类并设置server端的API URL路径以便客户端能够与服务端通信。
2、创建任务工作者Worker对象，具体的任务是由Worker来执行。
3、将Worker对象传入WorkerflowTaskCoordinator对象中，WorkerflowTaskCoordinator负责启动线程池来执行Worker任务，同时维护与server端的心跳以及最新任务数据的拉取操作。
通过阅读上述代码引出了几个类名称的解释：
- WorkerflowTaskCoordinator：工作流的协调者，负责管理Task Worker的线程池以及和服务端的通信。
- TaskClient：conductor的任务管理客户端类，负责从server端轮询任务以及更新任务状态等。
- Builder：用于创建WorkerflowTaskCoordinator实例的建造类。
这三个类的类图如图1-1所示，从图中可以看到类的依赖、组合等关系。
图1-1
图1-1展示是Client层最核心的三个类的依赖关系，我们接下来的源码解析就是围绕这三个类来展开。
整个Client模块的包结构和关键类如图1-2所示：
图1-2
其中：
- config包是关于Client的一些配置类
- exceptions包是自定义的client异常类
- http包是与服务端通信的基础类，包括基础基类ClientBase，还有元数据、负载、客户端任务，工作流等通信类
- task包主要包括工作流协调者和工作流任务统计类
- worker包主要包括Worker工作者接口类
二、Client层源码执行的全流程解析
我们拿文章 深入浅出Netflix Conductor使用 中介绍的案例来讲解源码流程（文章中包括了任务、工作流的DSL定义以及如何使用），流程图形表示如图1-3所示：
图1-3
这张图的含义非常简单，用户走下单流程到order模块，如果下单成功则走payment支付模块进行支付，如果下单失败则走失败模块进行重试等操作。
在Swagger界面上输入如下参数启动工作流，如图1-4
图1-4
启动的过程实际上是通过Swagger API接口调用server端的相关类，而client端则是通过拉取的方式来得到需要自己执行任务的通知和输入参数。
启动完工作流之后Client端的代码进入WorkerflowTaskCoordinator中的init方法，代码如下所示：
public synchronized void init() {
if(threadCount == -1) {
threadCount = workers.size();
}
logger.info("Initialized the worker with {} threads", threadCount);
this.workerQueue = new LinkedBlockingQueue(workerQueueSize);
AtomicInteger count = new AtomicInteger(0);
this.executorService = new ThreadPoolExecutor(threadCount, threadCount,
0L, TimeUnit.MILLISECONDS,
workerQueue,
(runnable) -> {
Thread thread = new Thread(runnable);
thread.setName(workerNamePrefix + count.getAndIncrement());
return thread;
});
this.scheduledExecutorService = Executors.newScheduledThreadPool(workers.size());
//定时轮询server状态策略，默认每隔1秒进行轮询，根据任务名获取当前任务信息
workers.forEach(worker -> {
scheduledExecutorService.scheduleWithFixedDelay(()->pollForTask(worker), worker.getPollingInterval(), worker.getPollingInterval(), TimeUnit.MILLISECONDS);
});
}
代码说明：
这段代码通过JDK中的scheduledExecutorService.scheduleWithFixedDelay方法每隔一秒对server端进行轮询，轮询任务的方法是pollForTask，代码如下：
private void pollForTask(Worker worker) {
if(eurekaClient != null && !eurekaClient.getInstanceRemoteStatus().equals(InstanceStatus.UP)) {
logger.debug("Instance is NOT UP in discovery - will not poll");
return;
}
if(worker.paused()) {
WorkflowTaskMetrics.incrementTaskPausedCount(worker.getTaskDefName());
logger.debug("Worker {} has been paused. Not polling anymore!", worker.getClass());
return;
}
String domain = Optional.ofNullable(PropertyFactory.getString(worker.getTaskDefName(), DOMAIN, null))
.orElse(PropertyFactory.getString(ALL_WORKERS, DOMAIN, null));
logger.debug("Polling {}, domain={}, count = {} timeout = {} ms", worker.getTaskDefName(), domain, worker.getPollCount(), worker.getLongPollTimeoutInMS());
List tasks = Collections.emptyList();
try{
// get the remaining capacity of worker queue to prevent queue full exception
int realPollCount = Math.min(workerQueue.remainingCapacity(), worker.getPollCount());
if (realPollCount <= 0) {
logger.warn("All workers are busy, not polling. queue size = {}, max = {}", workerQueue.size(), workerQueueSize);
return;
}
//获取当前客户端的任务名称
String taskType = worker.getTaskDefName();
//根据当前客户端的任务名称从server端的状态机获取是否有自己要执行的任务，如果有任务则获取执行，只能获取一次。
tasks = getPollTimer(taskType)
.record(() -> taskClient.batchPollTasksInDomain(taskType, domain, worker.getIdentity(), realPollCount, worker.getLongPollTimeoutInMS()));
incrementTaskPollCount(taskType, tasks.size());
logger.debug("Polled {}, domain {}, received {} tasks in worker - {}", worker.getTaskDefName(), domain, tasks.size(), worker.getIdentity());
} catch (Exception e) {
WorkflowTaskMetrics.incrementTaskPollErrorCount(worker.getTaskDefName(), e);
logger.error("Error when polling for tasks", e);
}
//根据获取的任务列表，以线程的方式启动执行任务
for (Task task : tasks) {
try {
executorService.submit(() -> {
try {
logger.debug("Executing task {}, taskId - {} in worker - {}", task.getTaskDefName(), task.getTaskId(), worker.getIdentity());
//这步就是执行用户自定义的任务逻辑
execute(worker, task);
} catch (Throwable t) {
//执行失败，置任务状态为失败，并将失败结果返回到server端
task.setStatus(Task.Status.FAILED);
TaskResult result = new TaskResult(task);
handleException(t, result, worker, task);
}
});
} catch (RejectedExecutionException e) {
WorkflowTaskMetrics.incrementTaskExecutionQueueFullCount(worker.getTaskDefName());
logger.error("Execution queue is full, returning task: {}", task.getTaskId(), e);
returnTask(worker, task);
}
}
}
代码说明：
每隔一秒从服务端的（tasks/poll/batch/{taskType}）获取当前需要执行的任务列表，任务只能获取一次不能重新获取。然后将任务通过异步线程的方式启动执行，每一个任务都是由用户自定义的逻辑实现，任务的返回值被封装到了TaskResult类中，execute方法的内容如下所示：
private void execute(Worker worker, Task task) {
String taskType = task.getTaskDefName();
try {
if(!worker.preAck(task)) {
logger.debug("Worker decided not to ack the task {}, taskId = {}", taskType, task.getTaskId());
return;
}
if (!taskClient.ack(task.getTaskId(), worker.getIdentity())) {
WorkflowTaskMetrics.incrementTaskAckFailedCount(worker.getTaskDefName());
logger.error("Ack failed for {}, taskId = {}", taskType, task.getTaskId());
returnTask(worker, task);
return;
}
} catch (Exception e) {
logger.error(String.format("ack exception for task %s, taskId = %s in worker - %s", task.getTaskDefName(), task.getTaskId(), worker.getIdentity()), e);
WorkflowTaskMetrics.incrementTaskAckErrorCount(worker.getTaskDefName(), e);
returnTask(worker, task);
return;
}
com.google.common.base.Stopwatch stopwatch = com.google.common.base.Stopwatch.createStarted();
TaskResult result = null;
try {
//前面大部分都是做监控和统计功能的，在这里不细说
//这段代码是真正执行用户Task任务的代码，执行完后返回值被封装为TaskResult对象
logger.debug("Executing task {} in worker {} at {}", task, worker.getClass().getSimpleName(), worker.getIdentity());
result = worker.execute(task);
result.setWorkflowInstanceId(task.getWorkflowInstanceId());
result.setTaskId(task.getTaskId());
result.setWorkerId(worker.getIdentity());
} catch (Exception e) {
logger.error("Unable to execute task {}", task, e);
if (result == null) {
task.setStatus(Task.Status.FAILED);
result = new TaskResult(task);
}
handleException(e, result, worker, task);
} finally {
stopwatch.stop();
WorkflowTaskMetrics.getExecutionTimer(worker.getTaskDefName())
.record(stopwatch.elapsed(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS);
}
logger.debug("Task {} executed by worker {} at {} with status {}", task.getTaskId(), worker.getClass().getSimpleName(), worker.getIdentity(), task.getStatus());
//更新任务状态，成功或者失败
updateWithRetry(updateRetryCount, task, result, worker);
}
代码说明：
通过worker.execute方法执行用户定义的任务逻辑，不管是否成功都执行updatewithRetry方法更新server端的任务状态和任务执行返回结果。
访问的URL是/api/tasks。
三、完整流程时序图
image.png