groovy

用360浏览器就行

如有字符串"hello.world"，用"."去切割这个字符串，得到的结果却是空数组： 原因是split()是用正则去匹配切割字符串，.是正则的特殊符号，所以必须转义，用"."去切割： 另外，还可以用tokenize()方法去切割： spli()方法和tokenize()方法的对比可见如下url中的介绍： http://www.tothenew.com/blog/groovy-tokenize-vs-split/ 截图加注释如下：

1.获取请求中参数的值：设下图是我们已经建好的一步test step，它是一个rest test request，请求的参数有client_id和password两个，这一步step我们之前已经给它取名为user了假设我们现在需要获取到client_id的值（也就是testor），那么我们可以新建一个groovy script，并且写入以下代码：testRunner.testCase.testSteps["user"].getPropertyValue("client_id")在soapUI中可以把它输出，结果就是我们想要的testor2.获取响应结果的值接上文，假设user这个request的返回结果是以下的json：{ "code": 200, "message": "", "result": { "token": "F7052EEE86FA6087CC0D1B2BD8BA8040" }}那么我们想要获取到token的值，应该怎么做呢？首先，要通过SoapUI提供的GroovyUtils获取返回的xml消息的操作XmlHolderimport com.eviware.soapui.support.GroovyUtils def gu = new GroovyUtils(context)def field = gu.getXmlHolder("user#ResponseAsXml") 接着，在XmlHolder中使用Xpath获取返回字段内容，可以自己写，如下：def b= field.getNodeValue("//*:result/*:token")如果觉得太麻烦老是写错path，而且你也不嫌代码难看，可以去assertion里选择Xpath Match，直接找到这个节点，用系统提供给你的值写到groovy中即可以：def c=field.getNodeValue("//ns1:Response[1]/ns1:result[1]/ns1:token[1]")到soapUI中查看输出结果，可以看到上文的b和c两个变量都能获取到正确的token值

1.获取请求中参数的值：设下图是我们已经建好的一步test step，它是一个rest test request，请求的参数有client_id和password两个，这一步step我们之前已经给它取名为user了假设我们现在需要获取到client_id的值（也就是testor），那么我们可以新建一个groovy script，并且写入以下代码：t********.testCas.testSteps["user"].getPropertyValue("client_id")在soapUI中可以把它输出，结果就是我们想要的testor2.获取响应结果的值接上文，假设user这个request的返回结果是以下的json：{"code": 200,"message": "","result": {"token": "F7052EEE86FA6087CC0D1B2BD8BA8040"}}那么我们想要获取到token的值，应该怎么做呢？首先，要通过SoapUI提供的GroovyUtils获取返回的xml消息的操作XmlHolderimport c*.eviware.s****.support.GroovyUtils def gu = new GroovyUtils(context)def field = g.getXmlHolder("user#ResponseAsXml") 接着，在XmlHolder中使用Xpath获取返回字段内容，可以自己写，如下：def b= f***.getNodeValue("//*:result/*:token")如果觉得太麻烦老是写错path，而且你也不嫌代码难看，可以去assertion里选择Xpath Match，直接找到这个节点，用系统提供给你的值写到groovy中即可以：def c=f***.getNodeValue("//ns1:Response[1]/ns1:result[1]/ns1:token[1]")到soapUI中查看输出结果，可以看到上文的b和c两个变量都能获取到正确的token值

1.spring+jasperReport生成PDF格式的报表时报 java.lang.NoSuchMethodError: com.lowagie.text.pdf.PdfWriter.setRgbTransparencyBlending(Z)V异常 原因：iText.jar文件过旧，将之改为2.1版就没事了。2.java.lang.NoClassDefFoundError: org/codehaus/groovy/control/CompilationFailedException异常 原因：没有导入 groovy-all.jar 包，导入 groovy-all.jar 包就可以了。3.Excle 应用：java.lang.NoClassDefFoundError: org/apache/poi/hssf/usermodel/HSSFCellStyle出现上述错误提示加入 poi-3.2-FINAL-20081019.jar4.net.sf.jasperreports.engine.JRRuntimeException: Could not load the following font :pdfFontName : STSong-LightpdfEncoding : UniGB-UCS2-HisPdfEmbedded : false出现上述错误提示加入iTextAsian.jar5.java.lang.NoClassDefFoundError: org/apache/commons/digester/Digester出现上述错误提示加入commons-digester-1.7.jar iReport/lib 功能简述：解析 xml 文件；6.java.lang.NoClassDefFoundError: org/apache/commons/collections/ArrayStack出现上述错误提示加入commons-beanutils-1.7.jar iReport/lib 7.java.lang.NoClassDefFoundError: org/apache/commons/collections/ReferenceMap出现上述错误提示加入commons-collections-2.1.jar iReport/lib

标题：小樱歌词库-Groovy!-日文 [点击:537]街に出かけよう 一人でいたって 暗いだけでしょループして落ち込んで なおさら ah 悩んじゃって 外に飞び出そう 心配イラナイ大昔から 地球だってまわってるきっと ツキだってまわるよBrand-New Love Song ハレハレルヤ！みんなハジけて爱し合おう単调な日常 通常な感情守らなくちゃダメなこと いつもある街を见渡そう 电话やパソコンも未来の扉隠れてる 探そうよ この世は宝岛さ一绪にはばたこう 楽しいことしよう大昔から 夜は明ける 阳は升る绝対 太阳は照らすのGroovy Love Song ハレハレルヤ！ヤなこと忘れ爱し合おう同情な现状 顽丈な友情动かなくちゃダメな时 いつもあるDancing in the streetGrooving to the light through the nightBrand-New Love Song ハレハレルヤ！みんなハジけて爱し合おうGroovy Love Song ハレハレルヤ！ヤなこと忘れ爱し合おうBrand-New Love Song ハレハレルヤ！明日のために踊ろうGroovy Love Song ハレハレルヤ！动かなくちゃダメな时 いつもある优しくなりましょう素直になりましょう…

歌曲名:Groovy Now (Album Version)歌手:Metis专辑:Time And ChanceGroovyMetis作词：Metis作曲：Metis闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationボクラ明日今だまだ未完成试せ可能性感性あびる为の君の天性绝望超えて覚醒人生は起死回生　决定戦狙え!　大逆転神がくれたスパルタBrand New FutureCome on!　Everybody Clap!Come Follow me.　Trust me.Take my hand.　Believe in me梦もIt"s all right!手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!人类が母体という豪华客船で言い争うプレジデント今日も目指す光の新惑星仆らはいつも 胜手Makin"Love　Makin"Loveベイビーもメイビー手にすり抜けてくメモリー我等に壊れた爱のメロディー奏で　One more time clap!Come Follow me.　Trust me.流れる音にまかせて爱もMake it right!また手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんです波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんですGroovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationhttp://music.baidu.com/song/549511

groovy代码[java] view plaincopypackage com.ingping.core import org.codehaus.groovy.grails.commons.ConfigurationHolder /** * Created by IntelliJ IDEA. * User: Web-03 * Date: 11-4-21 * Time: 下午3:43 * To change this template use File | Settings | File Templates. */ class SystemConfigRead { /* * 读取邮件验证访问路径 */ static String readEmailCodeUrl(){ ConfigurationHolder.config.site.emailCodeUrl } } -------------------------------------------------------------------------------------第一种，网上大部分都是这种[java] view plaincopy/** * JAVA调用GROOVY * @throws IOException * @throws IllegalAccessException * @throws InstantiationException * 添加人：** * 添加时间：211-08-30 14:27 */ public void groovyToJava() throws IOException, IllegalAccessException, InstantiationException { ClassLoader parent = getClass().getClassLoader(); GroovyClassLoader loader = new GroovyClassLoader(parent); //找到指定的groovy类 Class groovyClass = loader.parseClass(new File("site/grails-app/utils/com/ingping/core/SystemConfigRead.groovy")); //将对象实例化并且强制转换为GroovyObject对象 GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance(); //readEmailCodeUrl方法名，null 参数值，没有为null System.out.println("" + groovyObject.invokeMethod("readEmailCodeUrl", null)); } 第二种，真正常用，有用的是这样的，不要被蒙蔽了，JAVA类是可以直接调用GROOVY类的。[java] view plaincopySystemConfigRead.readEmailCodeUrl();

今天细说一下elasticsearch的update更新功能，以及如何利用script脚本更新数据。想要使用script脚本功能,需要在配置文件elasticsearch.yml里设置Pythonscript.disable_dynamic: false关于elasticsearch script的文章，总是会没完没了的修改ES支持更新，但是更新的方式是通过一个提供的脚本进行的。ES的做法是，通过index找到相应的存放记录的节点，然后执行脚本，执行完之后，返回新的索引。实际上执行的是一个get和reindex的过程，在这个过程中，通过versioning来控制没有其它的更新操作（这个功能是0.19后可用的）。具体实现的原理应该和elasticsearch Versioning相关。get，reindex的含义是，ES先取出这条记录，然后根据新数据生成新记录，然后在把新记录放回到ES中（并不会覆盖老的记录）。现在没有数据，首先我们需要创建一条记录Python$ curl -XPUT localhost:9200/xiaorui.cc/blog/1 -d "{ "counter" : 1, "tags" : ["red"]}"$ curl -XPUT localhost:9200/xiaorui.cc/blog/1 -d "{ "counter" : 1, "tags" : ["red"]}"直接修改数据,一定要注意，直接update的化，会覆盖以前的数据，另外update的时候，需要/index/type/id ,一定要带着id。 elasticsearch 应该不支持搜索query方式update修改数据。 Pythoncurl -XPUT "localhost:9200/xiaorui.cc/blog/1?pretty" -d "{ "name": "xiaorui.cc"}"curl -XPUT "localhost:9200/xiaorui.cc/blog/1?pretty" -d "{ "name": "xiaorui.cc"}"elasticsearch提供了doc这个局部更新参数，他可以局部修改，而不会直接覆盖以前的数据，这会针对特定的k v，字段修改。 Pythoncurl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update?pretty" -d "{ "doc": { "name": "ruifengyun" }}"curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update?pretty" -d "{ "doc": { "name": "ruifengyun" }}"当Elasticsearch API不能满足要求时，Elasticsearch允许你使用脚本实现自己的逻辑。脚本支持非常多的API，例如搜索、排序、聚合和文档更新。脚本可以通过请求的一部分、检索特殊的.scripts索引或者从磁盘加载方式执行。下面是es script的用法，这些脚本是groovy开发的。 下面的语句的意思是说，将counter的值加4Python$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.counter += count", "params" : { "count" : 4 }}"$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.counter += count", "params" : { "count" : 4 }}"通过上面的例子，我们知道tags是个列表，如果用doc局部更新的语法，他是无法做到append的，还是会覆盖tags这个字段。 那么怎么实现列表扩展？ 请使用elasticsearch script实现。 Python$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.tags += tag", "params" : { "tag" : "white" }}"$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.tags += tag", "params" : { "tag" : "white" }}"_update也支持upsert功能，没有这个字段或者key，也会添加这个记录。下面是一个例子，如果没有counter字段，则插入该字段：Python$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.counter += count", "params" : { "count" : 4 }, "upsert" : { "counter" : 1 }}"$ curl -XPOST "localhost:9200/xiaorui.cc/blog/1/_update" -d "{ "script" : "ctx._source.counter += count", "params" : { "count" : 4 }, "upsert" : { "counter" : 1 }}"下面我们来复杂点的groovy script脚本用法. 当你的source没有china这个key,那么我会增加一个kvPythoncurl -XPOST "http://localhost:9200/xiaorui.cc/blog/80/_update" -d"{ "script": "if (!ctx._source.containsKey("china")) { ctx._source.attending = newField }", "params" : {"newField" : "blue" }, "myfield": "data"}"curl -XPOST "http://localhost:9200/xiaorui.cc/blog/80/_update" -d"{ "script": "if (!ctx._source.containsKey("china")) { ctx._source.attending = newField }", "params" : {"newField" : "blue" }, "myfield": "data"}"下面的script语法相对复杂的，会遍历一组字典,然后进行判断赋值。{ “55555″: 22, “name”: “lisi”, “distr_pan”: [ { “k”: 15, “v”: 15 }， { “k”: 20, “v”: 20 } ] }Python$ curl -XPUT "localhost:9200/xiaorui.cc/blog/9123/_update" -d "{ "script" : "def x = false;ctx._source.distr_pan.each({if(it.get("k")==target){x=true}});if(x){ctx._source.distr_pan +=v}", "params":{ "v":{"k":nlp, "v":35}, "target":15 }}$ curl -XPUT "localhost:9200/xiaorui.cc/blog/9123/_update" -d "{ "script" : "def x = false;ctx._source.distr_pan.each({if(it.get("k")==target){x=true}});if(x){ctx._source.distr_pan +=v}", "params":{ "v":{"k":nlp, "v":35}, "target":15 }}elasticsearch script就讲解到这里了，很多例子已经简单明了… script貌似不是很安全，最少远程代码执行的漏洞暴露过几次了. 下次把python版的script走一遍试试. 貌似对于我们你者来说，不管是groovy python，没什么太大却别，语法看起来都一个模子。

歌曲名:So Easy歌手:Winston Groovy专辑:Please Don"T Make Me Cry: The Best Of潘美辰 - SO EASY(如此容易)当你对生活感到疲倦你必须做些改变许多从来没有做过的事不妨就尝试一遍日子会变得新鲜当你对爱情感到危险你需要时间考验或许暂时离开他的身边给自己换个空间也不要苦苦相约SO EASY 只要你放开自己把一切当作游戏不要说什么道理不要怀疑FLOVE ME 唱一首快乐的歌来一段轻松摇摆给心情一个彩旗把烦恼全部抛弃SO EASY。。。。。FLOVE ME。。。。。http://music.baidu.com/song/10318746

package com.ldc.test; import java.util.Scanner; /** * * @author 愿做无聊听众6 * */ public class Test { public static void main(String[] args) { String str="127"; int i=Integer.valueOf(str);//转int long l=Long.valueOf(str);//转l

if (a) { // a可以是任意类型 System.out.println("a不为空")}if (a) 等效于 if (a != null)

不需要引入任何包，print是groovy内置的函数，默认会调用System.out.println("")

for(int i=0;i<5;i++) { println "This is $i" }

动态拼接xml报文，和解析xml报文

Catch You Catch Me 广濑香美的中文歌词 想见却见不到的这种难受心情 老是错失说不出口却又想说的机会 但是想展开翅膀,我俩一起地 在天空跑马拉松,共谱美梦 你瞧,catch you catch you catch me catch me等等我 请看这里,跟我说爱我 是的,Nice to meet you Good to see you一定 让我的想念飞向你心扉 不迷惑地 有时候啊,身体的动能会丧失 却因你的笑容,总是处在满电状态而能量即将爆发 求求你,请先从朋友做起 想过着欢乐,注视,快乐的每一天 你瞧,catch you catch you catch me catch me绝对 不论是命中注定或是非常相配 是的,Nice to meet you Good to see you一定 不会输给任何人地是世界上最最最 爱．恋．你．的 你瞧,catch you catch you catch me catch me等等我 请看这里,跟我说爱我 是的,Nice to meet you Good to see you一定 让我的想念飞向你心扉 不迷惑地 你瞧,catch you catch you catch me catch me绝对 不论是命中注定或是非常相配 是的,Nice to meet you Good to see you一定 不会输给任何人地是世界上最最最 爱．恋．你．的 =============================== 《Groovy!》中文歌词: 上街去吧！ 一个人的话只不过是黑暗孤单罢了 翻跟斗落下来只会更加烦恼不已 飞奔出去吧！ 不用担心 从古早开始地球就旋转着 月亮一定也都跟着旋转呀！ Brand-New Love Song哈里露亚！ 大家敝开心胸来相亲相爱吧！ 虽单调的日常生活，平淡的感情 却常常也会有要守护的东西 眺望城市，电话和电脑都是通往未来的门 隐藏然後找寻哟！ 这世上是宝岛 一起拍动翅膀，做点快乐的事吧！ 从古早开始，夜晚到天明，太阳也会升起 太阳绝对会照耀大地的 Groovy Love Song 哈里露亚！ 忘掉讨厌的事相亲相爱吧！ 虽同情的现状，坚定的友情 却常常会有得行动的时候 Dancing in the street Grooving to the light through the night Brand-New Love Song哈里露亚！ 大家敝开心胸来相亲相爱吧！ Groovy Love Song哈里露亚！ 忘掉讨厌的事相亲相爱吧！ Brand-New Love Song哈里露亚！ 为了明天而跳舞吧！ Groovy Love Song哈里露亚！ 常常也会有不得不行动的时候 变得温柔吧 变得坦率吧┅┅┅

1.在maven中引入groovy依赖例：<properties> <!--在这里控制groovy 版本 --> <groovy.version>2.0.8</groovy.version> <project.build.sourceEncoding>utf8</project.build.sourceEncoding></properties><dependencies> <dependency> <groupId>org.codehaus.groovy</groupId> <artifactId>groovy-all</artifactId> <version>${groovy.version}</version> </dependency></dependencies>

图呢？

转换方法：import java.io.*; import org.json.*;public class Demo {public static void main(String[] args) throws Exception {String str = "{"id_no":"342422198012001122","mobile_no":"13666667789","name":"徐丽"}";JSONObject obj = new JSONObject(str); //在这里转换。System.out.println(obj);System.out.println(obj.get("id_no")); // "342422198012001122"} }要引入fast-json的包或者开源的包json.jar有用记得采纳

#include <<a href="https://www.baidu.com/s?wd=stdio.h&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1YLm1IBPjf3mWm4mhm4PWK90ZwV5Hcvrjm3rH6sPfKWUMw85HfYnjn4nH6sgvPsT6KdThsqpZwYTjCEQLGCpyw9Uz4Bmy-bIi4WUvYETgN-TLwGUv3EnHDknHD4njRkP1TvPWDLPHf4rf" target="_blank" class="baidu-highlight">stdio.h</a>> int iMax = 0; int fooMax(int arr[], int n) { int i; for (i = 0; i < n; i++) if (iMax < arr[i]) { iMax = arr[i]; } return iMax;} int main() { int arr[5] = { 10, 8, 15, 7, -1 }; printf("Max : %d ", fooMax(arr, 5)); printf("Max : %d ", iMax); return 0;}

街まち 出（で）かけ 暗（くら）い落（お）ち込（こ）んで 悩（なや）んじゃって外（そと） 飞（と）び出（だ）そう 心配（しんぱい）大昔（おおむかし） 地球（ちきゅう）爱（あ）し合（あ）おう単调（たんちょう） 日常（にちじょう） 通常（つうじょう） 感情（かんじょう）守（まも）らなく街（まち） 见渡（みわた）そう 电话（でんわ） 未来（みらい） 扉（とびら）隠（かく）れて 探（さが）そう この世（よ） 宝岛（たからじま）一绪（いっしょう）に 楽（たの）しい大昔（おおむかし） 夜（よる） 明（あ）ける 阳（よう） 升（のぼ）る绝対（ぜったい） 太阳（たいよう） 照（て）らす忘（わす）れ爱（あ）し合（あ）おう同情（どうじょう） 现状（げんじょう） 顽丈（がんじょう）动（うご）かない 时（とき）爱（あ）し合（あ）おう忘（わす）れ爱（あ）し合（あ）おう明日（あした或者あす） 踊（おど）ろう动（うご）かなく 时（とき）优（やさ）しく素直（すなお）

使用eclipse生成文档（javadoc）主要有三种方法： 1，在项目列表中按右键，选择Export（导出），然后在Export(导出)对话框中选择java下的javadoc，提交到下一步。 在Javadoc Generation对话框中有两个地方要注意的： javadoc command:应该选择jdk的bin/javadoc.exe destination:为生成文档的保存路径，可自由选择。 按finish(完成)提交即可开始生成文档。 2，用菜单选择：File->Export(文件－>导出)， 剩下的步骤和第一种方法是一样的。 3，选中要生成文档的项目，然后用菜单选择， Project->Generate Javadoc直接进入Javadoc Generation对话框，剩余的步骤就和第一种方法在Javadoc Generation对话框开始是一样的。---------------------------------------------------------1、选中项目，然后选project->Generate javadoc...，弹出setting对话框。在javadoc command地方选jdkinjavadoc.exe如C:jdk1.6injavadoc.exe，visibility可以自己设，一般选public，输出路径自己选。2、点next，下一步基本不需要设。3、再点next，这里要在extra javadoc options地方设定编码，不设的话中文会有乱码。如我的是utf-8，则为-encoding UTF-8-charset UTF-8点finish就可以输出java doc了。

和java一样···

Groovy语法与java语法基本上可以兼容，最近项目中使用groovy进行一些模块的开发。 发现抛了一个 GroovyRuntimeException: Ambiguous method overloading for method 异常。 原因是调用java的重载方法时， 传入参数为null值， groovy解析器无法判断使用哪个重载而抛出这个异常。isNotEmpty()方法有以下重载： groovy运行结果： 解决方案：groovy在调用重载方法，入参可能为空时，先进行判空，避免踩坑！ java中对于重载方法传参null不会抛异常， 还是很强大滴~

可以执行一个，不过好像一次执行不了多个。。你要多调用几次。。类似，你要调用 ipconfig ，再调用 ping可以试试如下代码，我已经调试通过：import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.ArrayList;import java.util.HashMap;public class Test {

你这语法不对呀，groovy里面的数组叫做区间，定义区间的方式是def ia = [];for(int i=0;i<serverhi.length;i++){ ia << Integer.parseInt(serverhi[i]);}而上面报的错是说serverhi没有length这个属性，那么你的serverhi是一个字符串，并不是一个字符串数组，java中定义数据的方式是String[] serverhi ，int[] ia；修改一下你的代码吧

String dst = "一个待生成md5值的字符串";MessageDigest md = MessageDigest.getInstance("MD5");md.update(dst.getBytes());// 将original传给md5byte[] digest = md.digest();// 产生md5序列StringBuffer sb = new StringBuffer();// 转换md5值为16进制for (byte b : digest) {sb.append(String.format("%02x", b & 0xff));}System.out.println("原值:" + dst);System.out.println("MD5:" + sb);

java调用c，好像只能用JNI吧。

java和groovy肯定能混编，java & groovy混编：一种最“势利”的折衷而groovy，说它是java++也不为过，因为java代码直接就可以被groovy编译, groovy完全兼容java语法。

idea写.groovy文件，报需要配置Groovy SDK： 点击Configure Groovy SDK，若Use library找不到groovy的sdk的话，需要手动去Create配置。 另外，在idea中无法切到/user目录下，mac按Cmd + Shift + G来切换目录。

Grails enhances the HttpServletRequest instance by adding the following new properties and methods:XML - An instance of XmlSlurper"s GPathResult class that allows parsing of an incoming XML request (useful for REST).JSON - An instance of Grails" JSONObject class that allows parsing of an incoming JSON request (useful for JSON based REST).forwardURI - Useful for obtaining the current request URI since the request objects requestURI property returns the original URI, not the matched one.get - Returns true if the current request is an HTTP GET request.post - Returns true if the current request is an HTTP POST request.each - Implementation of Groovy"s each method for iterating over request attributes.find - Implementation of Groovy"s default find method for searching request attributes.findAll - Implementation of Groovy"s default findAll method for searching request attributes.format - The request format, used for content negotiation.The XML and JSON properties are useful for XML APIs and can be used to parse incoming XML or JSON packages. For example given a request body of:<book> <title>The Stand</title></book>This can be parsed trivially:def title = request.XML?.book?.titlerender "The Title is $title"Request attributes which are normally accessible via the getAttribute can also be indexed into using the array index operator or de-reference operator:def user = request["user"]request["user"] = "John"asset "John" == request.user

ef execute（cmd）{ def proc = cmd.execute（） proc.waitFor（）} execute（“touch file”） execute（“echo hello> file”）

获取对象指定的文件名或路径。window.location.pathname获取整个 URL 为字符串。window.location.href设置或获取与 URL 关联的端口号码。alert(window.location.port)获取 URL 的协议部分。window.location.protocol获取 href 属性中在井号“#”后面的分段。window.location.hash获取 location 或 URL 的 hostname 和 port 号码。window.location.host获取 href 属性中跟在问号后面的部分。window.location.search获取变量的值(截取等号后面的部分) var url = window.location.search; var loc = url.substring(url.lastIndexOf("=")+1, url.length);

例如，我们经常需要对一个字符串进行如下的判断： if(str!=null&&!str.equals("")) { ...... }输入这样的语句的确使人生厌，而且有时候还会忘掉输入“!str.equals("")”语句中的“!”导致代码出现逻辑错误。而敏捷的Groovy语言开发就不需要我们担心...

答案是肯定的，java & groovy混编：一种最“势利”的折衷而groovy，说它是java++也不为过，因为java代码直接就可以被groovy编译, groovy完全兼容java语法, 对一般java开发人员来说，这真是太亲切了

例如，我们经常需要对一个字符串进行如下的判断： if(str!=null&&!str.equals("")) { ...... }输入这样的语句的确使人生厌，而且有时候还会忘掉输入“!str.equals("")”语句中的“!”导致代码出现逻辑错误。而敏捷的Groovy语言开发就不需要我们担心这样的问题。同样的判断语句，我们只需要输入下面的代码： def str = null if(str) { println"str is not null" } else { println"str is null" }这个语句段的执行结果为：str is null可以看出，if(str)判断语句，当str为null的时候，不执行。你可能要问，当str = ""的时候会怎样呢？ def str = "" if(str) { println"str is not null" } else { println"str is null" }执行结果还是：str is null这样，我们可以把开头的那段Java代码改写成如下的代码了： if(str) { ...... }这样就简洁多了。不是吗？除了字符串对象，那其他对象的非空判断呢？我们来看下面的例子： def map = ["key1":"value1"] if(map) { println"map is not null" } else { println"map is null" } map.remove("key1") if(map) { println"this time,map is not null" } else { println"this time,map is null" } 执行结果为：map is not nullthis time,map is null 同样，我们来看看List对象： def list = [] if(list) { println"list is not null" } else { println"list is null" } list

在Groovy里可以很方便的得到命令行的返回值（exitValue函数）： def cmd ="ls -lrt " def proc =cmd.execute() proc.waitFor() // 用以等待外部进程调用结束 println proc.exitValue() 如果需要在特定的folder运行可以用下面的代码

一、代码块在代码块中用def关键字定义的变量不能在外部访问，如:try{def msg="Hello,world!";}//pringln msg;如果运行最后一行"println msg;"，则会报错。但是，在代码块中没有用def关键字声明的变量，就可以在外部访问，如:try{msg="Hello,world!";}println msg;已经使用def定义的变量，不能再次用def定义: def a=10;//def a=20;代码块是可以嵌套的:try{try{try{println "Hello,world!";}}}二、闭包闭包是可以引用外部上下文环境的一系列语句。可以将闭包赋予一个变量，并在稍后执行。每个闭包都有一个返回值，默认的返回值就是该闭包中最后一行语句的结果闭包可以访问外部的变量

juese取值不能为null，你的constraints做了限定，所以报这个错误。

Jenkins下安装groovy 插件：编写groovy脚本：Execute Groovy script"执行报错了，java.io.IOException: Cannot run program "groovy" (in directory "D:Program Files (x86)Jenkinsworkspace*******"): CreateProcess error=2, 系统找不到指定的文件。原因是Jenkins没有配置groovy的安装. Manage Jenkins->Global Tool Configuration:再次执行成功：

在Groovy里可以很方便的得到命令行的返回值（exitValue函数）：def cmd ="ls -lrt " def proc =cmd.execute() proc.waitFor() // 用以等待外部进程调用结束 println proc.exitValue()如果需要在特定的folder运行可以用下面的代码path -- 相当于运行目录cmd.execute(null, new File(path))

Thread.start { //这里是另外开启一个线程运行（异步） System.out.println("异步运行")}

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的动态特性允许对象和类都能够在运行期动态地添加方法和属性，在复杂的应用场景，我们很难判断一个具体的对象是否有某个方法。也有这么一个应用场景，是我所经历到的，Groovy脚本代码被不同的Java应用系统加载，脚本依赖于各个应用系统提供的java环境运行，这个环境包括当前应用的classpath中有哪些jar包，jar包版本等等，以及由具体应用系统通过bingding对象向脚本中注入的一系列的作为技术服务的bean，比如获取数据的接口bean。有时候我们各个性用系统的这些环境不一致，导致运行同一个Groovy脚本出现错误，很多由于jar包版本的原因，出现找不到方法，找不到属性的情况。这就要求我们这在运行时动态判断对象的属性和方法是否存在。好在Groovy在1.1之后就提供了这样的判定支持。具体来看首先，我们声明了Foo类，包含了一个name属性和一个方法。通过对象的MetaClass的hasProperty方法我们可以判定并获得该属性对象的引用，通过MetaClass的respondsTo我们可以判定并获得该方法的引用

选择到这儿来发帖，有部分原因还是我对groovy更熟悉些。 确实是James Strachan创造了Groovy，（具体我没有去查，不过看“James Strachan”的博客，大家并没有对这点提出异议），但是“倒戈”这个词用得不好，这点我道歉。 你提到的那篇文章我在学groovy时也看到了： 我个人觉得这句话是个很大的误导（以前我就是因为这句话而放弃了看scala的），基本上来说没有一个正常人人会：“为了不同而不同”，scala的语法熟悉了以后会发现都是有道理的（个人觉得也是挺优美的），scala是为了保证“自认为的”语法上的完美，所以抛弃很多他认为java不对的语法，但是这确实造成的学习曲线高昂的代价。 我认为scala最大的优势（其实应该说是 区别），是他是静态语言。 对于静态语言IDE能提供很大的帮助，函数、域的调用提示、检查，重构。这些都是动态语言IDE无法做到的，有一种观点认为“大型系统必须要架构在静态语言之上”，我比较认同这种观点。 当然动态语言灵活快捷，这些都是公认的，这方面想必大家都深有感受，我就不多说了。

。

新建一个main类，创建两个线程，分别去调用两个main类

在GroovyConsole运行以下代码，结果良好。importgroovy.xml.StreamingMarkupBuilder//theoriginalXMLdefinput=""//addattributeName="attributeValue"totherootdefroot=newXmlSlurper().parseText(input)root.@attributeName="attributeValue"//getthemodifiedXMLandcheckthatitworkeddefoutputBuilder=newStreamingMarkupBuilder()StringupdatedXml=outputBuilder.bind{mkp.yieldroot}assert""==updatedXml增加一个特性与读一个特性是一样的：importgroovy.xml.StreamingMarkupBuilderdefinput=""""""defroot=newXmlSlurper().parseText(input)root.@stuff="new"defoutputBuilder=newStreamingMarkupBuilder()Stringresult=outputBuilder.bind{mkp.yieldroot}printlnresult将生成：

用groovy脚本自定义ElasticSearch查询，来实现以上功能。例，数据中包含字段birdtyday，记录游客生日："birthday": "1992-02-05 00:00:00",新建文件getAgeByBirthday.groovy，编辑其内容为:def b = doc[birthday_field].valuedef birthday = new Date(b) def now = new Date() long age = (now -birthday)/365age并把此文件放在es的config/scripts目录下(如果没有此目录就新建一个)。然后在config/elasticsearch.yml文件中加一行:script.groovy.sandbox.enabled: true最后重启es即可。接下来，我们就可以用以下DSL进行年龄统计了GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"aggs": {"counts_by_age": {"terms": {"script_file": "getAgeByBirthday","params": {"birthday_field": "birthday"},"size": 100}}}}或者：GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"aggs": {"histogram_by_age": {"histogram": {"script_file": "getAgeByBirdthday","params": {"birdthday_field": "birdthday"},"interval": 5}}}}不过脚本查询性能不佳，且不能利用es的缓存，所以在大数据量或高性能要求的场景下不适用。。-------------------------------------补充一个自定义的年龄range过滤:range_AgeByBirthday.groovy:def b = doc[birdthday_field].valuedef birdthday = new Date(b) def now = new Date() long age = (now -birdthday)/365gte<=age && age<=lteDSL:GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"query": {"filtered": {"filter": {"script": {"script_file": "range_AgeByBirdthday","params": {"birdthday_field": "birdthday","gte": 50,"lte": 60}}}}},"aggs": {"histogram_by_age": {"histogram": {"script_file": "getAgeByBirdthday","params": {"birdthday_field": "birdthday"},"interval": 5}}}}

1.下载eclipse的groovy插件2.新建java工程3.在工程的名字上面点击右键，在弹出的窗口中选add groovy nature4.设置工程property属性，参见附件截图，去掉disable groovy compiler generating class file4.新建一个groovy类5.运行。run as java application

可以

歌曲名:Groovy歌手:Burning Spear专辑:Man In The Hills / Dry & HeavyGroovyMetis作词：Metis作曲：Metis闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationボクラ明日今だまだ未完成试せ可能性感性あびる为の君の天性绝望超えて覚醒人生は起死回生　决定戦狙え!　大逆転神がくれたスパルタBrand New FutureCome on!　Everybody Clap!Come Follow me.　Trust me.Take my hand.　Believe in me梦もIt"s all right!手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!人类が母体という豪华客船で言い争うプレジデント今日も目指す光の新惑星仆らはいつも 胜手Makin"Love　Makin"Loveベイビーもメイビー手にすり抜けてくメモリー我等に壊れた爱のメロディー奏で　One more time clap!Come Follow me.　Trust me.流れる音にまかせて爱もMake it right!また手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんです波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんですGroovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationhttp://music.baidu.com/song/7917973

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 = """onetwothree"""//需要注意的是，这个字符串每一次换行都包含了一个换行转义符：assert str.contains(" ") == trueassert str.size() == 14//可以通过使用反斜杠换行符剥离该字符def str = """onetwothree"""assert str.contains(" ") == falseassert str.size() == 11

歌曲名:Groovy歌手:Burning Spear专辑:Man In The HillsGroovyMetis作词：Metis作曲：Metis闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationボクラ明日今だまだ未完成试せ可能性感性あびる为の君の天性绝望超えて覚醒人生は起死回生　决定戦狙え!　大逆転神がくれたスパルタBrand New FutureCome on!　Everybody Clap!Come Follow me.　Trust me.Take my hand.　Believe in me梦もIt"s all right!手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!人类が母体という豪华客船で言い争うプレジデント今日も目指す光の新惑星仆らはいつも 胜手Makin"Love　Makin"Loveベイビーもメイビー手にすり抜けてくメモリー我等に壊れた爱のメロディー奏で　One more time clap!Come Follow me.　Trust me.流れる音にまかせて爱もMake it right!また手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんです波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんですGroovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationhttp://music.baidu.com/song/8537847

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 = """onetwothree"""//需要注意的是，这个字符串每一次换行都包含了一个换行转义符：assert str.contains(" ") == trueassert str.size() == 14//可以通过使用反斜杠换行符剥离该字符def str = """onetwothree"""assert str.contains(" ") == falseassert str.size() == 11

Groovy 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。 Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。（在这点上，Ruby 与 Groovy 不同，因为它的语法与 Java 语法差异很大。）

groovy、hydro和indigo是三个不同词义的单词。groovy是形容词“绝妙的、流行的”的意思。Groovy是一种基于JVM（Java虚拟机）的敏捷开发语言，它结合了Python、Ruby和Smalltalk的许多强大的特性，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。hydro则是水疗院的意思。水疗(hydrotherapy)是利用不同温度、压力和溶质含量的水， 以不同方式作用于人体以防病治病的方法。indigo是名词“靛蓝色”、形容词“靛蓝色的”的意思。1、groovy 英[u02c8gru:vi] 美[u02c8ɡruvi] adj. 绝妙的; 槽的，沟的; 流行的; 最佳状态的; [例句]Once again, I am taking advantage of the seamless integration between the Java language and Groovy.我再次利用了Java语言和Groovy之间的无缝集成。[其他] 比较级：groovier 最高级：grooviest 2、hydro 英[u02c8hau026adru0259u028a] 美[u02c8hau026adrou028a] n. 水疗院; [例句]One suspects that hydro power is still the lesser evil.有人认为水力发电仍旧是两害相较取其轻。3、indigo 英[u02c8u026andu026agu0259u028a] 美[u02c8u026andu026agou028a] n. 靛蓝色; 靛蓝，靛蓝染料; [植] 槐蓝属植物; adj. 靛蓝色的; [例句]Indigo tattoos adorn her forehead.她的前额纹着靛青色的刺青。[其他] 复数：indigoes

歌曲名:Groovy歌手:Arling & Cameron专辑:All-InGroovyMetis作词：Metis作曲：Metis闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationボクラ明日今だまだ未完成试せ可能性感性あびる为の君の天性绝望超えて覚醒人生は起死回生　决定戦狙え!　大逆転神がくれたスパルタBrand New FutureCome on!　Everybody Clap!Come Follow me.　Trust me.Take my hand.　Believe in me梦もIt"s all right!手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!人类が母体という豪华客船で言い争うプレジデント今日も目指す光の新惑星仆らはいつも 胜手Makin"Love　Makin"Loveベイビーもメイビー手にすり抜けてくメモリー我等に壊れた爱のメロディー奏で　One more time clap!Come Follow me.　Trust me.流れる音にまかせて爱もMake it right!また手に入るって!Groovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんです波に乗れよタフLifeに上手く使えタフ&ラフフロアが沸き立つ若者はおどるのが仕事です地球が揺れてますムシャクシャな毎日に疲れますだから踊るのです太古の昔からそーなんですGroovy GroovyPlease don"t stop the musicGroovy Groovy跳びな　皆マッシヴGroovy GroovyLet"s everybody Shakin"Feel your heart!!Groovy GroovyPlease don"t stop musicGroovy Groovy跳びな　皆Jumpin"Groovy GroovyLet"s everybody Shakin"Feel your heart!!闻きな! Every nation手をとり Communication生み出せ Vibration宇宙からの 未来 Invitation闻きな! Every nation手をとり Imagination人が打つ波の Vibration星导く未来 Invitationhttp://music.baidu.com/song/8467712

Groovy 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。在编写新应用程序时，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。目前的 Groovy 版本是 1.6.3，在 Java 1.4 和 Java 5 平台上都能使用，也能在 Java 6 上使用。　　Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。（在这点上，Ruby 与 Groovy 不同，因为它的语法与 Java 语法差异很大。）　　许多 Java 开发人员非常喜欢 Groovy 代码和 Java 代码的相似性。从学习的角度看，如果知道如何编写 Java 代码，那就已经了解 Groovy 了。Groovy 和 Java 语言的主要区别是：完成同样的任务所需的 Groovy 代码比 Java 代码更少。（有时候会少很多！）

歌曲名:Groovy!歌手:広瀬香美专辑:Groovy!『Groovy!』「カードキャプターさくら」ED1歌　：広瀬 香美作词／作曲：広瀬 香美编曲：本间昭光、広瀬 香美街に出かけよう　一人でいたって　暗いだけでしょループして 落ち込んで　なおさら　ah　悩んじゃって外に飞び出そう　心配イラナイ大昔から　地球だってまわってるきっと　ツキだってまわるよBrand-New Love Song　ハレハレルヤ！みんなハジけて爱し合おう単纯な日常　通常な感情守らなくちゃダメなこと　いつもある街を见渡そう　电话やパソコンも未来の扉隠れてる　探そうよ　この世は宝岛さ一绪にはばたこう　楽しいことしよう大昔から　夜は明ける　日は升る绝対　太阳は照らすのGroovy Love Song　ハレハレルヤ！ヤなこと忘れ爱し合おう同情な现状　顽丈な友情动かなくちゃダメな时　いつもあるDancing in the streetGrooving to the light through the nightBrand-New Love Song　ハレハレルヤ！みんなハジけて爱し合おうGroovy Love Song　ハレハレルヤ！ヤなこと忘れ爱し合おうBrand-New Love Song　ハレハレルヤ！明日のために踊ろうGroovy Love Song　ハレハレルヤ！动かなくちゃダメな时　いつもある优しくなりましょう素直になりましょう优しくなりましょう素直になりましょう优しくなりましょう终わるhttp://music.baidu.com/song/56010443

● 是一个基于 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 开发者快速适应。在设计 Groovy 时，我们努力不让用户感到惊讶，即遵循“最小惊讶”原则，特别是针对那些此前有 Java 开发背景的 Groovy 初学者。下面讲讲 Groovy 与 Java 的主要不同点。1. 默认导入下面这些包和类都是默认导入的，也就是说，不用再显式地使用 import 语句了：java.io.*java.lang.*java.math.BigDecimaljava.math.BigIntegerjava.net.*java.util.*groovy.lang.*groovy.util.*2. 多重方法在 Groovy 中，调用的方法将在运行时被选择。这种机制被称为运行时分派或多重方法（multi-methods），是根据运行时实参（argument）的类型来选择方法。Java 采用的是相反的策略：编译时根据声明的类型来选择方法。下面的 Java 代码可以用 Java 和 Groovy 来编译，但两种编译结果截然不同：int method(String arg) { return 1;}int method(Object arg) { return 2;}Object o = "Object";int result = method(o);用 Java 编译的结果如下：assertEquals(2, result);用 Groovy 编译的结果则为：assertEquals(1, result);产生差异的原因在于，Java 使用静态数据类型，o 被声明为 Object 对象，而 Groovy 会在运行时实际调用方法时进行选择。因为调用的是 String 类型的对象，所以自然调用 String 版本的方法。3. 数组初始化表达式在 Groovy 中，{...} 语句块是留给闭包（Closure）使用的，这意味着你不能使用以下这种格式来创建数组：int[] array = { 1, 2, 3}正确的方式是这样的：int[] array = [1,2,3]4. 包范围可见性在 Groovy 中，如果某个字段缺失了修饰符，并不会导致像在 Java 中那样形成包的私有字段：class Person { String name} 相反，它会用来创建一个属性（property），也就是一个私有字段（private field），以及一个关联的 getter 和一个关联的 setter。在 Groovy 中创建包私有字段，可以通过标注 @PackageScope 来实现。class Person { @PackageScope String name}5. ARM 语句块ARM（Automatic Resource Management，自动资源管理）语句块从 Java 7 开始引入，但 Groovy 并不支持。相反，Groovy 提供多种基于闭包的方法，效果相同但却合乎习惯。例如：Path file = Paths.get("/path/to/file");Charset charset = Charset.forName("UTF-8");try (BufferedReader reader = Files.newBufferedReader(file, charset)) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); }} catch (IOException e) { e.printStackTrace();}可以写成下面这样的代码：new File("/path/to/file").eachLine("UTF-8") { println it}或者，如果你想让它更接近于 Java 的惯用形式，可以这样写：new File("/path/to/file").withReader("UTF-8") { reader -> reader.eachLine { println it }}

准备工作安装 gradle， groovy。要使用gradle的groovy plugin 来打包groovy 脚本，项目结构。目录 含义src/main/java Java 代码src/main/resources Java需要的资源文件src/main/groovy Groovy代码，也可以包含Java代码src/test/java Java 测试代码src/test/resources 测试需要的资源文件src/test/groovy Groovy测试需要的资源文件src/sourceSet/java Java代码源src/sourceSet/resources 资源文件源src/sourceSet/groovy Groovy代码源我们只需要编译打包groovy脚本 所以只需要创建 src/main/groovy目录结构。例子：gradle_groovy_archive项目 结构是：gradle_groovy_archive创建helloWorld.groovy脚本，代码如下：package helloprintln "Gradle compile groovy"创建Gradle构建文件：apply plugin: "groovy"apply plugin: "maven"group = "com.hello"archiveBaseName = "hello"version = "0.1-SNAPSHOT"defaultTasks "clean", "jar"configurations { deployerJars}repositories { mavenCentral()}dependencies { //使用本地groovy环境 groovy localGroovy() //groovy group: "org.codehaus.groovy", name: "groovy", version: "1.8.6" compile fileTree( dir: "lib", include: ["*.jar"]) deployerJars "org.apache.maven.wagon:wagon-webdav-jackrabbit:1.0-beta-7"}sourceSets { main { groovy { srcDir "src/main/groovy" } }}uploadArchives { repositories.mavenDeployer { uniqueVersion = false configuration = configurations.deployerJars repository(id : repositoryId, url : repositoryUrl) { authentication (userName : "deployment", password : "deployment") proxy() } }}创建构建文件属性文件：//根据不同情况修改repositoryId=NDrepositoryUrl=NDsystemProp.http.proxyHost=NDsystemProp.http.proxyPort=8080systemProp.http.proxyUser=NDsystemProp.http.proxyPassword=ND在命令行中 敲 gradle 运行，会自动运行 defaultTasks,clean 和 jar，会把 所有groovy下的脚本打成jar包。

Android studio 使用groovy console命令的具体方法如下： 进行打开Android studio的软件，进入到界面中，进行点击菜单中的“tools”的选项。 就会弹出了一个下拉的菜单的选项，进行选择下拉的菜单中的“Groovy console”的选项。 在代码的窗口当中就...

proxy对象是不能序列化的，就算能序列化也不能反序列化，因为proxy对象的类是动态生成出来的，序列化后，反序列化时目标jVM肯定没有加载过这个代理类。有个变通的方法，就是获取到对象本身，序列化；反序列化后获取到原对象，再重新用代理包装即可获得反序列化后的代理对象了。不知道是否贴题。下面有个例子，虽然没有序列化和反序列化，但是基本实现了获取对象本身这个功能，希望能帮到你。另外groovy对象也是java对象，应该仍然保持groovy对象本身（个人理解，groovy我也是略懂皮毛），spring应该不会对对象本身动刀子，最多加层代理啥的。//-------------------------------------------------------------------------------import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class Test implements TestInterface{ public static void main(String[] args) { final Test t = new Test(); TestInterface t2 = (TestInterface) Proxy.newProxyInstance( Test.class.getClassLoader(), Test.class.getInterfaces(), new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { return method.invoke(t, args); } catch(InvocationTargetException ite) { throw ite.getTargetException(); } } } ); t2.test(); //使用这种方式获取原对象，序列化原对象后，反序列化原对象 重新构造代理 System.out.println(t2.getThis().getClass()); System.out.println(t2.getClass()); } public void test() { System.out.println(1); } public Test getThis() { return this; }}interface TestInterface{ public void test() ; public Test getThis() ;}

最好是使用SpringSource的ggts（Groovy Grail Tool Suit）www.springsource.org/downloads/sts-ggts

你能把你的程序搞个简易示例吗？我需要在本地调试一下才知道问题，因为编码问题通常比较麻烦，注意Java是否用了UTF-8以及Groovy是否真用了UTF-8，仅仅声明不一定就是真的编码方式，另外，Java应用程序应该也有相应的国际化解决方案吧……刚查到一个解决方案：MyResource.java 文件：import java.util.*;public class MyResource extends ListResourceBundle {public Object[][] getContents() {return contents;}static final Object[][] contents = {{ "test_proxy", "测试代理" } ,{ "test_server", "测试服务器" }};}应用方法：import java.util.*;public class MyClass {static ResourceBundle varMsg = ResourceBundle.getBundle("MyResource");public String myFunc(){Groovy中同样的道理吧~

主要讲下Android Studio如何开发Groovy，搭环境这东西，最恶心。我查了N多的外文。。。。1.AS(Android Studio)本身是支持Groovy的，Gradle用的语法就是Groovy。也可以在AS中直接创建.groovy后缀的文件。2.Project、Module的build.gradle可以将目录的展现形式改为Android来识别：（后续添加：在D:Program FilesAndroidAndroid Studiogradlegradle-2.4samplesz中有详细的使用Gradle配置的例子scala、maven、groovy、eclipse等等，看来学习方法很重要啊！）

有时在其他语言中称为字典或关联数组，Groovy具有 Map 功能。 Map 将键与值相关联， 用冒号分隔键和值，使用逗号分隔每个键/值对，以及用方括号括起的整个键和值 。 当使用键的名称时，我们实际上在Map中定义了字符串键。Groovy创建的 map 实际上是 java.util.LinkedHashMap 的实例。 如果 map 中不存在对应的键，则返回 null 。例如： 在上面的例子中，我们用了字符串类型的键，你也可以使用其他类型的值作为键： 在这里，我们使用数字作为键，因为数字可以明确地被识别为数字，因此Groovy不会像我们之前的例子那样创建字符串键。有种场景，你如果要传递一个变量代替键，让该变量的值成为键： 您还可以传递带引号的字符串以及键： ["name": "Guillaume"] 。您的字符串键必需是有效的标识符，例如您想创建一个包含哈希的字符串键，如： ["street-name": "Main street"] 。 当您需要 在 map 定义中将变量值作为键传递时，必须用括号括起变量或表达式 ：

用生成器进行构建使 Groovy 中的 Ant 更迷人的核心之处是 生成器。实际上，生成器允许您很方便地在 Groovy 中表示树形数据结构，例如 XML 文档。而且，女士们先生们请看，秘密在这：使用生成器，特别是 AntBuilder，您可以毫不费力地构造 Ant 的 XML 构建文件，不必处理 XML 就可以 执行生成的行为。而这并不是在 Groovy 中使用 Ant 的惟一优点。与 XML 不同，Groovy 是非常有表现力的开发环境，在这个环境中，您可以容易地编写循环结构、条件选择代码，甚至可以利用“重用”的威力，而不必像以前那样，费力地用剪切-粘贴操作来创建新 build.xml 文件。而且您做这些工作时，完全是在 Java 平台中！生成器的优点，尤其是 Groovy 的 AntBuilder，在于它们的语法表示完全体现了它们所代表的 XML 文件的逻辑进程。被附加在 AntBuilder实例上的方法与对应的 Ant 任务匹配；同样的，这些方法可以接收参数（以 map 的形式），参数对应着任务的属性。而且，嵌套标签（例如include 和 fileset）也定义成闭包。构建块：示例 1我要用一个超级简单的示例向您介绍生成器：一个叫做 echo 的 Ant 任务。在清单 4 中，我创建了一个普通的、每天都会用到的 Ant 的 echo 标记的 XML 版本（用在这不要奇怪）：清单 4. Ant 的 Echo 任务<echo message="This was set via the message attribute"/> <echo>Hello World!</echo>事情在清单 5 中变得更有意思了：我用相同的 Ant 标签，并在 Groovy 中用 AntBuilder 类型重新定义了它。注意，我可以使用 echo 的属性message，也可以只传递一个期望的 String。

1、创建扩展类并实现扩展方法(以String类为例）： 2、添加配置文件(mainfest/META-INF/services/org.codehaus.groovy.rumtime.ExtensionModule)： 目录结构： 3、编译 4、打包 5、运行 Test.groovy 输出 true 最终的目录结构：

Androidstudio使用groovyconsole命令的具体方法如下：进行打开Androidstudio的软件，进入到界面中，进行点击菜单中的“tools”的选项。就会弹出了一个下拉的菜单的选项，进行选择下拉的菜单中的“Groovyconsole”的选项。在代码的窗口当中就会弹出了一个窗口，进行选择一个为“app”的选项。然后就会在底部的位置中进行弹出了一个Groovyconsole的命令的窗口。在Groovyconsole的命令的窗口中进行输入一条命令”system.out.println("小虾")“，然后进行点击左侧位置中的运行按钮。这样就会弹出了执行的命令的结果中内容，要关闭Groovyconsole的命令的窗口，进行点击”关闭“按钮。就会弹出了一个process”Groovyconsole“isRunning命令窗口确认框，进行点击discounect的按钮。

　　瑞典诺贝尔种植体整个过程完全透明化：电脑自动化处理患者的口腔三维CT数据，经计算机模拟确定种植体的精确位置，制作出引导手术的可视化的电脑模板，医生和患者均可以预先看到的精确的手术模型和种植效果，方便医患双方进行有效的术前沟通。　　瑞典诺贝尔种植体种植过程电脑引导，让种植牙更加精准快捷，安全高效：种植牙过程由电脑控制并完全按照电脑模板进行，如果医生在手术过程对植入的位置和深度掌握稍有偏差，电脑会自动停止手术操作，从而确保植入部位的精准和安全。因为是根据电脑模板的引导处理，手术时间短，常规种植每颗牙平均只需5-10分钟左右，使一小时种出一口美牙成可能。　　1、采印模制作放射导板：按照常规要求制作放射导板，在患者口腔中试戴，做放射颌记录及用牙胶做放射标点8-10个点。　　2、CT扫描：CT应用GE VCT，采用二次扫描法，患者戴放射导板及颌记录进行第一次扫描，扫描的层间距为小于0.5mm，然后单独对放射导板进行扫描。后将扫描的资料存盘为DICOM文件。　　3、颌骨三维重建：将扫描的DICOM文件倒入具有Nobel-Guide软件的计算机内，进行颌骨三维重建，在三维重建后的颌骨内将种植体安放到合适的位置，从而进行最佳手术方案的设计，确认设计方案无误后将设计方案通过网络传到瑞典的NobelBiocare工厂，利用CAD/CAM进行手术导板的制作，制作完成后将导板寄回，备用。　　4、进行种植手术：常规进行种植手术准备，手术前应先进行Nobel-Guide手术导板的试戴，调整合适后，再进行种植手术。采用不翻瓣技术，进行窝洞的制备及种植体的植入。应用的种植体为Nobel Biocare Replace Groovy RPφ3.5×13mm,术后进行X线检查。　　5、修复： 安放临时基台、临时冠即刻负重四个月后更换Procera基台，Procrea全瓷冠永久修复。

例如如下数据，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的Properties4.groovy编辑框中输入实现代码[java] view plain copyimport 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.contentAsStringdef slurper = new JsonSlurper()def result = slurper.parseText(xresponse)def id = re.calendar.calendar_id[i] //i为json数组中的第i个子json对象

1. 尝试绑定public void exec(File file, OutputStream output) throws Exception { Binding binding = new Binding() binding.setProperty("out", output) GroovyShell shell = new GroovyShell(binding); shell.evaluate(file);}Groovy脚本def name="World"out << "Hello $name!"2. 使用SystemOutputInterceptor类。你就可以开始拦截脚本之前评估和输出后停止。 3. 正是您需要的。 4. 我怀疑你可以通过覆盖做到这一点相当不错的println方法在你的了GroovyShell“在Groovy控制台以下工作：StringBuilder b = new StringBuilder()this.metaClass.println = { b.append(it) System.out.println it}println "Hello, world!"System.out.println b.toString()输出：Hello, world!Hello, world!5. javax.script.ScriptEngine中怎么样？你可以指定它的作家。ScriptEngine engine = new ScriptEngineManager().getEngineByName("Groovy");PrintWriter writer = new PrintWriter(new StringWriter());engine.getContext().setWriter(writer);engine.getContext().setErrorWriter(writer);engine.eval("println "HELLO"")

标题：小樱歌词库-Groovy!-日文[点击:537]街に出かけよう一人でいたって暗いだけでしょループして落ち込んでなおさらah悩んじゃって外に飞び出そう心配イラナイ大昔から地球だってまわってるきっとツキだってまわるよBrand-NewLoveSongハレハレルヤ！みんなハジけて爱し合おう単调な日常通常な感情守らなくちゃダメなこといつもある街を见渡そう电话やパソコンも未来の扉隠れてる探そうよこの世は宝岛さ一绪にはばたこう楽しいことしよう大昔から夜は明ける阳は升る绝対太阳は照らすのGroovyLoveSongハレハレルヤ！ヤなこと忘れ爱し合おう同情な现状顽丈な友情动かなくちゃダメな时いつもあるDancinginthestreetGroovingtothelightthroughthenightBrand-NewLoveSongハレハレルヤ！みんなハジけて爱し合おうGroovyLoveSongハレハレルヤ！ヤなこと忘れ爱し合おうBrand-NewLoveSongハレハレルヤ！明日のために踊ろうGroovyLoveSongハレハレルヤ！动かなくちゃダメな时いつもある优しくなりましょう素直になりましょう…

用groovy脚本自定义ElasticSearch查询，来实现以上功能。例，数据中包含字段birdtyday，记录游客生日："birthday": "1992-02-05 00:00:00",新建文件getAgeByBirthday.groovy，编辑其内容为:def b = doc[birthday_field].valuedef birthday = new Date(b) def now = new Date() long age = (now -birthday)/365age并把此文件放在es的config/scripts目录下(如果没有此目录就新建一个)。然后在config/elasticsearch.yml文件中加一行:script.groovy.sandbox.enabled: true最后重启es即可。接下来，我们就可以用以下DSL进行年龄统计了GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"aggs": {"counts_by_age": {"terms": {"script_file": "getAgeByBirthday","params": {"birthday_field": "birthday"},"size": 100}}}}或者：GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"aggs": {"histogram_by_age": {"histogram": {"script_file": "getAgeByBirdthday","params": {"birdthday_field": "birdthday"},"interval": 5}}}}不过脚本查询性能不佳，且不能利用es的缓存，所以在大数据量或高性能要求的场景下不适用。。-------------------------------------补充一个自定义的年龄range过滤:range_AgeByBirthday.groovy:def b = doc[birdthday_field].valuedef birdthday = new Date(b) def now = new Date() long age = (now -birdthday)/365gte<=age && age<=lteDSL:GET /lovingtrip-report/hotelcustomer/_search?search_type=count{"query": {"filtered": {"filter": {"script": {"script_file": "range_AgeByBirdthday","params": {"birdthday_field": "birdthday","gte": 50,"lte": 60}}}}},"aggs": {"histogram_by_age": {"histogram": {"script_file": "getAgeByBirdthday","params": {"birdthday_field": "birdthday"},"interval": 5}}}}

准备工作安装 gradle， groovy。要使用gradle的groovy plugin 来打包groovy 脚本，项目结构。目录 含义src/main/java Java 代码src/main/resources Java需要的资源文件src/main/groovy Groovy代码，也可以包含Java代码src/test/java Java 测试代码src/test/resources 测试需要的资源文件src/test/groovy Groovy测试需要的资源文件src/sourceSet/java Java代码源src/sourceSet/resources 资源文件源src/sou www.hbbz08.com rceSet/groovy Groovy代码源我们只需要编译打包groovy脚本 所以只需要创建 src/main/groovy目录结构。例子：gradle_groovy_archive项目 结构是：gradle_groovy_archive创建helloWorld.groovy脚本，代码如下：package helloprintln "Gradle compile groovy"创建Gradle构建文件：apply plugin: "groovy"apply plugin: "maven"group = "com.hello"archiveBaseName = "hello"version = "0.1-SNAPSHOT"defaultTasks "clean", "jar"configurations { deployerJars}repositories { mavenCentral()}dependencies { //使用本地groovy环境 groovy localGroovy() //groovy group: "org.codehaus.groovy", name: "groovy", version: "1.8.6" compile fileTree( dir: "lib", include: ["*.jar"]) deployerJars "org.apache.maven.wagon:wagon-webdav-jackrabbit:1.0-beta-7"}sourceSets { main { groovy { srcDir "src/main/groovy" } }}uploadArchives { repositories.mavenDeployer { uniqueVersion = false configuration = configurations.deployerJars repository(id : repositoryId, url : repositoryUrl) { authentication (userName : "deployment", password : "deployment") proxy() } }}创建构建文件属性文件：//根据不同情况修改repositoryId=NDrepositoryUrl=NDsystemProp.http.proxyHost=NDsystemProp.http.proxyPort=8080systemProp.http.proxyUser=NDsystemProp.http.proxyPassword=ND在命令行中 敲 gradle 运行，会自动运行 defaultTasks,clean 和 jar，会把 所有groovy下的脚本打成jar包。

groovy 在eclipse中要实现语法提示，需要安装插件。Groovy 的插件继承自 Java 插件并添加了对 Groovy 项目的支持。它可以处理 Groovy 代码，以及混合的 Groovy 和 Java 代码，甚至是纯 Java 代码（尽管我们不一定推荐使用）。该插件支持联合编译，可以任意地混合及匹配 Groovy 和 Java 代码各自的依赖。例如，一个 Groovy 类可以继承自一个 Java 类，而这个 Java 类也可以继承自一个 Groovy 类。这样一来，我们就能够在项目中使用最适合的语言，并且在有需要的情况下用其他的语言重写其中的任何类。用法要使用 Groovy 的插件，请在构建脚本中包含以下语句：使用 Groovy 插件build.gradleapply plugin: "groovy"配置方法：在 classpath 中找到 groovy-all(-indy) Jar，相同的 Jar 将添加到groovyClasspath 中。如果在 classpath 中找到 groovy(-indy) Jar ，并且该项目已经在至少一个仓库中声明了它，那么相应的 groovy(-indy)的仓库依赖将添加到 groovyClasspath 中。其他情况，该 task 将执行失败，并提示无法推断 groovyClasspath。

def AR_Interface=new AUTOSAR_Interface[2]{new AUTOSAR_Interface(),new AUTOSAR_Interface()};