hantsy 写道
就开发时所关注的启动速度和管理而已,GlassFish 已经遥遥领先了。
对于中间件如果能够精通一个足以,对于其他的只要知其所以然就可以了,而且这方面我更倾向于websphere。

相关推荐: XML中DTD,XSD的区别与应用 学习Spring必学的Java基础知识(4)----XML基础知识 JavaSE6.0 Web Service学习笔记 idea Spring中xmlns:xsi="http://www.w3.org/2001/XMLschema-instance"链接报红 persistence.xml schema 参考 JBoss AS7中的新概念－域 JBoss7配置指南 JBOSS7下部署服务（一）：EJB3集成Resteasy
推荐群组: WebServices
更多相关推荐
JBoss 1.XML Schema是干什么的? XML解决了数据表示的问题,但它没有定义一套标准的数据类型,更没有说怎么去扩展这套数据类型。例如,整形数到底代表什么?16位,32位,还是64位?这些细节对实现互操作性都是很重要的。W3C制定的XML Schema(XSD)和文档类型定义（Document Type Definition,DTD）格式就是专门解决这个问题的一套标准。它定义了一套标准的数据类型,并给出了一种语言来扩展这套数据类型。 2.XML Schema和DTD的区别 　XML Schema的作用和DTD类似。但不同的是,Schema文件所描述的是引用它的XML文件中的元素和属性的具体类型。另外,由于它是由XML编写的,Schema和DTD相比较还有以下优点： 　　1)XML Schema内容模型是开放的,可以随意扩充,而DTD无法解析扩充的内容。 　　2)DTD只能把内容类型定义为一个字符串,而XML Schema允许把内容类型定义为整型、浮点型、布尔型或者许多其它的简单数据类型。 　　3)XML Schema利用Namespaces将文档中特殊的节点与Schema相联系,一个XML文件可以有多个对应的Schema,而一个XML文件只能有一个DTD。 3.Schema的基本概念 一个Schema文档由注释,声明,类型定义,模型组,属性组五部分组成.我们可以在Schema文档中定义简单类型和复杂类型,也可以声明元素(elment),添加属性(attribute),给出注释,定义模型组和属性组 3.1声明文档元素 元素是通过使用element元素来声明的. 比如说声明一个number元素,并指定他的类型为Schema内建的字符串(string)型.通过在类型名称前冠以命名空间前缀来使用,syntax: 3.2添加属性 属性则是通过使用attribute元素来声明的。它们只能是简单类型,只能包含文本,且没有子属性。可以应用在attribute元素定义中的属性如下： default 初始默认值 fixed 不能修改和覆盖的属性固定值 name 属性的名称 ref 对前一个属性定义的引用 type 该属性的XSD类型或者简单类型 use 如何使用属性 form 确定attributeFormDefault的本地值 id 模式文档中属性唯一的ID 3.3类型定义 在Schema中,类型（type）可以分为两种形式,一种是简单的类型,被称为simple,一种是复杂的类型,被称为complex。复杂类型和简单类型之间最根本的区别就是：复杂类型的内容中可以包含其他元素,也可以带有属性（Attribute）,但简单类型既不能包含子元素,也不能带有任何属性。 当需要定义新的复合类型的时候,应当使用complexType元素来定义,这样的典型定义包括元素声明、元素引用和属性声明。 3.4定义模型组 分组定义中使用的是group元素。例如： 3.5定义属性组 对属性的分组,应该使用attributeGroup元素,例如： 4.深入了解复杂类型 4.1复杂类型的类型 复杂类型一般可以分为三类：第一类是包含字符内容和属性但不包含子元素；第二类是包含属性和子元素但不包含字符数据（字符数据包含在子元素中）；第三类是即包含属性和字符内容又包含子元素的；那么如何来定义这三类类型呢？针对第一类可以通过simpleContent来实现,第二类可以通过complexContent来做到,第三类只需要将complexType的属性mixed设为true就可以了。 1)第一种类型（从一个简单类型扩展而来,增加了属性）： 2)第二种类型（有一个element和两个attribute构成）： 3)第三种类型： 4.2利用组合器控制结构 1)sequence组合器 sequence组合器,定义了一列元素必须按照模式中指定的顺序显示（如果是可选的,也可以不显示）。语法如下： 2)all组合器 all组合器,允许所定义的元素可以按照任意顺序显示,all元素的子元素在默认情况下是必须的,而且每次最多显示一次。语法如下： 3)choice组合器 choice组合器,允许指定多组声明中的一个,用于互斥情况。语法如下： 4.3派生新类型 派生新类型有两种方式：第一种就是直接从其他类型中扩展（继承）而来,另外一种就是通过对已有类型进行限定性约束而来。如：以下有三种通过限定性约束定义的新类型： 1)通过值范围限定： 2)使用模式匹配限定： 3)使用枚举方式限定： 5.工具 XML Schema的语法并不简单。虽然可以用简单的文本编辑器手工创建schema,但是复杂的应用,这样做也许会很难。为了更好地利用它,你可以采用若干种XML工具,最近出现的一些工具甚至提供了创建XML Schema的图形界面。XML Spy和Cape Clear Studio都是具有XML Schema创建功能的全方位XML综合开发环境。dtd2xs是一种DTD-to-XML的Schema转换工具,它有两种形式：单独运行的应用程序和Java类。同DTD一样,标准的XML Schema定义非常多,你可以根据自己的需要在应用程序的开发中采用。

相关推荐: jboss rules3.1m终于用了一个el：mvel,性能与ognl的对比有些让人吃惊 性能低劣的OGNL Ognl/MVEL/Aviator/JSEL 四种表达式引擎执行效率对比 Atitit 架构师的技术框架体系图 各种引擎列表 脚本引擎 groovy beanshel php nodejs rhino等 表达式引擎技术 Ognl/MVELl等 通讯, rest 命令解 \(^_^)/ 表达式解析器(MVEL) mvel语法指南 mvel2.0语法指南
推荐群组: Groovy on Grails
更多相关推荐
JBoss 使用drools的时候发现MVEL的官方网站http://mvel.codehaus.org上面有一篇测试嵌入式脚本语言的文章,翻译一下共享给大家。有何问题请回复我修改。 对比： 上图表明：通过适用的简单基准来测试的MVEL相对其他流行的嵌入式脚本语言的性能差异,。 图块越短,性能越好。 无缓存值显示没有缓存时的性能,或再利用的资源如：解析器,工厂等,在这个类别中每一次迭代代表一个冷启动的解析器,它们通向表达式的解析结果。在MVEL的方式中,这一般涉及到解释性能。在各种嵌入式语言库的性能方面,这种方式可以用来评估他们如何有效地解析实际的表达式。 缓存值显示使用缓存时候的性能,包括重用一些常用的解析器或工厂。这未必反映了真实世界的性能,因为它可能在很长一段时间内不切合实际的操作缓存变量解析器。然而,基准允许这样做。 对于这个测试, 只有MVEL和Groovy能够通过可运行编译来实施测试。编译测试衡量字节码生成的性能。虽然OGNL 2.7.2支持字节码生成,但是它仅仅支持针对root context对象的字节码生成。所有这些试验都利用了变量反射,因此不可能以测试OGNL的Javassist字节码编译器。 Groovy没有测试无缓存值。这是因为Groovy的编译对合理性测试太慢。 25000编译在Groovy中执行超过5分钟。有趣的是,Groovy的编译测试取得比MVEL和JEXL都慢的性能 。编译测试Groovy使用了同样的groovy.lang.Script作为为每个迭代对象,并没有重新注入变量。 结果： 1：目前：MVEL拥有最快的解析器和编译器 2：MVEL优于其他嵌入式脚本语言的所有基准,除了算术性能基准方面：JEXL和MVEL并列（ 12ms操作50000次迭代） 。 3：Groovy的编译器最慢,其次是JUEL然后OGNL 。 4：OGNL最差缓存反射性能,其次是JEXL 。 5：OGNL的嵌套map基准表现最差。这个基准包括解决从使用索引语法的Map中获取属性的问题(foo['bar']['something']) 。 6：Groovy的编译器是目前使用一个特设的方式的时候速度太慢。 原始结果数据： Test Group: foo.bar.name (iterations: 25000) OGNL 2.7.2 [No Cache]: Average ms: 1633 OGNL 2.7.2 [Cached]: Average ms: 181 OGNL 2.7.2 [Compiled]: Not Supported JEXL 1.1 [No Cache]: Average ms: 540 JEXL 1.1 [Cached]: Average ms: 121 JEXL 1.1 [Compiled]: Not Supported JUEL 2.1.0 [No Cache]: Average ms: 2895 JUEL 2.1.0 [Cached]: Average ms: 52 JUEL 2.1.0 [Compiled]: Not Supported Groovy 1.5.7 [No Cache]: Not Supported Groovy 1.5.7 [Cached]: Average ms: 34 Groovy 1.5.7 [Compiled]: Not Supported MVEL 2.0 [No Cache]: Average ms: 127 MVEL 2.0 [Cached]: Average ms: 12 MVEL 2.0 [Compiled]: Average ms: 6 Test Group: x + y * z (iterations: 25000) OGNL 2.7.2 [No Cache]: Average ms: 1530 OGNL 2.7.2 [Cached]: Average ms: 66 OGNL 2.7.2 [Compiled]: Not Supported JEXL 1.1 [No Cache]: Average ms: 523 JEXL 1.1 [Cached]: Average ms: 12 JEXL 1.1 [Compiled]: Not Supported JUEL 2.1.0 [No Cache]: Average ms: 2908 JUEL 2.1.0 [Cached]: Average ms: 61 JUEL 2.1.0 [Compiled]: Not Supported Groovy 1.5.7 [No Cache]: Not Supported Groovy 1.5.7 [Cached]: Average ms: 39 Groovy 1.5.7 [Compiled]: Not Supported MVEL 2.0 [No Cache]: Average ms: 161 MVEL 2.0 [Cached]: Average ms: 12 MVEL 2.0 [Compiled]: Average ms: 15 Test Group: foo['bar']['something'] (iterations: 25000) OGNL 2.7.2 [No Cache]: Average ms: 1596 OGNL 2.7.2 [Cached]: Average ms: 75 OGNL 2.7.2 [Compiled]: Not Supported JEXL 1.1 [No Cache]: Average ms: 680 JEXL 1.1 [Cached]: Average ms: 11 JEXL 1.1 [Compiled]: Not Supported JUEL 2.1.0 [No Cache]: Average ms: 2889 JUEL 2.1.0 [Cached]: Average ms: 39 JUEL 2.1.0 [Compiled]: Not Supported Groovy 1.5.7 [No Cache]: Not Supported Groovy 1.5.7 [Cached]: Not Supported Groovy 1.5.7 [Compiled]: Average ms: 35 MVEL 2.0 [No Cache]: Average ms: 144 MVEL 2.0 [Cached]: Average ms: 8 MVEL 2.0 [Compiled]: Average ms: 5 原文地址点击 这里 ,以后更多twitter信息请在twitter上follow 我。

还是把　seam 默认的 xhtml文件全部用其它的后缀名,　例如把全部 *.xhtml　的文件改成 *.html　文件?

相关推荐: jBPM和spring的事务整合 jBPM-JPDL v3.2环境部署——发布到Tomcat + MySQL JBoss JBPM 实践系列（一）--- 安装配置（Tomcat 6.0 + MySQL 5.1） JBPM 实践 第四课 JBPM简单实例入门 jBPM开发入门指南(3) java jbpm 使用
推荐群组: JBPM @net
更多相关推荐
JBoss org.jbpm.context.def包下：
-org.jbpm.context.def
--Access.java
--ContextDefinition.java
--VariableAccess.java
--ContextDefinition.hbm.xml
--VariableAccess.hbm.xml
Access控制对Variable变量的访问控制,访问权限有read,write,required,还有一个lock参数,一个很简单的类,下面来看一下equals()方法,代码如下： public boolean equals(Object object) { if (object instanceof Access) { //将object强制转换为Access Access other = (Access) object; //Access的equals方法,比较object对象的各种权限,如下,是否可读,是 //否可写,是否被请求,是否锁住了... return (isReadable()==other.isReadable()) && (isWritable()==other.isWritable()) && (isRequired()==other.isRequired()) && (isLock()==other.isLock()); } else { return false; } } VariableAccess与jbpm数据库的JBPM_VARIABLEACCESS表相对应,JBPM_VARIABLEACCESS表有四个字段,ID_为VariableAccess的标识,VARIABLENAME_为变量的名字,ACCESS_为AccessType类,位置在org.jbpm.db.hibernate.AccessType,MAPPEDNAME_为被映射的名字. ContextDefinition继承ModuleDefinition,代码很简单,ModuleDefinition会在后面介绍.
org.jbpm.context.exe包下：
-org.jbpm.context.exe
--ContextInstance.java
--ContextInstance.hbm.xml
--Converter.java
--jbpm.varmapping.xml
--JbpmType.java
--JbpmTypeMatcher.java
--TokenVariableMap.java
--TokenVariableMap.hbm.xml
--VariableContainer.java
--VariableInstance.hbm.xml
--VariableInstance.java Converter是一个转换器接口,提供了三个方法的定义,supports(),convert(),revert(),supports()方法判断转换器是否支持以给的类型,支持返回true,convert()转换方法,revert()还原方法. ContextInstance是ModuleInstance的子类（ModuleInstance将会在后面介绍）,ContextInstance类是对变量variable的一些操作,比如说创建variable,获取variable,添加variable,删除variable等等. JbpmTypeMatcher是一个借口,定义了matches()方法, jbpm.varmapping.xml定义了使用何种类完成某种Java对象转换为jBPM中可存储的数据库实例. JbpmType指定jbpm如何支持一个JAVA类型,getJbpmTypes()方法通过读取jbpm.varmapping.xml,获得一个jbpmType的List. VariableInstance是一个抽象类,在数据库中,它作为一个基类存储变量值。对应于JBPM数据库表JBPM_VARIABLEINSTANCE。 VariableInstance的create()方法代码： public static VariableInstance create(Token token, String name, Object value) { VariableInstance variableInstance = null; //假如value为空 if (value==null) { //创建NullInstance(NullInstance是VariableInstance的子类) variableInstance = new NullInstance(); } else { //不为空,调用createVariableInstance()方法,createVariableInstance()方法获得JbpmType匹配value,返回一variableInstance variableInstance = createVariableInstance(value); } //设置token variableInstance.token = token; //设置名字 variableInstance.name = name; //设置流程实例 variableInstance.processInstance = (token!=null ? token.getProcessInstance() : null ); if (token!=null) { token.addLog(new VariableCreateLog(variableInstance)); } variableInstance.setValue(value); return variableInstance; } VariableContainer（抽象类）,一个变量容器,提供了设置、获取、添加、删除变量等方法.

相关推荐: jBPM4.0的用户指南（五-1） jBPM4开发 jbpm4.4 hibernate spring extjs3 jBPM4.0的用户指南（二） jBPM4.0的用户指南（一） JBPM4.0开发步骤 jBPM-4.0中文开发指南
推荐群组: 高级语言虚拟机
更多相关推荐
JBoss 续第5章 JPDL 5.2.3. exclusive唯一性 在多个选择中选择一条路径。也可以当做是一个决定。一个外挂活动拥有很多个向外的跳转。当一个流向到达一个外挂活动时,会自动评估并决定交给哪个向外的跳转。 5.2.3.1. exclusive唯一性条件 exclusive中会运行并判断每一个transition里的判断条件。当遇到一个嵌套条件是true或者没有设置判断条件的跳转,那么跳转就会被运行。 表 5.5. exclusive.transition.condition 属性 属性 类型 默认值 是否必须? 描述 expr expression required必须 将被运行的指定脚本 lang expression language 从第 7 章 Scripting脚本配置里得到的默认代表性语言（default-expression-language） 可选 指定expr中执行的脚本语言的种类 例子： 流程处理的唯一性条件例子 图 5.3. 流程处理的唯一性条件例子 5.2.3.2. exclusive expression唯一性表达式 exclusive表达式返回类型为字符串的向外跳转的名字。
表 5.6. 外挂属性 属性 类型 默认值 是否必须? 描述 expr expression required必须 将被运行的指定脚本 lang expression language 从第 7 章 Scripting脚本配置里得到的默认指定的脚本语言（default-expression-language） 可选 指定expr中执行的脚本语言的种类 例子： 流程处理的外挂代表例子 图 5.4. 流程处理的外挂代表例子 当你启动一个新的流程实例,代码如下： Map variables = new HashMap(); variables.put("distance","far"); Execution execution = executionService.startProcessInstanceByKey("Poolcar", variables); 然后流向会执行Big car 5.2.3.3. Exclusive handler唯一性管理 唯一性管理是继承了ExclusiveHandler接口的java类。唯一性管理负责向外跳转的选择。 public interface ExclusiveHandler{ String select(OpenExecution execution); } 这个handler被列为exclusive的子元素。 表 5.7. exclusive.handler 属性 属性 类型 默认值 是否必须? 描述 class classname required必须 handler的完整类名 下面是一个唯一性使用ExclusiveHandler的流程处理例子： 流程处理的exclusive管理例子 图 5.5. 流程处理的exclusive管理例子 下面是ContentEvalation类： public class ContentEvalation implement ExclusiveHandler { public select(OpenExecution execution) { String content = execution.getVariable("content"); if (content.equals("you're great")) { return "good"; } else if (content.equals("you gotta improve")) { return bad; } return "ugly"; } } 当你启动流程处理实例,并为变量content提供值you're great时,ContentEvalation就会返回字符串good,流程处理实例便会到达Submit document活动。

相关推荐: jBPM4.0的用户指南（五-3） jBPM4.0的用户指南（五-2） jBPM4.0的用户指南（四） jBPM4.0的用户指南（二） jBPM4.0的用户指南（一） JBPM4.0开发步骤 jBPM-4.0中文开发指南
推荐群组: JBPM @net
更多相关推荐
JBoss 第5章的内容太多了,所以我分开写了第 5 章 jPDL jPDL文件描述的是流程的过程,这篇文章也可以作为jPDL的快速参考文档。 下面是一个jPDL流程文件的例子： 5.1. process流程处理 顶级元素（element）是流程处理定义 表 5.1. process流程处理的属性 属性 类型 默认值 是否必须 描述 name名称 文本 必须 在与用户交互时,作为流程名字显示的一个名字或是标签。 key键 字母或数字字符 如果省略,key会被非字母和非数字的字符替换。 可选（optional） 用来辨别不同的流程定义。拥有同一个key的流程会有多个版本。对于所有已发布的流程版本,key:name这种组合都必须是完全一样的。 version版本 整型 比已部署的key相同的流程版本号高1,如果还没有与之相同的key的流程被部署,那么版本就从1开始。 可选 流程的版本号 表 5.2. process流程的元素 元素 个数 描述 description描述 0个或1个 描述文本 activities活动 至少1个 流程中会有很多活动,至少要有1个是启动的活动。 5.2. Activities活动 BPMN（Business Process Modeling Notation,业务流程建模符号）：我们在这里不仅涉及了BPMN活动,而且还介绍了BPMN的事件（events）和网关（gateways） 5.2.1. start启动 简单的说是流程启动的流向（execution）,准确地说是流程的一个启动活动（activity）。一个流程至少有一个启动（start）活动（activity）,一个启动活动必须有一个向外的跳转（transition）,这个跳转会在流程启动的时候被执行。 已知的限制：一个流程处理只能有一个启动节点（start）。
表 5.3. start启动的属性 属性 类型 默认值 是否必须 描述 name名称 文本 可选 活动的名字,在启动活动没有内部的跳转（transition）时,name名称是可选的。 表 5.4. start启动的元素 元素 个数 描述 transition跳转 1 向外的跳转
5.2.2. State状态节点 一个等待状态节点。流程处理的流向会在外部触发器调用提供的API之前一直等待。状态节点和其他的活动不一样,它没有其他任何属性或元素。 5.2.2.1. 序列状态节点 让我们看一个用序列连接状态和跳转的例子。 序列状态节点 图 5.1. 序列状态节点 下列代码将启动一个流向： Execution execution = executionService.startProcessInstanceByKey("StateSequence"); 创建的流程处理实例会停留在状态节点a的位置,使用signalExecution的方法就会触发一个外部触发器。 String executionId = exectuion.getId(); execution = executionService.signalExectuionById(executionId); 5.2.2.2. 可选择的状态节点
在第2个状态节点的例子里,我们将演示如何使用状态节点实现路径的选择。 状态节点中的选择 图 5.2. 状态节点中的选择 让我们在这个流程处理定义里启动一个新的流程实例。 Execution execution = executionService.startProcessInstanceByKey("StateSequence"); 现在,流向到达wait for response状态节点了。流向会一直等待到外部触发器的出现。这里的状态节点拥有多个向外的跳转,外部触发器将为向外的跳转提供不同的信号名（signalName）,下面我们将提供accept信号名（signalName）： executionService.signalExecutionById(executionId,"accept"); 流向会沿着名字是accept的向外的跳转继续进行。同样,当使用reject作为参数触发signalExecutionXxx方法时。流向会沿着名字是reject的向外的跳转继续进行。

相关推荐: jBPM的学习（一） jBPM工作流应用 jBPM-jPDL学习笔记——流程设计与控制 jbpm3.1.4.jar架包和jbpm-jpdl-3.2.2之间的区别之一 Installing JBoss jBPM 3.2.2 on Apache Tomcat 5.5 and MySQL 在JBoss AS 4.2.2.GA上部署JBPM3.2.2 web console 在Tomcat和Mysql下部署JBPM 3.2.2 jbpm3.2.2安装
推荐群组: JBPM @net
更多相关推荐
JBoss 从包名上就可以看出这个包的类似乎与数据库有关.... /*
*jBPM3.2.2
*/
类列表：
-ContextSession.java
-GraphSession.java
-Hibernate.queries.hbm.xml
-JbpmSchema.java
-JbpmSession.java
-JbpmSessionFactory.java
-JobSession.java
-LoggingSession.java
-TaskMgmtSession.java
--hibernate包下
---AccessType.java
---ConverterEnumType.java
---Converters.java
---HibernateHelper.java
---jbpm.converter.properties
---JbpmNamingStrategy.java
---StringMax.java
--compatibility
---JbpmSchemaUpdate.java
先来看看那一堆Session类都是些什么东西 从名字上看,JbpmSessioFactory是一个session工厂,里面提供了一些与session相关的方法,玩过Hibernate的对这个类应该比较清楚（Hibernate的sessionFactory）,这里就不多说了,来看看getInstance（）这个方法。 getInstance（）是一个静态方法,返回一个JbpmSessionFactory实例,代码如下： public static JbpmSessionFactory getInstance() { if (instance==null) { //假如Jndi名不为空 if (jndiName!=null) { try { // fetch the JbpmSessionFactory from JNDI log.debug("fetching JbpmSessionFactory from '"+jndiName+"'"); //实例化一个执行命名操作的初始化上下文 InitialContext initialContext = new InitialContext(); //从上下文中检索名字为jndiName的对象 Object o = initialContext.lookup(jndiName); //检查o是否可以强制转换为JbpmSessionFactory对象 instance = (JbpmSessionFactory) PortableRemoteObject.narrow(o, JbpmSessionFactory.class); } catch (Exception e) { throw new JbpmException("couldn't fetch JbpmSessionFactory from jndi '"+jndiName+"'"); } } else { // else there is no JNDI name configured // create a new default instance. log.debug("building singleton JbpmSessionFactory"); //假如jndi名为空,建立session工厂 instance = buildJbpmSessionFactory(); } } //返回session工厂实例 return instance; } JbpmSession就是对Hibernate的Session的封装,GraphSession这个是我们最长用到的session,流程定义的部署、查找流程定义、装载流程实例等等,特别的有用,那好,仔细的分析一下： 先来看看部署流程定义找个方法： public void deployProcessDefinition(ProcessDefinition processDefinition) { //获取流程定义的名字 String processDefinitionName = processDefinition.getName(); //流程定义有名字 if (processDefinitionName!=null) { //根据流程定义的名字来查找最后的流程定义 ProcessDefinition previousLatestVersion = findLatestProcessDefinition(processDefinitionName); // 假如有最后的流程定义 if (previousLatestVersion!=null) { //设置下一个流程定义版本号 processDefinition.setVersion( previousLatestVersion.getVersion()+1 ); } else { //假如没有流程定义,那么设置流程定义的版本号为1 processDefinition.setVersion(1); } //保存流程定义到Jbpm数据库 session.save(processDefinition); } else { throw new JbpmException("process definition does not have a name"); } } 在来看看findLatestProcessDefinition()这个方法： public ProcessDefinition findLatestProcessDefinition(String name) { ProcessDefinition processDefinition = null; try { //从hibernate.queries.hbm.xml中获取查询语句（hibernate.queries.hbm.xml封装了session的hql语句） Query query = session.getNamedQuery("GraphSession.findLatestProcessDefinitionQuery"); query.setString("name", name); query.setMaxResults(1); processDefinition = (ProcessDefinition) query.uniqueResult(); } catch (Exception e) { System.out.flush(); System.err.flush(); try { Thread.sleep(200); } catch (InterruptedException e1) { e1.printStackTrace(); } e.printStackTrace(); log.error(e); System.out.flush(); System.err.flush(); jbpmSession.handleException(); throw new JbpmException("couldn't find process definition '" + name + "'", e); } return processDefinition; } 其他的方法就不在多说,大同小异。 ContextSession只提供了两个构造函数。LoggingSession负责保存、加载、查询日志,来看一段代码,loadProcesslog()方法： public ProcessLog loadProcessLog(long processLogId) { ProcessLog processLog = null; try { //加载流程日志ID为processLogId的流程日志 processLog = (ProcessLog) session.load(ProcessLog.class, new Long(processLogId)); } catch (Exception e) { log.error(e); jbpmSession.handleException(); throw new JbpmException("couldn't load process log '"+processLogId+"'", e); } return processLog; TaskMgmtSession是一个查找、装载任务实例的session,对查找、装载任务实例提供了各种方法,方法与其他session的方法差不多,找里就不啰嗦了. 下面来看看HibernateHelper（Hibernate协助者）,该类里提供了对sessionFactory、configuration的一些操作,看一下clearHibernateCache（）方法的代码： public static void clearHibernateCache(SessionFactory sessionFactory) { //清除所有在查询缓冲区的查询结果 sessionFactory.evictQueries(); //获取从实体名到元数据对象的所有类元数据封装在一个Map里 Map classMetadata = sessionFactory.getAllClassMetadata(); Iterator iter = classMetadata.keySet().iterator(); while (iter.hasNext()) { String entityName = (String) iter.next(); log.debug("evicting entities "+entityName); //根据实体名字加载CLASS Class entityClass = ClassLoaderUtil.loadClass(entityName); //清除所有二级缓存的条目 sessionFactory.evict(entityClass); } //获取从collection名到元数据对象的所有连接元数据封装在以个Map里 Map collectionMetadata = sessionFactory.getAllCollectionMetadata(); iter = collectionMetadata.keySet().iterator(); while (iter.hasNext()) { String collectionName = (String) iter.next(); log.debug("evicting collection "+collectionName); //清除所有二级缓存的条目 sessionFactory.evictCollection(collectionName); } } JbpmNamingStrategy（jbpm命名策略类）是一个Jbpm命名的类,方法提供对属性,表,字段的命名...

相关推荐: jBPM4.0的用户指南（二） JBoss JBPM 实践系列（二）--- jbpm设计器的配置和使用 jBPM4.0的用户指南（一） jBPM4.0的用户指南（二） jBPM4.0的用户指南（一） JBPM4.0开发步骤 jBPM-4.0中文开发指南
推荐群组: JBPM @net
更多相关推荐
JBoss 第 3 章 流程设计器
这一章我们讲述了怎样使用流程设计器,在安装流程设计器和配置好例子之后,你会看到jPDL流程文件都有一个对应的特殊图标,在包的下面双击某一个这种图标文件,就会在流程设计器中打开一个jPDL流程文件。 流程设计器 图 3.1. 流程设计器 3.1. 创建一个新的流程文件 Ctrl+N将打开向导选择器。 选择向导对话框 图 3.2. 选择向导对话框 选择 jBPM --> jPDL 4 文件（File）. 点击下一步（ Next >）. 然后新的jPDL 4文件（New jPDL 4 File）,就会打开向导。 创建一个新的流程对话框
图 3.3. 创建一个新的流程对话框 选择上一级目录,输入一个文件名字并点击'完成'（Finish）,你便创建了第一个jPDL流程文件 3.2. 编辑流程文件的源码 直接编辑XML流程文件的源码,选择一个流程文件,右键并选择'打开为-->XML编辑器'（Open With-->XML Editor） 用XML编辑器打开流程文件
图 3.4. 用XML编辑器打开流程文件 你完成这些之后,eclipse就会记住这些设置,当你下次双击打开的时候,eclipse会自动使用XML编辑器打开你的流程文件。当你使用流程设计器打开流程文件时,可以使用同样的方式（Open-With-action）,但是要选择jPDL 4 编辑器（'jPDL 4 Editor'）。

ruby中没有什么值传递和引用传递的概念。在ruby中一切都是对象,而你向方法中传递的实质上是对象的引用（ object-reference）。ruby中变量都是对象的引用。
 
先来看
 
def pref2(agr)
agr.downcase
end

a2 = 'PREF2'
pref2(a2)
puts "#{a2}" #输出 PREF2
 
为什么调用了pref2后 a2还是大写的“PREF2”,看一下downcase的源码就不难发现问题了。
 

 
 
看到 str=rb_str_dup(str); 这句其实真相大白了,实际上dwoncase返回的是一个新的字符串,并不是你原来传进去的字符串对象的引用了。
所以经过了 pref2方法后,a2的值并没有发生改变。
 
 
再来看
 
 
def pref1(agr)
agr.downcase!
end
a1 = 'HELLO'
pref1(a1)
puts "#{a1}" #输出 hello
 
 为什么经过了pref1方法a1的值发生了变化。还是先来看看downcase！的源码

 
查看源码后发现传入的对象引用自始至终未被更改过,所以最终返回的还是a1的引用,所以a1对象的内容在dwoncase！方法中被改变了。
 
太晚了,明日继续后两个
 
 
 

相关推荐: rails c无法使用,checking for readline() in -lreadline... no Snow Leropard上编译ruby1.9.2 感觉ruby的环境好难搞啊 MAC OS 10.7安装xcode4.2失败的问题 mac os x lion 10.7 install xcode 3 (mac os c lion 10.7安装xcode 3) 10.7 安装 xcode 4.2失败的问题 Mac 10.7.*安装XCode3.2.6的方法 iphone lion10.7 安装 xcode3.2.5的方法
推荐群组: D语言
更多相关推荐
Ruby 没办法,系统和xcode是不能换的。我暂时有点晕。

相关推荐: NETBEANS的技术专题 关于Java的开发工具,到底应该长个什么样子？ Ruby IDE for NetBeans 可以用了 JAVA上百实例源码以及开源项目源代码 NetBeans有动态发布java代码的功能吗？ (转)Java IDE 之Netbeans篇 Eclipse,NetBeans及IntelliJ—Java IDE大战之IntelliJ IDEA篇 在Netbeans下开发Jboss-seam
推荐群组: 外包java
更多相关推荐
JBoss 前几天把自己做的一个系统整合到NetBeans里面去了。由于系统有jboss和tomcat这2个服务器,本来想直接把系统部署到jboss 4里面,后来发现我们这个系统这样做不合理,因为我们系统是要等jboss启动好了之后,再启动tomcat才能是系统正常跑起来。后来就分开发布到不懂的服务。把ejb发布到jboss,把action发布到tomcat,发布tomcat时采用netbeans的不打包成war的方式。整个系统跑起来之后,在netbeans里面修改jsp页面后,然后刷新系统,页面上也作了变动。但改了action的java代码后,然后去刷新系统,没有得到想要的结果。 在eclipse里面如果你改了action后,它会自动发布这个action,然后去用页面测试,是修改后的功能。 所以就想问下,netbeans带这个自动发布功能没有？ 我用的netbeans是M10最新版,eclipse是用的wpt形式

相关推荐: Tomcat5.5性能测试 详解用radrails调试rails应用程序 总结一下本学期读的书 Drools7_PDF教程 Drools中文文档 内容全面.zip Drools:规则流简介 基于 Jboss Drools 规则引擎开发框架 drools5.3 jboss 规则引擎入门eclipse IDE 环境搭建笔记 jboss规则引擎KIE Drools 6.3.0 Final 教程(1)
推荐群组: HTML5
更多相关推荐
JBoss  
规则流
作者： Kris Verlaenen
 
JBoss 规则引擎中已经加入了一个新的特性,允许用户建立一个流程图来定义规则集进行评估的顺序。本文列举一些怎样使用规则流的例子。规则流将在 Drools4.0 版本中发布,对此特别期望的用户可以在最新的 M2 , M3 版本中看到它。 JBoss 规则引擎已经提供了一些功能来定义规则的执行顺序,例如 salience 、 activation groups 等等。当处理海量的规则时,管理规则激发的顺序会变得很复杂。规则流允许你指定一个规则评估的流程。这允许你指定哪些规则应该按照先后顺序或并发的评估,指定规则评估的先决条件等等。这里有规则流的两个例子：
 

图 1: 图中的规则流显示了一个两个规则组简单的先后顺序执行流程,确认在处理订单之前要先对订单进行检查。
 

图 2: 更高级的规则流显示了并发、条件控制（例如处理订单的规则集只有在订单检查没有发现问题后才会执行）和循环的概念
JBoss 规则引擎 IDE 已经扩展以支持建立这些规则流：
* 有一个新的编辑器用来建立规则流文件（ *.rf ） , 如下图所示。当你保存 rf 文件时,一个关联的模型文件（ *.rfm ）文件也同时建立,它包含了规则流的定义信息。 Rf 文件包含了图形信息。
* 有一个新的建立规则流文件的向导
 
规则流定义可以被加入到 RuleBase ,与规则加入的方式几乎一样
// 建立 Package 包含所有规则
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new InputStreamReader(
getClass().getResourceAsStream( "rules.drl" ) ) );
final Package pkg = builder.getPackage();
// 建立一个包含规则流的过程
ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.addProcessFromFile(new InputStreamReader(
getClass().getResourceAsStream( "ruleflow.rfm" ) ) );
// 将包与过程加入 RuleBase
final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage( pkg );
ruleBase.addProcess( processBuilder.getProcesses()[0]);
// 为 RuleBase 建立一个新的 working memory
final WorkingMemory workingMemory = ruleBase.newWorkingMemory();
// 规则流可以通过 startProcess 开始执行
// 在这里增加需要设置到 working memory 中的元素 , 然后开始
// 规则流开始执行最初的规则集
workingMemory.startProcess(1);
使用规则流的更多细节会在不久被加入。
 

相关推荐: 总结一下本学期读的书 Drools4.0官方使用手册（中文） Drools高级技巧：Accumulate函数 [JBoss] JBoss Drools Business Rules (英文版) jboss drools 书籍源码 Mastering JBoss Drools 6 for Developers 无水印pdf 0分 Mastering JBoss Drools 6 Drools7_PDF教程 Drools中文文档 内容全面.zip
推荐群组: solr交流圈
更多相关推荐
JBoss
 
 
Drools 专家系统思维指导图
作者： Mark Proctor
当告诉人们关于 Drools4.0 的特性以及它们怎样工作时,我发现对于没有之前专家系统的经验的人很难进行理解。因此我想应该绘制一幅思维指导图,是否能够对这些高级特性有更好的理解。我找到了一个 GPL 版权的工具,叫做 FreeMind 。我使用的是 V9-Beta9 版本,它看上去已经够用了。

相关推荐: drools4: Conway示例分析 为何对于规则来说Java编码是不好的,而声明式编程是更好的选择 Drools 3.0官方使用手册第一章（中文） drools技巧：声明式关系编程 Drools 规则引擎----向领域驱动进步（五） 深入浅出JBoss Seam 21天通关Python（仅视频课）
推荐群组: OFBiz
更多相关推荐
JBoss  
声明式关系编程
作者： Mark Proctor
这篇文章是从我在 InfoQ 上的评论 Debate: ODBMS sometimes a better alternative to O/R Mapping? . （讨论： ODBMS 有时是比 O/R 映射更好的选择 ）引申而来
面向对象的深层图模型—— pojo 规范,难以通过声明进行推论,虽然它可以在命令式编程中有良好表现。随着 WSC 完成描述逻辑的标准化定义 OWL-DL （一种面向语义 Web 的知识表示标记语言 , 具有较强的知识表达能力并适合大规模应用的推理效率）并将其与声明式推论系统如 Drools 结合（将在 4.0 之后增加基于模型的描述逻辑）,你已经在应用开发方面有了一种更有力的方式（虽然可能没有框架式 / 子系统式开发）——不考虑 OWL-Full ,它是一种演习 , 并且 RDF （资源描述框架）三元组是不合适的 , 但可以幸运的被考虑成一种传输机制。声明式关系编程显然有一种更接近于 1 对 1 的数据库映射。 [ 译者注：这段话涉及 OWL 的理论定义,为了更好的理解,请翻阅 http://zh.transwiki.org/cn/owlguide.htm ]
看一个我们提供的简单示例 Conways Game of Life （将很快被更新到规则流,代替 agenda group ,使其更具有声明性）。在这个例子中,我们有一个巨大的 NxN 的表格单元对象,之前的方法是对每一格 Cell 有一个围绕在它周围的 Cell 的一个 HashSet 。要计算围绕在周围的死亡 / 生存单元格的数量,只能通过对每一个 cell 的 HashSet 进行命令式的迭代。这将产生重复多余的工作,因为我们不知道那里有 / 没有变化,我们可以进行跟踪,但是接着会带来更多的用于跟踪的命令式代码。更新的 Conways 例子将使用关系方法,没有嵌套的对象（虽然仍然没有 DL ,它在 4.0 中提供）,代替的是我们使用一个 Neighbour 类对每一个围绕的 Cell 进行双向的关联；这意味着我们简单的声明想要它对死亡 / 生存的 Cell 进行跟踪,系统将根据它对关系的理解以及什么有 / 没有变化的情况,为我们完成剩下的工作。
http://anonsvn.labs.jboss.com/labs/jbossrules/trunk/drools-examples/src/main/rules/org/drools/examples/conway/conway.drl
rule "Calculate Live"
    agenda-group "calculate"
    lock-on-active
when
    theCell: Cell(cellState == CellState.LIVE)
    Neighbor(cell == theCell, $neighbor : neighbor)
then
    $neighbor.setLiveNeighbors( $neighbor.getLiveNeighbors() + 1 );
    $neighbor.setPhase( Phase.EVALUATE );
    modify( $neighbor );
end
rule "Calculate Dead"
    agenda-group "calculate"
    lock-on-active
when
    theCell: Cell(cellState == CellState.DEAD)
    Neighbor(cell == theCell, $neighbor : neighbor )
then
    $neighbor.setLiveNeighbors( $neighbor.getLiveNeighbors() - 1 );
    $neighbor.setPhase( Phase.EVALUATE );
    modify( $neighbor );
end
我也建议你看一下 "register neighbor" 规则,你可以了解 Neighbour 关系怎样被设置声明,开发在 Cell 中的 column 与 row 字段的叉集。
这只是一个使用建议逻辑的简单例子,你可以将这些关系开发的更多,尤其工作在数据集和一阶逻辑中的 'collect', 'accumulate' , 'forall' 情况时。更多的信息请看 What's new in JBoss Rules 4.0 ,它会在下个月中旬发布。
 
 

相关推荐: Drools3.1M1 发布标注 Drools4.0官方使用手册（中文） drools 4.0M3发布标注 技巧： Drools中from,accumulate和collect之间的关联 Drools高级技巧：Accumulate函数 Drools Accumulate 语法解析及使用 Drools7中的万能函数accumulate drools技巧：声明式关系编程
推荐群组: solr交流圈
更多相关推荐
JBoss  
  'from', 'accumulate' 和 'collect' 之间的关联
作者： Mark Proctor
在 Drools4.0 中,我们介绍了‘ from ’关键字,它允许你为模式声明一个推论的来源。这允许引擎使用不在 Working Memory 中的数据进行推论。源数据可能是绑定变量的子字段,或者方法调用的结果；后一种方式提供了与 Hibernate 集成的方法（通过调用命名的查询）, Drools 将把返回的结果与模式统一为一体。
这里是一些简单的绑定子字段进行推论的例子 :
Person( personAddress : address )
address : Address( zc : zipcode == "23920W") from personAddress
利用 Drools 引擎提供的新的表示方法带来的灵活性,你可以用很多办法来解决这个问题。下面是同样的结果,但是用“ . ”来实现。
p : Person( )
address : Address( zc : zipcode == "23920W" ) from p.address
当然,我们也可以使用新的表达式语言扩展来完成 :
Person( zc : address.zipCode == "2392OW" )
下一个例子举例如何在一个 hibernate 查询结果上进行推论, Restaurant 模式将依次在每一个结果上进行推论和绑定。
p : Person( )
  Restaurant( food == p.favouriteFood )
                from hs.getNamedQuery( "list restaurants by postcode" )
                     .setProperties( [ "postcode" : p.address.zipcode ] )
                     .list()
'collect' 和 'accumulate' 在一个返回的对象上计算结果,这种模式可以指定‘ from’ 作为它的源。 'collect' 允许对集合推论并且返回对象列表。 'accumulate' 允许对集合中每一个数据项执行操作,匹配给定模式并且执行操作返回用户选择的对象——通常用来求和或汇总数据,当然也可以用来做更复杂的工作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 
 
示例将两个 from 连在一起使用。它绑定所有购买的每样东西（ item ）的价值都超过 10 元的 Customer （客户）, items 是 Customer 的字段,没有设置在 Working Memory 中。
c : Customer()
items : List( size == c.items.size )
      from collect ( Item( price > 10 ) from c.items )
这里的 List 是从 collect 产生的,其中有 size 的属性。
如果这里的 items 不是 Customer 的字段,但被设置到 working memory 中,我们可以使用一个相互关联的‘ collect ’模式。
  p : Customer ()
list : List()
      from collect ( Item( owner : p ) ) // 找到拥有者是 p 的所有 Item
items : List(size == list.size)
      from collect ( Item( price > 10 ) from list )
下面是如何使用 'accumulate' 达到同样的效果,它建立在 'count' 函数中；虽然这不与 'from' 举例关联,在这里将它做为一个补充。
  p : Person()
count : Number()
      from accumulate ( i : Item( owner == p ), count( i ) )
list : List( size == count )
      from collect ( Item( owner == p, price > 10 ) )
对于更复杂的情况——深奥但是更具说明性,我们可以看下面的‘ from ’例子。对每一个 Store （商店）,购物的 Person （顾客）有一个 account （账目）,我们返回 Person 在 Store 中所有购买的商品,并检查是否这些商品的价值平均超过 50 元的客户 Person 。
p : Person()
s : Store( accountOwner == p )
a : Number( intValue > 50 )
  from accumulate ( item : Item( )
                   from collect ( Item( store == s )
                                 from hs.getNamedQuery( "get user items in store" )
                                        .setProperties( [ "store" : s.name, "owner" : p.name ] )
                                        .list() ),
                   average( item.price ) )
因此对于那些 Rete 不能处理集合和嵌套或者 working memory 外的数据的说法,我希望这些可以让你改变想法。


 

相关推荐: 发现JBoss Seam很棒呀！有用Seam做过项目的吗？ 取舍于得失之间：权衡Java EE 5.0 & Seam & Spring & Yourself 我理想中的Seam Web应用 JBoss Seam 工作原理、seam和hibernate的范例、RESTFul的seam、seam-gen起步、seam组件、配置组件、jsf,jboss、标签、PDF、注解等等 开始关注JSF/Seam JSF/Seam资源收集贴 JBoss Seam without JSF Chapter 4. 设置 Seam 组件
推荐群组: JBoss SEAM
更多相关推荐
JBoss
        做基于Java技术体系的WEB应用系统有3、4年了,一直采用的是所谓的轻量级架构（如当下比较流行的SSH组合）,大部分原因是因为公司所面向的行业应用特点决定的,不需要分布式、大规模集群等,所以,对JavaEE的整个技术栈并没有一个完整清晰的认识。近期公司的项目不太忙,所以决定对JavaEE技术栈中的JSF、EJB3等技术进行一定的学习和研究。
         前几天一直在研究JSF,并且对我的技术偶像Gavin King领导开发的Seam框架进行了初步的了解。我的职业生涯是由作为一个Delphi程序员开始的,因此对于JSF的基于组件、事件驱动的思想并不陌生,浅尝之下,感觉还是相当不错的,学习曲线比较低,唯一的遗憾是XML配置工作量仍然蛮大。Seam框架在遵循JSF生命周期的基础上,对当前存在的JSF的一些弊病进行了很好的弥补,统一了JSF和EJB3的组件模型,并且提供了简化JavaEE应用开发的支持,值得去学习和研究。虽然部分我仰慕已久的业界前辈提出了对这个框架把应用状态放在服务器端进行管理的置疑,但是我感觉每种技术框架和体系总有其适用性,需要由实践和时间来检验,有些东西自己没有研究和验证过就永远理解不了。
        
        BTW,在javaeye上已经建立了一个 JBoss SEAM 圈子,研究SEAM框架本身、所涉及到的技术及其反映出的思想,希望有很多感兴趣的朋友一起来学习、研究。

相关推荐: Drools4.0官方使用手册（中文） drools 4.0M2发布标注 Drools3.1M1 发布标注 技巧：使用规则寻找最大值 面试笔试技巧 Linux 就该这么学 值得关注的开源软件推荐 我的Java开发学习之旅------>Java经典面试题
推荐群组: HTML5
更多相关推荐
JBoss  

使用规则寻找最大值		原文网址： http://wiki.jboss.org/wiki/Wiki.jsp?page=RulesFindMax

有时你可能想查找 fact 的最大值。你可以通过使用 not 实现这个目的,如下例所示（如果你喜欢也可以将它放在一个 Query 中）：
 
rule "Highest Temperature for a Day"
       when
               Day(highest : temp)
               not Day(temp > highest)
       then...
 
感谢 Mitch Christensen 提供建议 .
[ 译者注：
   这里为一些初学者解释一下上面规则的执行思路,在说明之前我们先回顾 Drools 中对于 Fact 匹配有一个原则：在没有限制条件的情况下,引擎寻找最大限度的组合
   回到规则分析,假设在 Working Memory 中设置了三个 Day 对象, temp 分别是 10 , 20 , 30 ；那么考虑一下规则引擎如何执行。
   首先规则的第一个条件是 Day(highest : temp) 没有对 Day 有过滤限制,则上面三个 Day 对象都会尝试激发 "Highest…" 规则。假设 Day(10) 先进入,则对第二个条件,因为 highest 是上一个条件传过来的变量,所以引擎会为 highest 和 temp 建立 3 种组合： [ Day(10) , Day(10) ] [ Day(10) , Day(20) ] [ Day(10) , Day(30) ], 显然后两种组合对于 not Day(temp > highest) 是不成立的。由此类推只有当 Day （ 30 ）尝试激发规则时才能满足两个条件。
]
Fact 的排序过程
类似的方法通常用来对一组关联的 fact 进行排序处理。例如,要按照 timestamp( 时间戳 ) 的顺序处理一组 Alert Fact ,你可以如下进行：
rule "Process Alerts by time received"
    when
        $alert : Alert($oldest : timestamp)
        not Alert(timestamp < $oldest)
    then
        // process the Alert in some application specific way
        $alert.process()
 
        // 必须将处理过的 Alert 从 Working Memory 中删除
        // 否则引擎不会对 Working Memory 中的 Fact 重新评估
        retract($alert);
end
该规则将按照 Alert 中的 timestamp 属性的早晚来依次进行处理,完成处理的 Alert 从 working memory 中删除,接着进行下一个的处理。
-Mitch Christensen
Mitch 提供的这种模式是最简单的但不是最有效率的。简单来说,如果有 1000 个 Day 对象在 Working Memory 中,则引擎要对 （ 1+2+…+1000 ）种组合进行判断（考虑到 Drools 引擎在碰到第一个不满足条件的组合时就会抛弃 Fact ）。显然在 Day 对象数量过于庞大时,这种判断方法会成为性能瓶颈。因此下面是改进后的判断最大值规则：
 
rule "Try day"
   when
       $d : Day($temp : temp)
   then
       assert(new TryDay($d));
end
 
rule "Highest unknown"
   when
       $attempt : TryDay($d : day)
       not (Highest())
   then
       assert (new Highest($d));
end
 
rule "Highest lower"
   when
       $highest: Highest($highDay : day)
       $attempt : TryDay($day : day -> ($day.getTemp() > $highDay.getTemp()))
   then
       $highest.setDay($day);
       modify($highest);
end
 
rule "Highest higher"
   when
       Highest($highest: day)
       $attempt : TryDay($day : day -> ($day.getTemp() <= $highest.getTemp()))
   then
       retract($attempt);
end
rule "Print highest"
   salience -10
   when
       Highest($day : day)
   then
       System.out.println("Highest day is " + $day);
end
Steven Williams
经过测试,当 Day 的数量为 1000 时, Mitch 的规则执行时间约 2000 毫秒,而 Steven 的规则为 223 毫秒；当 Day 的数量为2 000 时, Mitch 的规则执行时间约8 000 毫秒,而 Steven 的规则为 345 毫秒
更多关于查找最大值
“ 查找最大值 ” 的问题通常并不限制于对单个属性或字段进行比较。
 
当面对这个问题时,让我们概括它为“发现最好”或“发现最佳”的模式,这在现实中是非常有可能碰到的。如最好的投资机会,最好的网络节点,最好的保险策略等等。
这些问题有两个特点使得采用基于规则的方法具有吸引力。第一,当最好的标准经常发生变更时,规则允许我们在代码外对此进行调整 ( 例如：对于有小孩的家庭最好的新家不一定就是没有小孩家庭的最佳选择 ). 第二 , 最好的可能是复杂的事务 , 常常难以用语言捕捉,更不用说在程序开发语言中了。
Steven Williams 在上面提供的方案,一旦在碰到更多的判断属性时,当保持性能时,规则的规模将会增加的很快。
假设我们的任务不是仅仅发现最高的温度,而是有一个组合的温度——最高的温度与最高的 dewPoint 。

public class HeatRecord
{
    int temp;
    int dewPoint;
    .
    .
}
一个简单的解决方案可能是 :
rule "Filter" // 测试每一个,如果被另一个超越则删除
        salience 100
        when
               HR1 : HeatRecord($t1:temp, $d1:dewPoint )
               HeatRecord( temp > $t1 ) || HeatRecord( temp == $t1, dewPoint > $d1   )
        then
               retract( HR1 );
end
 
rule "Report" // 报告留下了什么
        salience 50
        when
               HR1 : HeatRecord( )
        then
               System.out.println("The Most Sweltering Conditions were: " + HR1.getTemp() +" "+ HR1.getDewPoint() );
end
 
如果我们试图使用 Steven Williams 提到的方法,它将会是多大？怎样维护？
想一想 ?
Mike Panihill
 

相关推荐: 规则引擎 大型企业信息化中的BPM和SOA实战 国内开源工作流 Fire Workflow 出炉了 精品文章翻译：在业务流程中绑定商业规则 值得关注的开源软件推荐 Java这十年 - 与Java相关的四十个名字 (2) 十大事件与Java相关的四十个名字
推荐群组: JBPM @net
更多相关推荐
JBoss
在业务流程中绑定商业规则 1
概要 1
JBoss 规则引擎 2
场景 2
定义Webservice 2
编写 WSDL 2
产生对象模型 5
编写商业规则 5
部署 6
增加库到Axis2 7
配置Janino编译器 7
打包Webservice 7
集成到商业过程 8
从过程到webservice的映射: 9
从过程返回借口的映射(send response): 9
测试 10
将来的考虑: 11
 详细内容见附件：
原文网址： http://bpms.intalio.com/content/view/121/87/

相关推荐: eclipse 常用插件 myeclipse 8.x 插件安装方法终极总结 让Myeclipse支持jQuery、Ext等主流框架自动完成、调试功能 Drools4.0在RAD7.0中的插件安装 HUDSON Plugins 插件按主题分类-简介 Hudson插件之按主题分类
推荐群组: Drools
更多相关推荐
JBoss

RAD70 Eclipse插件安装介绍

RAD7.0 Eclipse 插件（Drools4.0）安装介绍
 
1. 下载插件: http://download.jboss.org/jbossrules/release/4.0.0.11754MR2/jbossrules-4.0.0.11754MR2-eclipse.zip
2. 如果 RAD 7.0运行中,请先停止.
3. 解压下载文件到临时目录,并拷贝:
\features\org.drools.eclipse.feature_4.0.0.11754MR2 -> IBM\SDP70\features
\plugins\org.drools.eclipse_4.0.0.11754MR2.jar -> IBM\SDP70\plugins
3. 启动RAD 7.0
4. 插件特性默认显示。打开菜单: "Help/Software Updates/Manage Configuration" 点击按钮"Show disabled features" 然后启用它
5. 需要再次重启RAD 7.0.
6. 完成!
注意插件和规则引擎都运行在JDK1.4上,只有BRMS 需要Java 5.

相关推荐: Tomcat5.5性能测试 总结一下本学期读的书 详解用radrails调试rails应用程序 JBoss Drools 4.0 发布 基于 Jboss Drools 规则引擎开发框架 jboss drools basic requirements with maven； drools 所需基本依赖 开源规则引擎 Drools 4.0 发布 jboss规则引擎KIE Drools 6.3.0-集群篇
推荐群组: 奋斗教育
更多相关推荐
JBoss  

4.0.0 .MR3ReleaseNotes

API/ 语言变更
assert 将变成 insert 为了避免常数关键字与“ assert ”发生冲突,绝大多数语言都支持 insert 将在 drl 和 working memory api 中一起改变
modify 变成 update workingMemory.modify( FactHandle? , Object) 将被 workingMemory.update( FactHandle? , Object) 代替,在 drl 中将 modify 改为 update 这个方法现在仅用于阴影对象,它用来让引擎知道一个扩展对象已经被更新,并且在内部缓存中更新它。 避免关键字冲突,在 MVEL 中使用了 modify 。
insertObject (assertObject), retractObject 和 updateObject 变成 insert, retract and update Object 部分看起来是多余的,应该删除它,特别是我们开始支持无对象的 fact 类型。 Drl 和 working memory api 将会使用同样的函数名称
增加新的 WorkingMemory 的 modifyRetract 和 modifyAssert 方法 允许非阴影 fact 对象 当不使用阴影 fact （虽然将和阴影 fact 一起工作）,你不能调用‘ update ’或者过去称为“ modify ”,因为我们需要知道字段的旧值,这样我们可以从 working memory 中移除它。仅有的安全办法是首先删除对象,然后设置它。无论怎样,使用这样的 api 为新的 fact 处理增加了额外的工作和结果。 modifyRetract 和 modifyAssert 现在可以一起用来模仿在非阴影 fact 对象上的修改,分两个步骤。首先调用 modifyRetract 改变字段的值,然后调用 modifyAssert 。 MVEL 有好办法做这个： modify ( person ) { age += 1, location = "london" }, 这里实际发生的事情是首先调用 modifyRetract 然后通过 Set 方法改变属性值,接着调用 modifyAssert 。
核心与编译器
JBRULES-231 – 增加 "not contains" 和 "not matches" 约束,以支持加入语言中的相应操作。
JBRULES-315 – 支持符号和嵌套的存取,如下：
Person( address 'business'? .phone [0] .areaCode == $country.area 'south'? .code )
JBRULES-500 – “ || ”逻辑连接符现在可以在字段以及任何表达式嵌套级别中使用。例： : Person( ( age ( > 20 && < 30) || (>40 && <50) && location=="atlanta" ) || ( age > 20 && location=="Seatle" ) || location == "Chicago" )
JBRULES-585 – 在一个已绑定 Fact 中绑定字段的语法糖
JBRULES-662 – 使 TMS 可选
JBRULES-866 – 允许绑定变量到被使用的字段约束
JBRULES-874 – 允许对绑定变量的直接属性存取。这避免了还需要绑定到变量自身的字段。当然也仍然允许对字段进行绑定。如： c: Customer() p: Person(customerId == c.id)
JBRULES-708 – 完全的 MVEL 集成, MVEL 现在完全集成到引擎中,并且能够被所有条件元素调用,这允许客户的代码也在规则的推论中。
JBRULES-713 – 可插入方言。我们有两个正式支持的语言： Java 和 MVEL ,但是用户现在可以加入他们自己的语言,通过实现相关的构建器。
JBRULES-875 – 动态优先级引擎支持。现在通过使用一个包含字段和模式绑定的表达式支持动态优先级。意味着规则可以基于匹配它的数据进行优先级划分。
JBRULES-895 – 更好的属性集支持引擎。现在支持链接属性的配置文件,并且自动调用默认的配置
JBRULES-900 – 允许用参数表示查询
JBRULES-916 – 建立一个新的规则名称 Agenda 过滤器,使用正则表达式进行过滤
JBRULES-917 – 允许查询参数指定类型
JBRULES-922 – API 变更。将“ assert ”改为“ insert ”,“ modify ”改为“ update ”,避免与语言关键字冲突。
JBRULES-925 – 在 Accumulate 条件元素中支持 MVEL ,允许使用 MVEL 编写用户的代码块。
JBRULES-927 – 移植 java 语法到版本 5 。使用 Java5 的语法解析器
JBRULES-930 – 阴影 Fact 现在是可选的,允许在类级别上关闭。
JBRULES-880 – 更新 XML 组件处理 4.0 语言变化
JBRULES-935 – 更新 DrlDumper 以处理新的 DRL 导出器特性, XML 解析器和 XML 导出器现在被更新到 4.0 语言特性。
JBRULES-936 – 增加 CE 集合处理能力。提供更好的执行性能。
JBRULES-941 – 增加插件化的集合功能支持。更多的细节在 : http://markproctor.blogspot.com/2007/06/accumulate-functions-edson-tirelli.html
JBRULES-214 – 减少了关键字冲突,关键字冲突被缩小到最小的范围内
JBRULES-908 – 依照 ANTLR 顾问的推荐, DRL 语法器被整理和增强,允许更好的执行性能与错误处理,也在 IDE 中支持 .
规则流 在（ X ） OR 分开的部分中支持约束 支持循环 在 Working Memory 中的监听支持 对 Working Memory 事件的审计支持 IDE 增强 对齐网格 更多高级的路由层 约束编辑器包括语法着色和代码补齐 当建立时可能包括简单的规则流和装载者 新的规则项目
IDE 增强 : 在构建器中支持 *.package 文件 审计视图支持规则流 对 core / compiler API 改变的更新 新的导航编辑器

相关推荐: Drools4.0官方使用手册（中文） Lucene-2.0学习文档（１） FCKEditor使用说明 drools 4.0M2发布标注 Drools4.0官方使用手册中文 Drools3.1M1 发布标注 25个让Java程序员更高效的Eclipse插件
推荐群组: GT-Grid
更多相关推荐
JBoss  

Drools 4.0.0 .MR2ReleaseNotes

引擎
规则流程
现在可以使用 Eclipse GUI 建立规则流程,并且保存为一个文件,这些文件然后可以用来控制规则的执行流程：
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream( "ruleflow.drl" ) ) );
final Package pkg = builder.getPackage();
final ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.addProcessFromFile( new InputStreamReader( getClass().getResourceAsStream( "ruleflow.rfm" ) ) );
 
final RuleBase ruleBase = getRuleBase();
ruleBase.addPackage( pkg );
ruleBase.addProcess( processBuilder.getProcesses()[0] );
通过执行执行应用过程来激活规则流：
workingMemory.startProcess( processId );
使用规则流分组属性指定规则属于哪一个规则流分组
该插件产生两个版本的规则流： *.rf( 规则流文件 ) 包含完整的规则流,包括所有的图形信息如所有元素的坐标 *.rfm 版本（规则流模型文件）只包含规则流的定义,没有图形信息
当增加规则流到 ProcessBuilder 中时需要使用 *.rfm 格式的文件,如果使用 *.rf 文件会引起异常“ CannotResolveClassException ”,因为该类中包含的图形信息不是 Drools 核心的一部分,不能被识别。
lock-on-active
一旦 agenda-group 或 rule-flow-group 开始激发它的规则,它不能接受指定 lock-on-active 属性设置为 True 的规则的任何更多的新事务,这有助于处理递归情况。
WorkingMemory 现在分成 StatefulSession 和 StatelessSession
WorkingMemory wm = ruleBase.newWorkingMemory()
WorkingMemory 现在删除了,代替的是 :
StatefulSession session = ruleBase.newStatefulSession();
StatelessSession session = ruleBase.newStatelessSession();
异步方法
StatefulSession 和 StatelessSession 都支持异步方法对于 working memory 的动作和 fireAllRules 。使用 DefaultExecutorService 处理线程模型,它仅仅是建立一个新的模型。一个自定义的 ExecutorService 能够同通过使用 RuleBaseConfiguration 指定。
更简单的依赖
对于 core 和 compiler 的额外的依赖已经被消减。
stateful conways game of life
Conway's Game of Life 示例被更新,现在是完全状态的,这是最好的用来理解规则引擎的例子。
DSL 的重新介绍 新的改良的规则,完全的国际化支持（能够将 LHS 和 RHS 混合,甚至关键字的重定义）
新的操作 : "in", "not in", "memberOf", "not memberOf" 示例 :
Cheese( type in ( 'stilton', 'brie' ))
Cheese( type not in ( 'stilton', 'brie' ))
Cheese( type memberOf $myCheeseTypeList )
Cheese( type not memberOf $myCheeseTypeList )
新的自动的有益字段 : “ this” 现在可以用来作为约束 fact 的一个字段。 现在你可以对 fact 的相等比较如下 :
rule "keeps consistency"
when
$r : Relationship( $s: source, $t: target )
not( Source( this == $s ) )
then
retract( $r );
end
Fact 不再需要默认的构造函数 阴影 Fact 不再需要实现一个默认的无参数构造函数。它们现在也缓存 hashcode 以提高性能。
对断言和返回值的隐式绑定 在断言和返回值中不再需要显式的绑定字段
Cheese( oldPrice : oldPrice, newPrice == ( oldPrice * 1.10 ) )
等同于 :
Cheese( newPrice == ( oldPrice * 1.10 ) )
因为 oldPrice 已经被用户在断言返回值中隐式声明
BRMS
BRMS ( 商业规则管理系统 ) 作为里程碑的一部分第一次可用了。这个组件有许多特性,这里只是简单的进行介绍（示例和手册在准备中）
Installation 安装
BRMS 应用是一个 war 文件,这意味着要部署它只需要简单的将它放到部署目录下（如果你愿意使用默认设置,这是所有你需要做的）
The BRMS application itself is a war file, this means deploying it can be as simple as dropping it into an deploy directory (if you are happy with defaults, thats all you need to do)
使用方法
Package 配置 一旦部署,使用 "http:///drools-jbrms/" 访问 这将显示初始信息屏幕 如果是第一次运行,你将进入“ Admin ”,并且选择“ Manage Categories ” 按你的意愿增加一些目录,它仅仅用于分类,而不是执行或任何其它用途 规则需要 Fact 模型（对象模型）来工作,因此下一步你将需要去到 Package 管理特性。从这里你可以点击图标增加一个新 Package 。 为了装载一个模型,使用一个带有 fact 模型（ API ）的 jar 文件,你将使用在你的规则和代码中。然后点击装载新模型图标。当你在模型编辑界面时,你可以装载一个 jar 文件,从列表中选择之前你建立的 Package 名称。 现在修改你刚刚建立的 Package 配置,以导入你刚刚装载的 fact 类型,并且保存更改。 这时, Package 配置好并准备使用
规则编制 一旦你设置好至少一个目录和一个 Package ,你可以开始编制规则 有许多种规则的格式,但从 BRMS 的角度来说,它们都是“ assets （资产）” 你通过点击规则图标（在上面）建立规则,并且输入规则名称 你将不得不选择一个目录。目录提供一个观察规则的视图,将规则分开到 Package 中（你可以将规则显示在多个 Package 中）,想象它们像标记一样 选择“商业规则”格式 这将打开一个规则建模器,它是一个导航编辑器。你可以在当前使用的 package 的模型上增加和修改条件和行为。当然,任何为该 Package 设置的 DSL 语法模板将有效。 当前值得注意的规则格式是： DSL 模板规则,它是一个文本格式,能够通过在 Package 中定义的 DSL 配置使用自然语言 同样也有旧的无格式的 drl ,对于“技术”规则——这些可以是单个规则（仅仅包含 when 和 then 部分就是全部所需）或者许多规则的整体,像你可能在过去看到的（你不需要任何 import 或其它依赖,它们在 package 中被关注）。注意,如果规则名称没有被 drl 包括,它将使用 ”assert 资产 ” 的名称 你也可以装载 XLS 决策表。建立一个基于决策表的新的表格,然后装载,默认它与一个模板一起提供,你可以下载并整理它。 当你完成了规则的编辑,你可以保存变更,或者你可以验证或“查看源码”（对有效的源代码）。 你也可以从这里增加 / 删除目录和其它属性,如文档（如果你不确信要做什么,使用自然语言编写一个文档描述规则,然后导入它,这在后面也可以作为一个模板）。
发现素材
在导航的时候,你也可以使用规则特性,它显示被目录分组的内容,或者你可以使用 Packaget 特性 , 通过 Package 和规则类型查看。如果你知道一个 asset 资产的名称的一部分,你也可以使用查找器,开始输入一个规则名,它将返回所有匹配你输入的名称的 asset 列表（因此如果你有一个明智的命名规则,可以很快地发现素材）。 目录能够像标签那样使用,你可以增加和删除它们,例如标记某些是脏的,这完全取决于你 你也会注意到任何东西有一个状态,这也仅仅用来报告（如果你想可以选择忽略它）。
部署 在你修改了一些 Package 中的规则后,你可以去到 Package 特性,并且构建整个 Package 如果成功,你将能够下载一个二进制的 Package 文件,它可以用来部署到运行时系统中 你也可以取一个 Package 的快照进行部署。这个快照在那一点上冻结了 Package ,这样任何并发的改变不会影响这个 Package 。它也使得 Package 在一个 URL 上可见 "http:///drools-jbrms/org.drools.brms.JBRMS/packages/ /"
配置 ( 可选 ) 默认情况下,当库第一次运行时,它将在服务运行的目录中建立一个新的数据库：这由一个 "repository.xml" 和一个称为 "repository" 的目录组成。 如果你想将库放在不同位置,你可以解压 war 文件,查找 "components.xml” 文件。在那里你可以看到如何更改库的根路径到其它目录（或文件系统） 如果你想使用不同的 RDBMS 保存库内容,那也可以在配置中设置 一个简单的方式是启动库,并且让它产生一个默认的 "repository.xml" 。 然后修改 "repository.xml" 以使用你选择的数据库。
BRMS 使用 Apache Jackrabbit JCR 实现作为内容存储,它有 " PersistenceManagers " 的概念,这些 PMs 支持所有在 sun 下的数据库（你也可以使用文件系统）。了解更多关于为你的环境配置 PM 的问题,请浏览 Apache Jackrabbit: http://jackrabbit.apache.org/faq.html （在 repository.xml 已经带有一些示例） 重点注意：如果你使用一个扩展的 RDBMS ,那么所使用的许可应当可以建立表（至少第一次,当库进行自设置时）
需求 一个应用 Server/Servlet 容器能够与 Java5 一起工作,不需要和 JEE5 ,只要 Java5 运行时即可 这一限制在 Boss AS 4.0.5 和 JBossWeb 1.0.1 上会主动检查,但是可能在 Tomcat 和其它容器中可以工作（可能有新增 / 删除的依赖在 war 文件中） 没有扩展数据库的需要,但可以根据需要配置一个
 

相关推荐: 技巧：使用规则寻找最大值 Drools4.0官方使用手册（中文） drools 4.0M2发布标注 基于 Jboss Drools 规则引擎开发框架 jboss drools basic requirements with maven； drools 所需基本依赖 jboss规则引擎KIE Drools 6.3.0-集群篇 JBoss Tools 3.1 M3发布 jboss规则引擎KIE Drools 6.3.0 Final 教程(1)
推荐群组: 奋斗教育
更多相关推荐
JBoss  

Drools 3.1M 1 ReleaseNotes

语言增强
新的条件元素 : 'from', 'collect', 'accumulate', 'forall'
'from' http://jira.jboss.com/jira/browse/JBRULES-341
'from' 允许引擎对不在引擎之中的数据进行推论,这可以通过使用全局变量与数据提供服务进行交互,如 Hibernate 。 MVEL 为此提供脚本语言,任何之前绑定的变量可以用在 MVEL 表达式中。接下来的例子显示一个 Hibernate 命名的查询使用一些虚拟的属性,返回一个餐馆列表。 Restaurant() 是标准的模式,能够像其它模式一样拥有自己的字段约束和绑定。
    $r : Restaurant( $postCode ) from hbSession.getNamedQuery( "some query" ).setProperties( [ key1 : value2, key2 : value ] ).list()
collect http://jira.jboss.com/jira/browse/JBRULES-486
'collect' 允许在数据集上进行推论 a
rule "Collect Test" salience 70
    when
        $person       : Person( name == "Bob", $likes : likes )
        $cheeseList   : ArrayList(size > 2) from collect( Cheese( type == $likes ) );
    then
        results.add($cheeseList);
end
accumulate http://jira.jboss.com/jira/browse/JBRULES-337
'accumulate' 是 collect 的更强大的版本,它能够用来承担集合操作,如 sum 或 total
 
rule "Accumulate with Bindings" salience 90
    when
        $person       : Person( name == "Bob", $likes : likes )
        $totalAmount : Integer() from accumulate( $cheese : Cheese( type == $likes ),
                                                  init( int total = 0; ),
                                                  action( total += $cheese.getPrice(); ),
                                                   result( new Integer( total ) ) );
    then
        results.add($totalAmount);
end  
forall http://jira.jboss.com/jira/browse/JBRULES-218
'forall' 允许规则在引擎中所有的值都是真时激活
 
 
rule "test nested CEs"
        when
            forall( State( $state : state ),
                    Person( status == $state, $likes : likes ),
                    Cheese( type == $likes ) )
        then
               results.add("OK");             
end
完全支持一阶逻辑 : 元素的嵌套完成 http://jira.jboss.com/jira/browse/JBRULES-218
You can now nest 'and' and 'or' inside 'not' and 'exists'.
rule "test nested CEs"  
  when
      not ( State( $state : state ) and
            not( Person( status == $state, $likes : likes ) and
                 Cheese( type == $likes ) ) )
  then
    results.add("OK");    
end
支持多个约束条件的逻辑组合 http://jira.jboss.com/jira/browse/JBRULES-216
“ & ”和“ | ”现在可以使用在模式中。它们的行为是不同的,因为它不会导致产生子规则。
 
rule "& operator with ! and strings"
    when      
    $person : Person( hair != "blue" & != "purple", age > 30 & < 40   )        
    then
        list2.add( $person );
end   
 
rule "| operator with == and strings"
    when      
    $person : Person( hair == "blue" |   == "purple",    age < 30 )       
    then
        list3.add( $person );
end   
解析器增强 :
解决关键字冲突 http://jira.jboss.com/jira/browse/JBRULES-214
对断行的更好支持 http://jira.jboss.com/jira/browse/JBRULES-269
支持字符串中的 Escaped 字符 http://jira.jboss.com/jira/browse/JBRULES-519
原型支持 : 不再需要自动封箱 / 拆箱 http://jira.jboss.com/jira/browse/JBRULES-527
原型现在可以直接使用,允许更容易的维护规则以及更好的执行性能
 
模板支持 : http://jira.jboss.com/jira/browse/JBRULES-330
现在可以使用 Fact 模板,允许你在自己的 DRL 中定义 Fact ,并在规则中使用,而不需要一个 POJO 。
 
template Cheese
    String   name
    Integer price
end
 
rule "Match Stilton"
  when
      $stilton : Cheese( name == "stilton" )
    then
      $stilton.setFieldValue( "price", new Integer( 200 ) );
      list.add( $stilton );
end   
支持额外的断言语义： http://jira.jboss.com/jira/browse/JBRULES-556
在变量绑定之后,你不再需要使用“ ->” 语法标记。现在断言只要在逗号后面简单的使用一个相等 / 不等判断表达式,引擎会自己找到它需要的变量,
Pattern( $var1 : attr1, $var2 : attr2, ( $var1.blabla() != $var2.xyz() ) )
核心增强 :
阴影 Fact: http://jira.jboss.com/jira/browse/JBRULES-44
现在阴影 Fact 允许系统在多线程环境下工作,并且在引擎外面对 Fact 进行改变。每一个值都被隐藏在引擎中,只有在一个“安全点”才更新。因此不用再危及引擎的完整性。
支持在相同对象的字段之间进行约束判断 http://jira.jboss.com/jira/browse/JBRULES-515
之前绑定的变量只能用在下一个范式中,现在它们可以在定义的范式中就使用。
执行性能增强 http://jira.jboss.com/jira/browse/JBRULES-484 http://jira.jboss.com/jira/browse/JBRULES-498 http://jira.jboss.com/jira/browse/JBRULES-526
JBoss Rules 比之前更快,使用更少的内存。
为执行性能特殊化的“ exists ”节点 http://jira.jboss.com/jira/browse/JBRULES-547
传统的 Rete 系统为 exists 实现两个 Not 节点,我们发现使用一个专门的 Exists 节点可以增强性能并使得 Rete 网络更简单。
IDE 摘要
IDE 现在支持调试规则：断点可以加在 Drl 文件中规则的右手边（推论）以及函数中。无论何时在调试中遇到规则断点,相应的规则被显示,你可以单步调试。规则调试与 Java 调试完全集成,这样同时可以使用两者。
一个新的规则视图允许你可以同时对所有在工作空间中的规则,函数,查询和全局变量做一个快速浏览。你也可以通过选择一个元素然后双击来快速浏览它们。
支持新的语言特性（像 from,collect,accumulate ）,并且 IDE 也已经更新以支持所有内核改变。并且不断改进和更好的调整其它的功能,如对大纲和规则视图提供过滤器,（可配置的）解析器结果缓存等等
注意
M1 版本有一个遗留问题将在 M2 版本解决 http://jira.jboss.com/jira/browse/JBRULES-675 在 BetaNode 节点直接的节点共享问题
 

相关推荐: 规则引擎实现探讨 规则引擎 DROOLS语法详解 [JBoss] JBoss Drools Business Rules (英文版) Drools3.0特性简表 jboss drools 书籍源码 Mastering JBoss Drools 6 for Developers 无水印pdf 0分 Mastering JBoss Drools 6
推荐群组: Drools
更多相关推荐
JBoss

Drools 3.0 特性列表

核心规则引擎特性——JBoss规则引擎实现的这些特性能够使用JBoss规则语言表达。 完全的Rete算法实现,高性能索引和优化 作为另一种选择,一个完整的Leaps算法实现 字段约束 字符串,绑定变量,返回值和断言约束 条件元素 And ,Or,Not,Exists和Eval Agenda 议程管理 冲突解决方案（优先级+深度算法） Agenda 议程组 Agenda 议程过滤 递归的无循环管理 真值维护与逻辑断言 临时规则——允许规则基于时间需要激发 动态增加和删除规则 完整的事件模型 执行审计日志 功能 全局数据 Working Memory 工作内存查询支持 语言独立引擎 Drools 是接口驱动的,使用规则程序集API构造规则 基于中间层字符表达,API 编制——Drools规则语言支持所有所有以前提到的特性,并且使用Java表达字段约束,功能和推论；其它的语言,如Groovy将最终作为Java的另一种选择加入。Drools规则语言提供可扩展性,通过属性映射文件,支持自然语言。标准DRL和扩展的自然语言都被JBoss规则工作台支持。DRL文件能够从Excel和Open Office决策表中产生。 Drools 规则语言 扩展自然语言 决策表 Excel ,Open Office,CSV JBoss 规则工作台IDE特性 语法着色 内容助理 大纲视图 调试视图 WorkingMemory ,Globals,Agenda,Execution Audit（执行审计） 新的规则向导 基本规则检查和错误报告 部署 动态运行时编译与使用 预编译规则集

相关推荐: Drools 3.0官方使用手册第四五章（中文） Drools 3.0官方使用手册第三章（中文） Drools3.0官方使用手册第三章（中文） Drools4.0官方使用手册中文 Drools 7.4.1.Final参考手册（十四）集成Spring drools。drools_使用Drools和JPA进行连续的实时数据分析 Drools 7.4.1.Final参考手册（八） 规则语言参考 Activiti 5.16 用户手册
推荐群组: HTML5
更多相关推荐
JBoss
第六章.  Java 规则引擎API 2
6.1. 简介 2
6.2. 如何使用 2
6.2.1. 创建与注册RuleExecutionSet 2
6.2.2. 使用有状态和无状态RuleSession 4
6.3. 参考书目 6
第7章. 性能调整 7
7.1. 性能考虑 7
7.1.1. Beta Node Memory Indexing（节点内存索引） 7
7.1.2. 索引性能调整 9
7.1.3. 大型Ruleset 10
第8章. 示例 14
8.1. 获得示例 14
第9章. 部署与测试 14
9.1. 部署选项 14
9.1.1. 可发布对象RuleBase, Package 等 15
9.1.2. 部署模式 16
9.1.3. Web Services 19
9.1.4. 未来的期望 20
9.2. 测试 20
9.2.1. 测试框架 20
9.2.2.规则的集成测试框架 20
第10章. 论文 22
10.1. Manners小姐和基准分析（Benchmarking） 22
10.1.1. 介绍 22
10.1.2. 深度研究 25
10.1.3. 结论 32
10.1.4. 输出摘要 33
 以上为章节内容,详细内容见附件。
相关文章：
Drools3.0官方使用手册第四五章（中文）
Drools 3.0官方使用手册第三章（中文）
Drools 3.0官方使用手册第二章（中文）
Drools 3.0官方使用手册第一章（中文）

相关推荐: Drools3.0官方使用手册六~十章完（中文） Drools 3.0官方使用手册第三章（中文） JBossRulesUserGuide 主要部分的翻译 [JBoss] JBoss Drools Business Rules (英文版) jboss drools 书籍源码 Mastering JBoss Drools 6 for Developers 无水印pdf 0分 Drools7_PDF教程 Drools中文文档 内容全面.zip 基于 Jboss Drools 规则引擎开发框架
推荐群组: HTML5
更多相关推荐
JBoss
第四章. 决策表 2
4.1. 在电子表格中的决策表 2
4.1.1. 何时使用决策表 2
4.1.2. 概述 2
4.1.3. 决策表如何工作 4
4.1.4. 关键字和语法 7
4.1.5. 基于决策表建立并集成电子表格 11
4.1.6. 在决策表中管理商业规则 12
第五章. 规则工作台 (IDE) 13
5.1. 简介 13
5.1.1. 特性概要 13
5.1.2. 建立规则项目 14
5.1.3. 新建规则向导 15
5.1.4. 规则编辑器 17
5.1.5. 视图 19
5.1.6. 领域规范语言DSL 22
5.1.7.  Rete 视图 24
5.1.8. 大容量DRL文件 25
5.1.9. 调试规则 26
 以上为章节内容,详细内容见附件。
相关文章：
Drools 3.0官方使用手册第三章（中文）
Drools 3.0官方使用手册第二章（中文）
Drools 3.0官方使用手册第一章（中文）

相关推荐: 详解spring事务属性 编程使用Spring事务管理,图解事务传播行为 DAO设计模式和事物处理 Java笔试题含答案 SUN Solaris　问题小结 Java面试笔试题大汇总(最全+详细答案) webmagic采集CSDN的Java_WebDevelop页面 java 面试
推荐群组: struts2
更多相关推荐
JBoss 做一个小项目,经验较浅。使用jboss 4.0,EJB3.0,数据库：Oricla 9i,事务全在业务代码中控制,数据库层不管事务。问题描述：进行一个复杂操作,jboss 默认5分钟事务超时了,引起操作中断,数据库回滚了,但业务代码中并没有对此操作做事务控制。是不是由此可以得出,jboss当遇到事务超时时会自动将数据库回滚？还是在什么地方可设置？ 非常感谢有人能回复一下,谢谢！

相关推荐: Seam生命周期 JBOSS 5.0.0GA 下开发JSF 的注意 发现JBoss Seam很棒呀！有用Seam做过项目的吗？ 在JBoss4.2.0GA中配置JSF+EJB3遇到的问题 JBoss7配置指南 JBOSS4,JBOSS5和JBOSS6各主要版本特性 \(^_^)/ Jboss资料
推荐群组: JSF
更多相关推荐
JBoss JBoss启动时总是报类转换异常org.jboss.web.jsf.integration.config.JBossJSFConfigureListener..之前在Tomcat下部署都是成功的,竟然在JBoss下报这个错误...在google上搜了半天也没有找到答案..最后在JBoss的论坛上面看到有人提到此问题..原来是JSF1.2参考实现的问题.JBoss和Sun的实现各不相同,就造成了上面的类转换异常..于是换下原来Sun的实现,在%JBOSS_HOME%/server\default\deploy\jboss-web.deployer\jsf-libs下拷贝出JBoss的JSF实现..启动服务器,成功!!环境:JBoss4.2.0GA、JSF1.2、Tomcat6.0.13

相关推荐: netbeans + jboss4.X 集成开发碰到的问题 jboss seam 2.0beta1的常见bug列表及解决（持续更新） Seam生命周期 JBoss Forge NetBeans集成–入门 在Netbeans下开发Jboss-seam 使用netbeans部署到jboss4.2时的问题 卸载NetBeans7.3.1出错
推荐群组: JBoss SEAM
更多相关推荐
JBoss 我在netbeans中添加Jboss服务器时,在第2步骤选择服务器位置后无法选择“下一步”。jboss已经能够运行。

相关推荐: Drools3.0官方使用手册第三章（中文） Drools 3.0官方使用手册第四五章（中文） Drools3.0官方使用手册六~十章完（中文） Drools4.0官方使用手册中文 drools。drools_使用Drools和JPA进行连续的实时数据分析 Drools 7.4.1.Final参考手册（八） 规则语言参考 Activiti 5.16 用户手册 Java高手真经. 高级编程卷：Java Web高级开发技术：EJB+消息通信+分布式+开源框架...
推荐群组: Drools
更多相关推荐
JBoss 第三章. 规则语言... 23.1. 概述... 2 3.1.1. 规则文件... 2 3.1.2. What makes a rule. 2 3.1.3. 领域语言 Domain Specific Languages. 3 3.1.4. Reserved words. 3 3.2. Comments 注释... 4 3.2.1. 单行注释... 4 3.2.2. 多行注释... 4 3.3. Package 包... 4 3.3.1. import 导入... 5 3.3.2. expander 扩展... 6 3.3.3. global 全局变量... 6 3.4. Function 函数... 6 3.5. Rule 规则... 7 3.5.1. Left Hand Side 左手元... 8 3.5.2. The Right Hand Side 右手元... 9 3.5.3. Rule Attriutes 规则属性... 9 3.5.4. Column. 11 3.5.5. Conditional Elements 条件元素... 18 3.5.6. 对原型数据自动封箱的提醒... 22 3.6. Query  查询... 22 3.7. Domain Specific Languages 领域语言... 24 3.7.1. 何时使用DSL. 24 3.7.2. 修改与管理 DSL. 24 3.7.3. 在规则中使用DSL. 26 3.7.4. 增加facts的约束条件... 27 3.7.5. 怎样工作... 28 3.7.6. 从头开始建立DSL. 28 3.8. XML 规则语言... 29 3.8.1. 何时使用XML. 29 3.8.2. XML格式... 30 3.8.3. 遗留的Drools 2.x XML 规则格式... 33 3.8.4. 在XML 和DRL格式之间自动转换... 34 以上为章节内容,详细内容见附件。 相关文章： Drools 3.0官方使用手册第二章（中文） Drools 3.0官方使用手册第一章（中文）

相关推荐: 总结一下本学期读的书 FCKEditor使用说明 Drools4.0官方使用手册（中文） Drools4.0官方使用手册中文 drools。drools_使用Drools和JPA进行连续的实时数据分析 Drools 7.4.1.Final参考手册（八） 规则语言参考 Activiti 5.16 用户手册 Java高手真经. 高级编程卷：Java Web高级开发技术：EJB+消息通信+分布式+开源框架...
推荐群组: HTML5
更多相关推荐
JBoss
第三章.  规则语言 ... 2
3.1.  概述 ... 2
3.1.1.  规则文件 ... 2
3.1.2. What makes a rule . 2
3.1.3.  领域语言 Domain Specific Languages . 3
3.1.4. Reserved words . 3
3.2. Comments 注释 ... 4
3.2.1.  单行注释 ... 4
3.2.2.  多行注释 ... 4
3.3. Package 包 ... 4
3.3.1. import 导入 ... 5
3.3.2. expander 扩展 ... 6
3.3.3. global 全局变量 ... 6
3.4. Function 函数 ... 6
3.5. Rule 规则 ... 7
3.5.1. Left Hand Side 左手元 ... 8
3.5.2. The Right Hand Side 右手元 ... 9
3.5.3. Rule Attriutes 规则属性 ... 9
3.5.4. Column . 11
3.5.5. Conditional Elements 条件元素 ... 18
3.5.6.  对原型数据自动封箱的提醒 ... 22
3.6. Query   查询 ... 22
3.7. Domain Specific Languages 领域语言 ... 24
3.7.1.  何时使用 DSL . 24
3.7.2.  修改与管理 DSL . 24
3.7.3.  在规则中使 用 DSL . 26
3.7.4.  增加 facts 的 约束 条件 ... 27
3.7.5.  怎样工作 ... 28
3.7.6.  从头开始建立 DSL . 28
3.8. XML 规则语言 ... 29
3.8.1.  何时使用 XML . 29
3.8.2. XML 格式 ... 30
3.8.3.  遗留的 Drools 2.x XML 规则格式 ... 33
3.8.4.  在 XML 和 DRL 格式之间自动转换
以上为章节目录,详细内容见附件。相关文章：
Drools3.0官方使用手册第二章（中文）
Drools3.0官方使用手册第一章（中文）

相关推荐: Lucene-2.0学习文档（１） 总结一下本学期读的书 FCKEditor使用说明 [JBoss] JBoss Drools Business Rules (英文版) jboss drools 书籍源码 Mastering JBoss Drools 6 for Developers 无水印pdf 0分 Mastering JBoss Drools 6 Drools7_PDF教程 Drools中文文档 内容全面.zip
推荐群组: GT-Grid
更多相关推荐
JBoss
第二章：安装和设置 ... 2
2.1.  安装和使用 ... 2
2.1.1.  依赖库 ... 2
2.1.2.  运行时 ... 3
2.1.3.  安装 IDE ( 规则工作台 ) . 3
2.2.  从源码进行安装 ... 13
2.3.  源码 Checkout . 14
2.4.  构建 ... 16
2.4.1.  构建源码 ... 16
2.4.2. 手工构建 ... 18
2.5. Eclipse . 22
2.5.1.  产生 Eclipse 项目 ... 22
2.5.2.  导入 Eclipse 项目 ... 23
2.5.3.  导出 IDE 插件 ... 29
2.5.4.  建立更新站点 Building the update site . 34
以上为目录章节,详细内容请下载附件。

TreeCache可以独立在tomcat里面使用,唯一的问题就是Tomcat的Session不是TreeCache实现的,如果要做cluster,你要自己处理这部分的问题,例如使用apache的mod_proxy_balancer实现session sticky。

相关推荐: jBPM中文开发指南（实现基本活动） jBPM中文开发指南（实现基本活动二） jBPM4.0中文开发指南（高级图形执行下） jBPM4.0的用户指南（二） jBPM-4.0中文开发指南 JBPM4.0开发步骤
推荐群组: JBPM @net
更多相关推荐
JBoss 第 7 章 高级图形执行7.1. 循环 活动可以实现循环,基于转移或活动组合。 循环可以包含等待状态。 为了支持多次自动循环执行,流程虚拟机 把执行的传播从尾部递归转换成while循环。 7.2. 子流程 TODO: 子流程 7.3. 默认执行行为 当一个Activity被用作活动行为, 它可以使用下面的方法从外部控制流程： * waitForSignal() * take(Transition) * end(*) * execute(Activity) * createExecution(*) 当Activity实现用做活动行为, 没有调用任何下面的流程传播方法,然后 在活动执行时,执行会使用默认执行行为。 默认执行行为定义在下面： * 如果当前活动有一个默认向外转移,选择它。 * 如果当前活动有一个父活动,回退到父活动。 * 否则,结束这个执行。 流程语言可以重写默认执行行为, 通过重写ExecutionImpl中的 proceed方法。 7.4. 功能活动 活动也可以用作事件监听器,被称作功能活动。 自动活动的例子是发送邮件,执行数据库更新, 生成pdf,计算平均数,等等。 所有这些都是自动活动,没有改变执行流向。 这里是这些活动如何实现： public class FunctionalActivity implements Activity, EventListener { public void execute(ActivityExecution execution) { perform(execution); } public void notify(EventListenerExecution execution) { perform(execution); } void perform(OpenExecution execution) { ...do functional work... } } perform方法获得一个OpenExecution, 这是ActivityExecution和 EventListenerExecution的超类。 OpenExecution没有提供任何特定目的的方法, 但是依旧是当前状态,流程定义可以通过变量检验, 这包含了环境信息 对应流程执行。 这些方法其实都不能调用执行传播方法。 所以在perform方法完成后,执行会 执行默认的方式。 7.5. 执行和线程 这一章解释流程虚拟机如何通过客户端的线程, 把一个执行从一个等待状态带到另一个。 当一个客户调用一个执行的一个方法（比如signal方法）。 默认,流程虚拟机会使用线程执行流程 直到它到达一个等待状态。一旦下一个等待状态到达, 这个方法会返回,客户端的线程就会返回。 这是流程虚拟机操作的默认方式。 两个更多的异步执行可以补充默认行为： 异步继续 和异步命令服务。 下一个流程会展示基本理论。 它有三个等待状态和四个自动活动。 有很多顺序自动活动的流程。 图 7.1. 有很多顺序自动活动的流程。 这里是如何构建流程： ClientProcessDefinition processDefinition = ProcessFactory.build("automatic") .activity("wait 1").initial().behaviour(new WaitState()) .transition().to("automatic 1") .activity("automatic 1").behaviour(new Display("one")) .transition().to("wait 2") .activity("wait 2").behaviour(new WaitState()) .transition().to("automatic 2") .activity("automatic 2").behaviour(new Display("two")) .transition().to("automatic 3") .activity("automatic 3").behaviour(new Display("three")) .transition().to("automatic 4") .activity("automatic 4").behaviour(new Display("four")) .transition().to("wait 3") .activity("wait 3").behaviour(new WaitState()) .done(); 让我们和你一起顺着流程的执行一起走。 ClientExecution execution = processDefinition.startProcessInstance(); 启动一个新执行意味着初始活动被执行。 所以如果一个自动活动是初始活动,这意味着第一个未命名的向外转移会被立刻选择。 这些都发生在startProcessInstance调用的内部。 然而在这种情况下,初始活动是一个等待状态。 所以startProcessInstance方法会立刻返回, 执行会定位到初始活动'wait 1'。 一个新执行会被定为到'wait 1'。 图 7.2. 一个新执行会被定为到'wait 1'。 然后一个外部触发器会执行signal方法。 execution.signal(); 像上面解释的介绍WaitState, signal会导致选择默认的转移。 转移会把执行移动到automatic 1活动,并执行它。 automatic 1中的Display活动的execute方法, 向控制台打印一行,它不会 调用execution.waitForSignal()。 因此,执行会通过选择automatic 1外部的默认转移进行执行。 在这种状态,signal方法一直阻塞着。另一个需要考虑的方式是执行方法, 像signal会使用客户端的线程 来拦截流程定义,直到到达一个等待状态。 然后执行到达wait 2, 执行WaitState活动。那个方法会调用 execution.waitForSignal(),这会导致signal方法返回。 线程会返回到调用signal方法 的客户端。 所以,当signal方法返回时,执行定义到wait 2。 一个signal会把执行从'initial'带到'wait 2'。 图 7.3. 一个signal会把执行从'initial'带到'wait 2'。 然后执行会等待一个外部触发器, 像是一个对象（更准确的是一个对象图）在内存中, 直到下一个外部触发器执行signal方法。 execution.signal(); 第二个调用的signal会直接让执行进入wait 3, 在它返回之前。 第二个signal让执行进入'wait 3'。 图 7.4. 第二个signal让执行进入'wait 3'。 使用这个范例的好处是相同的流程定义可以在 客户执行模式中执行 （在内存内不使用持久化）,就像在持久化执行模式, 依赖应用和环境。 当在持久化模式下执行一个流程,你如何绑定 流程执行到数据库的事务上。 持久化模式下的事务超时 图 7.5. 持久化模式下的事务超时 在大多情况下,计算工作是流程需要完成的一部分, 在外部触发器（红色部分）之后的部分,其实很少。 一般来说,处理流程执行和处理UI传递过来的请求 的事务不会超过一秒。 而业务流程中的等待状态可能超过几小时,几天甚至几年。 当等待状态启动后,线索就变得很清晰, 在等待状态启动之前,只有计算工作的完成包含在事务中。 考虑一下这种方式： "当到达审批时,所有的自动流程需要做的是什么, 在流程系统需要等待另一个外部触发器之前？"。 除非pdf需要被创建,或大邮件需要被发送, 大部分时候,它消耗的时间都是可以忽略的。 这就是为什么在默认的持久化执行模式下, 流程工作在客户端线程下执行。 这个原因也保证着流程同步路径的情况。 当一个执行的单独路径切分成流程同步路径, 流程花在计算上的时间是可忽略的。 所以为什么分支或切分活动实现是有意义的, 目标持久化模式产生的同步路径在同一个线程中按顺序执行。 基本上它们都只是在同一个事务中的计算工作。 因为分支或切分知道每个执行的同步路径会返回,所以这只能被完成, 当出现一个等待状态的时候。 因为这里有一个困难的概念需要掌握,我会再次使用其他词语来解释它。 从头再看一次在持久化执行模式下被流程执行创建出来的它。 如果在一个事务中,一个执行被给与一个外部触发器, 那导致执行切分成多个执行的同步路径。 然后执行在计算上的部分也可以忽略。 生成SQL的部分也可以忽略。 因为所有在同步分支上完成的功能,必须在同一个事务中完成, 这里一般没有指针在分支或切分实现, 在多个线程中产生执行的同步路径。 为了创建可执行流程,开发者需要确切知道什么是自动活动, 什么是等待状态,哪些线程会被分配给流程执行。 对于画业务流程的业务分析人员,事件就很简单了。 对于他们画的活动,他们通常只要知道这是一个人或是一个系统响应。 但是他们通常不知道如何转换线程和事务。 所以对于开发者,第一个任务是分析什么是流程控制的线程中需要执行的, 什么是外部的。 查找外部触发器是寻找一个流程中的等待状态的很好的开始, 就像动词和名词可以在构建UML类图中的元素的规则。

相关推荐: jBPM4.0中文开发指南（高级图形执行上） jBPM中文开发指南（实现基本活动） jBPM4开发 JBPM5 官方用户指南 完整中文版 jBPM开发入门指南 工作流开发指南1 JBoss jBPM 3.0 中文文档 jboss jbpm_使用JBoss ESB和JBPM实施VMS解决方案
推荐群组: JBPM @net
更多相关推荐
JBoss 5.5. 基本流程执行在下一个例子里,我们会结合自动活动和等待状态。 这里例子构建了贷款审批流程,使用WaitState 和Display活动,我们刚刚创建的。 贷款流程的图形看起来像这样： 贷款流程 图 5.3. 贷款流程 使用Java构建流程图形是很乏味的事情, 因为你必须在局部变量中跟踪所有的引用。 为了解决这个问题,流程虚拟机提供了一个ProcessFactory。 ProcessFactory是一种领域特定语言（DSL）,可以嵌入到Java中, 简化流程图形的结构。这个模型也叫做 流畅接口。 ClientProcessDefinition processDefinition = ProcessFactory.build("loan") .activity("submit loan request").initial().behaviour(new Display("loan request submitted")) .transition().to("evaluate") .activity("evaluate").behaviour(new WaitState()) .transition("approve").to("wire money") .transition("reject").to("end") .activity("wire money").behaviour(new Display("wire the money")) .transition().to("archive") .activity("archive").behaviour(new WaitState()) .transition().to("end") .activity("end").behaviour(new WaitState()) .done(); 为了了解ProcessFactory的更多细节,可以参考 api文档。 ProcessFactory的另一种选择是创建一个XML语言和一个XML解析器,来表示流程。 XML解析器可以直接实例化 org.jbpm.pvm.internal.model包中的类。 这种方式一般都被流程语言选择使用。 初始化活动submit loan request和 wire the money活动是自动活动。 在这个例子中,wire the money活动的 Display实现 使用Java API来把信息输出到控制台上。但是读取器可以想象一个可选的 Activity实现,使用支付流程库的Java API 来实现一个真实的自动支付。 上述流程的一个新执行可以像下面这样启动 ClientExecution execution = processDefinition.startProcessInstance(); 当startExecution方法返回时, submit loan request活动会被执行, 执行会位于evaluate活动。 位于'evaluate'活动的执行 图 5.4. 位于'evaluate'活动的执行 现在,执行处在一个很有趣的点。这里有两个转移从evaluate指向外边。 一个转移叫approve 一个转移叫reject。像我们上面解释的, WaitState实现会根据执行的signal选择转移。 让我们像这样执行'approve' signal： execution.signal("approve"); 这个approve signal会导致执行选择approve转移 它会到达wire money活动。 在wire money活动中,信息会打印到控制台里。 因为Display没有调用execution.waitForSignal(), 也没有调用其他执行传播方法, 默认流程行为只会让执行继续, 使用向外的转移到达archive活动, 这也是一个WaitState。 位于'archive'活动的执行 图 5.5. 位于'archive'活动的执行 所以只有当archive到达时, signal("approve")会返回。 另一个signal就像这样： execution.signal("approve"); 将让执行最终到达结束状态。 位于'end'活动的执行 图 5.6. 位于'end'活动的执行 5.6. 事件 事件位于流程定义中, 一系列的EventListener可以进行注册。 public interface EventListener extends Serializable { void notify(EventListenerExecution execution) throws Exception; } 事件的目的是让开发者可以为流程添加程序逻辑, 不必改变流程图。 这是非常有价值的机制,可以促进业务分析人员和开发者之间的协作。 业务分析人员负责描述需求。 当他们使用流程图归档那些需求, 开发者可以获得这些图形,让它可执行化。 事件会非常方便,向一个流程中添加技术细节（比如一些数据库插入操作） 这些都是业务分析人员不感兴趣的东西。 最常用的事件是由执行自动触发的： TODO: 在用户手册中解释事件 事件是由流程元素和事件名称结合而成。 用户和流程语言也可以出发事件, 使用编程的方式在流程中使用fire方法。 public interface Execution extends Serializable { ... void fire(String eventName, ProcessElement eventSource); ... } 可以把一系列的EventListeners分配给一个事件。 但是事件监听器不能控制执行的流向, 因为它们仅仅是监听已经执行了的执行。 这与活动处理活动的行为是不同的。 活动行为可以响应执行的传播。 我们会创建一个PrintLn事件监听器, 这与上面的Display活动是非常相似的。 public class PrintLn implements EventListener { String message; public PrintLn(String message) { this.message = message; } public void notify(EventListenerExecution execution) throws Exception { System.out.println("message"); } } 多个PrintLn监听器 会在流程中注册。 PrintLn监听器流程 图 5.7. PrintLn监听器流程 ClientProcessDefinition processDefinition = ProcessFactory.build() .activity("a").initial().behaviour(new AutomaticActivity()) .event("end") .listener(new PrintLn("leaving a")) .listener(new PrintLn("second message while leaving a")) .transition().to("b") .listener(new PrintLn("taking transition")) .activity("b").behaviour(new WaitState()) .event("start") .listener(new PrintLn("entering b")) .done(); 第一个事件演示如何为相同的事件注册多个监听器。 它们会根据它们指定的顺序依次执行。 然后,在转椅上,这里的事件只有一种类型。 所以在那种情况下,事件类型不需要指定, 监听器可以直接添加到转移上。 一个监听器每次都会执行,当一个执行触发事件时,如果这个监听器被注册了。 执行会作为一个参数提供给活动接口, 除了控制流程传播的方法以外, 都可以被监听器使用。 5.7. 事件传播 事件会默认传播给最近的流程元素。 目的是允许监听器在流程定义或组合活动中 可以执行所有发生在流程元素中的事件。 比如这个功能允许为end事件在流程定义或一个组合活动中注册一个事件监听器。 这种动作会被执行,如果一个活动离开。 如果事件监听器被注册到一个组合活动中, 它也会被所有活动执行,当组合活动中出现了离开事件。 为了清楚地显示这个,我们会创建一个DisplaySource事件监听器, 这会把leaving信息和事件源 打印到控制台。 public class DisplaySource implements EventListener { public void execute(EventListenerExecution execution) { System.out.println("leaving "+execution.getEventSource()); } } 注意事件监听器的目的不是可视化,这是为什么事件监听器本身 不应该显示在图形中。一个DisplaySource事件监听器 会作为end事件的监听器添加到组合活动中。 下一个流程展示了DisplaySource事件监听器如何 作为'end'事件的监听器注册到composite活动： 一个在组合活动中为end事件注册了不可见的事件监听器的流程。 图 5.8. 一个在组合活动中为end事件注册了不可见的事件监听器的流程。 TODO 更新代码片段 下一步,我们会启动一个执行。 ClientExecution execution = processDefinition.startProcessInstance(); 在启动一个新执行后,执行将在a活动中 作为初始活动。没有活动离开,所以没有信息被记录下来。 下一个signal会给与执行, 导致它选择从a到b。 execution.signal(); 当signal方法返回,执行会选择转移 然后end事件会被a活动触发。 那个组合活动会被传播到组合活动和流程定义中。 因为我们的DisplaySource 监听器放到 composite活动中, 它会接收事件,把下面的信息打印到控制台中： leaving activity(a) 另一个 execution.signal(); 会选择b到c的转移。那会触发两个活动离开事件。 一个在b活动,一个在组合活动。 所以下面的几行会添加到控制台输出中： leaving activity(b) leaving activity(composite) 事件传播建立在流程定义的继承组合结构中。 顶级元素总是流程定义。 流程定义包含一系列活动。每个活动可以是叶子活动或者可以是一个组合节点, 这意味着它包含了一系列内嵌活动。 内嵌活动可以被使用,比如超级状态或组合活动,在内嵌流程语言中,像BPEL。 所以事件模型在组合活动和上面的流程定义中的功能是相似的。 想象'Phase one'模型一个超级状态作为一个状态机。 然后事件传播允许在超级状态中注册所有事件。 这个主意是继承组合响应图形展示。 如果一个'e'元素画在另一个'p'元素中, 'p'是'e'的父节点。一个流程定义拥有一系列定义活动。 每个活动可以拥有一系列内嵌活动。 一个转移的父节点就是它的源头和目的的第一个父节点。 如果一个事件监听器对传播的事件没有兴趣, 可以在构建流程使用ProcessFactory的propagationDisabled()。 下一个流程是与上面相同的流程, 除了传播的事件会被事件监听器禁用。 图形还是一样。 注册到'end'事件的事件监听器被禁用的流程。 图 5.9. 注册到'end'事件的事件监听器被禁用的流程。 使用流程工厂构建流程： TODO 更新代码 所以当第一个signal在流程中调用时,end事件 会再次触发在a活动上,但是现在在组合活动的事件监听器 不会被执行,因为传播的事件被禁用了。 禁用传播是单独的事件监听器的一个属性, 不会影响其他监听器。事件会一直被触发, 传播到整个父继承结构。 ClientExecution execution = processDefinition.startProcessInstance(); 第一个signal会选择从a到b的流程。 没有信息会被打印到控制台。 execution.signal(); 下一步,第二个signal会选择从b到c的转移。 execution.signal() 还是两个end事件被触发, 就像上面分别在b和composite活动中。 第一个事件是b活动上的 end事件。 那将被传播给composite活动。 所以事件监听器不会为这个事件执行,因为它已经禁用了传播。 但是事件监听器会在composite活动上 为end事件执行。 那是不传播的,但是直接在composite活动上触发。 所以事件监听器现在会被执行 一次,为组合活动,就像下面控制台里显示的那样： leaving activity(composite) jBPM4.0中文开发指南完整版 http://family168.com/tutorial/jbpm4devguide/html/index.html

相关推荐: jBPM4 PVM的流程定义模型与过程调度 jBPM4.0中文开发指南（高级图形执行上） jBPM中文开发指南（实现基本活动二） JBPM5 官方用户指南 完整中文版 jBPM开发入门指南 工作流开发指南1 JBoss jBPM 3.0 中文文档 jboss jbpm_使用JBoss ESB和JBPM实施VMS解决方案
推荐群组: JBPM @net
更多相关推荐
JBoss 第 5 章 实现基本活动这一章解释了流程定义的基础,流程虚拟机给予的功能 以及活动实现是如何构建的。 同时,客户端API被用来执行包含了那些活动实现的流程。 5.1. ActivityBehaviour PVM库没有包含完整的流程结构。 作为替代的是,活动的运行时行为被委派给一个ActivityBehaviour。 换句话讲,ActivityBehaviour是一个接口, 它用来在纯java环境实现流程结构的运行时行为。 public interface ActivityBehaviour extends Serializable { void execute(ActivityExecution execution) throws Exception; } 当一个活动行为被调用时,它就处于执行传播的全部控制中。 换句话说,一个活动行为可以决定下一步应该执行什么执行。 比如,可以使用execution.take(Transition)获得一个转移, 或者使用execution.waitForSignal()进入等待阶段。 万一活动行为没有调用任何上述的执行传播方法, 执行将 按默认方式执行。 5.2. ActivityBehaviour实例 我们会启动一个非常原始的hello world例子。 一个Display活动会将一条信息打印到控制台： public class Display implements ActivityBehaviour { String message; public Display(String message) { this.message = message; } public void execute(ActivityExecution execution) { System.out.println(message); } } 让我们使用这个活动构建我们第一个流程定义： Display实例流程 图 5.1. Display实例流程 TODO add ProcessBuilder example code 现在我们可以像下面这样执行流程： Execution execution = processDefinition.startExecution(); startExecution的调用会在控制台打印hello world： hello world 一个总是值得提醒的事情是活动可以使用属性进行配置。 在Display例子中,你可以看到message属性在两种使用方法中配置的不同。 通过配置属性,我们可以写出可复用的活动。 它们可以在以后每次使用在流程中都进行不同的配置。 这是一个基本的部分, 将流程语言构建在流程虚拟机之上。 其他需要解释的部分是 这个活动实现没有包含任何执行传播的功能。 当一个新流程实例启动时, 执行会定位到初始活动,那个活动会被执行。 Display.execute方法用来决定默认的执行传播。 具体的,这意味着活动自己 没有调用任何执行传播的方法。 那种情况下,默认的传播会执行。默认传播会选择第一个转移,如果这个转移存在的话。 如果没有,它会结束这个执行。 这揭示了为什么a活动和b活动都被执行, 而在b活动执行完执行会停止。 关于默认流程行为的更多细节可以 在第 7.3 节 “默认执行行为”找到。 5.3. ExternalActivityBehaviour 外部活动是负责流程执行由外部转移进来的活动, 外部的意思是来自流程系统的外部。 这意味着这个执行流程对于系统来说,这是一个等待状态。 这个执行会一直等待到外部触发器调用。 为了处理外部触发器,ExternalActivityBehaviour 为ActivityBehaviour添加了一个方法： public interface ExternalActivity extends Activity { void signal(Execution execution, String signal, Map parameters) throws Exception; } 就像普通的活动,当一个执行到达一个活动, 外部活动行为的execute方法会被调用。 在外部活动中,execute方法会传递另一个系统的响应, 然后通过调用execution.waitForSignal() 进入等待状态。 比如在execute方法中,响应可能是由一个人传入, 通过在任务管理系统中创建一个任务入口, 然后等待到这个人完成这个任务。 一旦活动行为已经处于等待状态, 然后执行会等待到调用signal方法。 执行会委派signal给ExternalActivityBehaviour对象 分配给当前的活动。 所以活动的signal方法 会在等待期间,在执行获得一个外部触发器的时候调用。 signal方法中,响应会传递给后面的流程执行。 比如,当一个人完成了一个任务,任务管理系统 会在执行中调用signal方法。 一个signal可选择使用signal名字和一个参数map。 活动行为拦截signal和参数的最常用方式是 signal对应选择的外出转移, 参数作为执行中的变量。但那些只是例子, 它一直等到活动使用singal和它期望的参数。 5.4. ExternalActivity实例 这里是一个简单等待状态实现的第一个例子： public class WaitState implements ExternalActivity { public void execute(ActivityExecution execution) { execution.waitForSignal(); } public void signal(ActivityExecution execution, String signalName, Map parameters) { execution.take(signalName); } } execute方法调用execution.waitForSignal()。 execution.waitForSignal()的调用 会使流程执行进入等待状态, 直到一个外部触发器出现。 signal方法使用signal参数对应的转移名称 来选择转移。所以当一个执行获得一个外部触发器, signal名称被拦截,作为外部转移的名称, 执行会被传播到那个转移上。 这里是从a到b有一个转移的相同的流程。 这时候,两个活动的行为都是WaitState。 外部活动实例流程 图 5.2. 外部活动实例流程 ClientProcessDefinition processDefinition = ProcessFactory.build() .activity("a").initial().behaviour(new WaitState()) .transition().to("b") .activity("b").behaviour(new WaitState()) .done(); 让我们为流程定义启动一个新流程实例： ClientExecution execution = processDefinition.startProcessInstance(); 启动这个流程会执行a中的WaitState活动。 WaitState.execute会调用 ActivityExecution.waitForSignal。 所以当processDefinition.startProcessInstance()返回, 执行会一直处在a活动。 assertEquals("a", execution.getActivityName()); 然后我们提供了外部触发器, 通过调用signal方法。 execution.signal(); execution.signal()会委派给当前活动。 所以在这种情况下就是a活动里的 WaitState活动。WaitState.signal会调用 ActivityExecution.take(String transitionName)。 当我们没有提供一个signal名称,第一个名字是null会被选中。 我们指定的a的唯一转移没有名字,所以会选中这个。 然后这个转移指向b。 当执行到达b活动, b活动中的WaitState活动会被执行。 就像我们上面看到的,执行会在b一直等待, 这时signal会返回, 离开的执行指向b活动。 assertEquals("b", execution.getActivityName()); jBPM4.0开发指南完整版 http://family168.com/tutorial/jbpm4devguide/html/index.html

相关推荐: Redhat9.2 安装ORACLE 10.1g Redhat 5 下 Oracle10g 安装,相信没有比这个更全的了 oracle9i installation on fedora core 6 JBOSS添加oracle驱动 配置jboss的oracle数据源 Jboss配置Oracle数据库连接池 记录一下自己部署jboss配置oracle数据库的小白经验 jboss7 配置Oracle数据源
推荐群组: 高级语言虚拟机
更多相关推荐
JBoss
     项目用的jboss-4.2.0.GA,的数据库连接临时从thin的方式转到了OCI的方式,修改了oracle-ds.xml文件后,只能在相应的server上安装oracle client,以前很少在linux的机器上安装oracle client,这次算是找到了实战的机会。
 
 首先要得到安装文件,我用的是ship.client.lnxx86-64.cpio
 
首先要解压
cd /home/
cpio -idcmv < ship.client.lnxx86-64.cpio
增加组和用户
# groupadd oinstall
# useradd -g oinstall oracle
# passwd oracle
 
建立ORACLE_BASE目录
# mkdir -p /usr/app/oracle
# chown -R oracle:oinstall /usr/app/oracle
# chmod -R 775 /usr/app/oracle
 
开始修改环境变量
# su - oracle
#vi ~/.bash_profile
 
加上下面的配置
 
umask 022
export ORACLE_BASE=/usr/app/oracle
export ORACLE_HOME=$ORACLE_BASE/product/db/10.2.0/client
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/lib64:/usr/lib64:/usr/local/lib:$ORACLE_HOME/lib
export PATH=$ORACLE_HOME/bin:$PATH
export LC_ALL="en_US"
export LANG="en_US"
export NLS_LANG="AMERICAN_AMERICA.ZHS16GBK" #SIMPLIFIED CHINESE_CHINA.ZHS16GBK
export PATH ORACLE_HOME LD_LIBRARY_PATH
 
 
# su -
# vi /etc/oraInst.loc
inventory_loc=/usr/app/oracle/oraInventory
inst_group=oinstall
# chmod 664 /etc/oraInst.loc
# exit
 
可以运行安装文件了
cd /home/Disk1
./runInstaller -ignoreSysPrereqs -silent -noconfig -responseFile /home/Disk1/response/clientruntime.rsp UNIX_GROUP_NAME="oraclient" ORACLE_HOME="/usr/app/oracle/product/db/10.2.0/client" ORACLE_HOME_NAME="OraClient10g_home"
 
在运行这个后,遇见了很多问题,最挠头的就是OS的版本不适合,可以用下面的方法解决
 
# su
Password:
[root@server Disk1]# cp /etc/redhat-release /etc/redhat-release.backup
[root@serverDisk1]# cat > /etc/redhat-release << EOF
> Red Hat Enterprise Linux AS release 3 (Taroon)
> EOF
[root@serverDisk1]# exit
 
这样可以暂时骗过安装程序,：）
继续安装,待成功后退出
 
 
安装完毕后要验证下是否安装成功
#sqlplus /nolog 
 
如果sqlplus能够找到并能成功运行的话,最好用下面的语句连接下数据库,看看是不是能够连接成功。
 
#sqlplus username/pwd@db (应用OCI 模式中的servername)
 
 
补注下：
thin是纯java实现tcp/ip的c/s通讯；而oci（oracle called interface）方式,客户端通过native java method调用c library访问服务端。所用的驱动方式也不相同。

相关推荐: Object-Relational Mapping The Fake TOB - An ORM Replacement Unleashes Real Power Of Java OO Per 为什么java里不能把域对象和DAO合并,rails里面就可以? Object-Relational Mapping The Fake ORM(Object Relation Mapping) [译]OOSE第8章：Construction 软件构建 8.2 The design model 设计模型 ABAP OO Explained (by Manfredo P. do Carmo) Notes
推荐群组: D语言
更多相关推荐
OO The Object-Relation-Kin ModelToward Relational Analysis and Design in General Object Oriented Languages Abstract: The relational model is in use by many database systems. Object oriented technology is also widely used in database application development. But “object-relational impedance mismatch” was found between the two approaches. However, in the study behind this paper, the REAL mismatch is revaluated, and the Object-Relational Mapping approach is found being actually mapping between the Network Model and the SQL interface. A new data model - the Object-Relation-Kin model is then derived from the relational model and the entityrelationship model, to better consolidate object technology and the relational model without defective mappings. Ableverse™ TheObjectBase as the DBMS and WebOfWeb as the blueprint project are showing a feasible solution in the Java™ programming language as realworld practices, on the basis of this new data model. 全文见: http://www.ableverse.org/articles/orkm.pdf 或 http://www.ableverse.org/articles/orkm.html Table of Contents: 1 . Introduction 1 .1. Backgrounds 1 .1.1. The Relational Model and the Entity-Relationship Model 1 .1.2. Conventional Relational Databases and SQL 1 .2. New Situations 1 .2.1. Impedance Mismatch Problems and SQL's Limitations 1 .2.2. Physical RAM Capacity Increased to Hold Mass Data 1 .2.3. Developed Garbage Collection Technologies 1 .2.4. More CPUs, More Cores, Sharing a Same Memory Space 1 .3. New Ideas 1 .3.1. Adding Persistence Ability to Application Object Model 1 .3.2. Unique Object Graph 1 .3.3. Relational Data Traverse for Embedded DB Access 1 .3.4. Hosting Based Interfacing for Distributed DB Access 2 . Premised Object Orientation 2 .1. Object Oriented Analysis and Design 2 .2. The Java Programming Language 3 . The Object-Relation-Kin Model 3 .1. Data in Object Models: Exposed Properties and Encapsulated Fields 3 .2. Multilevel Views of Data 3 .3. Information Concerning Entities and Relationships (Level 1) 3 .3.1. Entity and Relation Objects 3 .3.1.1. Entity Object Inheritance 3 .3.1.2. Relation Object Inheritance 3 .3.2. Role in Relationship 3 .3.3. Properties, Value and Type 3 .3.4. Conceptual Information Structure 3 .4. Information Structure (Level 2) 3 .4.1. Object Identifiers 3 .4.2. Data Fields Encapsulated by Objects 3 .4.3. Entity and Relation Classes 3 .5. Object Graph in Operational Memory (Level 4) 3 .5.1. Relation Object Ties Other Objects with Tie Fields 3 .5.1.1. Tie Field Name reflects Role 3 .5.1.2. Behaviors of Tie Reference Object 3 .5.2. Related Objects Reach Each Others through Kin Fields 3 .5.2.1. Kin Field and Kin Set Field 3 .5.2.2. Source Relation, Self Roles and Target Roles 3 .5.2.3. Kin Reference 3 .5.3. Derive 3NF Schema from E-R Schema, Direct Kin 3 .6. Tabular Object States in Permanent Storage (Level 3) 3 .7. Object Swapping and Swap Engine 3 .7.1. Update Tables On Transaction Commit 3 .7.2. Inflate Objects On Initial Access 4 . Persistence System Design with ORK Model 4 .1. Database Management System for ORK Model 4 .2. Create Domain Model with Persistent Objects 4 .2.1. Design Domain Object Topography 4 .2.2. Design Object Behaviors (Domain Logics) 4 .2.2.1. Concern Persistence Behaviors 4 .3. Provide Access to the System 4 .3.1. Define and Implement Service Interfaces 4 .3.1.1. Create Domain Objects 4 .3.1.2. Find Domain Objects 4 .3.1.2.1. Query Persistent Objects using SQL 4 .3.1.2.2. More Query Mechanisms 4 .3.1.3. Delete Domain Objects 4 .3.1.4. Invoke Domain Object Methods 4 .3.1.4.1. Methods Read Persistent Fields 4 .3.1.4.2. Methods Write Persistent Fields 4 .3.1.4.3. Methods Update Tie Fields 4 .3.2. Host Foreign Task Agents with Domain Model Environment 4 .3.2.1. Enable Task Agent Transmission 4 .3.2.2. Impose Security Constraints 4 .4. Design Data Analytical Applications using SQL 5 . Object-Relation-Kin Diagram 6 . Software Products for Reference

相关推荐: The Object-Relation-Kin Model TOB - An ORM Replacement Unleashes Real Power Of Java OO Per 用面向对象的思想去维护对象之间的关系 Object-Relational Mapping The Fake 阿里云实战之一(必备程序安装) Awesome C++（C++教程） 健壮的系统 Django Web开发之ORM操作
推荐群组: D语言
更多相关推荐
OO Object-Relational Mapping The FakeSpeak of Relational Model In Your Favorite OO Languages Abstract: What is today's Object-Relational Mapping REALLY doing? The answer will be given by this paper is: Mapping the Network Model and SQL interface. In this paper, we shall see why and how this is the truth. And your favorite object oriented programming languages, with sufficient modern features, such as Java™, are quite possible to be effectively consolidates with the power of relational model, without defective mappings. Ableverse™ TheObjectBase as the DBMS and WebOfWeb as the blueprint project are showing a feasible solution in the Java™ programming language as realworld practices, on the basis of a new relational data model called the Object-Relation-Kin model. 全文见: http://www.ableverse.org/articles/fakeorm.pdf 或 http://www.ableverse.org/articles/fakeorm.html Table of Contents: 1 . The Object-Relational Impedance Mismatch 2 . The Object-Relational Mapping 2 .1. Problems Solved 2 .1.1. Perform CRUD on Objects 2 .1.2. Query Objects Expressively and Accelerated 2 .1.3. Reduce Data Traffic by Cache 2 .2. New Problems Created 2 .2.1. Multi-Source of Schema/MetaData 2 .2.2. Transaction Serializability 2 .2.3. Confusing Property Writers 2 .2.4. Discomfort for Purists 2 .3. Problems Not (Effectively) Solved 2 .3.1. Relationship Manipulation 2 .3.2. Overall Complexity/Productivity 3 . Thank Again, What Is What 3 .1. The Network Model Called Object Model 3 .2. True Nature of the Relational Model 3 .3. How ORM's Usage of SQL Harms Consistency/Isolation 4 . Make a Match Instead of Defective Mapping 4 .1. A Simple Job Hard To Do 4 .2. What versus How 4 .3. Implement Concurrency/Transaction Control Based On Objects 4 .4. Server Side Object Graph and Hosting Based Interfacing 4 .5. SQL Does Query 5 . Seeking Fresh Meat

Cache本身的配置可以在代码中更改吗？比如:timeToIdleSeconds想要修改。 根据用户输入的数值进行修改。 只能是 new Cache(...)来操作？