亚洲精品自在在线观看,久久精品视频亚洲,久久99国产亚洲高清观看首页

Hibernate的subclass用法

java世界畅谈 — Mon, 03 Oct 2005 02:22:00 GMT

　　看到jBPM中大量��用了subclass的用法，应该说这个是比较OO的，设计的非常合理�?BR>　　(一)、首先先�ȝ��看Hibernate的subclass�Q?BR>　　1.对于“每一个类�l�承�?w��i)对应一个表”的�{�略来说�Q�就需要��?lt;subclass>定义�?BR>　　
            name="className" //子类的全�?BR>            discriminator-value="discriminator-value"　//辨别标识�Q�一个用于区分每个独立的子类的�?BR>            proxy="proxyInterface" //指定一个类或接口，在�g�q�加载时作�ؓ(f��)代理使用
            lazy="true|false"
            dynamic-update="true|false"
            dynamic-insert="true|false"
            entity-name="entityName"
            node="element-name">

          ......

　　2.每个子类都应该定义它自己的持久化属性和子类�?lt;version>�?lt;id>属性可以从根父�cȝ��承下厅R��在一��늑�承树(w��i)上的每个子类都必��d��义一个唯一的discriminator-value。如果没有指定，��׃��(x��)使用Java�cȝ��全限定名�?BR>　　3.必须在子�cȝ��影射中指定extends属性来指定已媄��的��类�?BR>
　(�?在jBPM中的使用
　1.在jBPM的definition�l�的�c�L��构中��采用上�q�的技术。其中ModuleDefinition是作为抽象父�c�d��在的�Q�而ContextDefinition、FileDefinition、LoggingDefinition、SchedulerDefinition、MgmtDefinition�c�L��做�ؓ(f��)subclass存在的�?BR>　2.在父�c�M��使用了discriminator鉴别器的技术：(x��)在��承策略中的�?STRONG>一个对象��承树(w��i)应对应一个表”的�{�略中，元素是必��ȝ��。鉴别器字段包含标志��|��用于告知持久层应该�ؓ(f��)某个特定的行创徏哪一个类别的实例。例如：(x��)
父类的媄��片�D�：(x��)









　3.鉴别器字�D늚�实际值是�Ҏ(gu��)��?lt;subclass>元素中的discriminator-value属性得来的�?BR>　例如�Q?BR>　　父媄��文�Ӟ��(x��)
　　         table="JBPM_MODULEDEFINITION"
         abstract="true"
         discriminator-value="M"
         lazy="false">
       子媄��文�Ӟ��(x��)
　　            extends="org.jbpm.module.def.ModuleDefinition"
            discriminator-value="C"
            lazy="false">

java世界畅谈 2005-10-03 10:22 发表评论

java世界畅谈 — Sun, 02 Oct 2005 02:52:00 GMT

　　有一阉|��有看jBPM的source了，正好�q�几天是国庆�Q�口袋也没有多少�c�I��没有出去旅游的计划，所以，又重新研�I�分析一下src。希望从中可以学�?f��n)到有用的东东�?BR>　　JbpmConfiguration�Q�从名字上就知道是获取jBPM的相关配�|�信息。不�q�这里写的是一个公��q��获取properties的方法�?BR>　　首先声明了一个static properties�Q�静态属性）的实例properties,然后使用静态方法getProperties�Q�）�Q��ؓ(f��)properties获得具体的��|��取org.jbpm.jbpm.properties�Q��?BR>　　然后是N多获取方法：(x��)
　　public static String getString(String key)
　　public static String getString( String key, String defaultValue )　//如果没有�q�个��|��默认�q�回的是defaultValue
　　public static long getLong( String key, long defaultValue )
　　public static boolean getBoolean(String key, boolean defaultValue)
　　public static Object getObject(String key)
　　public static Object getObject(String key, Object defaultValue)
　　�q�些��取String、long、boolean、Object提供基础的支持，��Z��后的操作提供了很多的方便�?/P>

java世界畅谈 2005-10-02 10:52 发表评论

Task management ��d��理

java世界畅谈 — Thu, 22 Sep 2005 10:02:00 GMT

Task management ��d��理
The core business of jBPM is the ability to persist the execution of a process. A situation in which this feature is extremely useful is the management of tasks and tasklists for people. jBPM allows to specify a piece of software describing an overall process which can have wait states for human tasks.
jBPM的核心逻辑是有能力持久化流�E�的执行。一个�ؓ(f��)��Z��用来��理��d��和�Q务列表的特征的情形是非常有用的。jBPM允许指定一些��Y件描�q�C��个全面的��程�Q�它可以��Z�h��d��拥有�{�待状态�?/P>

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

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.
��d��可以在task-nodes和process-definition中被定义。最常用的方式是在task-node中定义一个或多个��d��。如果是那样的话�Q�task-node表现一个�Q务被用户执行�q�且��程执行应该�{�待知道actor完成�q�个��d��。当�q�个actor完成�q�个��d��Q�流�E�定义应该��l�。当更多��d��在task-node被定义，�~�省的行为是�{�待所有�Q务的完成�?/P>

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.
��d��也被定义在process-definition中。指定在��程定义上的��d��可以通过名称查询�q�且参考从内部的task-nodes或者从内部actions中��用。事实上�Q�所有的�l�定名称��d��Q�也在task-nodes�Q�可以在��程定义中通过名字查询�?/P>

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.
��d��名称在整个流�E�定义中是非重复。�Q务可以被指定一个优先权。这个优先权?y��u)��被使用在初始化优先权��?f��)每个��Z�Q务创建的��程实例。�Q务实例然后可以修改初始化优先�?/P>

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.
一个�Q务实例可以被委派�l�一个actorId(java.lang.String).所有�Q务实例被储存在数据库的一个表�?JBPM_TASKINGSTANCE)。通过�l�定的actorId来对所有的��d��实例查询�q�个表，你�ؓ(f��)特定用户得到��d��列表�?/P>

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.

�q�个jBPM��d��列表机制可以�l�合jBPM��d��和其他�Q务，甚至当这些�Q务于��程执行无关。那�U�方法jBPM开发者可以很�Ҏ(gu��)��的在一个集中的��d��列表仓库中组合jBPM��程��d��和其他应用程序�?/P>

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.
��d��实例生命周期是简单的�Q�创��Z��后，��d��实例可以随意地开始。接着�Q��Q务实例可以被�l�结�Q�这意味着��d��实例内标志�ؓ(f��)完成�?/P>

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.

注意寚w��应性、委�z�不是生命周期的�l�成部分。所以�Q务实例可以被委派或者不委派。�Q务实例委�z�֜�生命周期��d��实例中没有媄响�?/P>

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.
一个�Q务实例维护它的状态借助于日期属性：(x��)create,start 和end. �q�些属性可以在��d��实例中通过他们分别的getter获得通道�?/P>

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

9.2.2. Task instances and graph execution ��d��实例和图形执�?BR>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�Q�以�Ԍ�� 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�Q��g�q�） the specified transition.

java世界畅谈 2005-09-22 18:02 发表评论

script脚本

java世界畅谈 — Tue, 20 Sep 2005 07:42:00 GMT

script脚本�Q?BR>一个script是一个执行BeanShell脚本的action。缺省地�Q�所有流�E�定义变量都是合法的�q�且无脚本变量将被写入流�E�变量。下列脚本变量也是合法的�Q?BR>executionContext
token
node
task
taskInstance

...

为定制缺省加载行为�ƈ且储存变量进script�Q�变量元素可以被用来作�ؓ(f��)script的子元素。那��P��脚本表达式不得不被放入一个脚本的子元�?expression

      a = b+c;

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

如果access变量属性包�?read"�Q�这个流�E�变量在脚本赋��g��前将被加载作��Z��个脚本变量。如果access变量属性包�?write"�Q�这个流�E�变量在脚本赋��g��后将被加载作��Z��个脚本变量�?/P>

java世界畅谈 2005-09-20 15:42 发表评论

Nodetype节点�c�d��

java世界畅谈 — Tue, 20 Sep 2005 02:25:00 GMT

Nodetype task-node 节点�c�d�� d��节点
A task node represents one or more tasks that are to be performed by humans. So when execution arrives in a task node, task instances will be created in the task lists of the workflow participants. After that, the node will behave as a wait state. So when the users perform their task, the task completion will trigger the resuming of the execution. In other words, that leads to a new signal being called on the token.
　　一个�Q务节点表��Cؓ(f��)被�h所�q�行的一个或多个��d��。所以当执行到达一个�Q务节点，��d��实例��被创徏在工作流创徏者业务列表中。毕竟，�q�个节点��作��Z��个等待状态。所以当用户�q�行他们的�Q务，�q�个��d��完成��触发执行的恢复。换�a�之，那导致一个新的标记在那个toke上被呼叫�?/P>

7.3.3. Nodetype state 节点�c�d��　状�?BR>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.
　　一个状态是裔R��{�待状态。这个不同一个�Q务节点的是没有�Q务实例将被创建在��d��d��列表中。这可以是有用的�Q�如果流�E�应当�ؓ(f��)外部�pȝ��{�待。例如，在节点实体之上（依靠在节点进入事件的一个动作）�Q�一个消息将被发送到外部�pȝ��。毕竟，�q�个��程��进入等待状态。当外部�pȝ��发送一个返回信息，�q�可以导致token.signal(),�q�将触发一个流�E�执行的恢复�?/P>

7.3.4. Nodetype decision　节点�c�d��　军_��
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.
　　实际上这里有两种�Ҏ(gu��)��来创��Z��个决定。两者的区别是基谁在做这个决定。　应该被流�E�来军_��。（限定在流�E�定义中�Q�或者应该一个外部实体支持决定的�l�果�?/P>

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.
　　当这个决定被��程执行�Q�一个决定节点应该被使用。这里有两个基本�Ҏ(gu��)��来限定决定标准。最��单是在跃�q�上增加条�g因素。条件是Beanshell脚本表达式返回一个boolean倹{��在�q�行时这个决定节点将循环��d��跃迁�Q�顺序和xml定义的一��P��。一个DecisionHandler的实现被定义是可选择的。那么，军_��被计��在java�c�M��q�且选择��d��跃迁被DecisionHandler实现的决定方法返回�?/P>

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).
　　当这个决定被外部执行�Q�意味着�Q�不是流�E�定义部分）�Q�你应该使用多跃�q�离开一个状态或�{�待节点。那么这个离开跃迁在外部的除法器可以被支持恢复执行�Q�在�{�待状态完成后。例如，Token.signal(String transitionName) 和TaskInstance.end(String transitionName).
7.3.5. Nodetype fork 节点�c�d��　�?BR>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.
一个叉分离一个�\径执行到多个�q�行的执行�\径。这个缺省的叉行为是为每个离开叉跃�q�创��Z��个子token�Q�创��Z��个到辑֏�中父�Q�子关系�?/P>

7.3.6. Nodetype join 节点�c�d��　合�ƈ
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.
�~�省的合�q�假设所有的token到达合�ƈ点，�q�些都都是相同父的子。这个情形被创徏如我们以上提到的使用叉�ƈ且当所有被fork创徏的所有token到达相同的join.　一个join��结束每个进入join的token.　那么�q�个join��检查进入join的token�Ӟ��子关�p�R��当所有的兄弟姐们tokens�Ȁ�z�，�q�个��d��的跃�q�join��传播。当�q�里�q�有兄弟tokens�Ȁ�z�，�q�个join��作��Z��个等待状态�?/P>

7.3.7. Nodetype node　节点�c�d��　节点
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.
节点�c�d��服务在你惛_��你自��q��代码在节点中。这个节点类型节�Ҏ(gu��)��待一个子元素行�ؓ(f��)。这个行��执行当所有执行到达这个节炏V��在actionHandler中你写的代码可以做你惛_��的�Q何事情，当时它是也是一个责��Mؓ(f��)执行传播�?/P>

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.
�q�个节点可以被��用，如果你将使用JavaAPI来实��C��些功能逻辑�Q�对逻辑分析是重要的. 作�ؓ(f��)使用一个node,node 是可以视的在��程囑�Ş表现中。�ؓ(f��)�Ҏ(gu��)��Q�actions-convered next--��允许在��程囑�Ş表现中增加不可见的代码，万一对你逻辑分析是不重要�?/P>

java世界畅谈 2005-09-20 10:25 发表评论

java世界畅谈 — Mon, 19 Sep 2005 13:51:00 GMT

三个字段�Q?BR>1. List entities
2. Map user
3. Map groups
�q�个�c�M��要从一个流文�g中获�?BR>users用户列表 Map列表 name,user�?user : name email password
�l�列�?nbsp; Map列表 name,group�?group : name type
父组列表
memberships列表

�q�个�c�M��要用来解析XML��中的用�?�l?父组以及�?x��)员�{�等操作的�?/P>

java世界畅谈 2005-09-19 21:51 发表评论

Token-ProcessInstance-ProcessDefinition-ContextInstance-TaskInstance杂记

java世界畅谈 — Mon, 19 Sep 2005 03:49:00 GMT

Class Token
represents one path of execution and maintains a pointer to a node in the ProcessDefinition. Most common way to get a hold of the token objects is with ProcessInstance.getRootToken() or ProcessInstance.findToken(String).
在流�E�定义中表现一个执行�\径和�l�持一个指�C�器�l�一个节炏V�?BR>ProcessInstance.getRootToken()
ProcessInstance.findToken(String)

signal()
provides a signal to the token. this method activates this token and leaves the current state over the default transition.
准备一个信��L(f��ng)��标记。这个方法激�z�这个标记�ƈ且离开当前的状态越�q�缺省的跃迁�?BR>------------------------------------
Class ProcessInstance
is one execution of a ProcessDefinition. To create a new process execution of a process definition, just use the ProcessInstance(ProcessDefinition).
是一个流�E�定义的执行�?BR>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();
为流�E�实例维持所有的key-variable寏V�?/P>

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

--------------------------
��d��节点�Q?BR>

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

taskInstance.end(); //标志�q�个��d��已经�l�束

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

java世界畅谈 2005-09-19 11:49 发表评论

java世界畅谈 — Sun, 18 Sep 2005 13:26:00 GMT

security安全包应该是identity�w�䆾模块中很重要的组成部分，其中主要包含以下�c�：(x��)
一、AuthenticatedUser认证用户�c�：(x��)其中很简单，��是gettter和setter �Ҏ(gu��)��Q�设�|�和获取authenticatedUser�?BR> 　　其中的authenticatedUser是一个ThreadLocal�?BR>二、IdentityLoginModule�w�䆾登陆模块�c�：(x��)
　　实现LoginModule接口。这个类和javax.security.auth.*�{�包�l�合非常紧密�?BR>三、IdentityPolicy�w�䆾政策�c�：(x��)扩展Policy�c�R�?BR>四、IdentityService�w�䆾服务接口�Q�验证用户和获取User
五、Password和Usename　JavaBean
------------------------------------------------------------

补充知识�Q?BR>�Q?ThreadLocal
This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).
�q�支持支持thread-local 变量。这些变量不同于它们常用的对应物�Q�在那每一个线�E�获得一�?依靠get或set�Ҏ(gu��)��)拥有它自��q��Q�独立地初始化复制这个变量。ThreadLocal实例是典型地�U�有静态字�D�，它希望联�pȝ��态��用线�E?例如�Q�一个用户ID或事务ID)�?BR>

java世界畅谈 2005-09-18 21:26 发表评论

java世界畅谈 — Sun, 18 Sep 2005 06:08:00 GMT

JBpm赋值包�Q?BR>一、ExpressionAssignmentException�c�：(x��)表达式赋值异常类扩展了RuntimeException
二、ExpressionAssignmentHandler�c�：(x��) 表达式赋值处理器�c?实现AssignmentHandler接口�?BR>　　主要字段�Q?BR>　　　1.String expression;
            2.ExecutionContext executionContext
　　   3.TermTokenizer tokenizer
            4.Entity entity
　　语法�Q�syntax : first-term --> next-term --> next-term --> ... --> next-term
　　　first-term ::= previous |
*                swimlane(swimlane-name) |
*                variable(variable-name) |
*                user(user-name) |
*                group(group-name)

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

三、ExpressionSession接口
四、TermTokenizer�c�：(x��)"-->"

java世界畅谈 2005-09-18 14:08 发表评论

java世界畅谈 — Sun, 18 Sep 2005 05:45:00 GMT

PermissionUserType�c�L��一个Hibernate�l�合用户自定义数据类型：(x��)
实现了抽象接口CompositeUserType�Q?BR>其中实现的是一个String[] 数据�c�d��Q�其中将Java的Permission对象和这个数据类型绑定在一赗��?BR>
hbm.xml影射文�g�?BR>







一些特�D�的�l�合�Q��用Hibernate的组合用戯��定义�c�d��Q�在使用上还是很方便的。目前的开发中��g��q�个用的比较?y��u)��，可是在特定场合下可能用的比较多的�?img src ="http://www.tkk7.com/javaora/aggbug/13304.html" width = "1" height = "1" />

java世界畅谈 2005-09-18 13:45 发表评论

java世界畅谈 — Sun, 18 Sep 2005 04:16:00 GMT

IdentitySessionFactory�c�d��本上�c�M��于Hibernate 的SessionFactory�Q�Jbpm中很多采用了�c�M��于SessionFactory的机制。其中有获取IndentitySession的几个方法。其中还有一个evictCachedIdentities()也不知道有什么用法，可能是将�~�存中的数据�q�行清空的操作�?img src ="http://www.tkk7.com/javaora/aggbug/13302.html" width = "1" height = "1" />

java世界畅谈 2005-09-18 12:16 发表评论

java世界畅谈 — Sun, 18 Sep 2005 04:05:00 GMT

一、这个类实现了IndentityService接口和ExpressionSession接口�Q?BR>1.IndentityService接口�Q?BR>校验用户�Ҏ(gu��)��Q�Object verify(String userName, String pwd);
�Ҏ(gu��)��用户id获得User�Q�User getUserById(Object userId);
2.ExpressionSession接口�Q?BR> Group getGroupByName(String groupName);
User getUserByName(String userName);
二、包含字�D�：(x��)
　　Session session
Transaction transaction
三、方法：(x��)
�Q?其中的verify(String userName,String pwd)的处理是通过传递用户名和密码获得一个User列表�Q�如果�ؓ(f��)�I�或者size()为０�Q�返回异常，否则get(0)获得对象�Q�User�Q��?BR>�Q?采用了Session的get�Ҏ(gu��)��获取一个User
�Q?其中实现事务的开始、确认、回滚方�?BR>�Q?实现了用戗��组、实体的保存加蝲�{�方�?BR>�Q?�q�有一堆的获得List的方法：(x��)

java世界畅谈 2005-09-18 12:05 发表评论

org.jbpm.identity.hibernate包之一�c�IdentitySchema.java

java世界畅谈 — Sun, 18 Sep 2005 03:42:00 GMT

　　IdentitySchema �c�M��要用来生成SQL脚本<删除、创建、清�?gt;建立数据表以及其他相关的数据库表的操作：(x��)
　　delimiter 定界�W?BR>Fields�Q?BR> private static final String IDENTITY_TABLE_PREFIX = "JBPM_ID_";
Configuration configuration = null;
Properties properties = null;
Dialect dialect = null;
Mapping mapping = null;
String[] createSql = null;　//创徏SQL脚本
String[] dropSql = null; //删除SQL脚本
String[] cleanSql = null; //清除SQL脚本

　　通过�q�个�c�d��以创建数据库表结构，通过Hibernate的configuration.generateSchemaCreationScript(dialect)来创建SQL表结构schema的SQL脚本�Q�通过Jbpm特定的execute�Ҏ(gu��)��Q�JDBC�Q�，��传入的SQL脚本执行executeUpdate执行表结构的操作�?BR>　　要完成这个操作，要先修改hibernate.cfg.xml配置文�g�?BR>

java世界畅谈 2005-09-18 11:42 发表评论

java世界畅谈 — Sat, 17 Sep 2005 13:33:00 GMT

(org.jbpm.identity)�w�䆾包包含有如下几个�c�：(x��)
一、Entity 实体�c�：(x��)�q�个�c�M��为users<用户>groups<�l?gt;和memberships<成员>的超�c�，用来��理名称和权限的增加删除和获取。其中用��C��jdk的Permission�c�R��目前还不知道这个对具体权限的控制有什么作用？
二、Group�l�类�Q�这个类是Entity的��承子�c�，�q�个�c�M��要用于区分层�ơ组、安全角色和其他�?nbsp;
(1)主要包含以下几个Filed�Q?BR>     protected String type = null;
     protected Group parent = null; //父就是自�?BR>     protected Set children = null; //子是一个集合，其中的元素也是Group
     protected Set memberships = null; //�?x��)�?BR>   (2)JBpm的类内部�Ҏ(gu��)��的命名还是很不错的：(x��)
public Set getUsersForMembershipName(String membershipName) 很容易理解�ؓ(f��)通过membershipName来获得所有的用户�?�q�个内不仅仅是简单的JavaBean的setter和getter�Q�而是�q�行一些引申的操作�Q�例如获取用户以及addXXX�{�操作�?BR>   (3)与之相对应的hibernate Mapping文�gGroup.hbm.xml其中也有几个地方�Q�值得注意�Q�其实这个在Jbpm中是大量使用的：(x��)
         table="JBPM_ID_GROUP"
         discriminator-value="G">
    ....

�q�里表示的是在JBPM_ID_GROUP表中的CLASS_字段�{�于G的�ؓ(f��)Group的媄��对象。这里我们在使用一个表的不同类�?一个字�D�对应不同的�?��可以表�C�Z��同的�c�d��对象。这一点很值得我们学习(f��n)的。其他值得我们��x��的是它采用的集合�c�d��的操作方式，在我们以前的开发中�q�种做法�q�值得采用的�?BR>三、Membership成员�c�：(x��)它是用户和组之间的一个联�pȝ��桥梁。会(x��)员的名称代表角色的名�U�。一个会(x��)员可能是一个组�l�的位置�Q�所以权限往往于会(x��)员联�p�R��会(x��)员的名字能用来做角色的名字。不同的�?x��)员来担当不同的角色�?BR>protected String role = null;
protected Group group = null;
protected User user = null;
�q�个�c�L��有采用传�l�的构造子复用的方式，而是用很了很多的create()�Ҏ(gu��)��Q�有些方法让人感觉有些茫然不知所措，不过直接相关的代码，也就明白了�?BR>　　其中影射文�g也��用了discriminator(鉴别�?的功能，以及many-to-one和set集合的做�?BR>四、User�c�：(x��)包含有三个字�D�：(x��)password email 以及Set memeberships�?BR>　　以下是通过两种方式获得Groups的方法，一个是通过�l�的�c�d��Q�一�U�是通过成员名称�Q�角色名�U�ͼ�
　　public Set getGroupsForGroupType(String groupType)
　　public Set getGroupsForMembershipName(String membershipName)

　　通过观察�Q�我们发现这里其实有以下几个对象�Q�Entity Group Memebership User Permission。其中Group、Memebership、User都是Entity都是子类和父�cȝ��关系。Entity和Permission是一对多的关�p�，表示一个实体拥有各�U�不同的权限�Q�同样其他的Group�{�子�c�，也与Permission都是一对多的关�p�R��Group 和Memeber是一对多的，一个组��h��不同的角�Ԍ��成员�Q�。Membership与User和Group是多对一的关�p�R��User和Membership之间是一对多的关�p�R�?BR>
其中涉及的表有：(x��)
jbpm_id_group;
jbpm_id_membership;
jbpm_id_user;

java世界畅谈 2005-09-17 21:33 发表评论