Groovy实战：Java开发者的效率加速器

需积分: 6 178 浏览量更新于2024-07-28 1 收藏 5.3MB PDF 举报

"Groovy Recipes Greasing the Wheels of Java" Groovy Recipes Greasing the Wheels of Java 是一本面向Java开发者的指南，旨在将Groovy转变为一种强大的工具，帮助开发者更高效地完成工作。这本书专注于通过简洁、实用的代码示例来解决实际问题，正如书名所示，它提供了各种Groovy的“配方”，帮助读者快速解决遇到的问题。 Groovy是一种动态、灵活的编程语言，它与Java有着良好的互操作性，能够无缝集成到Java项目中。Groovy的特点包括简洁的语法、内置的元编程能力以及对XML和Java集合处理的便利性，这些都使得它成为Java开发者提高生产力的理想选择。书中的内容覆盖了广泛的主题，例如： 1. **数据解析**：书中提到如何快速解析Atom feed，这涉及到Groovy对XML和JSON的处理能力。Groovy提供了易于使用的API来解析和操作这些数据格式，使开发者可以快速地从各种数据源获取信息。 2. **Web应用集成**：对于使用Grails（一个基于Groovy的现代Web应用框架）的开发者，书中提供了解决方案来从应用程序中服务Excel spreedsheets。这展示了Groovy如何与Java库集成，如Apache POI，来处理Office文档。 3. **自动化任务**：创建tarball on the fly的示例揭示了Groovy在自动化任务中的实用性。Groovy可以方便地调用系统命令，如打包和压缩，使得脚本编写更加便捷。 4. **代码简洁性**：作者Scott摒弃了不必要的仪式感，直接展示解决问题的代码，让读者可以立即看到解决方案。书中的每个章节都以代码开始，然后提供清晰的解释，让开发者可以选择深入理解或者直接应用。 5. **敏捷开发支持**：这本书的设计适应敏捷开发的需求，允许开发者在需要时迅速找到关键信息。这种格式使得开发者能够在面对新挑战时迅速找到解决方案，提高了工作效率。 6. **社区认可**：书评人Jason Rudolph和Dierk König等对Groovy Recipes给予了高度评价，认为它是Groovy开发者必备的参考书，可以帮助开发者快速上手并解决日常任务。通过这本书，Java开发者可以学习到如何利用Groovy的强大功能来简化工作流程，提高代码的可读性和效率，同时还能体验到Groovy带来的编程乐趣。无论你是初识Groovy，还是已经有一定经验，Groovy Recipes都将是一本有价值的参考资料。

GROOVY, THE WAY JAVA SHOULD BE 16

1.1 Groovy, the Way Java Should Be

roovy w as expressly designed to appeal to Java developers. Groovy is

Java at the end of the day. The other languages that r un on the JVM

are just that—other languages. The point of JRuby

is to get existing

Ruby code running on the JVM. The point of Jython

is to get existing

Python code running on the JVM. The point of Groovy is to integrate

with your existing Java code.

I’m not trying to diminish the value of those other languages. If you

already have an existing codebase implemented in another language,

the beneﬁts are undeniable. But how do they beneﬁt Java developers

with an existing Java codebase? Groovy and Java are so compatible

that in most cases you can take a Java ﬁle—foo.java—and r ename it to

foo.groovy. You will have a perfectly valid (and executable) Groovy ﬁle.

That trick won’t work with any of y our oth er neighbors on the JVM.

But more than language-level compatibility, Groovy allows you to dra-

matically reduce the amount of code you would normally wr i te in Java.

For example, let’s start with a simple Java class named Person.java that

has two attributes, ﬁrstName and lastName. As Java developers, we are

trained from a tender young age to create public classes with private

attributes. All outside access to the attributes is routed through public

getters and setters.

Java

Code

public class Person {

private String firstName;

private String lastName;

public String getFirstName() {

return firstName;

}

public void setFirstName(String firstName) {

this.firstName = firstName;

}

public String getLastName() {

return lastName;

}

public void setLastName(String lastName) {

this.lastName = lastName;

}

2. http://jruby.codehaus.org/

3. http://www.jython.org

Download at Boykma.Com

GROOVY, THE WAY JAVA SHOULD BE 17

I’m not arguing with established Java practices. Encapsulat

ion offers

many beneﬁts. Unfortunately, it comes w i th a heavy verbosity tax.

It took us more than twenty lines of code to deﬁne a class that has two

attributes. Each new attribute will cost us six more lines of code f or

boilerplate getters and setters. The fact that modern IDEs will generate

the requisite getters and setters for us doesn’t make the problem go

away; it makes the symptoms only slightly less painful.

What does the corresponding Gr oovy class look like? You can rename

Person.java to Person.groovy and the ﬁle will compile, but it is hardly

idiomatic Groovy.

What Java developers ﬁrst notice about Groovy is its brevity. Good

Groovy code is Java boiled down to its essence. You can see this imme-

diately in the Groovy version of the Person class:

Groovy

Code

class Person {

String firstName

String lastName

}

Yes, that’s all there is. Even better, it’s a drop-in replacement for the

Java class. Compile it down to bytecode, and t he Groovy version is

indistinguishable from it s Java counterpart. You’ll need to have groovy.

jar in your classpath, but with that in place your Java code can seam-

lessly call any plain old Groovy object (POGO) in lieu of a POJO with

the same name and ﬁelds.

All POGOs ar e public by default. All attributes are private. There are

getters and setters for each ﬁeld, but these methods are autogenerated

in the bytecode rather than the source code. This drops the 6:1 code

ratio for new ﬁelds down to exactly 1:1. Looking at t his POGO compared

to the Java class, there is noth i ng more that could be left out. It i s the

core of the POJO with all the syntactic noise stripped away.

Of course, you could slowly begin adding Java language features back

in one by one.

You could certainly use semicolons if you prefer. You could explicitly say

public class Person and private String ﬁrstName. There is n oth i ng stopping

you from having getters and setters in your source code.

Download at Boykma.Com

GROOVY: THE BLUE PILL OR THE RED PILL? 20

replacement for Java without changing any of the semantics of

the Java

language. This should appeal to conservative organiz ations.

In “red pill” mode, Groovy introduces new language constructs that are

different from Java. File.eachLine is a clos ure—it is a whole new way

to iterate over a ﬁle without using java.util.Iterator. Closures are being

considered for in clusion in Java 1.7, yet you have them ri ght her e,

right now. This should appeal to folks who are envious of cool features

in other languages, wishing Java could do similar things.

Perhaps James Strachan said it best on August 29, 2003, when he

intr oduced the world to a little open source project he had been work-

ing on. In a blog entry

titled “Groovy: The Birth of a New Dynamic

Language for the Java Platform,” he said this:

“Dynamically typed languages like Ruby and Python are g etting quite

popular it seems. I’m still not convinced we should all move to dynami-

cally typed languages any time soon—however, I see no reason why we

can’t use both dynamically and statically typed languages and choose

the best tool for the job.

“I’ve wanted to use a cool dynamically typed scripting language specif-

ically for the Java platform for a little while. Ther e’s plenty to choose

from, but none of t hem quite feels right—especially from the perspec-

tive of a die-har d Java programmer. Python and Ruby are both pretty

cool—though they are platforms in their own right. I’d rather a dynamic

language that builds right on top of all th e groovy Java code out there

and the JVM.

“So I’ve been musing a little while if it’s time the Java platform had

its own dynamic language designed from the ground up to work real

nice with existing code, creating/extending objects normal Java can

use, and vice versa. Python/Jython [is] a pretty good base—add the

nice stuff fr om Ruby and maybe sprinkle on some AOP features, and

we could have a really groovy new language for scripting Java objects,

writing test cases, and, who knows, even doing real development in it.”

That i s how Groovy got both its name and its worldview. Groovy is

a language that takes on the characteristics you’d like it to take on.

Traditional Java development made easier or a way to get all those

exciting new features from other languages onto the JVM? The answer

is both.

4. http://radio.weblogs.com/0112098/2003/08/29.html

Download at Boykma.Com

剩余253页未读，继续阅读

tmm88720

粉丝: 8
资源: 52

Groovy实战：Java开发者的效率加速器

Groovy Recipes Greasing the Wheels of Java.pdf

groovy和Java相互调用1

Groovy and Grails Recipes.pdf

groovy recipes

Making-Java-Groovy:曼宁的书“ Making Java Groovy”的源代码-java source code

Groovy_Recipes(中文翻译版)

基于Groovy脚本与XML配置的Java分布式多维BI报表分析引擎设计源码

Java Groovy

Groovy入门与Java转型：Java开发者的新选择

Java中融合的Groovy语言：动态特性与Java集成

最新资源