Ⅰ Groovy脚本实现轻量级规则引擎
1） 当业务规则变更时，对应的代码也得跟着更改，每次即使是小的变更都需要经历开发、测试验证上线等过程，变更成本比较大。
2） 长时间系统变得越来越难以维护。
3） 开发团队一般是由一个熟悉业务的BA（业务分析人员）和若干个熟悉技术的开发人员组成，开发人员对业务规则的把握能力远不及BA，但实际上却承担了将业务规则准确无误实现的重任。
4） 系统僵化，新需求插入困难。
5） 新需求上线周期较长。
规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了 将业务决策从应用程序代码中分离出来 ，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策。
把规则和核心业务拆开， 规则单独配置 。这样当我们的规则变化的时候，就可以通过修改规则文件而 不用修改核心的代码 了。
在 规则较为复杂的行业 ，都是适用的，如金融、制造、医疗、物流等行业，面临的规则变化较为复杂，目前使用较多。而且对规则引擎需求的行业也将越来越多，如团购平台、传统企业管理渠道等。
JBoss Drools Rete算法
Mandarax
JLisa
OpenRules
JEOPS
InfoSapient
JRuleEngine
Roolie
Rete 模式匹配算法是在模式匹配中利用推理机的时间冗余性和规则结构的相似性, 通过保存中间去处来提高推理效率的一种模式匹配算法。
在模式匹配过程中, 规则的前提中可能会有很多相同的模块, 因此在匹配规则前提时, 将进行大量的重复运算, 这样就带来时间冗余性问题。例如:
RULE1:if (A>B) and D or C then E=100
RULE2:if (A>B) and (BB) or (BB 要进行三次计算, 对B B, M2=B
Ⅱ 利用groovy脚本获取soapui中请求和响应的值
例如如下数据，calendar_id是需要根据返回值动态获取的，此时需要通过获得数组中的calendar_id
{"calendar":
[
{"calendar_id":"1705","showtime":"1288927800","endshowtime":"1288931400","allDay":false},
{"calendar_id":"1706","showtime":"1288933200","endshowtime":"1288936800","allDay":false}，
{"calendar_id":"1709","showtime":"1288935600","endshowtime":"1288938900","allDay":false}
]
}
在SoapUI中可以通过groovy脚本实现提取json数组数据，提取到数据后就可以遍历访问列表中的每条新闻正文了
1.新建一个REST请求步骤，获取接口返回的数据
2.新建一个DataSource步骤，选择Groovy方式
3.添加一个名为cal_id的Properties
4.groovy编辑框中输入实现代码
[java] view plain
import groovy.json.JsonSlurper
def xresponse = testRunner.testCase.testSteps["getCalendarListByCoid"].testRequest.response.contentAsString
def slurper = new JsonSlurper()
def re = slurper.parseText(xresponse)
def num=re.calendar.size()
def i = testRunner.testCase.testSteps["DataSource"].currentRow
if(i<num)
{
result["cal_id"]=String.valueOf(re.calendar_id.id[i])
}
5.新建一个Property Transfer步骤，将DataSource的cal_id传递给当前testCase的变量
6.新建 一个REST请求步骤，将得到的cal_id去请求另一个接口
7.新建一个DataSource Loop步骤，使DataSource与Property Transfer步骤循环，这样就可以遍历数组中的每个数据了
[reply]tz0705010216[/reply]
你好
以博文中的json为例，新增的groovy步骤则如下：
def xresponse = testRunner.testCase.testSteps["getCalendarListByCoid"].testRequest.response.contentAsString
def slurper = new JsonSlurper()
def re = slurper.parseText(xresponse)
def id = re.calendar.calendar_id[i] //i为json数组中的第i个子json对象
若为在脚本断言处添加groovy断言，则如下：
def xresponse = messageExchange.modelItem.testCase.testSteps["getCalendarListByCoid"].testRequest.response.contentAsString
def slurper = new JsonSlurper()
def result = slurper.parseText(xresponse)
def id = re.calendar.calendar_id[i] //i为json数组中的第i个子json对象
Ⅲ 如何在groovy脚本定义全局变量
例如，我们经常需要对一个字符串进行如下的判断： if(str!=null&&!str.equals("")) { ...... }输入这样的语句的确使人生厌，而且有时候还会忘掉输入“!str.equals("")”语句中的“!”导致代码出现逻辑错误。
Ⅳ Groovy基本语法
官方文档
和Java一样，支持单行（使用 // ）、多行（ /* */ ）和文档注释（使用 /** */ ）。
UNIX系统支持一种特殊的单行注释叫作 Shebang line ，用于指明脚本的运行环境，这样就可以直接在终端中使用 ./xxx.groovy 运行（当然，前提是文件得有可运行的权限），而不用像 groovy xxx.groovy 这样运行：
# 号必须是文件的第一个字符。
以字母、美元符号 $ 或下划线 _ 开始，不能以数字开始。以下是可用的标识符：
以下是不可用的标识符：
注意：在点号后，是可以使用关键字作为标识符的：
Groovy在点表达式（dotted expression）后面可以使用引号标识符，比如 persion.name 可以表示为 persion.'name' 或 persion."name" 。而引号中可以包含普通标识符中不支持的字符，比如空格、中档线 - 这些：
其实，Groovy支持多种字符串的字面量表达形式，这些都是可以出现在点号后面的：
更方便的是，Groovy中的 GString 支持 插值 ，也可以用在点号后面的：
在Groovy中字符串有两种类型，一种是Java原生的 java.lang.String ；另一种是 groovy.lang.GString ，又叫 插值字符串 (interpolated strings)。
在Groovy中，使用单引号括住的字符串就是 java.lang.String ，不支持插值：
使用三单引号括住字符串支持多行，也是 java.lang.String 实例，在第一个 ’‘’ 起始处加一个反斜杠 可以在新一行开始文本：
如果双引号括住的字符串中没有插值表达式（interpolated expression），那它就是 java.lang.String ；如是有插值表达式，那它就是 groovy.lang.GString ：
在Groovy所有的字符串字面量表示中，除了单引号字符串和三单引号字符串，其他形式都支持字符串插值。字符串插值，也即将占位表达式中的结果最终替换到字符串相应的位置中：
当使用点号表达式时，可以只用 $ 代替 ${} ：
插值占位符中还支持闭包，而闭包的一个好处是 惰性求值 （lazy evaluation）：
当一个方法的需要一个 java.lang.String 变量，而我们传递的是一个 groovy.lang.GString 实例时， GString 的 toString 方法会被自动调用，看起来像我们可以直接将一个 GString 赋值给一个 String 变量一样。
注意： GString 与 String 的hashCode是不一样的，即使他们最终结果一样。所以，在Map中，不应该用 GString 去做元素的Key，而又使用普通的 String 去取值：
类似于三单引号字符串，但支持字符串插值。
除了使用引号来括住字符串，还可以使用 / 。它一般用来定义正则表达式：
这种字符串使用 $/ 开始，使用 /$ 结束，其中的转义字符为 $ ：
在Groovy中并没有明确的字符字面量表示形式，我们必须明确指明：
当使用 def 指明整数字面量时，变量的类型会根据数字的大小自动调整：
为了精确地计算小数，在Groovy中使用 def 声明的小数是 BigDecimal 类型的：
如果要强制指明一个数字的字面量类型，可以给字面量加上类型后缀：
默认情况下Groovy的列表使用的是 java.util.ArrayList ，用中括号 [] 括住，使用逗号分隔：
如果要使用其它类型的列表（如： LinkedList ）可以使用 as 操作符或显式分配给一个指定类型的变量：
Groovy重载了列表的 [] 和 << 操作符，可以通过 List[index] 访问指定位置元素，也可以通过 List << element 往列表末尾添加元素：
在Groovy中，没有数组的字面量定义方式。和特定类型列表的定义方式一样，我们需要使用 as 操作符或显式地分配给一个数组类型的变量：
Groovy使用中括号 [] 来定义映射，元素需要包含key和value使用冒号分隔，元素与元素之间用逗号分隔：
在上边的例子中，虽然没有明确的使用字符串 ’red‘ 、 ’green‘ ，但Groovy会自动把那些key转化为字符串。并且，在默认情况下，初始化映射时，key也不会去使用已经存在的变量：
如果要使用一个变量作为key，需要用括号括住：
Ⅳ groovy脚本中字符串怎样拼空格
Groovy字符串及其常用方法
字符串方法
与java不同，在GString中提供了多种表示字符串的方法，分别是单引号字符串、双引号字符串、三单引号字符串、三双引号字符串、斜杠字符串和$修饰的斜杠字符串。
单引号字符串
单引号字符串是一系列被单引号包围的字符，是普通的java.lang.String。不支持插值。
def str = 'groovy'
assert str.class == java.lang.String
三单引号字符串
三单引号字符串是一列被三个单引号包围的字符，是普通的java.lang.String。不支持插值。
def str = '''groovy'''
assert str.class == java.lang.String
三单引号字符串是多行的。你可以使字符串内容跨越行边界，不需要将字符串分割为一些片段，不需要连接，或换行转义符：
def str = '''
one
two
three'''
//需要注意的是，这个字符串每一次换行都包含了一个换行转义符：
assert str.contains("\n") == true
assert str.size() == 14
//可以通过使用反斜杠换行符剥离该字符
def str = '''\
one\
two\
three'''
assert str.contains("\n") == false
assert str.size() == 11
Ⅵ 什么是 Groovy
● 是一个基于 Java虚拟机的敏捷 动态语言。 ● 构建在强大的Java语言之上 并 添加了从Python，Ruby和Smalltalk等语言中学到的 诸多特征。 ●为Java开发者提供了 现代最流行的编程语言特性，而且学习成本很低（几乎为零）。 ● 支持DSL（Domain Specific Languages领域定义语言）和其它简洁的语法，让你的代码变得易于阅读和维护。 ● Groovy拥有处理原生类型，面向对象以及一个Ant DSL，使得创建Shell Scripts变的非常简单。 ● 在开发Web，GUI，数据库或控制台程序时 通过 减少框架性代码 大大提高了开发者的效率。 ● 支持单元测试和模拟（对象），可以 简化测试。 ● 无缝集成 所有已经存在的 Java对象和类库。 ● 直接编译成Java字节码，这样可以在任何使用Java的地方 使用Groovy。 Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想象成 Java 语言的一种更加简单、表达能力更强的变体。（在这点上，Ruby 与 Groovy 不同，因为它的语法与 Java 语法差异很大。） Groovy 快捷方式 开始使用 Groovy 时，您会发现它使日常的编程活动变得快了许多。完成本教程之后，您会了解更多的 Groovy 语法快捷方式。不过现在只需知道以下这些要点： Groovy 的松散的 Java 语法允许省略分号和修改符。 除非另行指定，Groovy 的所有内容都为 public。 Groovy 允许定义简单脚本，同时无需定义正规的class 对象。 Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式，使得它们更容易使用。 Groovy 语法还允许省略变量类型。 Groovy 的新增特性 虽然Groovy 允许省略 Java 语法中的一些元素，但也增加了一些新特性，例如本地集合、内置的正则表达式和闭包。在标准的 Java 代码中，如果想要创建一个项列表，首先要导入<code>java.util.ArrayList</code>，然后程序化地初始化 <code>ArrayList</code> 实例，然后 再向实例中添加项。在 Groovy 中，列表和映射都内置在语法中 — 无需导入任何内容。正则表达式也不需要额外的导入或对象；它们可以通过特殊的 Groovy 语法来创建。 关于闭包 对于任何 Java 开发人员来说，闭包都是一个令人兴奋的新技巧。这些神奇的构造将会包含在未来的 Java 发行版（很可能是 Java 7）中，成为正式的 Java 语法，但现在已经可以在 Groovy 中使用了。可以将闭包 想象为一个代码块，可以现在定义，以后再执行。可以使用这些强大的构造做许多漂亮的事，不过最着名的是简化迭代。使用 Groovy 之后，就有可能再也不需要编写Iterator 实例了。 动态的 Groovy 从技术上讲，Groovy 可能是您最近听说过的类型最松散的动态语言之一。从这个角度讲，Groovy 与 Java 语言的区别很大，Java 语言是一种固定类型语言。在 Groovy 中，类型是可选的，所以您不必输入String myStr = "Hello"; 来声明 String 变量,可以使用def myStr = "Hello";(分号可有可无)。 除此之外,Groovy 代码还能在运行时轻松地改变自己。这实际上意味着，能够在运行时轻松地为对象指定新方法和属性。这一编程领域称为元编程，Groovy 能够很好地支持这种编程方式。在学习本教程的过程中，您将了解到关于 Groovy 的动态性质的更多内容。现在惟一要补充的是，您会惊讶地发现，在 Groovy 会使操作 XML 或普通的 java.io.File 实例变得非常轻松。 一体两面 用Groovy 编写的任何内容都可以编译成标准的 Java 类文件并在 Java 代码中重用。类似地，用标准 Java 代码编写的内容也可以在 Groovy 中重用。所以，可以轻易地使用 Groovy 为 Java 代码编写单元测试。而且，如果用 Groovy 编写一个方便的小工具，那么也可以在 Java 程序中使用这个小工具。 Groovy是用Java实现的开源脚本语言并且和它联系紧密.它需要JDK 1.4. Groovy向Java添加了许多Ruby和Python脚本语言的特性. Groovy的特性包括动态类型（dynamic typing）, 闭包（closures）,简单对象导航（ easy object navigation）和更加简洁的Lists和Maps语法. Groovy是由James Strachan和Bob McWhirter创造的. James还参与了许多其他开源项目的开发，其中包括Jelly, dom4j, Jaxen, Betwixt和Maven. Bob是Jaxen和Drools (一个开源的面向对象的JAVA规则引擎) 的创始人. 目前最新稳定版为Groovy1.8。
Ⅶ 在java中使用groovy怎么搞
一种基于Java虚拟机的动态语言，可以和java无缝集成，正是这个特性，很多时候把二者同时使用，把groovy作为java的有效补充。对于Java程序员来说，学习成本几乎为零。同时支持DSL和其他简介的语法（例如闭包），使代码便于阅读。可以用groovy的动态特性来做规则引擎，在DB中维护脚本，业务变化的时候让应用系统动态加载。
如果引入groovy在java工程中？
这个很简单，不需要做别的事情，仅仅把groovy的二方包加入到pom文件中即可。例如：
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version> 1.8 . 3 </version>
</dependency>
java和groovy混合使用的方法有几种？
1、 静态编译 ，在java工程中直接写groovy的文件，然后可以在groovy的文件中引用java工程的类，这种方式能够有效的利用groovy自身的语言特性，例如闭包；
2、通过 groovyShell 类直接执行脚本，例如：
package groovy_dsl.shell;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;
public class GroovyShellEx {
public static void main(String[] args) {
Binding bind = new Binding();
bind.setVariable( "name" , "iamzhongyong" );
bind.setVariable( "age" , "25" );
GroovyShell shell = new GroovyShell(bind);
Object obj = shell.evaluate( "str = name+age;return str" );
System.out.println(obj);
}
}
3、通过 groovyScriptEngine 执行文件或者脚本，例如：
package groovy_dsl.script;
import groovy.util.GroovyScriptEngine;
public class ScriptEngine {
public static void main(String[] args) throws Exception {
GroovyScriptEngine engine = new GroovyScriptEngine( "" );
Object obj = engine.run( "src/main/java/groovy_dsl/script/script_test.groovy" , "iamzhongyong" );
System.out.println(obj);
}
}
4、通过 GroovyClassLoader 来执行，例如：
package groovy_dsl.classloader;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import java.io.File;
import java.io.IOException;
public class GroovyClassLoaderEx {
public static void main(String[] args) throws Exception, IOException {
GroovyClassLoader loader = new GroovyClassLoader();
for ( int i= 0 ;i< 100 ;i++){
Class<?> clazz = loader.parseClass( new File( "src/main/java/groovy_dsl/classloader/UserDO.groovy" ));
GroovyObject clazzObj = (GroovyObject)clazz.newInstance();
clazzObj.invokeMethod( "setName" , "iamzhongyong" );
clazzObj.invokeMethod( "setSex" , "Boy" );
clazzObj.invokeMethod( "setAge" , "26" );
System.out.println(clazzObj.invokeMethod( "getAllInfo" , null ));
}
}
}
使用groovy尤其需要主要的问题？
通过看groovy的创建类的地方，就能发现，每次执行的时候，都会新生成一个class文件，这样就会导致JVM的perm区持续增长，进而导致FullGCc问题，解决办法很简单，就是脚本文件变化了之后才去创建文件，之前从缓存中获取即可。
groovy中的源码如下：
return parseClass(text, "script" + System.currentTimeMillis() + Math.abs(text.hashCode()) + ".groovy" );
这个是增加缓存的代码：
GroovyClassLoader groovyClassLoader = new GroovyClassLoader(GroovyScriptExecute. class .getClassLoader());
Class<?> groovyClass = null ;
String classKey = String.valueOf(scriptClass.hashCode());
//先从缓存里面去Class文件
if (GroovyScriptClassCache.newInstance().containsKey(classKey)){
groovyClass = GroovyScriptClassCache.newInstance().getClassByKey(classKey);
} else {
groovyClass = groovyClassLoader.parseClass(scriptClass);
GroovyScriptClassCache.newInstance().putClass(classKey, groovyClass);
}
GroovyObject go = (GroovyObject)groovyClass.newInstance();
下面这个是缓存的单例类，贴一下：
public class GroovyScriptClassCache {
private static final Map<String /*class文件的描述*/ ,Class<?>> GROOVY_SCRIPT_CLASS_CACHE = new HashMap<String,Class<?>>();
private GroovyScriptClassCache(){}
private static GroovyScriptClassCache instance = new GroovyScriptClassCache();
public static GroovyScriptClassCache newInstance(){
return instance;
}
public Class<?> getClassByKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.get(key);
}
public void putClass(String key,Class<?> clazz){
GROOVY_SCRIPT_CLASS_CACHE.put(key, clazz);
}
public boolean containsKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.containsKey(key);
}
}
为啥要每次new一个GroovyClassLoader，而不是所有的脚本持有一个？
因为如果脚本重新加载了，这时候就会有新老两个class文件，如果通过一个classloader持有的话，这样在GC扫描的时候，会认为老的类还在存活，导致回收不掉，所以每次new一个就能解决这个问题了。
注意CodeCache的设置大小
对于大量使用Groovy的应用，尤其是Groovy脚本还会经常更新的应用，由于这些Groovy脚本在执行了很多次后都会被JVM编译为native进行优化，会占据一些CodeCache空间，而如果这样的脚本很多的话，可能会导致CodeCache被用满，而CodeCache一旦被用满，JVM的Compiler就会被禁用，那性能下降的就不是一点点了。
Code Cache用满一方面是因为空间可能不够用，另一方面是Code Cache是不会回收的，所以会累积的越来越多（其实在不采用groovy这种动态更新/装载class的情况下的话，是不会太多的），所以解法一可以是增大code cache的size，可通过在启动参数上增加-XX:ReservedCodeCacheSize=256m（Oracle JVM Team那边也是推荐把code cache调大的），二是启用code cache的回收机制（关于Code Cache flushing的具体策略请参见此文），可通过在启动参数上增加：-XX:+UseCodeCacheFlushing来启用。
Ⅷ jenkins执行groovy 脚本报错
Jenkins下安装groovy 插件：
编写groovy脚本：
Execute Groovy script'执行报错了，java.io.IOException: Cannot run program "groovy" (in directory "D:\Program Files (x86)\Jenkins\workspace\*******"): CreateProcess error=2, 系统找不到指定的文件。原因是Jenkins没有配置groovy的安装.
Manage Jenkins->Global Tool Configuration:
再次执行成功：
Ⅸ 六、ElasticSearch之groovy脚本执行partial update
es，其实是有个内置的脚本支持的，可以基于groovy脚本实现各种各样的复杂操作。
基于groovy脚本，如何执行partial update
准备数据
（1）内置脚本
（2）外部脚本，放在es的config/scripts下
（3）用脚本删除文档
（4）upsert操作
Ⅹ groovy语言主要是用来干什么,和JAVA的区别是什么
Groovy是Java平台上设计的面向对象编程语言。这门动态语言拥有类似Python、Ruby和Smalltalk中的一些特性，可以作为Java平台的脚本语言使用。 groovy的语法跟java完全按类似。
它和java的区别是：
一：java为强类型的语言；Groovy为弱类型，可以自动推断类型；
创建数组的时候Groovy的语法为：def intArray=[2,3,4]
创建MAP的时候Groovy的语法为：def m={}
二：Groovy默认访问修饰符为Public，可以不写访问修饰符
可以直接用def关键字定义，如：
def sayHello(){}
限定访问范围
@PackageScope修饰方法