9.1. Tasks 任务
Tasks are part of the process definition and they define how task instances must be created and assigned during process executions.
任务是流程定义的一部分，并且他们定义了任务实例如何在流程执行中必须被创建并且委派。

Tasks can be defined in task-nodes and in the process-definition. The most common way is to define one or more tasks in a task-node. In that case the task-node represents a task to be done by the user and the process execution should wait until the actor completes the task. When the actor completes the task, process execution should continue. When more tasks are specified in a task-node, the default behaviour is to wait for all the tasks to complete.
任务可以在task-nodes和process-definition中被定义。最常用的方式是在task-node中定义一个或多个任务。如果是那样的话，task-node表现一个任务被用户执行并且流程执行应该等待知道actor完成这个任务。当这个actor完成这个任务，流程定义应该继续。当更多任务在task-node被定义，缺省的行为是等待所有任务的完成。

Tasks can also be specified on the process-definition. Tasks specified on the process definition can be looked up by name and referenced from within task-nodes or used from inside actions. In fact, all tasks (also in task-nodes) that are given a name can be looked up by name in the process-definition.
任务也被定义在process-definition中。指定在流程定义上的任务可以通过名称查询并且参考从内部的task-nodes或者从内部actions中使用。事实上，所有的给定名称任务（也在task-nodes）可以在流程定义中通过名字查询。

Task names must be unique in the whole process definition. Tasks can be given a priority. This priority will be used as the initial priority for each task instance that is created for this task. TaskInstances can change this initial priority afterwards.
任务名称在整个流程定义中是非重复。任务可以被指定一个优先权。这个优先权将被使用在初始化优先权为每个为任务创建的流程实例。任务实例然后可以修改初始化优先权

9.2. Task instances
A task instance can be assigned to an actorId (java.lang.String). All task instances are stored in one table of the database (JBPM_TASKINSTANCE). By querying this table for all task instances for a given actorId, you get the task list for that perticular user.
一个任务实例可以被委派给一个actorId(java.lang.String).所有任务实例被储存在数据库的一个表中(JBPM_TASKINGSTANCE)。通过给定的actorId来对所有的任务实例查询这个表，你为特定用户得到任务列表。

The jBPM task list mechanism can combine jBPM tasks with other tasks, even when those tasks are unrelated to a process execution. That way jBPM developers can easily combine jBPM-process-tasks with tasks of other applications in one centralized task-list-repository.

这个jBPM任务列表机制可以组合jBPM任务和其他任务，甚至当这些任务于流程执行无关。那种方法jBPM开发者可以很容易的在一个集中的任务列表仓库中组合jBPM流程任务和其他应用程序。

9.2.1. Task instance life cycle
The task instance lifecycle is straightforward: After creation, task instances can optionally be started. Then, task instances can be ended, which means that the task instance is marked as completed.
任务实例生命周期是简单的：创建之后，任务实例可以随意地开始。接着，任务实例可以被终结，这意味着任务实例内标志为完成。

Note that for flexibility, assignment is not part of the life cycle. So task instances can be assigned or not assigned. Task instance assignment does not have an influence on the task instance life cycle.

注意对适应性、委派不是生命周期的组成部分。所以任务实例可以被委派或者不委派。任务实例委派在生命周期任务实例中没有影响。

Task instances are typically created by the process execution entering a task-node (with the method TaskMgmtInstance.createTaskInstance(...)). Then, a user interface component will query the database for the tasklists using the TaskMgmtSession.findTaskInstancesByActorId(...). Then, after collecting input from the user, the UI component calls TaskInstance.assign(String), TaskInstance.start() or TaskInstance.end(...).

TaskMgmtInstance.createTaskInstance(...)
TaskMgmtSession.findTaskInstancesByActorId(...)
TaskInstance.assign(String)
TaskInstance.start()
TaskInstance.end()

A task instance maintains it's state by means of date-properties : create, start and end. Those properties can be accessed by their respective getters on the TaskInstance.
一个任务实例维护它的状态借助于日期属性：create,start 和end. 这些属性可以在任务实例中通过他们分别的getter获得通道。

Currently, completed task instances are marked with an end date so that they are not fetched with subsequent（随后） queries for tasks lists. But they remain in the JBPM_TASKINSTANCE table. JBPM_TASKINSTANCE.

9.2.2. Task instances and graph execution 任务实例和图形执行
Task instances are the items in an actor's tasklist. Task instances can be signalling. A signalling task instance is a task instance that, when completed, can send a signal to its token to continue the process execution. Task instances can be blocking, meaning that the related token (=path of execution) is not allowed to leave the task-node before the task instance is completed. By default task instances are signalling and non-blocking.

In case（以防） more than one task instance are associated with a task-node, the process developer can specify how completion of the task instances affects continuation of the process. Following is the list of values that can be given to the signal-property of a task-node.

last: This is the default. Proceeds execution when the last task instance is completed. When no tasks are created on entrance of this node, execution is continued.
last-wait: Proceeds execution when the last task instance is completed. When no tasks are created on entrance of this node, execution waits in the task node till tasks are created.
first: Proceeds execution when the first task instance is completed. When no tasks are created on entrance of this node, execution is continued.
first-wait: Proceeds execution when the first task instance is completed. When no tasks are created on entrance of this node, execution waits in the task node till tasks are created.
unsynchronized: Execution always continues, regardless wether tasks are created or still unfinished.
never: Execution never continues, regardless wether tasks are created or still unfinished.
Task instance creation might be based upon a runtime calculation. In that case, add an ActionHandler on the node-enter event of the task-node and set the attribute create-tasks="false". Here is an example of such an action handler implementation:

public class CreateTasks implements ActionHandler {
  public void execute(ExecutionContext executionContext) throws Exception {
    Token token = executionContext.getToken();
    TaskMgmtInstance tmi = executionContext.getTaskMgmtInstance();
     
    TaskNode taskNode = (TaskNode) executionContext.getNode();
    Task changeNappy = taskNode.getTask("change nappy");

    // now, 2 task instances are created for the same task.
    tmi.createTaskInstance(changeNappy, token);
    tmi.createTaskInstance(changeNappy, token);
  }
}
As shown in the example the tasks to be created can be specified in the task-node. They could also be specified in the process-definition and fetched from the TaskMgmtDefinition. TaskMgmtDefinition extends the ProcessDefinition with task management information.

The API method for marking task instances as completed is TaskInstance.end(). Optionally, you can specify a transition in the end method. In case the completion of this task instance triggers continuation of the execution, the task-node is left over（延迟） the specified transition.

<process-definition>
  <event type="node-enter">
     <script>
        System.out.println("this script is enering node"+node);
     </script>
  </event>
  ...
</process-definition>

为定制缺省加载行为并且储存变量进script，变量元素可以被用来作为script的子元素。那样，脚本表达式不得不被放入一个脚本的子元素:expression

<prcession-definition>
  <event type="process-end">
    <expression>
      a = b+c;
    </expression>
    <variable name="XXX" access="write" mapped-name="a"/>
    <variable name="YYY" access="read" mapped-name="b"/>
    <variable name="ZZZ" access="read" mapped-name="c"/>
  </event>
</prcession-definition>

在脚本开始之前，这个流程变量YYY和ZZZ将分别作为脚本变量b和c使其合法。所有脚本完成之后，脚本变量值a被存储进流程变量XXX.

如果access变量属性包含"read"，这个流程变量在脚本赋值之前将被加载作为一个脚本变量。如果access变量属性包含"write"，这个流程变量在脚本赋值以后将被加载作为一个脚本变量。

7.3.3. Nodetype state  节点类型　状态
A state is a bare-bones wait state. The difference with a task node is that no task instances will be created in any task list. This can be usefull if the process should wait for an external system. E.g. upon entry of the node (via an action on the node-enter event), a message could be sent to the external system. After that, the process will go into a wait state. When the external system send a response message, this can lead to a token.signal(), which triggers resuming of the process execution.
　　一个状态是裸骨等待状态。这个不同一个任务节点的是没有任务实例将被创建在任务任务列表中。这可以是有用的，如果流程应当为外部系统等待。例如，在节点实体之上（依靠在节点进入事件的一个动作），一个消息将被发送到外部系统。毕竟，这个流程将进入等待状态。当外部系统发送一个返回信息，这可以导致token.signal(),这将触发一个流程执行的恢复。

7.3.4. Nodetype decision　节点类型　决定
Actually there are 2 ways to model a decision. The distinction between the two is based on *who* is making the decision. Should the decision made by the process (read: specified in the process definition). Or should an external entity provide the result of the decision.
　　实际上这里有两种方法来创建一个决定。两者的区别是基谁在做这个决定。　应该被流程来决定。（限定在流程定义中）或者应该一个外部实体支持决定的结果。

When the decision is to be taken by the process, a decision node should be used. There are basically 2 ways to specify the decision criteria. Simplest is by adding condition elements on the transitions. Conditions are beanshell script expressions that return a boolean. At runtime the decision node will loop over its leaving transitions (in the order as specified in the xml), and evaluate each condition. The first transition for which the conditions resolves to 'true' will be taken. Alternatively, an implementation of the DecisionHandler can be specified. Then the decision is calculated in a java class and the selected leaving transition is returned by the decide-method of the DecisionHandler implementation.
　　当这个决定被流程执行，一个决定节点应该被使用。这里有两个基本方法来限定决定标准。最简单是在跃迁上增加条件因素。条件是Beanshell脚本表达式返回一个boolean值。在运行时这个决定节点将循环离开跃迁（顺序和xml定义的一样）。一个DecisionHandler的实现被定义是可选择的。那么，决定被计算在java类中并且选择离开跃迁被DecisionHandler实现的决定方法返回。

When the decision is taken by an external party (meaning: not part of the process definition), you should use multiple transitions leaving a state or wait state node. Then the leaving transition can be provided in the external trigger that resumes execution after the wait state is finished. E.g. Token.signal(String transitionName) and TaskInstance.end(String transitionName).
　　当这个决定被外部执行（意味着：不是流程定义部分），你应该使用多跃迁离开一个状态或等待节点。那么这个离开跃迁在外部的除法器可以被支持恢复执行，在等待状态完成后。例如，Token.signal(String transitionName) 和TaskInstance.end(String transitionName).
7.3.5. Nodetype fork 节点类型　叉
A fork splits one path of execution into multiple concurrent paths of execution. The default fork behaviour is to create a child token for each transition that leaves the fork, creating a parent-child relation between the token that arrives in the fork.
一个叉分离一个路径执行到多个并行的执行路径。这个缺省的叉行为是为每个离开叉跃迁创建一个子token，创建一个到达叉中父－子关系。

7.3.6. Nodetype join 节点类型　合并
The default join assumes that all tokens that arrive in the join are children of the same parent. This situation is created when using the fork as mentioned above and when all tokens created by a fork arrive in the same join. A join will end every token that enters the join. Then the join will examine the parent-child relation of the token that enters the join. When all sibling tokens have arrived in the join, the parent token will be propagated over the (unique!) leaving transition. When there are still sibling tokens active, the join will behave as a wait state.
缺省的合并假设所有的token到达合并点，这些都都是相同父的子。这个情形被创建如我们以上提到的使用叉并且当所有被fork创建的所有token到达相同的join.　一个join将结束每个进入join的token.　那么这个join将检查进入join的token父－子关系。当所有的兄弟姐们tokens激活，这个离开的跃迁join将传播。当这里还有兄弟tokens激活，这个join将作为一个等待状态。

7.3.7. Nodetype node　节点类型　节点
The type node serves the situation where you want to write your own code in a node. The nodetype node expects one subelement action. The action is executed when the execution arrives in the node. The code you write in the actionhandler can do anything you want but it is also responsible for propagating the execution.
节点类型服务在你想写你自己的代码在节点中。这个节点类型节点期待一个子元素行为。这个行为被执行当所有执行到达这个节点。在actionHandler中你写的代码可以做你想做的任何事情，当时它是也是一个责任为执行传播。

This node can be used if you want to use a JavaAPI to implement some functional logic that is important for the business analyst. By using a node, the node is visible in the graphical representation of the process. For comparison, actions --covered next-- will allow you to add code that is invisible in the graphical representation of the process, in case that logic is not important for the business analyst.
这个节点可以被使用，如果你将使用JavaAPI来实现一些功能逻辑，对逻辑分析是重要的. 作为使用一个node,node 是可以视的在流程图形表现中。为对比，actions-convered next--将允许在流程图形表现中增加不可见的代码，万一对你逻辑分析是不重要的

signal()
    provides a signal to the token. this method activates this token and leaves the current state over the default transition.
    准备一个信号给标记。这个方法激活这个标记并且离开当前的状态越过缺省的跃迁。
------------------------------------
Class ProcessInstance
is one execution of a ProcessDefinition. To create a new process execution of a process definition, just use the ProcessInstance(ProcessDefinition).
是一个流程定义的执行。
ProcessInstance(ProcessDefinition)
---------------------------------------
Class ProcssDefinition
创建一个ProcessDefinition
parseParResource(String parResource)
parseParZipInputStream(ZipInputStream zipInputStream)
parseXmlInputStream(InputStream inputStream)
parseXmlReader(Reader reader)
parseXmlResource(String resource)
parseXmlString(String string)
-----------------------------
Class ContextInstance
maintains all the key-variable pairs for a process instance. You can obtain a ContextInstance from a processInstance from a process instance like this :
 ProcessInstance processInstance = ...;
 ContextInstance contextInstance = processInstance.getContextInstance();
为流程实例维持所有的key-variable对。

ContextInstance  contextInstance = ProcessInstance.getContextInstance();
contextInstance.setVariable("amount",new Integer(500));
contextInstance.setVariable("reason","I met my deadline");

--------------------------
任务节点：
<task-node name="t">
  <task name="change nappy">
    <assignment  class="org.jbpm.tutorial.taskmgmt.NappyAssignmentHandler"/>
  </task>
  <transition to="end">
</task-node>

TaskInstance taskInstance = (TaskInstance)processInstance.getTaskMgmtInstance().getTaskInstances().iterator().next();

taskInstance.end(); //标志这个任务已经结束

--------------------------------------------