Groovy 笔记
Groovy的基础语法
Groovy的基础语法Groovy的基础语法Groovy 的语法融合了Ruby、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。
对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句Groovy的语句和Java类似，但是有一些特殊的地方。
例如语句的分号是可选的。
如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。
动态类型像其他Script一样，Groovy 不需要显式声明类型。
在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。
在Groovy中，类型对于值(varibles)、属性(properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外）。
例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功能：class Song{ Property length Property name }class Book{ def public name def public author }def doSomething(thing){ println "going to do something with a thing named = " + }这里定义了两个Groovy 类，Song 和Book。
这两个类都包含一个name 属性。
函数doSomething，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。
GROOVY_快速入门
Groovy快速入门1、集合（1）List(java.util.List)4、collect遍历集合，逐个传递给闭包，处理后的结果返回给对应的项//Bindingbinding.setVariable("foo", GroovyShellObjectassertassertClassLoader GroovyClassLoader Class//GroovyObjectObject[]groovyObject.invokeMethod("run",args);如果你想使用一个用Groovy脚本实现的接口,你可以这么使用它:GroovyClassLoader gcl=new GroovyClassLoader();Class clazz=gcl.parseClass(myStringwithGroovyClassSource"SomeName.groovy");Object aScript=clazz.newInstance();MyInterface myObject=(MyInterface)aScript;myObject.interfaceMethod();如果某个Groovy类实现口MyInterface接口,那么上面的代码就会很好的工作.myObject的使用方法与其他实现了MyInterface接口的Java对象一样.3.Groovy脚本引擎对于那些想将Groovy脚本嵌入到服务器并且在每次修改后重新装入的人来说,Groovy脚本引擎提供了一个彻底的解决方案.你可以设定系列CLASSPATH作为根来初始化Groovy脚本引擎,这些GLASSPATH可以是URL也可以是目录名.接着你就可以这些根路径下的任何Groovy脚本了.GSE 会跟踪脚本间的依赖关系,因此如果任何有依赖关系的脚本被修改,整颗树将会重新编译和载入.另外,每次执行脚本时,你都可以传入一个包含脚本可接受属性的Binding.脚本执行完以后,传入脚本中的那些属性在Binding中依然有效.下面是一个例子:/my/groovy/script/path/hello.groovy:output="Hello,${input}!"import ng.Binding;import groovy.util.GroovyScriptEngine;String[]roots=new String[]{"/my/groovy/script/path"}; GroovyScriptEngine gse=new GroovyScriptEngine(roots);Binding binding=new Binding();binding.setVariable("input","world");gse.run("test.groovy",binding);System.out.println(binding.getVariable("output"));将打印"Hello,world!".4.运行时依赖和JDK1.4一样,Groovy Jar也依赖与ASM库上的运行时,ASM库包括4个Jar(asm-2.1.jar,asm-util-2.1.jar,asm-attrs-2.1.jar and asm-analysis-2.1).也就是说,只要将上面的5个Jar添加到路径中,你就能将轻松地Groovy嵌入到你的应用里.另一种方案可以不用那么多的Jar.你可以用GROOVY_HOME/embeddable目录下的groovy-all-1.0-beta-x.jar.这个Jar包将Groovy和ASM组合打包成一个方便的Jar包.注意:groovy-all-1.0-beta-x.jar中的ASM类使用了不同的命名空间,因此要避免与使用ASM的库发生冲突.Groovy全攻略--运行篇Groovy脚本是一个包含许多语句和类声明的文本文件.Groovy的用法和其他脚本语言类似.下面是几种运行Groovy脚本的方法:1.使用交互控制台Groovy有一个Swing交互控制台,允许你像使用SQL工具一样输入和执行Groovy语句.控制台支持历史记录,因此你可以向前或向后遍历命令.如果你已经安装了Groovy二进制分发包,你可以使用下面的命令启动Groovy Swing控制台.如果像启动命令行控制台,可以输入下面的命令:GroovyConsole如果想启动命令行控制台,可以输入下面的命令Groovysh从源代码分发包中启动Swing Groovy控制台maven console2.通过IDE运行Groovy脚本有一个叫做GroovyShell的类含有main(String[])方法可以运行任何Groovy脚本.你可以用下面的语句执行任何Groovy脚本:java ng.GroovyShell foo/MyScript.groovy[arguments你可以在你的IDE中使用上面的Groovy main()执行或调试任何Groovy脚本.3.用命令行执行Groovy脚本在GROOVY_HOME\bin里有个叫'groovy'或'groovy.bat'的脚本文件(或者二者都有,根据你的平台不同而不同).这些脚本文件是Groovy运行时的一部分.一旦安装了Groovy运行时,你就可以这样运行Groovy脚本:groovy foo/MyScript.groovy[arguments]如果你使用从CVS构建的Groovy,那么除了Groovy脚本以外,命令行上可能还运行着其他的类.1.拥有main()方法的类;2.和JUnit的测试一起运行的继承自GroovyTestCase的类,3.实现Runnable接口的类.run()方法被调用.获得最新最强的Groovy,输入下面的命令做一个CVS检出maven groovy:make-install在groovy/target/install里会有一份完整的二进制分发包.你可以将groovy/target/install/bin添加到你的路径,这样你就可以轻松地用命令行执行你的Groovy脚本了.4.用Groovy创建Unix脚本你可以用Groovy编写Unix脚本并且像Unix脚本一样直接从命令行运行它.倘若你安装的是二进制分发包并且设置好了路径,那么下面的代码将会很好的工作:将其保存为helloWorld.groovy.#!/usr/bin/env groovyprintln("Hello world")for(a in this.args){println("Argument:"+a)}接着从命令行运行这个脚本,chmod+x helloWorld./helloWorld。
Playframework Groovy整理
一、模板语法1、${...}:声明一个动态元素；例：<h1>Client ${}</h1>2、#{extends /} 和#{doLayout}：继承和布局例：<html xmlns="/1999/xhtml" xml:lang="en" lang="en"> <head><title>#{get 'title' /}</title><link rel="stylesheet" type="text/css" href="@{'/public/stylesheets/main.css'}" /></head><body><h1>#{get 'title' /}</h1>#{doLayout /}<div class="footer">Built with the play! framework</div></body></html>3、#{tagName /}：如果某个标签只有一个属性，按惯例被声明为arg，而且名字可以使缺省的例：插入一个js文件#{script 'jquery.js' /} 或者#{script 'jquery.js'}#{/script}list标签允许在任何一个集合迭代，它有两个强制的属性。
例：<h1>Client ${}</h1><ul>#{list items:client.accounts, as:'account' }<li>${account}</li>#{/list}</ul>${title.raw()}:<h1>Title</h1>#{verbatim}${title} --> <h1>Title</h1>#{/verbatim}4、@{...}和@@{...}：表示要执行的动作；例：<h1>Client ${}</h1><p><a href="@{Clients.showAccounts(client.id)}">All accounts</a></p><hr /><a href="@{Clients.index()}">Back</a>5、${...}：信息，像要国际化时可以使用${...}来显示一个国际化部分；例：在conf/messages配置文件种指定：clientName=The client name is %s在一个模板中显示这个消息：<h1>&{'clientName', }</h1>6、*{...}*：注释7、%{...}%：脚本：脚本就是设置一个复杂的表达式，一个脚本中可以声明一些变量和属性例：%{fullName = .toUpperCase()+' '+client.forname;out.print('<h1>'+fullName+'<>');}%<h1>Client ${fullName}</h1>用脚本语言在模板中创建一个像地迭代的结构：<h1>Client ${}</h1><ul>%{for(account in client.accounts) {}%<li>${account}</li>%{}}%</ul>注：一个模板不是在一个地方做复杂的事情。
Groovy
Groovy特性
语法上支持动态类型，闭包等新一代语言特性 无缝集成所有已经存在的Java类库 即支持面向对象编程也支持面向过程编码
Groovy优势
一种更加敏捷的编程语言 入门非常的容易，单功能非常的强大 即可以作为编程语言也可以作为脚本语言 熟练掌握Java的同学会非常容易掌握Groovy
Groovy语法讲解
DSL介绍
全称domain specific language 有哪些常见的DSL语言及特点 DSL与通用编程语言的区别 核心思想：求专不求全，解决特定问题
Groovy介绍
是一种基于JVM的敏捷开发语言 结合了Python、Ruby和Smalltalk的许多强大的特性 Groovy可以与Java完美结合，而且可以使用java所有的库
Groovy中列表 Groovy中的映射 Groovy中的范围
第四部分 面向对象
Groovy中类、接口、方法等的定义和使用 Groovy中的元编程
Groovy高级语法
Groovy json操作详解 Groovy xml文件操作详解 Groovy 文件操作详解 Groovy与java对比及总结
groovy基础语法 groovy闭包讲解 groovy数据结构 groovy面向对象
第一部分oovy中的逻辑控制讲解
第二部分 闭包
groovy中闭包基础讲解 groovy中闭包使用讲解 groovy中闭包进阶讲解
第三部分 数据结构
Groovy学习总结
Groovy变量，字符串，循环等基本语法 Groovy中的数据结构：列表、映射、范围用法 Groovy中方法、类等面向对象相关知识 Groovy中对普通文件、xml、json处理
文件操作
Groovy中如何解析一个xml格式数据 Groovy中如何创建一个xml格式数据 所有java对文件的处理类，groovy都可以使用 Groovy扩展了许多更加快捷和强大的方法
Groovy的基础语法
Groovy的基础语法Groovy的基础语法Groovy 的语法融合了Ruby、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。
对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句Groovy的语句和Java类似，但是有一些特殊的地方。
例如语句的分号是可选的。
如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。
动态类型像其他Script一样，Groovy 不需要显式声明类型。
在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。
在Groovy中，类型对于值(varibles)、属性(properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外）。
例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功能：class Song{ Property length Property name }class Book{ def public name def public author }def doSomething(thing){ println "going to do something with a thing named = " + }这里定义了两个Groovy 类，Song 和Book。
这两个类都包含一个name 属性。
函数doSomething，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。
Groovy脚本基础全攻略
Groovy脚本基础全攻略1 背景Groovy脚本基于且拓展了Java，所以从某种程度来说掌握Java是学习Groovy的前提，故本⽂适⽤于不熟悉Groovy却想快速得到Groovy核⼼基础⼲货的Java开发者（注意是Java），因为我的⽬的不是深⼊学习Groovy语⾔，所以本⽂基本都是靠代码来解释，这样最直观，同时也够⼲货基础⼊门Groovy的特点和结构。
开始介绍前先给⼀个⼤法，英⽂好的可以直接略过本⽂后续内容，我需要的只是Groovy⽪⽑；再次向Groovy的标志致敬，左⼿⼀个Java，右⼿⼀个Groovy，不好意思，我技术⽔平太Low了（T–T__《琅琊榜》看多了）。
Groovy是⼀种动态语⾔，它和Java类似（算是Java的升级版，但是⼜具备脚本语⾔的特点），都在Java虚拟机中运⾏。
当运⾏Groovy脚本时它会先被编译成Java类字节码，然后通过JVM虚拟机执⾏这个Java字节码类。
快速安装指南：安装Groovy在各种Bash下都是通⽤的，具体如下命令就可搞定：$ curl -s get.sdkman.io | bash$ source "$HOME/.sdkman/bin/sdkman-init.sh"$ sdk install groovy$ groovy -version//⾄此就可以享⽤了！我们在写Groovy代码时可以直接使⽤⾃⼰喜欢的⽂本编辑器编辑OK以后以.groovy后缀保存，然后在终端执⾏如下命令即可运⾏：$ groovy ./TestFile.groovy或者我们可以通过groovyConsole来进⾏groovy代码开发运⾏（由于不需要特别深⼊学习使⽤Groovy，所以个⼈⾮常喜欢这种模式的开发运⾏），如下图：再或者我们还可以使⽤Intellij IDEA等⼯具安装groovy插件进⾏groovy开发，这⾥不再⼀⼀叙述了（），直接给出⼀个读取指定⽂件内容打印的例⼦，如下：OK，有了上⾯这些简单粗暴的基础和环境之后那我们快速开战吧。
Groovy入门教程(一)
Groovy入门教程杨宏焱2009-5-13 一、groovy是什么简单地说，Groovy 是下一代的java语言，跟java一样,它也运行在JVM 中。
作为跑在JVM中的另一种语言，groovy语法与Java 语言的语法很相似。
同时，Groovy 抛弃了java烦琐的文法。
同样的语句，使用groovy能在最大限度上减少你的击键次数——这确实是“懒惰程序员们”的福音。
二、开发环境1、jdk 1.5以上2、eclipse+groovy plugin（支持Groovy 1.5.7）打开eclipse，通过Software Updates > Find and Install...菜单，使用“Search for new features to install”下载并安装groovy插件。
New一个远程站点，url可使用/groovy/distributions/update/，插件名：Groovy plug-in。
根据需要你可以同时选择groovy和grails（后续会学习到）：三、创建groovy项目1、新建一个groovy项目New --> Project Java Project 创建一个java项目。
为了方便管理，建议在source中建两个source文件夹java和groovy，分别用于存储java源文件和groovy源文件：2、添加Groovy 特性在项目上右击，Groovy → Add Groovy Nature，这样会在项目中添加Groovy Libraries。
3、添加Groovy 类在项目groovy源文件下右键，New → Other →Groovy → Groovy Class自动生成的源代码如下：public class HelloWorld{/*** @param args*/public static void main(def args){//TODO Auto-generated method stub}}我们在main方法中加一句打印语句：println "Hello World"4、编译运行groovy类在源文件上右键，Compile Groovy File，然后右键，Run As Groovy ，在控制台中查看运行结果。
Groovy编程基础教程
Groovy编程基础教程第一章：Groovy简介与安装Groovy是一种基于Java的编程语言，旨在提供更简单、更灵活的编程体验。
本章将介绍Groovy的背景和特点，并提供安装Groovy的步骤和指南。
首先，可以了解Groovy的历史和与Java的关系。
接下来，详细介绍如何从Groovy官方网站上下载和安装Groovy，并配置所需的环境变量。
最后，通过一个简单的Hello World程序，确保Groovy已正确安装并可运行。
第二章：Groovy语法本章将介绍Groovy的语法规则和基本结构。
首先，对比Java和Groovy的语法差异，强调Groovy在简化代码书写方面的优势。
然后，详细介绍Groovy的变量和数据类型，包括字符串、数字和集合。
接着，讲解Groovy的控制流语句，如条件语句和循环语句。
最后，介绍如何在Groovy中定义和使用函数，并探讨闭包的概念。
第三章：面向对象编程与Groovy本章将探讨如何在Groovy中使用面向对象编程的思想和特性。
首先，介绍类和对象的概念，以及如何在Groovy中定义类和创建对象。
然后，介绍如何实现继承和多态，以及在Groovy中的具体应用。
接下来，介绍在Groovy中如何处理异常和错误，并展示常见的错误处理模式。
最后，探讨如何使用Groovy的元编程能力来扩展现有的类和方法。
第四章：Groovy与Java的交互本章将重点介绍Groovy与Java之间的交互方式。
首先，讨论如何在Groovy中引用和使用Java类和库。
接着，介绍如何使用Groovy的@Grab注解来动态加载和使用Java库。
然后，介绍如何在Groovy中调用Java类的方法，以及如何处理Java异常。
最后，介绍如何在Groovy中编写JavaBean和接口，并与Java代码进行交互。
第五章：Groovy脚本编程本章将介绍Groovy脚本编程的基础知识和技巧。
首先，介绍Groovy脚本的特点和用途，以及如何编写和运行Groovy脚本。
精通 Groovy
关于 Groovy这一节将学习 Groovy 的基础知识：它是什么，它与 Java 语言和 JVM 的关系，以及编写 Groovy 代码的一些要点。
什么是 Groovy？Groovy 是 JVM 的一个替代语言—替代是指可以用 Groovy 在 Java 平台上进行Java 编程，使用方式基本与使用 Java 代码的方式相同。
在编写新应用程序时，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。
目前的 Groovy 版本是 1.5.4，在 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 语法快捷方式。
不过现在只需知道以下这些要点：∙Groovy 的松散的 Java 语法允许省略分号和修改符。
∙除非另行指定，Groovy 的所有内容都为public。
∙Groovy 允许定义简单脚本，同时无需定义正规的class对象。
∙Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式，使得它们更容易使用。
Groovy 学习笔记-p6
Groovy 学习笔记Groovy 学习笔记(一)1. 关于字符串：简单字符串可以用单引号和双引号, 但如果使用GString, 则必须使用双引号. 比如“$foo, hello world”多行字符串则可以使用“”" (3个双引号), 例如:def text = “”"\hello there ${name}how are you today?“”"如果对这个text进行输出,会发现输出是按原样式输出的,即换行符也输出. 这在处理类似HTML 代码时时特别有用的.另外, 可以使用/…/ 来定义字符串, 如: def basename = /[Strings and GString^\/]+$/在这种情况下, 只需对/ 进行转义: \/; 但如下定义是不合法的:def x = //, 可以这么写: def x = /${}/2.字符串操作:a). 字符串加减操作def string = …hippopotamus‟print string –‘hippo’–‘mus’+ ‘to’== ‘potato’// 果然强悍!!!b).字符串转化为字符数组‘apple‟.toList()def string = “an apple a day”assert string.toList().unique().sort().join() == … adelnpy‟c).字符串反转assert‟string‟.reverse() == …gnirts‟def string = …Yoda said, “can you see this?”…def revwords= string.split(‟ …).toList().reverse().join(‟ …)assert revwords== …this?” see you “can said, Yoda‟d).字符串查找def words = ['bob', 'alpha', 'rotator', 'omega', 'reviver']def bigPalindromes = words.findAll {w -> w == w.reverse() && w.size() > 5}assert bigPalindromes == ['rotator', 'reviver']3. 数字a). 一切皆为对象, 数字也不例外b). 对于非整型数字, 使用BigDecimal 作为默认类型4. 日期可以直接对日期操作: def date = new Date() + 1还可以:use(TimeCategory) {println new Date() + 1.hour + 3.weeks -2.days}其中TimeCategory 是org.codehaus.groovy.runtime.TimeCategoryGroovy 学习笔记(二)5. 方法调用: 方法调用时, 括号是可选的. 例如: print ‘hello, world’6. 方法返回值: 默认最后一句就是方法的返回值, 也就是说, 最后一句的return语句是可有可无的. 当然, 如果在方法中间需要return值, 还是要写return 语句才行.7. 闭包(closure): 闭包可以访问与闭包定义在同一scope的变量. 例如:def name = “” //initialize variabledef printNam e = { println “The string in the name variable is ” + name } //define methodname = “Youssef” //set string Youssef in variable nameprintName() //result: The string in the name variable is Youssef如果不在同一scope, 那么需要给闭包指明参数, 参数与闭包的body部分用-> 符号分隔. 如果只有一个参数, 则该参数可不必明确写出来, 默认用it 作为该参数的名称.def name = “” //initialize variabledef printName = { println “The string in the name variable is ” + it } //define methodname = “Youssef” //set string Youssef in variable nameprintName(name) //result: The string in the name variable is Youssef8. 异常处理: 不是强制性的9. methodMissing 与propertyMissing 方法:10. categories:class StringCategory {static String lower(String string) {return string.toLowerCase()}}use (StringCategory) {assert "test" == "TeSt".lower()}Groovy 学习笔记(三)1. == 是判断是否equals, 而判断是否是同一对象则用is2. list 和map 的一些方法：def x = 1..10assert x.contains(5)assert x.contains(15) == falseassert x.size() == 10assert x.from == 1assert x.to == 10assert x.reverse() == 10..13. 以下对象都有size() 方法Array, String, StringBuffer, Collection, Map, File4. 数据类型：12 –Integer, 100L –Long, 1.23F –Float, 1.23D –Double, 123G –BigInteger, 1.23,1.23G –BigDecimal如果一个小数, 末尾什么字符都没加, 那么这个小数使用的是BigDecimal.class Money {private int amountprivate String currencyMoney (amountValue, currencyValue) {amount = amountValuecurrency = currencyValue}boolean equals (Object other) {if (null == other) return falseif (! (other instanceof Money)) return falseif (currency != other.currency) return falseif (amount != other.amount) return falsereturn true}int hashCode() {amount.hashCode() + currency.hashCode()}Money plus (Money other) {if (null == other) return nullif (other.currency != currency) {throw new IllegalArgumentException("cannot add $other.currency to $currency") }return new Money(amount + other.amount, currency)}}def buck = new Money(1, 'USD')d Use overridden ==assert buckassert buck == new Money(1, 'USD')e Use overridden +assert buck + buck == new Money(2, 'USD')Groovy 学习笔记(四)Groovy 支持操作符重载, 每个操作符对应一个方法签名, 如‘+’对应的是’plus’. Groovy 支持多种字符串表示, 单引号, 双引号(支持GString), 3个单引号(支持多行), 3个双引号(支持多行, 支持GString).在Groovy 中, 方法的括号是可选的, 如果一行只有一个语句, 那么语句后的分号也可省略不写.Groovy range, 可用于: 数字, 日期, 字符串. 只要数据类型实现了next(++), previous(–), 和parable 接口, 就可以使用range .Groovy list 默认使用ArrayList, 欲使用LinkedList 等其它类型List, 需要明确声明.List 可以使用负值作为index值进行访问, 例如list[-1]返回的就是list的最后一个值, list[-2]则返回倒数第二个值. 也可以指定倒序的range, 如list[4..0].需注意: list[0..<-2] 等价于list[0..-1] 而非list[0..-3].声明空的map: [:]['a':1] 等价于[a:1]Groovy 学习笔记(五)(1..10).each{ log += it } 等价于(1..10).each({ log += it })Closure声明方式之一是: reference.& （其中receiver是对象）def adder = { x, y -> return x+y } 等价于adder(4, 3) 或adder.call(2, 6)文件读写更加简单：def file = new File(‟myFileName.txt‟)for (line in file) println line方法的最后一个语句得到的值作为返回值，所以return语句是可选的异常不强制要求捕获for (it in aaa) 中，变量aaa 可以是字符串，可以是对象，等等。
groovy 注释
groovy 注释在 Groovy 中，注释以 "#" 开头，并以 "#" 结尾。
Groovy 注释可以用于解释代码的作用、实现原理、参数等。
它们可以被看作是一种更加灵活和易于阅读的表达方式，可以让开发人员在编写代码时更好地沟通和理解。
在 Groovy 中，单行注释以 "#" 开头，可以在行中的任何位置使用。
例如，以下代码段是一个单行注释:```println "Hello, World!"```而多行注释通常用于解释代码的功能、实现原理等，通常以 "#" 开头，并以 "#" 结尾。
例如:```println "Hello, World!"``````def x = 10println "The value of x is: " + x```在 Groovy 中，注释的语法比较灵活，可以使用多种方式来表示注释，例如:```// 这是一条单行注释println "Hello, World!"# 这是一条多行注释println "Hello, World!"println "World, Hello!""""这是一条文档注释"""def x = 10println "The value of x is: " + x```总之，在 Groovy 中，注释是一种非常灵活和实用的表达方式，可以用于解释代码的作用、实现原理、参数等，可以让开发人员更好地理解和沟通。
groovy调用存储过程获取返回记录
groovy调用存储过程获取返回记录1. 引言1.1 概述本文将介绍如何使用Groovy调用存储过程来获取返回记录。
存储过程是一种数据库对象，它包含一系列的SQL语句并可在数据库服务器上执行。
通过调用存储过程，我们可以实现对数据库中的数据进行操作和查询。
1.2 文章结构本文分为五个主要部分：引言、Groovy调用存储过程的基本原理、调用存储过程获取返回记录的步骤、实例演示与代码展示以及结论和展望。
在“引言”部分中，我们将介绍本文所涉及的主题以及文章的整体结构。
接下来，在“Groovy调用存储过程的基本原理”部分，我们将详细探讨Groovy与存储过程结合的优势以及它们之间的工作原理。
然后，在“调用存储过程获取返回记录的步骤”部分，我们将解释在Groovy中如何一步步地执行并处理存储过程，并从中获取返回结果。
接着，在“实例演示与代码展示”部分，我们将设计一个示例存储过程，并编写相应的Groovy代码来调用和解析返回结果。
最后，在“结论和展望”部分，我们将对全文内容进行总结回顾，并对Groovy 调用存储过程的未来发展进行展望和思考。
1.3 目的本文的目的是帮助读者了解Groovy如何调用存储过程，并提供详细的步骤和示例代码。
通过学习本文，读者将能够掌握在Groovy中使用存储过程的基本技巧，并且能够灵活运用这些技巧解决实际问题。
同时，我们也对Groovy调用存储过程的未来发展做出一定的展望，以启发读者进一步深入研究和应用这个领域。
2. Groovy调用存储过程的基本原理2.1 存储过程简介存储过程是一组预编译的SQL语句，被封装为一个可重复使用的程序单元。
它们通常在数据库服务器上执行，可以接收输入参数并返回结果。
2.2 Groovy与存储过程结合的优势Groovy是一种强大的动态语言，它为开发人员提供了灵活性和简洁性，并且与Java代码无缝集成。
当需要调用存储过程时，Groovy可以通过JDBC连接到数据库，并以简洁的方式执行和处理返回结果。
goovry语法
goovry语法
Groovy是一种Java语法兼容的面向对象编程语言，自2003年起出现在Java领域。
以下是Groovy语法的一些特点：
1. 变量声明：在Groovy中，可以使用`def`关键字来声明变量。
例如，`def count = 0`声明并初始化了一个名为`count`的变量，其初始值为0。
2. 运算符：Groovy支持常见的算术运算符，如加法（`+`）、减法（`-`）、乘法（``）、除法（`/`）等。
3. 控制结构：Groovy支持常见的控制结构，如条件语句（`if`/`else`）、循环语句（`for`、`while`）等。
4. 函数和方法：在Groovy中，可以使用`def`关键字定义函数和方法。
例如，`def add(a, b) { a + b }`定义了一个名为`add`的函数，该函数接受两个参数并返回它们的和。
5. 闭包：Groovy支持闭包，即可以嵌套函数。
闭包可以作为参数传递给其他函数或作为函数的返回值。
6. 集合：Groovy提供了丰富的集合类，如List、Set、Map等。
这些集合
类支持常见的操作，如添加、删除、查找等。
7. 类型转换：在Groovy中，可以使用强制类型转换将变量转换为指定的类型。
例如，将字符串转换为整数可以使用`(str)`。
这只是Groovy语法的一些基本特点，还有很多其他的语法和特性等待你去探索和学习。
groovy collect语法
groovy collect语法Groovy中的`collect`方法是用于对集合中的每个元素进行转换或映射的功能。
它类似于Java 8中的`map`方法。
`collect`方法接受一个闭包作为参数，该闭包定义了对集合中每个元素的转换规则，并返回转换后的新元素组成的集合。
`collect`方法的语法如下：groovy.def newList = oldList.collect { / 转换逻辑 / }。
在这个语法中，`oldList`是原始集合，`newList`是转换后的新集合。
`{ / 转换逻辑 / }`是一个闭包，其中包含了对每个元素的转换逻辑。
例如，如果我们有一个整数列表，我们可以使用`collect`方法将每个元素乘以2，并将结果存储在新的列表中：groovy.def numbers = [1, 2, 3, 4, 5]def doubledNumbers = numbers.collect { it 2 }。
println doubledNumbers // 输出 [2, 4, 6, 8, 10]在这个例子中，`it`代表当前正在处理的元素，`it 2`就是转换逻辑，它将每个元素乘以2。
最后，`doubledNumbers`中包含了转换后的元素。
除了基本的`collect`方法，Groovy还提供了一些其他形式的`collect`方法，比如`collectEntries`用于将集合中的元素转换为键值对，`collectMany`用于将每个元素转换为另一个集合并将所有结果合并为一个集合等等。
总之，`collect`方法是Groovy中非常强大且灵活的集合转换工具，可以帮助我们轻松地对集合中的元素进行转换和映射操作。
groovy 字典定义
groovy 字典定义Groovy字典定义1. 什么是Groovy字典？•Groovy字典是一种集合类型，用于存储键值对数据。
•与Java中的HashMap类似，但Groovy字典更加简洁和易用。
2. Groovy字典的定义方式•在Groovy中，可以使用两种方式定义字典：使用方括号表示法def myDict = ['key1': 'value1', 'key2': 'value2']•使用方括号表示法，可以在字典中直接指定键和值，并使用冒号分隔。
•字典元素之间使用逗号分隔。
使用中括号表示法def myDict = [:]= 'value1'= 'value2'•使用中括号表示法，先创建一个空字典，然后使用点号语法为字典添加键值对。
3. Groovy字典的特性与优势•与Java中的HashMap相比，Groovy字典具有以下特性与优势：声明简洁•Groovy字典的声明方式更加简洁，不需要在代码中显式地指定泛型类型。
动态类型•Groovy字典是动态类型的，可以存储不同类型的值。
简化操作•Groovy提供了许多简化字典操作的语法糖，使代码更加简洁易读。
支持闭包•Groovy字典可以使用闭包作为值，方便进行一些复杂的逻辑处理。
4. 推荐学习资源•《Groovy编程指南》（The Groovy Programming Language）•作者：Venkat Subramaniam•出版社：O’Reilly Media•书籍简介：本书是一本全面介绍Groovy的指南，适合初学者和有经验的开发者。
书中涵盖了Groovy的语法、特性以及常见的使用场景。
通过阅读本书，读者将掌握Groovy字典的定义和使用方法，以及利用字典简化编码的技巧。
结论•Groovy字典是一种在Groovy编程语言中常用的数据结构，具有声明简洁、动态类型、简化操作和支持闭包等特性。
groovy try语句
groovy try语句在Groovy中，try语句用于捕获可能会抛出异常的代码块，并在异常发生时执行相应的处理逻辑。
try语句通常和catch和finally语句一起使用。
try语句的基本语法如下：groovy.try {。
// 可能会抛出异常的代码块。
} catch (ExceptionType e) {。
// 捕获特定类型的异常并执行相应的处理逻辑。
} finally {。
// 无论是否发生异常，都会执行的代码块。
}。
在try语句中，首先是try块，其中包含可能会抛出异常的代码。
如果在try块中抛出了异常，程序会立即跳转到与抛出的异常类型匹配的catch块。
catch块用于捕获特定类型的异常，并执行相应的处理逻辑。
在catch块中，你可以访问异常对象（通常命名为e），以便获取异常的相关信息。
如果没有catch块匹配抛出的异常类型，异常会继续向上层调用栈传播，直到找到匹配的catch块或者到达顶层调用栈。
无论是否发生异常，finally块中的代码都会被执行。
通常在finally块中放置一些清理资源的代码，例如关闭文件或释放其他资源。
除了基本的try-catch-finally结构，Groovy还支持try-with-resources语句，用于自动管理资源的关闭。
这种语句类似于Java 7中引入的try-with-resources语句，可以在try语句中声明资源，然后在try块执行完毕后自动关闭这些资源。
总之，try语句在Groovy中扮演着捕获和处理异常的重要角色，能够帮助我们编写健壮的程序并进行合理的异常处理。
希望这个回答能够满足你的要求，如果有其他问题，请随时提出。
groovy笔记
//Read information from property filedef projectdirprovider = new ProjectDirProvider()def currentproject = testRunner.testCase.testSuite.projectdef properitesFilePah = projectdirprovider.getProjectFolder(currentproject) + "/UserInfo.properties"def propertiesFile = new FileInputStream(properitesFilePah)def properties = new java.util.Properties()properties.load(propertiesFile)//Parse information from responsedef groovyUtils = new com.eviware.soapui.support.GroovyUtils(context)def holder = groovyUtils.getXmlHolder("getCurrentUserInfo#ResponseAsXml")//properties need to be checked in responsedef accountid=holder.getNodeValue("//ns1:accountId")//Read information from property filedef projectdirprovider = new ProjectDirProvider()def currentproject = testRunner.testCase.testSuite.projectdef properitesFilePath = projectdirprovider.getProjectFolder(currentproject) + "/UserInfo.properties"def propertiesFile = new FileInputStream(properitesFilePath)def properties = new java.util.Properties()properties.load(propertiesFile)//将一个值写入testcase的custom properties中testRunner.testCase.setPropertyValue("token", token)//Assert information----比较属性值assert accountid.equals(properties.getProperty("accountid"))//生成一个1~1000的随机数def rd=new Random()def MaxResults=rd.nextInt(1000)//生成一个随机字符串String base = "abcdefghijklmnopqrstuvwxyz0123456789"; //生成字符串从此序列中取Random random = new Random();StringBuffer sb = new StringBuffer();for (int i = 0;i < 5; i++) {int number = random.nextInt(base.length());sb.append(base.charAt(number));}( sb.toString())//获取xml某个节点的个数，下例中获取的是节点Fleet的个数def idNodeList = holder.getNodeValues("//ns2:Fleet") //将<ns2:Fleet>节点的内容取出后放到idNodeList数组中def cnt=idNodeList.length //获取idNodeList数组的长度//当节点后面的中括号中是变量的话就需要在变量前加$def FleetId = holder.getNodeValue( "//ns2:Fleet[$Fleetrd]/ns1:Id[1]" )//Parse information from responsedef groovyUtils = new com.eviware.soapui.support.GroovyUtils(context)def holder = groovyUtils.getXmlHolder("getCurrentUserInfo#ResponseAsXml")Notes:Property ResponseAsXml is for REST; Property Response is for SOAP//添加一个assertion，不区分大小写的字符串比较def accountid = holder.getNodeValue("//ns1:accountId")assert accountid.equals(testRunner.testCase.getPropertyValue("accountid"))def firstName=holder.getNodeValue("//ns2:AccountUser[$i]/ns2:FirstName[1]")def firstNameUpCase=firstName.toUpperCase()(firstName)(i)def firstNameStr=testRunner.testCase.getPropertyValue("firstNameContains")def firstNameStrUpCase=firstNameStr.toUpperCase()assert firstNameUpCase.contains(firstNameStrUpCase)//让下面的语句延迟3分钟运行Sleep(3*60*1000)以下的例子展示了在Groovy中声明一个字符串的不同方式：s1 = "Hello \"World\" " //Escape double quotes，转义双引号s2 = 'Hello "World" ' assert s1 == s2 s3 = 'Hello \'World\' ' //Escape single quotes，转义单引号s4 = "Hello 'World' " assert s3 == s4 assert new String('Hello World') == "Hello World" def s = ['h','e','l','l','o'] as char[] assert new String(s) == 'hello' assert new String(s,0,4) == 'hell' s.eachWithIndex{ch,index -> assert ch == s[index]} assert 'hello'.toCharArray() == ['h','e','l','l','o'] 常用的转义符：assert '\t' == '\011' //Tab，Tab键assert '\n' == '\012' //New line，换行符assert '\r' == '\015' //Carriage return，回车assert '\n' == """ """ //Spanning multiple lines，跨越多行对象的字符串表示：def object = new Object() assert String.valueOf(object) == object.toString() //Objects assert String.valueOf(true) == true.toString() //Booleans assert String.valueOf('a') == 'a'.toString() //Characters assert String.valueOf(1) == 1.toString() //Numbers assert String.valueOf([a:1,b:2]) == [a:1,b:2].toString() //Collections 字符串长度：s = "Hello World" assert s.size() == 11 assert s.size() == s.length() 填充（pad）字符串：assert 'Hello'.padRight(7,'*') == 'Hello**' assert 'Hello'.padLeft(7,'*') == '**Hello' assert 'Hello'.center(9,'*') == '**Hello**' 分解字符串：s = "The quick brown fox jumps over the lazy dog" assert s.tokenize() == ['The','quick','brown','fox','jumps','over','the','lazy','dog'] assert s.tokenize() == new StringTokenizer(s).collect{it} s1 = "The,quick*brown*fox,*jumps*over*the*lazy*dog" assert s1.tokenize(',*') == s.tokenize() 查询字符串：alphabets = new String('a' .. 'z' as char[]) assert alphabets.find{it > 'f'} == 'g' //First one found assert alphabets.findAll{it > 'f'} == 'g' .. 'z'//ALl found assert alphabets.findIndexOf{ it > 'f'} == alphabets.indexOf('g') assert alphabets.every {it > 'A'} assert alphabets.any{it < 'c'} assert alphabets.startsWith('abc') assert alphabets.endsWith('xyz') assert alphabets.contains('def') assert alphabets.indexOf('c') == 2 assertalphabets.indexOf('d') == stIndexOf('d') assert alphabets.count('a') == 1 替换字符串：s = "Hello" assert s.replace('H','Y') == 'Yello' assert s.replace('l','p') == 'Heppo' 字符串反转：s = 'mirror' assert s.reverse() == 'rorrim' 字符串操作符：assert 'hello' + ' world' - 'l' == 'helo world' //Subtracts at most one l assert ('Today is Sunday' - 'Sunday').trim() == 'Today is' assert 'hello ' * 2 == 'hello hello ' def empty = [] assert 'abc'.each{empty << it} == 'abc' assert 'abc'.next() == 'abd' assert 'abc'.previous() == 'abb' 下标操作符：assert 'hello'[1] == 'e' assert 'hello'[2..'hello'.size() - 1] == 'llo' assert 'hello'[0,2,4] == 'hlo' assert 'hello'[-4,-2] == 'el' 字符串比较：assert 'a' < 'b' assert 'a' > 'A' assert 'a'.compareTo('b') == -1 assert 'a'.compareToIgnoreCase('A') == 0 寻找最大值和最小值：Collections.max('abcdeF'.toList()) == 'e' assert Collections.max('abcdeF'.toList(), String.CASE_INSENSITIVE_ORDER) == 'F' assert Collections.min(['abc','abd','abe']) == 'abc' assert Collections.min(['Abc','aBd','abE'], String.CASE_INSENSITIVE_ORDER) == 'Abc' StringBuffers和StringBuilders是可变的，允许字符串改变。
Groovy闭包学习笔记
Groovy闭包学习笔记1. 闭包的初步认识闭包通常⽤于函数式语⾔中，它允许执⾏⼀个制定好的代码块。
通俗的说，⼀个闭包就是⼀个⽤花括号括起来的语句块，为了传递参数给闭包，闭包有⼀个可选的参数列表，通过“->”表⽰列表的结束闭包的简单实例：⾯向对象的最⾼原则是对象有⾃⼰的⾏为和数据，闭包也是对象，其⽬的是其⾏为。
可以把闭包理解为⼀个类中的⽅法。
但是始终记住：闭包是由⼀些代码组成的对象。
2. 闭包的缺省参数it下⾯两个closure作⽤是⼀样的[plain] copy1. [1,2,3].each{println it}2. [1,2,3].each{i->println i}等效的java代码：[java] copy1. List<Integer> list=new ArrayList<Integer>();2. list.add(1);3. list.add(2);4. list.add(3);5. for(Integer i:list){6. System.out.println(i);7. }3. 闭包的⽤途3.1 处理集合，迭代上⾯的例⼦都是关于集合的实例3.2 处理资源在Java中打开流必须对应⼀个close来关闭流来释放资源。
通过groovy闭包可以实现：newFile("D:\\carinfo.txt").eachLine { println it }eachLine会处理流的打开及关闭。
4. 声明闭包4.1 花括号声明在⼀个⽅法调⽤的后⾯，放置闭包代码在⼀对花括号⾥，闭包的参数和代码通过箭头进⾏分割。
箭头是闭包的参数和代码的分隔指⽰符。
4.2 声明变量使⽤复制的⽅式声明闭包，将其赋给⼀个变量。
def printer={line -> println line}4.3 ⽅法返回值通过⽅法返回值[plain] copy1. def Closure getPrinter(){2. return {line -> println line}3. }4.4 引⽤⼀个⽅法作为闭包重⽤已有的声明：⼀个⽅法。
Groovy正则表达式小结
Groovy正则表达式⼩结正⽂:如果你在Java编码时使⽤过正则表达式，那么会发现Groovy对正则表达式的⽤法做了很⼤的简化，从⽽让更多的⼈不再惧怕正则表达式。
Ted Naleid的博⽂中，详细介绍了Groovy中正则表达的⽤法。
⽤/../定义正则表达式Groovy中使⽤slashy（斜线）语法“//”定义正则表达式，对于出现在表达式中特殊字符，会⾃动进⾏转义。
⽐如：assert ng.String == /foo/.classassert ( /Count is \d/ == "Count is \\d" )“//”中也可以使⽤GString，⽐如：def name = "Ted Naleid"assert ( /$name/ == "Ted Naleid" )assert ( /$name/ == "$name" )操作符~：⽤在字符串之前，会将字符串编译成Pattern。
⽐如：def shoutedWord = ~/\b[A-Z]+\b/=~：将操作符左边的字符串跟右边的Pattern进⾏局部匹配，返回值为Matcher。
如：def matcher=("finda" =~ /find/)assert "find"==matcher[0]==~：⽤法跟=~类似，只是这⾥进⾏的精确匹配，即左边的整个字符串跟左边的模式进⾏匹配，==~的结果跟Matcher.matches()的结果是⼀样的。
返回值为Boolean。
如：def matcher=("finda"==~ /find/)assert ng.Boolean==matcher.getClass()对字符串的改进replaceFirst：将满⾜正则表达式的第⼀个字符串进⾏替换，⽐如：assert "Green Eggs and Spam" == "Spam Spam".replaceFirst(/Spam/, "Green Eggs and") replaceAll：将所有满⾜正则表达式的字符串进⾏替换，⽐如：assert "The armor was colored silver" == "The armour was coloured silver".replaceAll(/ou/, "o")replaceAll的第⼆个参数可以使⽤闭包，但需要注意，闭包中的第⼀个参数是匹配的字符串，⽐如：def dashedToCamelCase(orig) {orig.replaceAll(/-(\w)/) { fullMatch, firstCharacter -> firstCharacter.toUpperCase() }}assert "firstName" == dashedToCamelCase("first-name")对集合的改进Groovy中除了each、collect、inject等，还有⼀个对正则表达式敏感的迭代器：grep，即在集合中查找满⾜表达式的元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
例 2： window 下设置环境变量 def env = ['USERNAME=mittie'] def proc = 'cmd /c set'.execute(env, new File('/')) println proc.text //打印输出文本 //种定向输出流 InputStream InputStream in = proc.in err = proc.err
第6页 div "Your guess $guess is " switch (guess) { case goal : div 'correct!'; break
case {it < goal} : div 'too low' ; break case {it > goal} : div 'too high'; break } } p "What's your guess (0..100)?" form(action:'NumberGuesser.groovy'){ input(type:'text', name:'guess', '') button(type:'submit', 'Guess') button(type:'submit', name:'restart', value:'true', 'New Game') } } }
第7页 <head> <title>Think of a Number</title> </head> <body> <h1>Think of a Number</h1> Your guess $guess is <% switch (guess) { case goal : out << 'correct!'; break
class Storage { List stack = [] synchronized void leftShift(value){ stack << value println "push: $value" notifyAll() } synchronized Object pop() { while (stack.isEmpty()) { try{ wait() } catch(InterruptedException e){} } 第1页
第2页 def value = stack.pop() println "pop : $value" return value } } storage = new Storage() Thread.start { for (i in 0..9) { storage << i sleep 100 } } Thread.start { 10.times { sleep 200 value = storage.pop() } }
第7页
第8页
五、 数据库编程
Table 10.1 HSQLDB subprotocols
初始化连接
import groovy.sql.Sql db = Sql.newInstance( 'jdbc:hsqldb:mem:GinA', 'sa', '', 'org.hsqldb.jdbcDriver') source = new org.hsqldb.jdbc.jdbcDataSource() source.database = 'jdbc:hsqldb:mem:GinA' er = 'sa' source.password = '' db = new groovy.sql.Sql(source) 执行 sql db.execute(statement) db.execute ''' CREATE TABLE Athlete ( firstname lastname VARCHAR(64), VARCHAR(64),
Groovy 学习笔记
一、 多线程的运用
t = new Thread() { /* Closure body */ } t.start() Thread.start { /* Closure body */ } Thread.startDaemon { /* Closure body */ } new Timer().runAfter(1000){ /* Closure body */} Listing 9.11 problem Using threads with synchronization for the producer/consumer
<web-app> <display-name>Groovlet Demonstrator</display-name> <description> Showing the use of Groovlets for Groovy in Action </description> <servlet> <servlet-name>Groovy</servlet-name> <servlet-class>groovy.servlet.GroovyServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>Groovy</servlet-name> <url-pattern>*</url-pattern> </servlet-mapping> </web-app>
第4页
your collaboration is very much appreciated '''
四、 使用 Groovlets
Listing 9.15 Groovlet use Sample web.xml file for configuring a web application for
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "/j2ee/dtds/web-app_2_2.dtd" >
OutputStream out = proc.out
第2页
ห้องสมุดไป่ตู้3页
三、 模板使用
Listing 9.14 Using a simple template engine for email text mailReminder = ''' Dear ${salutation?salutation+' ':''}$lastname, another month has passed and it's time for these <%=tasks.size()%> tasks: <% tasks.each { %>- $it <% } %> your collaboration is very much appreciated ''' def engine def binding = new groovy.text.SimpleTemplateEngine() = [ def template = engine.createTemplate(mailReminder) salutation: 'Mrs.', lastname tasks ] assert template.make(binding).toString() == ''' Dear Mrs. Davis, another month has passed and it's time for these 2 tasks: - visit the Groovy in Action (GinA) page - chat with GinA readers 第3页 : 'Davis', : ['visit the Groovy in Action (GinA) page', 'chat with GinA readers']
case {it < goal} : out << 'too low' ; break case {it > goal} : out << 'too high'; break } %> <p>What"s your guess (0..100)?</p> <form action='Templater.groovy'> <input type='text' name='guess'> <button type='submit'>Guess</button> <button type='submit' name='restart' value='true'>New Game </button> </form> </body> </html> groovy： def engine def source = new groovy.text.SimpleTemplateEngine() = getClass().classLoader. getResource('/Number.template.html') def template = engine.createTemplate(source) out << template.make(goal:50, guess:49)