- 浏览: 5171661 次
- 性别:
- 来自: 天津
博客专栏
-
实战 Groovy
浏览量:29395
文章分类
- 全部博客 (639)
- 代码之谜 (6)
- JavaScript quirks (5)
- 程序员 (92)
- Java (93)
- BT编程 (7)
- html/css (64)
- Groovy&Grails (42)
- Android (20)
- C/C++ (5)
- PHP/Perl/Python (46)
- 经典文章 (51)
- CodeIgniter (14)
- JQuery (10)
- 笑话 (4)
- 其他 (32)
- javascript (69)
- 云计算 (0)
- html5 (7)
- 面试 (8)
- google (3)
- nosql (2)
- nodejs (11)
- go (5)
- erlang (1)
- 小常识 (3)
- 冷知识 (5)
- database (4)
- web (12)
- 架构 (12)
- Exception (0)
最新评论
-
jqw1992:
https://www.chromefor.com/libra ...
[福利] 开发者必备的 Chrome 插件——ChromeSnifferPlus -
litjerk:
初步算了一下,目前最最精简的Win98版是5M,他5个小时多敲 ...
让人目瞪口呆的三位世界级电脑大师 -
379855529:
。。似乎重点没说NIO啊,前面基础只是铺垫的很好的,可是我要的 ...
Java NIO与IO的详细区别(通俗篇) -
springmvc_springjpa:
spring mvc demo教程源代码下载,地址:http: ...
一步步开发 Spring MVC 应用 -
匡建武:
Good
四个程序员的一天
您有没有想过在自己相对复杂的 Java 程序中嵌入 Groovy 简单的、易于编写的脚本呢?在这一期 实战 Groovy 系列文章中,Andrew Glover 将介绍把 Groovy 集成到 Java 代码中的多种方法,并解释在什么地方、什么时候适合这么做。
如果您一直在阅读这个系列,那么您应该已经看到有各种各样使用 Groovy 的有趣方式,Groovy 的主要优势之一就是它的生产力。Groovy 代码通常要比 Java 代码更容易编写,而且编写起来也更快,这使得它有足够的资格成为开发工作包中的一个附件。在另一方面,正如我在这个系列中反复强调的那样,Groovy 并不是 —— 而且也不打算成为 —— Java 语言的替代。所以,这里存在的问题是,能否把 Groovy 集成到 Java 的编程实践中?或者说这样做有什么用?什么时候 这样做有用?
这个月,我将尝试回答这个问题。我将从一些熟悉的事物开始,即从如何将 Groovy 脚本编译成与 Java 兼容的类文件开始,然后进一步仔细研究 Groovy 的编译工具(groovyc
)是如何让这个奇迹实现的。了解 Groovy 在幕后做了什么是在 Java 代码中使用 Groovy 的第一步。
注意,本月示例中演示的一些编程技术是 Groovlets
框架和 Groovy 的 GroovyTestCase
的核心,这些技术我在前面的文章中已经讨论过。
在本系列中以前的文章中,当我介绍如何 用 Groovy 测试普通 Java 程序 的时候,您可能已经注意到一些奇怪的事:我 编译了 那些 Groovy 脚本。实际上,我将 groovy 单元测试编译成普通的 Java .class 文件,然后把它们作为 Maven 构建的一部分来运行。
这种编译是通过调用 groovyc
命令进行的,该命令将 Groovy 脚本编译成普通的 Java 兼容的 .class 文件。例如,如果脚本声明了一个类,那么调用 groovyc
会生成至少三个 .class 。文件本身会遵守标准的 Java 规则:.class 文件名称要和声明的类名匹配。
作为示例,请参见清单 1,它创建了一个简单的脚本,脚本声明了几个类。然后,您自己就可以看出 groovyc
命令生成的结果:
package com.vanward.groovy class Person { fname lname age address contactNumbers String toString(){ numstr = new StringBuffer() if (contactNumbers != null){ contactNumbers.each{ numstr.append(it) numstr.append(" ") } } "first name: " + fname + " last name: " + lname + " age: " + age + " address: " + address + " contact numbers: " + numstr.toString() } } class Address { street1 street2 city state zip String toString(){ "street1: " + street1 + " street2: " + street2 + " city: " + city + " state: " + state + " zip: " + zip } } class ContactNumber { type number String toString(){ "Type: " + type + " number: " + number } } nums = [new ContactNumber(type:"cell", number:"555.555.9999"), new ContactNumber(type:"office", number:"555.555.5598")] addr = new Address(street1:"89 Main St.", street2:"Apt #2", city:"Utopia", state:"VA", zip:"34254") pers = new Person(fname:"Mollie", lname:"Smith", age:34, address:addr, contactNumbers:nums) println pers.toString() |
在清单 1 中,我声明了三个类 —— Person
、Address
和 ContactNumber
。之后的代码根据这些新定义的类型创建对象,然后调用 toString()
方法。迄今为止,Groovy 中的代码还非常简单,但现在来看一下清单 2 中 groovyc
产生什么样的结果:
aglover@12d21 /cygdrive/c/dev/project/target/classes/com/vanward/groovy $ ls -ls total 15 4 -rwxrwxrwx+ 1 aglover user 3317 May 3 21:12 Address.class 3 -rwxrwxrwx+ 1 aglover user 3061 May 3 21:12 BusinessObjects.class 3 -rwxrwxrwx+ 1 aglover user 2815 May 3 21:12 ContactNumber.class 1 -rwxrwxrwx+ 1 aglover user 1003 May 3 21:12 Person$_toString_closure1.class 4 -rwxrwxrwx+ 1 aglover user 4055 May 3 21:12 Person.class |
哇!五个 .class 文件!我们了解 Person
、Address
和 ContactNumber
文件的意义,但是其他两个文件有什么作用呢?
研究发现,Person$_toString_closure1.class
是 Person
类的 toString()
方法中发现的闭包的结果。它是 Person
的一个内部类,但是 BusinessObjects.class
文件是怎么回事 —— 它可能是什么呢?
对 清单 1 的深入观察指出:我在脚本主体中编写的代码(声明完三个类之后的代码)变成一个 .class 文件,它的名称采用的是脚本名称。在这个例子中,脚本被命名为 BusinessObjects.groovy
,所以,类定义中没有包含的代码被编译到一个名为 BusinessObjects
的 .class 文件。
反编译这些类可能会非常有趣。由于 Groovy 处于代码顶层,所以生成的 .java 文件可能相当巨大;不过,您应当注意的是 Groovy 脚本中声明的类(如 Person
) 与类之外的代码(比如BusinessObjects.class
中找到的代码)之间的区别。在 Groovy 文件中定义的类完成了 GroovyObject
的实现,而在类之外定义的代码则被绑定到一个扩展自 Script
的类。
例如,如果研究由 BusinessObjects.class 生成的 .java 文件,可以发现:它定义了一个 main()
方法和一个 run()
方法。不用惊讶, run()
方法包含我编写的、用来创建这些对象的新实例的代码,而main()
方法则调用 run()
方法。
这个细节的全部要点再一次回到了:对 Groovy 的理解越好,就越容易把它集成到 Java 程序中。有人也许会问:“为什么我要这么做呢?”好了,我们想说您用 Groovy 开发了一些很酷的东西;那么如果能把这些东西集成到 Java 程序中,那不是很好吗?
只是为了讨论的原因,我首先试图 用 Groovy 创建一些有用的东西,然后我再介绍把它嵌入到普通 Java 程序中的各种方法。
我热爱音乐。实际上,我的 CD 收藏超过了我计算机图书的收藏。多年以来,我把我的音乐截取到不同的计算机上,在这个过程中,我的 MP3 收藏乱到了这样一种层度:只是表示品种丰富的音乐目录就有一大堆。
最近,为了让我的音乐收藏回归有序,我采取了第一步行动。我编写了一个快速的 Groovy 脚本,在某个目录的 MP3 收藏上进行迭代,然后把每个文件的详细信息(例如艺术家、专辑名称等)提供给我。脚本如清单 3 所示:
package com.vanward.groovy import org.farng.mp3.MP3File import groovy.util.AntBuilder class Song { mp3file Song(String mp3name){ mp3file = new MP3File(mp3name) } getTitle(){ mp3file.getID3v1Tag().getTitle() } getAlbum(){ mp3file.getID3v1Tag().getAlbum() } getArtist(){ mp3file.getID3v1Tag().getArtist() } String toString(){ "Artist: " + getArtist() + " Album: " + getAlbum() + " Song: " + getTitle() } static getSongsForDirectory(sdir){ println "sdir is: " + sdir ant = new AntBuilder() scanner = ant.fileScanner { fileset(dir:sdir) { include(name:"**/*.mp3") } } songs = [] for(f in scanner){ songs << new Song(f.getAbsolutePath()) } return songs } } songs = Song.getSongsForDirectory(args[0]) songs.each{ println it } |
正如您所看到的,脚本非常简单,对于像我这样的人来说特别有用。而我要做的全部工作只是把某个具体的目录名传递给它,然后我就会得到该目录中每个 MP3 文件的相关信息(艺术家名称、歌曲名称和专辑) 。
现在让我们来看看,如果要把这个干净的脚本集成到一个能够通过数据库组织音乐甚至播放 MP3 的普通 Java 程序中,我需要做些什么。
正如前面讨论过的,我的第一个选项可能只是用 groovyc
编译脚本。在这个例子中,我期望 groovyc
创建 至少 两个 .class 文件 —— 一个用于 Song
类,另一个用于 Song
声明之后的脚本代码。
实际上,groovyc
可能创建 5 个 .class 文件。这是与 Songs.groovy
包含三个闭包有关,两个闭包在 getSongsForDirectory()
方法中,另一个在脚本体中,我在脚本体中对 Song
的集合进行迭代,并调用println
。
因为 .class 文件中有三个实际上是 Song.class 和 Songs.class 的内部类,所以我只需要把注意力放在两个 .class 文件上。Song.class 直接映射到 Groovy 脚本中的 Song
声明,并实现了GroovyObject
,而 Songs.class 则代表我在定义 Song
之后编写的代码,所以也扩展了 Script
。
此时此刻,关于如何把新编译的 Groovy 代码集成到 Java 代码,我有两个选择:可以通过 Songs.class 文件中的 main()
方法运行代码 (因为它扩展了 Script
),或者可以将 Song.class 包含到类路径中,就像在 Java 代码中使用其他对象一样使用它。
通过 java
命令调用 Songs.class 文件非常简单,只要您记得把 Groovy 相关的依赖关系和 Groovy 脚本需要的依赖关系包含进来就可以。把 Groovy 需要的类全都包含进来的最简单方法就是把包含全部内容的 Groovy 可嵌入 jar 文件添加到类路径中。在我的例子中,这个文件是 groovy-all-1.0-beta-10.jar。要运行 Songs.class,需要记得包含将要用到的 MP3 库(jid3lib-0.5.jar>),而且因为我使用 AntBuilder
,所以我还需要在类路径中包含 Ant
。清单 4 把这些放在了一起:
c:\dev\projects>java -cp ./target/classes/;c:/dev/tools/groovy/ groovy-all-1.0-beta-10.jar;C:/dev/tools/groovy/ant-1.6.2.jar; C:/dev/projects-2.0/jid3lib-0.5.jar com.vanward.groovy.Songs c:\dev09\music\mp3s Artist: U2 Album: Zooropa Song: Babyface Artist: James Taylor Album: Greatest Hits Song: Carolina in My Mind Artist: James Taylor Album: Greatest Hits Song: Fire and Rain Artist: U2 Album: Zooropa Song: Lemon Artist: James Taylor Album: Greatest Hits Song: Country Road Artist: James Taylor Album: Greatest Hits Song: Don't Let Me Be Lonely Tonight Artist: U2 Album: Zooropa Song: Some Days Are Better Than Others Artist: Paul Simon Album: Graceland Song: Under African Skies Artist: Paul Simon Album: Graceland Song: Homeless Artist: U2 Album: Zooropa Song: Dirty Day Artist: Paul Simon Album: Graceland Song: That Was Your Mother |
虽然命令行的解决方案简单有趣,但它并不是所有问题的最终解决方案。如果对更高层次的完善感兴趣,那么可能将 MP3 歌曲工具直接导入 Java 程序。在这个例子中,我想导入 Song.class ,并像在 Java 语言中使用其他类那样使用它。类路径的问题与上面相同 :我需要确保包含了 uber-Groovy jar 文件、Ant
和 jid3lib-0.5.jar 文件。在清单 5 中,可以看到如何将 Groovy MP3 工具导入简单的 Java 类中:
package com.vanward.gembed; import com.vanward.groovy.Song; import java.util.Collection; import java.util.Iterator; public class SongEmbedGroovy{ public static void main(String args[]) { Collection coll = (Collection)Song.getSongsForDirectory ("C:\\music\\temp\\mp3s"); for(Iterator it = coll.iterator(); it.hasNext();){ System.out.println(it.next()); } } } |
就在您以为自己已经掌握全部的时候,我要告诉您的是,还有更多在 Java 语言中使用 Groovy 的方法。除了通过直接编译把 Groovy 脚本集成到 Java 程序中的这个选择之外,当我想直接嵌入脚本时,还有其他一些选择。
例如,我可以用 Groovy 的 GroovyClassLoader
,动态地 加载一个脚本并执行它的行为,如清单 6 所示:
清单 6. GroovyClassLoader 动态地加载并执行 Groovy 脚本
package com.vanward.gembed; import groovy.lang.GroovyClassLoader; import groovy.lang.GroovyObject; import groovy.lang.MetaMethod; import java.io.File; public class CLEmbedGroovy{ public static void main(String args[]) throws Throwable{ ClassLoader parent = CLEmbedGroovy.class.getClassLoader(); GroovyClassLoader loader = new GroovyClassLoader(parent); Class groovyClass = loader.parseClass( new File("C:\\dev\\groovy-embed\\src\\groovy\\ com\\vanward\\groovy\\Songs.groovy")); GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance(); Object[] path = {"C:\\music\\temp\\mp3s"}; groovyObject.setProperty("args", path); Object[] argz = {}; groovyObject.invokeMethod("run", argz); } } |
注意,默认情况下,类加载器将加载与脚本名称对应的类 —— 在这个例子中是 Songs.class,而不是 Song.class>。因为我(和您)知道 Songs.class 扩展了 Groovy 的 Script 类,所以不用想也知道接下来要做的就是执行 run()
方法。
您记起,我的 Groovy 脚本也依赖于运行时参数。所以,我需要恰当地配置 args
变量,在这个例子中,我把第一个元素设置为目录名。
对于使用编译好的类,而且,通过类加载器来动态加载 GroovyObject
的替代,是使用 Groovy 优美的 GroovyScriptEngine
和 GroovyShell
动态地执行 Groovy 脚本。
把 GroovyShell
对象嵌入普通 Java 类,可以像类加载器所做的那样动态执行 Groovy 脚本。除此之外,它还提供了大量关于控制脚本运行的选项。在清单 7 中,可以看到 GroovyShell
嵌入到普通 Java 类的方式:
package com.vanward.gembed; import java.io.File; import groovy.lang.GroovyShell; public class ShellRunEmbedGroovy{ public static void main(String args[]) throws Throwable{ String[] path = {"C:\\music\\temp\\mp3s"}; GroovyShell shell = new GroovyShell(); shell.run(new File("C:\\dev\\groovy-embed\\src\\groovy\\ com\\vanward\\groovy\\Songs.groovy"), path); } } |
可以看到,运行 Groovy 脚本非常容易。我只是创建了 GroovyShell
的实例,传递进脚本名称,然后调用 run()
方法。
还可以做其他事情。如果您喜欢,那么也可以得到自己脚本的 Script
类型的 GroovyShell
实例。使用 Script
类型,您就可以传递进一个 Binding
对象,其中包含任何运行时值,然后再继续调用 run()
方法,如清单 8 所示:
package com.vanward.gembed; import java.io.File; import groovy.lang.Binding; import groovy.lang.GroovyShell; import groovy.lang.Script; public class ShellParseEmbedGroovy{ public static void main(String args[]) throws Throwable{ GroovyShell shell = new GroovyShell(); Script scrpt = shell.parse( new File("C:\\dev\\groovy-embed\\src\\groovy\\ com\\vanward\\groovy\\Songs.groovy")); Binding binding = new Binding(); Object[] path = {"C:\\music\\temp\\mp3s"}; binding.setVariable("args",path); scrpt.setBinding(binding); scrpt.run(); } } |
GroovyScriptEngine
对象动态运行脚本的时候,非常像 GroovyShell
。区别在于:对于 GroovyScriptEngine
,您可以在实例化的时候给它提供一系列目录,然后让它根据要求去执行多个脚本,如清单 9 所示:
package com.vanward.gembed; import java.io.File; import groovy.lang.Binding; import groovy.util.GroovyScriptEngine; public class ScriptEngineEmbedGroovy{ public static void main(String args[]) throws Throwable{ String[] paths = {"C:\\dev\\groovy-embed\\src\\groovy\\ com\\vanward\\groovy"}; GroovyScriptEngine gse = new GroovyScriptEngine(paths); Binding binding = new Binding(); Object[] path = {"C:\\music\\temp\\mp3s"}; binding.setVariable("args",path); gse.run("Songs.groovy", binding); gse.run("BusinessObjects.groovy", binding); } } |
在清单 9 中,我向实例化的 GroovyScriptEngine
传入了一个数组,数据中包含我要处理的路径,然后创建大家熟悉的 Binding
对象,然后再执行仍然很熟悉的 Songs.groovy
脚本。只是为了好玩,我还执行了BusinessObjects.groovy
脚本,您或许还能回忆起来,它在开始这次讨论的时候出现过。
最后,当然并不是最不重要的,是来自 Jakarta 的古老的 Bean 脚本框架( Bean Scripting Framework —— BSF)。BSF 试图提供一个公共的 API,用来在普通 Java 应用程序中嵌入各种脚本语言(包括 Groovy)。这个标准的、但是有争议的最小公因子方法,可以让您毫不费力地将 Java 应用程序嵌入 Groovy 脚本。
还记得前面的 BusinessObjects
脚本吗?在清单 10 中,可以看到 BSF 可以多么容易地让我把这个脚本插入普通 Java 程序中:
package com.vanward.gembed; import org.apache.bsf.BSFManager; import org.codehaus.groovy.runtime.DefaultGroovyMethods; import java.io.File; import groovy.lang.Binding; public class BSFEmbedGroovy{ public static void main(String args[]) throws Exception { String fileName = "C:\\dev\\project\\src\\groovy\\ com\\vanward\\groovy\\BusinessObjects.groovy"; //this is required for bsf-2.3.0 //the "groovy" and "gy" are extensions BSFManager.registerScriptingEngine("groovy", "org.codehaus.groovy.bsf.GroovyEngine", new String[] { "groovy" }); BSFManager manager = new BSFManager(); //DefaultGroovyMethods.getText just returns a //string representation of the contents of the file manager.exec("groovy", fileName, 0, 0, DefaultGroovyMethods.getText(new File(fileName))); } } |
如果在本文中有一件事是清楚的话,那么只件事就是 Groovy 为了 Java 代码内部的重用提供了一堆选择。从把 Groovy 脚本编译成普通 Java .class 文件,到动态地加载和运行脚本,这些问题需要考虑的一些关键方面是灵活性和耦合。把 Groovy 脚本编译成普通 .class 文件是 使用 您打算嵌入的功能的最简单选择,但是动态加载脚本可以使添加或修改脚本的行为变得更容易,同时还不必在编译上牺牲时间。(当然,这个选项只是在接口不变的情况下才有用。)
把脚本语言嵌入普通 Java 不是每天都发生,但是机会确实不断出现。这里提供的示例把一个简单的目录搜索工具嵌入到基于 Java 的应用程序中,这样 Java 应用程序就可以很容易地变成 MP3 播放程序或者其他 MP3 播放工具。虽然我 可以 用 Java 代码重新编写 MP3 文件搜索器,但是我不需要这么做:Groovy 极好地兼容 Java 语言,而且,我很有兴趣去摆弄所有选项!
发表评论
-
实战 Groovy: 用 Groovy 打造服务器端
2010-07-10 11:07 2730Groovlet 和 GroovyServer P ... -
实战 Groovy: 用 Groovy 生成器作标记
2010-07-10 11:07 2069Groovy 生成器让您能够利用诸如 Swing 这样 ... -
实战 Groovy: for each 剖析
2010-07-10 11:07 18202在这一期的 实战 Groovy 中,Scott Davi ... -
实战 Groovy: 用 Groovy 进行 Ant 脚本编程
2010-07-10 11:07 2061Ant 和 Maven 两者在构建处理工具的世界中占统 ... -
实战 Groovy: Groovy 的腾飞
2010-07-10 11:06 2192随着 Groovy JSR-1(及其后续发行版本)的发 ... -
实战 Groovy: 用 curry 过的闭包进行函数式编程
2010-07-10 11:06 3256在 Groovy 中处处都是闭包,Groovy 闭包惟 ... -
实战 Groovy: 关于 MOP 和迷你语言
2010-07-10 11:06 2072将耳朵贴到地上仔细听 —— MOP 正在前进!了解一下 ... -
实战 Groovy: 用 Groovy 更迅速地对 Java 代码进行单元测试
2010-07-10 11:06 2306不久以前,developerWor ... -
实战 Groovy: 构建和解析 XML
2010-07-10 11:05 7122通过本文,您将了解 ... -
实战 Groovy: 用 Groovy 进行 JDBC 编程
2010-07-10 11:05 5195这个月,随着 Andrew G ... -
实战 Groovy: 美妙的操作符
2010-07-10 11:05 2287Java™ 取消了操作符重载,但是新兴的 Groovy ... -
实战 Groovy: 使用 Groovy 模板进行 MVC 编程
2010-07-10 11:04 2923视图是 MVC 编程的一个重要部分,而 MVC 编程本 ... -
实战 Groovy: 用 Groovy 减少代码冗余
2010-07-10 11:04 2062Groovy 简洁的语法将 ... -
实战 Groovy: Groovy:Java 程序员的 DSL
2010-07-10 11:04 3083Groovy 专家 Scott Davis 将重新开始 ... -
精通 Grails: 构建您的第一个 Grails 应用程序
2010-07-06 09:37 1651Java™ 程序员不需要 ... -
Grails 部署
2010-07-06 09:36 6075部署 Grails可以使用很多种方式来部署,每一种 ... -
Grails 脚手架
2010-07-05 08:20 4080脚手架 根据指定的领域类,脚手架为你自动生成 ... -
Grails Grails 与 Hibernate
2010-07-05 08:19 2703Grails 与 Hibernate 如果 GOR ... -
Grails Grails和 Spring
2010-07-05 08:19 7915Grails和 Spring 这一节适合于高级用户 ... -
Grails Web服务
2010-07-05 08:19 3959Web服务 Web服务就是让你的web应用提供一套 ...
相关推荐
标签:groovy、codehaus、jar包、java、中文文档; 使用方法:解压翻译后的API文档,用浏览器打开“index.html”文件,即可纵览文档内容。 人性化翻译,文档中的代码和结构保持不变,注释和说明精准翻译,请放心使用...
标题中的“Groovy和Java相互调用1”指的是在编程时如何在Groovy语言环境中调用Java类,以及反之,如何在Java程序中调用Groovy类。这是一种跨语言交互的方式,特别是在混合使用Groovy和Java的项目中非常常见。 ...
本文将详细讲解如何在Java应用程序中调用Groovy脚本,实现从MongoDB数据库中读取并实时运行Groovy脚本,以及其背后的原理和优势。 首先,Groovy是一种与Java高度兼容的脚本语言,它可以无缝地与Java代码集成,共享...
3. 微服务:Groovy可以快速构建微服务,如Spring Boot应用,它与Spring框架的集成非常紧密。 4. Gradle构建工具:Gradle使用Groovy作为其脚本语言,使得构建配置更加灵活。 四、实战Groovy学习路径 1. 基础语法学习...
Maven坐标:org.codehaus.groovy:groovy-all:2.4.5; 标签:codehaus、groovy、all、中英对照文档、jar包、java; 使用方法:解压翻译后的API文档,用浏览器打开“index.html”文件,即可纵览文档内容。 人性化翻译...
在一次代码拉取中,出现了以下问题:Could not download groovy-all.jar (org.codehaus.groovy:groovy-all:2.4.15) 详细的报错信息如下: // 报错信息如下 Could not resolve all files for configuration ':jcore-...
Groovy不仅支持静态类型检查,还可以在运行时动态地编译和执行代码,这使得它在Java平台中的应用场景非常广泛。本文将详细介绍Groovy脚本的基本概念、特点、用途以及如何在Java平台中使用Groovy进行动态编程。 ...
本文将深入探讨在Java项目中使用Groovy的三种主要方式,并阐述它们各自的优势和应用场景。 一、作为嵌入式脚本 Java 6引入了JSR 223(Scripting for the Java Platform),允许在Java程序中直接执行脚本语言。...
Groovy 脚本化Bean jar包下载
Making Java Groovy is a practical handbook for developers who want to blend Groovy into their day to day work with Java It starts by introducing the key differences between Java and Groovy and how you...
- **定义**:Groovy是一种面向对象的编程语言,它直接运行在Java平台上,并且能够与现有的Java代码无缝集成。 - **特点**: - **语法简洁**:Groovy提供了更为简洁、动态的语法特性,使得编写代码变得更加高效。 -...
通过学习Groovy,开发者可以利用其强大的特性来优化Java应用程序,实现更快的迭代和更高的生产效率。无论是在日常开发中混合使用Java和Groovy,还是使用Groovy进行脚本编写、自动化测试,它都是Java开发者值得掌握的...
最近的groovy-all-2.4.12.jar包供使用,解决as编译时报错问题
在自动化测试领域,Groovy脚本以其在Java平台上的卓越性能和灵活性,成为了开发者的热门选择。Groovy是一种基于JVM的动态编程语言,它不仅继承了Java的强大功能,还引入了动态类型、闭包、DSL等现代编程特性,使得...
标签:groovy、codehaus、jar包、java、中英对照文档; 使用方法:解压翻译后的API文档,用浏览器打开“index.html”文件,即可纵览文档内容。 人性化翻译,文档中的代码和结构保持不变,注释和说明精准翻译,请放心...
9. **Scripting in Java Applications**:Groovy可以嵌入到Java应用中作为脚本语言使用,例如在服务器端处理HTTP请求,或者作为配置文件来动态改变应用行为。 10. **持续集成与构建工具**:Groovy也是构建工具如...
通过本书,读者将学会如何利用Groovy脚本来优化现有的Java项目,或构建全新的应用程序,使其更加健壮、易于维护和扩展。 总的来说,《Groovy食谱:润滑Java的轮子》是一本针对Java开发者的技术宝典,它不仅教会你...
SpringBoot、Gradle、Maven、Java和Groovy是Java生态系统中的重要组成部分,它们在现代软件开发中扮演着至关重要的角色。这篇详细的知识点解析将深入探讨这些技术及其相互关系。 1. **SpringBoot**: SpringBoot是...
- **动态性**:Groovy支持动态类型,这意味着变量的类型可以在运行时改变,这在编写快速原型或者配置脚本时非常有用。 - **简洁的语法**:Groovy语法比Java更简洁,例如,它允许省略分号和大括号,使得代码更易读...
Groovy 是一种基于 Java 语言的脚本语言,运行在 JVM 中,语法与 Java 相似,但抛弃了 Java 的一些烦琐的语法规则,提供了更加简洁和灵活的编程体验。 Groovy 的特点 1. 简洁的语法:Groovy 语法简洁,减少了代码...