曰本一区二区,高清视频一区二区,春暖花开成人亚洲区

jBPM的fork

java世界畅谈 — Thu, 16 Jun 2005 06:17:00 GMT

Fork : A fork spawns�Q��生） multiple concurrent(�q�发) paths of execution.

java世界畅谈 2005-06-16 14:17 发表评论

java世界畅谈 — Thu, 16 Jun 2005 06:17:00 GMT

              0 (延迟)
              halleluya





          halleluya

java世界畅谈 2005-06-16 14:17 发表评论

jBPM的Decision例子

java世界畅谈 — Thu, 16 Jun 2005 06:14:00 GMT

Decision : A decision decides between multiple paths of execution which are exclusive(独占�?

java世界畅谈 2005-06-16 14:14 发表评论

java世界畅谈 — Wed, 15 Jun 2005 05:42:00 GMT

9.4. Swimlanes�Q�咏道）
A swimlane is a process role(角色). It is a mechanism to specify that multiple tasks in the process should be done by the same actor.(多个��d��被同一个用��h��? So after the first task instance is created for a given swimlane, the actor should be remembered in the process for all subsequent�Q�后来的�Q?tasks that are in the same swimlane. A swimlane therefore has one assignment and all tasks that reference a swimlane should not specify an assignment.

When the first task in a given swimlane is created, the AssignmentHandler of the swimlane is called. The Assignable that is passed to the AssignmentHandler will be the SwimlaneInstance. Important to know is that all assignments that are done on the task instances in a given swimlane will propagate to the swimlane instance. This behaviour is implemented as the default because the person that takes a task to fulfilling(实行) a certain process role will have the knowledge of that perticular process. So all subsequent(�q�发�? assignements of task instances to that swimlane are done automatically to that user.

Swimlane is a terminology(术语) borrowed from UML activity(�z�d��) diagrams.

------------------------------------------------------------
9.5. Task events (��d��事�g)
Tasks can have actions associated with them. There are 4 standard event types defined for tasks: task-create, task-assign, task-start and task-end.

(1)task-create
is fired when a task instance is created.

(2)task-assign
is fired when a task instance is being assigned. Note that in actions that are executed on this event, you can access the previous actor with executionContext.getTaskInstance().getPreviousActorId();
executionContext.getTaskInstance().getPreviousActorId();

(3)task-start
is fired when TaskInstance.start() is called. This can be used to indicate�Q�指�C�） that the user is actually starting to work on this task instance. Starting a task is optional.

(4)task-end
is fired when TaskInstance.end(...) is called. This marks the completion of the task. If the task is related to a process execution, this call might trigger the resuming(恢复) of the process execution.

Since tasks can have events and actions associated with them, also exception handlers can be specified on a task. For more information about exception handling, see Section 7.5, “Exception handling�?

---------------------------------------------------------------
9.6. Task timers(��d��定时�?
As on nodes, timers can be specified(指定) on tasks. See Section 10.1, “Timers�?

The special(特别�? thing about timers for tasks is that the cancel-event for task timers can be customized(取消事�g可以被定�?. By default, a timer on a task will be cancelled when the task is ended (=completed). But with the cancel-event attribute on the timer, process developers can customize that to e.g. task-assign or task-start. The cancel-event supports multiple events.|取消事�g支持多种事�g| The cancel-event types can be combined by specifying them in a comma(逗号) separated list in the attribute.

9.7. Customizing task instances(定制��d��实例)
Task instances can be customized. The easiest way to do this is to create a subclass of TaskInstance.|创徏一个�Q务实例的子类| Then update the property jbpm.task.instance.class and specify the class name of your custom class that inherits from TaskInstance. Also create a hibernate mapping file for the subclass (using the hibernate extends="org.jbpm.taskmgmt.exe.TaskInstance"). Then add that mapping file to the list of mapping files in the hibernate.cfg.xml
(1)更新jbpm.task.instance.class 的属�?BR>(2)指定�l�承TaskInstance的定制类
(3)创徏一个子�cȝ��影射文�g(使用 extends="org.jbpm.taskmgmt.exe.TaskInstance")
(4)��这个媄��文件加�?hibernate.cfg.xml

9.8. The identity component(�w�䆾�l��g)
Management of users, groups and permissions is commonly known as identity management. jBPM includes an optional identity component that can be easily replaced by a company's own identity data store.

The jBPM identity management component includes knowledge of the organisational model. Task assignment is typically done with organisational knowledge. So this implies knowledge of an organisational model, describing the users, groups, systems and the relations between them. Optionally, permissions and roles can be included too in an organisational model. Various academic(理论�? research attempts failed, proving that no generic organisational model can be created that fits every organisation.

The way jBPM handles this is by defining an actor as an actual participant(参与�? in a process. An actor is identified by its ID called an actorId. jBPM has only knowledge(知道) about actorId's and they are represented as java.lang.Strings for maximum flexibility. So any knowledge about the organisational model and the structure of that data is outside the scope of the jBPM core engine.

As an extension to jBPM we will provide (in the future) a component to manage that simple user-roles model. This many to many relation between users and roles is the same model as is defined in the J2EE and the servlet specs and it could serve as a starting point in new developments. People interested in contributing should check the jboss jbpm jira issue tracker for more details. 用户和角�?(user-roles 模型)

Note that the user-roles model as it is used in the servlet, ejb and portlet specifications, is not sufficiently powerful for handling task assignments. That model is a many-to-many relation between users and roles. This doesn't include information about the teams and the organisational structure of users involved in a process.

The classes in yellow are the relevant(相关�? classes for the expression assignment handler that is discussed next.

A User represents a user or a service.|一个用戯��Cؓ一个用��h��一个服务。| A Group is any kind of group of users.|一个组是�Q何种�cȝ��L��。| Groups can be nested to model the relation between a team, a business unit and the whole company.|�l�可以被内嵌到在团队、商业单元和整个公司的关�p�L��型�?| Groups have a type to differentiate between the hierarchical groups and e.g. haircolor groups.|�l�可以有一个种�c�L��区分分等�U�的�l�和haircolor�l�。| Memberships represent the many-to-many relation between users and groups. A membership can be used to represent a position in a company.|一个membership可以被用来表现在公司中的位置。| The name of the membership can be used to indicate(指出) the role that the user fullfills in the group.

9.8.2. Assignment expressions �Q�分�z�表辑ּ��Q?BR>The identity component comes with one implementation that evaluates an expression for the calculation of actors during assignment of tasks. Here's an example of using the assignment expression in a process definition:

...






...
Syntax of the assignment expression is like this:

first-term --> next-term --> next-term --> ... --> next-term

where

first-term ::= previous |
               swimlane(swimlane-name) |
               variable(variable-name) |
               user(user-name) |
               group(group-name)

and

next-term ::= group(group-type) |
member(role-name)

9.8.2.1. First terms
An expression is resolved�Q�分解） from left to right.|一个表辑ּ�被从左到双��行分解| The first-term specifies a User or Group in the identity model.|�W�一个项目是在��n份模型中指定了一个用��h��l�| Subsequent terms calculate the next term from the intermediate�Q�中间的�Q?user or group.

previous means the task is assigned to the current authenticated actor. This means the actor that performed the previous step in the process.

swimlane(swimlane-name) means the user or group is taken from the specified swimlane instance.

variable(variable-name) means the user or group is taken from the specified variable instance. The variable instance can contain a java.lang.String, in which case that user or group is fetched from the identity component. Or the variable instance contains a User or Group object.

user(user-name) means the given user is taken from the identity component.

group(group-name) means the given group is taken from the identity component.

9.8.2.2. Next terms
group(group-type) gets the group for a user. Meaning that previous terms must have resulted in a User. It searches for the the group with the given group-type in all the memberships for the user.

member(role-name) gets the user that performs a given role for a group. The previous terms must have resulted in a Group. This term searches for the user with a membership to the group for which the name of the membership matches the given role-name.

9.8.3. Removing the identity component
When you want to use your own datasource for organisational information such as your company's user database or ldap system, you can just rip out the jBPM identity component. The only thing you need to do is make sure that you delete the line ...

from the hibernate.cfg.xml

The ExpressionAssignmentHandler is dependent on the identity component so you will not be able to use it as is. In case you want to reuse the ExpressionAssignmentHandler and bind it to your user data store, you can extend from the ExpressionAssignmentHandler and override the method getExpressionSession.

protected ExpressionSession getExpressionSession(AssignmentContext assignmentContext);

java世界畅谈 2005-06-15 13:42 发表评论

jBPM的分�z�Assignment

java世界畅谈 — Wed, 15 Jun 2005 03:18:00 GMT

Assignment(分派)
A process definition contains can have task nodes. A task-node contains zero or more tasks. Tasks are a static description as part of the process definition. At runtime, tasks result(��h��? in the creation of task instances. A task instance corresponds to�Q�相应） one entry in a person's task list.
tasknodes-->>task-node--->>tasks

With jBPM, push and pull model (see below) of task assignment can be applied in combination. The process can calculate(考虑) the responsible for a task and push it in his/her tasklist. Or alternatively�Q�作为选择�Q? a task can be assigned to a pool of actors, in which case each of the actors in the pool can pull the task and put it in the actor's personal tasklist. {�q�里提到了一个行为池的概�?pool of actors}

9.3.1. Assignment interfaces
Assigning task instances is done via the interface AssignmentHandler: {��d��实例分派是依靠AssignmentHandler来实现的}

public interface AssignmentHandler extends Serializable {
void assign( Assignable assignable, ExecutionContext executionContext );
}
An assignment handler implementation is called when a task instance is created. At that time, the task instance can be assigned to one or more actors. The AssignmentHandler implementation should call the Assignable methods (setActorId or setPooledActors) to assign a task. The Assignable is either a TaskInstance or a SwimlaneInstance (=process role).

Assignable ��程角色�Q�TaskInstance SwimlaneInstance

public interface Assignable {
public void setActorId(String actorId);
public void setPooledActors(String[] pooledActors);
}

Both TaskInstances and SwimlaneInstances can be assigned to a specific user or to a pool of actors. To assign a TaskInstance to a user, call Assignable.setActorId(String actorId). To assign a TaskInstance to a pool of candidate�Q�侯选） actors, call Assignable.setPooledActors(String[] actorIds).

分配对象�Q?BR>分配�l�一个用�?nbsp; Assignable.setActorId(String actorId);
分配�l�一个侯选用��h�� Assignable.setPooledActors(String[] actorIds);

Each task in the process definition can be associated with an assignment handler implementation to perform the assignment at runtime.

When more then one task in a process should be assigned to the same person or group of actors, consider the usage of a swimlane

在一个流�E�当多于一个�Q务时应当被分�z��一个用��h��多用��L��l�，考虑使用泳道�?/P>

To allow for the creation of reusable AssignmentHandlers, each usage of an AssignmentHandler can be configured in the processdefinition.xml. See Section 13.2, “Delegation�Q�委托）�?for more information on how to add configuration to assignment handlers.

9.3.2. The assignment data model
The datamodel for managing assignments of task instances and swimlane instances to actors is the following. Each TaskInstance has an actorId and a set of pooled actors.

The actorId is the responsible for the task, while the set of pooled actors represents a collection of candidates that can become responsible if they would take the task. Both actorId and pooledActors are optional and can also be combined.

Pull model(拉模�?
On the other hand, the tasks of pooled tasks for a given user are the tasks for which the given user is referenced in the pooled actors.
Fetching the list of pooled tasks is typically a two step operation :
1) get all the groups for the given user from the identity component. and
2) get the list of all pooled tasks for the combined set of the user's actorId and the actorId's that reference the users' groups.
Getting the list of pooled tasks that are offered to a given user can be done with the methods TaskMgmtSession.findPooledTaskInstances(String actorId) or TaskMgmtSession.findPooledTaskInstances(List actorIds). These methods will only return task instances for which the actorId is null and one of the given actorIds matches one of the pooled actors.

TaskMgmtSession.findPooledTaskInstance(String actorId)
TaskMgmtSession.findPooledTaskInstance(List actorIds)

To prevent multiple users working on the same pooled task, it is sufficient to update the actorId of the TaskInstance with the user's actorId. After that, the task instance will not appear in the list of pooled tasks, but only in the user's personal task list. Setting the actorId of a taskInstance to null will put the task instance back in the pooled tasks.

java世界畅谈 2005-06-15 11:18 发表评论

��d��实例

java世界畅谈 — Wed, 15 Jun 2005 02:33:00 GMT

9.2. Task instances|��d��实例|
A task instance can be assigned to an actorId (java.lang.String).|��d��实例被分�z��一个行为ID。| All task instances are stored in one table of the database (JBPM_TASKINSTANCE).|所有的实例都被存储在数据库的一个表格里(JBPM_TASKINSTANCE)。| By querying this table for all task instances for a given actorId, you get the task list for that perticular user. |通过查询�q�个行�ؓID表的所有�Q务实例的表，你得到指定用��L��d��列表。|

The jBPM task list mechanism can combine jBPM tasks with other tasks, even when those tasks are unrelated to a process execution.|jBPM��d��列表机制可以与其它�Q务结合jBPM��d��Q�甚臛_��q�些��d��与一个流�E�执行无兟뀂| That way jBPM developers can easily combine jBPM-process-tasks with tasks of other applications in one centralized task-list-repository.|那种�Ҏ(gu��)��jBPM开发�h员可以和�Ҏ(gu��)��的��jBPM��程��d��在一个集中的��d��列表库与其他�E�序中的��d��|

9.2.1. Task instance life cycle |��d��实例生命周期|
The task instance lifecycle is straightforward: After creation, task instances can optionally be started.|��d��生命周期�?��单的�Q�在创徏之后�Q��Q务实例可以随意地被开始。| Then, task instances can be ended, which means that the task instance is marked as completed.|接着�Q��Q务实例可能被�l�束�Q�它意味着��d��实例已经被标志已完成。|

Note that for flexibility, assignment is not part of the life cycle.|注意适应性、委�z�不是生命周期的一部分。| So task instances can be assigned or not assigned.|所有�Q务实例可能被委派也可能不被委�z�。| Task instance assignment does not have an influence on the task instance life cycle.|��d��实例委派不媄响�Q务实例的生命周期。|

Task instances are typically created by the process execution entering a task-node (with the method TaskMgmtInstance.createTaskInstance(...)).|��d��实例被进入一个�Q务节�Ҏ(gu��)��E�执行代典型的创�?使用TaskMgmtInstance.createInstance(...)�Ҏ(gu��)��)| Then, a user interface component will query the database for the tasklists using the TaskMgmtSession.findTaskInstancesByActorId(...).|接着一个用��h��口组件将要�ؓ��d��列表查询数据库��用TaskMgmtSession.findTaskInstancesByActorId(...)| Then, after collecting input from the user, the UI component calls TaskInstance.assign(String), TaskInstance.start() or TaskInstance.end(...).|接着�Q�在攉��从用��h��入之后，�q�个UI�l��g调用TaskIntsance.assign(String),TaskInstance.start() 或�?TaskInstance.end(...)。|

A task instance maintains it's state by means of date-properties : create, start and end.|一个�Q务实例依靠日期属性维护它的状态：创徏、开始、结束。| Those properties can be accessed by their respective getters on the TaskInstance.|�q�些属性可以通过它们的各自在��d��实例上的的getters被访问。|

Currently, completed task instances are marked with an end date so that they are not fetched with subsequent queries for tasks lists.|通常圎ͼ�完成的�Q务实例被标志为结束状态，所以他们�ƈ不通过对�Q务列表的子查询获得。| But they remain in the JBPM_TASKINSTANCE table.|但是他们仍然保持在JBPM_TASKINGSTANCE表中。|

9.2.2. Task instances and graph execution|��d��实例和图表执行|
Task instances are the items in an actor's tasklist.|��d��实例是在行动者的��d��列表中的��目。| Task instances can be signalling.|��d��实例可以被发信号的| A signalling task instance is a task instance that, when completed, can send a signal to its token to continue the process execution.|一个发信号的�Q务实例是一个这��L��d��实例�Q�当被完成时候，可以发送一个信��L��它的令牌以��l�流�E�的执行。| 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.|��d��实例可以被模块化�Q�意味着有关�pȝ��令牌�Q�执行�\径）在�Q务实例完成之前允许离开��d��节点。| By default task instances are signalling and non-blocking. |�~�省的�Q务实例是被信号化且非模块化的。|

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.|万一��过一个的��d��实例与一个�Q务节点关联，�q�个��程开发者可以定�?��d��实例的完成如何媄响流�E�的�l�箋。| Following is the list of values that can be given to the signal-property of a task-node.|接下来是值的列表可以指定�l�节点的信号属性。|

last: This is the default.|最后：�q�是�~�省的。| Proceeds execution when the last task instance is completed.|当最后流�E�执行完毕，�l�箋�q�行执行。| When no tasks are created on entrance of this node, execution waits in the task node till tasks are created.|当在�q�个的节点的入口没有��d��被创建，在�Q务节点中执行�{�待直到�q�些��d��被创建。|
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 is continued.
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.

java世界畅谈 2005-06-15 10:33 发表评论

java世界畅谈 — Tue, 14 Jun 2005 15:03:00 GMT

Task management『�Q务管理�?BR>The core business of jBPM is the ability to persist the execution of a process. 『jBPM的核心业务是有能力持久化��程的执行。』A situation in which this feature is extremely useful is the management of tasks and tasklists for people.『在�q�特征中的一个解��x��案对��Z��d��或者�Q务列表的��理是非常有用的�?jBPM allows to specify a piece of software describing an overall process which can have wait states for human tasks.『jBPM 允许定义一块��Y件描�q�全部的��程�Q�它可以为用户�Q务持有等待状态�?/P>

1. Tasks『�Q务�?BR>Tasks are part of the process definition and they define how task instances must be created and assigned during process executions.『�Q务是 ��程定义的一部分�Q��ƈ且它们定义了在流�E�执行中��d��实例如何必须被创建和分派�?�?/P>

Tasks can be defined in task-nodes and in the process-definition.『�Q务可以被定义在task-nodes和流�E�定义的中�?The most common way is to define one or more tasks in a task-node.『最通用的方式是在task-node中定义一个或多个��d��。�?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.『如果是那样的话�q�个��d��节点表现了一个�Q务被用户执行�q�且�q�个��程执行应当�{�待直到行动者完成。�?When the actor completes the task, process execution should continue.『当行动者完成这个�Q务，��程执行应该�l�箋。�?When more tasks are specified in a task-node, the default behaviour is to wait for all the tasks to complete.『当在�Q务节点中定义多个��d��Q�缺省行为是�{�待所有所有�Q务完成。�?

Tasks can also be specified on the process-definition.『�Q务也可以被定义在��程定义中。�?Tasks specified on the process definition can be looked up by name and referenced from within task-nodes or used from inside actions.『定义在��程定义中的��d��可以通过名字查找和从��d��节点内部参考或者从内部行�ؓ中��用。�?In fact, all tasks (also in task-nodes) that are given a name can be looked up by name in the process-definition. 『实际上�Q�所有的��d��Q�在��d��节点中的也一��P��可以在流�E�定义通过名字�q�行查找�?/P>

Task names must be unique in the whole process definition.『�Q务名�U�在整个��程定义中必��L��不能重复的�?/P>

java世界畅谈 2005-06-14 23:03 发表评论

JBpm的持久层 Persistence

java世界畅谈 — Tue, 14 Jun 2005 10:04:00 GMT

�Q�一�Q�结�?
(1)XML定义文�g(definition)
(2)plain java JBpm对象模型定义执行日志
(3)DataBase 定义执行日志
�Q�二�Q?BR>A process definition can be represented in 3 different forms : as xml, as java objects and as records in the jBPM database. Executional (=runtime) information and logging information can be represented in 2 forms : as java objects and as records in the jBPM database.{一个流�E�定义可以表��Cؓ三种不同的�Ş态：XML 、java对象和jBpm数据库中的记录。执行（�q�行�Q�信息和日志信息可以表现��Z��U��Ş态：java对象和jBpm数据库中的记录}

For more information about the xml representation of process definitions and process archives, see Chapter 13, jBPM Process Definition Language (JPDL).{Process Definition Language JPDL}

This chapter will discuss the transformations done between the java objects and the jBPM database. To store java objects in the database and retrieve them, jBPM uses hibernate internally. While it is not strictly necessary to have hibernate knowledge for using jBPM, it is recommended. {�q�个章节��要讨论在java对象和jBPM数据库之间的转换。�ؓ了在数据库中存储对象和获取他们，jBPM使用内部使用了Hibernate。当然不是在使用jBPM中严��D��拥有Hibernate的知识，它是��的}

More information on how to deploy a process archive to the database can be found in Section 13.1.1, “Deploying a process archive�?.

�Q�四�Q?The jBPM database classes

The jBPM persistence operations can be found in the named sessions like e.g. GraphSession, TaskMgmtSession and ContextSession,... The named sessions can be obtained from a JbpmSession. The JbpmSession in its turn can be obtained from a JbpmSessionFactory. {jBPM持久层操作可以发现被命名为sessions,例如想GraphSession TaskMgmtSession和ContextSession.... �q�个命名sessions可以从JbpmSession中获得。JbmpSession可以从JbpmSessionFactory中获得}

A JbpmSessionFactory is threadsafe so in your application, you need one JbpmSessionFactory. That singleton can be referenced e.g. in a static variable with lazy initialization (beware about the issues around lazy initialization and double-checked locking). At creation time, the JbpmSessionFactory prepares all information in a way that JbpmSessions can be created super fast. {一个JbpmSessionFactory在你的程序中是线�E�安全的�Q�你仅仅需要一个JbpmSessionFactory. 那个单例可以被参考在例如在lazy初始化下的静态变量（��心发布在Lazy 初始化�ƈ且双层检查锁定。在创徏时刻�Q�JbpmSessionFactory 在某�U�程度准备所有信息那样可以被快速创建）}

As a user, you should create one JbpmSession per thread or per request. The JbpmSession has a JDBC connection to the database. {作�ؓ一个用��P��你应该创��Z��个JbpmSession 每一个线�E�或每一�ơ请求。JbpmSession拥有一个连接数据库的Jdbc�q�接。}

The purpose of the JbpmSession and JbpmSessionFactory is only to wrap their hibernate counterparts. For advanced features such as detached objects or optimistic locking, see the hibernate documentation. {�q�个JbpmSession和JbpmSessionFactory的目的仅仅是��Z��包装Hibernate 副本�?对于高��特征例如分离对象或乐观锁�Q�看hibernate文档。}

public class PersistenceApiTest extends TestCase {

static JbpmSessionFactory jbpmSessionFactory = JbpmSessionFactory.buildJbpmSessionFactory();

public void testStartProcessInstance() {
    // obtain a session
    JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
    try {
      // start a user managed transaction
      jbpmSession.beginTransaction();

      // load information from the database
      // (note that process definitions will be cached in memory
      // in the second level cache of hibernate)
      ProcessDefinition auctionProcess =
        jbpmSession.getGraphSession().findLatestProcessDefinition("auction");

      // perform a POJO workflow operation on the plain object model.
      ProcessInstance auctionInstance = new ProcessInstance(auctionProcess);
      auctionInstance.signal();

      // store the result in the database
      jbpmSession.getGraphSession().saveProcessInstance(auctionInstance);

      // commit the user transaction
      jbpmSession.commitTransaction();

    } finally {
      // close the session.
      jbpmSession.close();
    }
}
}

java世界畅谈 2005-06-14 18:04 发表评论

jBpm��程定义XML格式

java世界畅谈 — Mon, 06 Jun 2005 09:07:00 GMT

��程定义XML��：
1.定制action�Q?BR>










2.有对应事件的















3.��d��分派XML��程定义

java世界畅谈 2005-06-06 17:07 发表评论

jBPM表的猜测

java世界畅谈 — Mon, 06 Jun 2005 05:27:00 GMT

JBPM_ACTION                                 action记录�?BR>JBPM_DECISIONCONDITIONS     �l�果条�g�?BR>JBPM_DELEGATION                        委托�?BR>JBPM_EVENT                                    事�g�?处理�q�入或者离开事�g
JBPM_EXCEPTIONHANDLER        异常处理�?BR>JBPM_ID_GROUP                             用户�l�表
JBPM_ID_MEMBERSHIP                 用户成员�?nbsp; 表现用户和组之间的多对多关系
JBPM_ID_PERMISSIONS                用户权限�?BR>JBPM_ID_USER                                用户�?BR>JBPM_MODULEDEFINITION         模块定义�?BR>JBPM_MODULEINSTANCE            模块实例�?BR>JBPM_NODE                                     ��程节点�?BR>JBPM_POOLEDACTOR                   汇集参与着�?BR>JBPM_PROCESSDEFINITION         ��程定义�?BR>JBPM_PROCESSFILE                       ��程文�g�?BR>JBPM_PROCESSFILEBLOCK         ��程文�g块表
JBPM_PROCESSINSTANCE           ��程实例�?BR>JBPM_RUNTIMEACTION               �q�行中行��
JBPM_SCRIPTVARIABLES             脚本变量�?BR>JBPM_SWIMLANE                          泳道�?BR>JBPM_SWIMLANEINSTANCE       泳道实例�?BR>JBPM_TASK                                     ��d��?BR>JBPM_TASKACTORPOOL             用户行�ؓ汇�?BR>JBPM_TASKINSTANCE                 ��d��实例
JBPM_TIMER                                   计时�?BR>JBPM_TOKEN                                 令牌�?BR>JBPM_TOKENVARIABLEMAP      令牌变量影射�?BR>JBPM_TRANSITION                        转换�?BR>JBPM_VARIABLEINSTANCE         变量实例�?BR>JBPM_VARIABLEINSTANCEBLOCK 变量实例块表
JBPM_VARIABLEMAPPING            变量影射�?BR>

java世界畅谈 2005-06-06 13:27 发表评论

java世界畅谈 — Mon, 06 Jun 2005 05:02:00 GMT

　　最�q�刚刚开始接触工作流�Q�感觉这个东西确实很不错。当然现在自��p��没有入门�Q�因��q��几个朋友在开发中接触�c�M��的东�ѝ��现在也开始接触一些�?BR>　　目前选择jBPM作�ؓ研究的对象，其他的工作流(OSWorkflow)暂时先放在一边，因�ؓjBPM��hibernate3.0作�ؓ其持久层的解��x��案，而自己对Hibernate现在也有了一定的认识。想来，上手应该好一些的�?BR>　　昨天和朋友在一��L��游泳的时候，也谈了很长时间的工作��。工作流有自��q��一套Database�Q�其中主要记录的是状态信息。工作流兛_��的就是状态信息。可以有��程描述语言来设�|�流�E�，jBPM有自�׃��套绘制流�E�的工具�Q�提供的是一个插�Ӟ��。不�q�在具体的业务信息中也要处理状态信息，方便于流向下个业务层面。流�E�可以回滚处理�?BR>　　典型的一个流�E�，甲写了一个请假申��P��提交�l�领��g��Q�领导拿到后�Q�不�l�予审批�Q�然后将�l�第三方丙。丙来处理这个流�E��?BR>

java世界畅谈 2005-06-06 13:02 发表评论