实战 Groovy 系列

Groovy 是运行在 Java 平台上的现代编程语言。它将提供与现有 Java 代码的无缝集成，同时引入闭包和元编程等出色的新功能。简言之，Groovy 是 21 世纪根据 Java 语言的需要编写的。 把任意一个新工具集成到开发工具包中的关键是：知道何时使用以及何时不应使用该工具。Groovy 可以提供强大的功能，但是必须正确地应用到适当的场景中。为此，实战 Groovy 系列将探究 Groovy 的实际应用，帮助您了解何时及如何成功应用它们。 2009 年 3 月 9 号 更新 Groovy：Java 程序员的 DSL Groovy 专家 Scott Davis 将重新开始撰写 实战 Groovy 系列文章，该系列文章于 2006 年停止编写。作为开篇文章，本文将介绍 Groovy 最近的发展以及 Groovy 当前的状态。然后了解大约 从 2009 年开始，使用 Groovy 是多么的轻松！ 更多 > 2006 年 用 Groovy 减少代码冗余 （2006 年 10 月） Groovy 简洁的语法将开发人员从那种需要进行代码编译但却无助于表达 什么 是程序真正想要实现的典型的 Java 结构中解放了出来。本文将带您进行一系列对常规 Java 代码和 Groovy 代码的比较，展示这门令人兴奋的语言如何将您解放出来，让您能够专注于编码的重要方面。 回页首 2005 年 关于 MOP 和迷你语言 （2005 年 10 月） 将耳朵贴到地上仔细听 —— MOP 正在前进！了解一下元对象协议（Meta Object Protocol，MOP）吧，这是一种将应用程序、语言和应用程序构建为 语言的翻新方法。 用 curry 过的闭包进行函数式编程 （2005 年 9 月） 在 Groovy 中处处都是闭包，Groovy 闭包惟一的问题是：当每天都使用它们的时候，看起来就有点平淡了。本文介绍了如何对标准的闭包（例如闭包复合和 Visitor 设计模式）进行 curry 处理。curry() 方法是由 Haskell Curry 发明的，在 JSR 标准发布之前就已经在 Groovy 语言中了。 Groovy 的腾飞 （2005 年 8 月） 随着 Groovy JSR-1（及其后续发行版本）的发布，Groovy 语法的变化已经规范化 —— 这意味着如果以前没有对此加以注意，那么现在是开始注意它的时候了。本文将介绍 Groovy 语法最重要的变化，以及在经典 Groovy 中找不到的一个方便特性。 在 Java 应用程序中加一些 Groovy 进来 （2005 年 6 月） 您有没有想过在自己相对复杂的 Java 程序中嵌入 Groovy 简单的、易于编写的脚本呢？本文将介绍把 Groovy 集成到 Java 代码中的多种方法，并解释在什么地方、什么时候适合这么做。 用 Groovy 生成器作标记 （2005 年 4 月） Groovy 生成器让您能够利用诸如 Swing 这样的框架来模拟标记语言（如 XML、HTML、Ant） 任务以及 GUI。它们对于快速原型化非常有用，并且正像本文中向您展示的那样，当您马上需要可消费的标记时，它们是数据绑定框架的一种便利的替代方案。 用 Groovy 打造服务器端 （2005 年 3 月） Groovlet 和 GroovyServer Pages（GSP）框架都是建立在 Java Servlet API 基础之上。不过，与 Strut 和 JSF 不同，Groovy 的服务器端实现不意味着适用于所有情况。相反，它提供了一种快速而又方便地开发服务器端应用程序的简化方法。本文介绍这些框架，并展示它们的应用。 使用 Groovy 模板进行 MVC 编程 （2005 年 2 月） 视图是 MVC 编程的一个重要部分，而 MVC 编程本身又是企业应用程序开发的一个重要组件。本文向您介绍了 Groovy 的模板引擎框架是如何用来简化视图编程的，并如何使您的代码更加经久容易维护。 用 Groovy 进行 JDBC 编程 （2005 年 1 月） 随着本文向您演示的如何用 GroovySql 构建简单的数据报告应用程序，您对 Groovy 的实用知识会更进一步。GroovySql 结合利用闭包（closure）和迭代器（iterator），把资源管理的负担转移到 Groovy 框架本身，从而简化了 Java 数据库连通性（Java Database Connectivity，JDBC）的编程。 用 Groovy 进行 Ant 脚本编程 （2005 年 1 月） Ant 和 Maven 两者在构建处理工具的世界中占统治地位。但是 XML 却凑巧是一种非常没有表现力的配置格式。本文将介绍 Groovy 的生成器实用工具，这个工具能够极其容易地把 Groovy 与 Ant 和 Maven 结合在一起，形成更具表现力、更可控的构建。 回页首 2004 年 用 Groovy 更迅速地对 Java 代码进行单元测试 （2004 年 11 月） 本文是第一期，将介绍使用 Groovy 和 JUnit 对 Java 代码进行单元测试的一个简单策略。 感受 Groovy （2004 年 8 月） 虽然 Java 语言因其严密性和扩展性的承诺而在整整一代程序员中胜出，但是 Groovy 预示了 Java 平台上的一个编程新时代，这种语言是以方便性、适宜性和敏捷性为出发点定义的。本文对提议添加到 Java 平台的标准编程语言作了非正式的介绍。 回页首

2、一定要确定自己的发展方向，并为此目的制定可行的计划。不要说什么，“我刚毕业，还不知道将来可能做什么？”，“跟着感觉走，先做做看”。因为，这样的观点会通过 你的潜意识去暗示你的行为无所事事、碌碌无为。一直做技术，将来成为专家级人物？向管理方向走，成为职业经理人？先熟悉行业和领域，将来自立门户？还是先 在行业里面混混，过几年转行做点别的？这很重要，它将决定你近几年、十年内“做什么事情才是在做正确的事情！”。

3、软件开发团队中，技术不是万能的，但没有技术是万万不能的！在技术型团队中，技术与人品同等重要，当然长相也比较重要哈，尤其在MM比较多的团队中。在软件项目团队 中，技术水平是受人重视和尊重的重要砝码。无论你是做管理、系统分析、设计、编码，还是产品管理、测试、文档、实施、维护，多少你都要有技术基础。算我孤 陋寡闻，我还真没有亲眼看到过一个外行带领一个软件开发团队成功地完成过软件开发项目，哪怕就一个，也没有看到。倒是曾经看到过一个“高学历的牛人”(非 技术型)带一堆人做完过一个项目，项目交付的第二天，项目组成员扔下一句“再也受不了啦！”四分五裂、各奔东西。那个项目的“成功度”大家可想而知了。

4、详细制定自己软件开发专业知识学习计划，并注意及时修正和调整(软件开发技术变化实在太快)。请牢记：“如果一个软件开发人员在1、2年内都没有更 新过自己的知识，那么，其实他已经不再属于这个行业了。”不要告诉自己没有时间。来自时间管理领域的著名的“三八原则”告诫我们：另外的那8小时如何使用 将决定你的人生成败！本人自毕业以来，平均每天实际学习时间超过2小时。

5、书籍是人类进步的阶梯，对软件开发人员尤其如此。书籍是学 习知识的最有效途径，不要过多地指望在工作中能遇到“世外高人”，并不厌其烦地教你。对于花钱买书，我个人经验是：千万别买国内那帮人出的书！我买的那些 家伙出的书，100%全部后悔了，无一本例外。更气愤的是，这些书在二手市场的地摊上都很难卖掉。“拥有书籍并不表示拥有知识；拥有知识并不表示拥有技 能；拥有技能并不表示拥有文化；拥有文化并不表示拥有智慧。”只有将书本变成的自己智慧，才算是真正拥有了它。

6、不要仅局限于对某项 技术的表面使用上，哪怕你只是偶尔用一、二次。“对任何事物不究就里”是任何行业的工程师所不应该具备的素质。开发Windows应用程序，看看 Windows程序的设计、加载、执行原理，分析一下PE文件格式，试试用SDK开发从头开发一个Windows应用程序；用VC＋＋、

Delphi、Java、.Net开发应用程序，花时间去研究一下MFC、VCL、J2EE、.Net它们框架设计或者源码；除了会用J2EE、 JBoss、Spring、Hibernate等等优秀的开源产品或者框架，抽空看看大师们是如何抽象、分析、设计和实现那些类似问题的通用解决方案的。 试着这样做做，你以后的工作将会少遇到一些让你不明就里、一头雾水的问题，因为，很多东西你“知其然且知其所以然”！

7、在一种语言上编程，但别为其束缚了思想。“代码大全”中说：“深入一门语言编程，不要浮于表面”。深入一门语言开发还远远不足，任何编程语言的存在都有其自身的理由， 所以也没有哪门语言是“包治百病”的“灵丹妙药”。编程语言对开发人员解决具体问题的思路和方式的影响与束缚的例子俯拾皆是。

我的经验 是：用面对对象工具开发某些关键模块时，为什么不可以借鉴C、C51、汇编的模块化封装方式？用传统的桌面开发工具(目前主要有VC++、Delphi) 进行系统体统结构设计时，为什么不可以参考来自Java社区的IoC、AOP设计思想，甚至借鉴像Spring、Hibernate、JBoss等等优秀 的开源框架？在进行类似于实时通信、数据采集等功能的设计、实现时，为什么不可以引用来自实时系统、嵌入式系统的优秀的体系框架与模式？为什么一切都必须 以个人、团队在当然开发语言上的传统或者经验来解决问题？？？“他山之石、可以攻玉”。

8、养成总结与反思的习惯，并有意识地提炼日常 工作成果，形成自己的个人源码库、解决某类问题的通用系统体系结构、甚至进化为框架。众所周知，对软件开发人员而言，有、无经验的一个显著区别是：无经验 者完成任何任务时都从头开始，而有经验者往往通过重组自己的可复用模块、类库来解决问题（其实这个结论不应该被局限在软件开发领域、可以延伸到很多方 面）。这并不是说，所有可复用的东西都必须自己实现，别人成熟的通过测试的成果也可以收集、整理、集成到自己的知识库中。但是，最好还是自己实现，这样没 有知识产权、版权等问题，关键是自己实现后能真正掌握这个知识点，拥有这个技能。

9、理论与实践并重，内外双修。工程师的内涵是：以工 程师的眼光观察、分析事物和世界。一个合格的软件工程师，是真正理解了软件产品的本质及软件产品研发的思想精髓的人（个人观点、欢迎探讨）。掌握软件开发 语言、应用语言工具解决工作中的具体问题、完成目标任务是软件工程师的主要工作，但从软件工程师这个角度来看，这只是外在的东西，并非重要的、本质的工 作。学习、掌握软件产品开发理论知识、软件开发方法论，并在实践中理解、应用软件产品的分析、设计、实现思想来解决具体的软件产品研发问题，才是真正的软 件工程师的工作。站在成熟理论与可靠方法论的高度思考、分析、解决问题，并在具体实践中验证和修正这些思想与方式，最终形成自己的理论体系和实用方法论。

10、心态有多开放，视野就有多开阔。不要抱着自己的技术和成果，等到它们都已经过时变成垃圾了，才拿出来丢人现眼。请及时发布自己的研究成果：开发的 产品、有创意的设计或代码，公布出来让大家交流或者使用，你的成果才有进化和升华的机会。想想自己2000年间开发的那些Windows系统工具，5、6 年之后的今天，还是那个样子，今天流行的好多Windows系统工具都比自己的晚，但进化得很好，且有那么多用户在使用。并且，不要保守自己的技术和思 想，尽可能地与人交流与分享，或者传授给开发团队的成员。“与人交换苹果之后，每个人还是只有一个苹果；但交换思想之后，每个人都拥有两种思想”，道理大 家都懂，但有多少人真正能做到呢？

11、尽量参加开源项目的开发、或者与朋友共同研制一些自己的产品，千万不要因为没有钱赚而不做。网 络早已不再只是“虚拟世界”，网上有很多的开源项目、合作开发项目、外包项目，这都是涉猎工作以外的知识的绝好机会，并且能够结识更广的人缘。不要因为工 作是做ERP，就不去学习和了解嵌入式、实时、通信、网络等方面的技术，反过来也是一样。如果当别人拿着合同找你合作，你却这也不会，那也不熟时，你将后 悔莫及。

12、书到用时方恨少，不要将自己的知识面仅仅局限于技术方面。诺贝尔经济学奖得主西蒙教授的研究结果表明：“对于一个有一定基础的人来说，他只要真正肯下功夫，在6个月内就可以掌握任何一门学问。”教育心理学界为感谢西蒙教授的研究成果，故命名为西蒙学习法。

可见，掌握一门陌生的学问远远没有想象的那么高难、深奥。多方吸取、广泛涉猎。极力夯实自己的影响圈、尽量扩大自己的关注圈。财务、经济、税务、管理等等知识，有空花时间看看，韬光养晦、未雨绸缪。

13、本文的总结与反思：

A：不要去做技术上的高手，除非你的目标如此。虽然本文是关于提高软件开发知识的建议，做技术的高手是我一向都不赞同的。你可以提高自己的专业知识，但能胜任工作即止。

B：提高软件知识和技术只是问题的表面，本质是要提高自己认识问题、分析问题、解决问题的思想高度。软件专业知识的很多方法和原理，可以很容易地延伸、应用到生活的其它方面。

C：在能胜任工作的基础上，立即去涉猎其它领域的专业知识，丰富自己的知识体系、提高自己的综合素质，尤其是那些目标不在技术方面的朋友。

我经常收集各种各样的至理名言，最近我重温敏捷开发；真正的问题是什么？下面是一份26条关键原则的清单，以指引敏捷软件开发团队。

• 新的挑战：敏捷开发与优秀的程序员
• 敏捷开发中常犯的10大错误
• 讨论：敏捷开发真的对架构设计不利吗？
• 理解敏捷开发：需求处理与齐头并进
• 详解敏捷开发全景图
1、完整地干完一件事后在开始另一件事：用厨房比喻来说就是：“先上这道菜，再开始做下一道”。软件开发的最大问题就是同时开始几件事情，这将不可避免的造成某些工作被废弃，从而造成浪费。专注于一件事；完整地实现其功能；运行测试；编写文档；签入所有，把这当做一项工作完成，然后再开始下一件事。

2、不要破坏构建：非常明显，但必须被包含在任何软件开发建议清单中。程序员在签入之前采取所有合适的预防措施进行测试，则永远不会破坏构建。如果构建被破坏，通常是因为有人偷懒了。

3、在用例需要之前，不要实现程序：当你实现一个特定的类，你应该在脑海中有一个特定的用例，同时应该只实现用例需要的方法。你可以考虑该类潜在的功能，写入注释之中，但直到用例真正需要时，才应去实现它。

4、在用例需要之前，不要添加数据成员：同上一条，不过这是从类的数据成员角度考虑的。似乎显而易见地，“客户”记录需要“送货地址”，但直到有用例明确需要送货地址，才应该实现它。

5、不要害怕做决定，不要害怕改变先前的决定：敏捷开发是关于相应变化和快速相应的。开发初期，你没有完整的信息。你应该尽可能的推迟决策，直到你必须做出决策的时候。没有信息，无法支持你的决定，相反，在有效信息的基础上做出最佳决定。有了新的信息，不要害怕改变先前的决定。（某些“恐龙”称之为摇摆不定，但我称之为响应变化的环境）

6、持续学习如何改善质量：这项工作永不会结束，因此你应经常留意可以改善的事情，并收集质量问题被确认和处理的案例。

7、度量、度量、度量：敏捷开发帮助处理未来不确定性问题，但对于过去应没有不确定性。测试应持续运行，每次运行的性能表现应被度量和记录。

8、为人而设计，而不是系统：开发者常常因技术而使设计误入歧途。绝不要忘记设计的最终目标，那就是帮助人们完成工作。

9、测试是产品的一部分：很多开发者和经理认为产品就是交付给客户的东西，而其它所有东西都不那么重要。测试应被认为是产品实实在在的一个部分，值得在设计时仔细考虑，甚至，在很多情况下，和产品一起交付给客户。（后半部分有争议，但是内建测试作为软件交付的一部分仅仅占用无关紧要的空间，却在必要时提供显而易见的好处，这种方式应该被考虑。）

10、在代码之前编写测试：测试本身可以用来阐释真正需要的设计。设计的缺陷常常是通过测试用例被发现的。想想看，编码之前，通过这些用例，可以节约多少时间。但是，为用例1编写测试，然后编码，然后再开始用例2。

11、消除浪费：坦率的说，这是另一个必须包含在任何开发原则清单中的陈词滥调，因为它太重要了。发现浪费并消除它，这项工作没有尽头。消除任何不能增加客户价值的东西。如果你不能确认客户价值，那很可能你并不需要它。

12、建立对构建破坏立即响应的文化：要明白当构建被破坏，会影响项目中的每一个人，因此，最重要的是确认核心代码被构建并合理测试。我曾见过有些团队放任失败测试持续数月，因为那是其它人的工作。每个人都痛苦，但没人采取行动。想反，必须形成共识，那就是小工作能为团队获得大的回报。

13、所有团队成员应理解客户需要：大型的复杂项目定然被分解为独立的团队，进而被分派给开发人员。但是，不应在此范围内做的是，失去关注最终项目真正用户的期望和目标。

14、把相关定义放在一起：组织代码以使高度相关的事情在一起，或在一个类中。这是标准面向对象设计封装原则。理想情况下，所有的类外的代码不需要知道内部工作细节。一些开发者乐于将细节扩散到多个文件中以便按不同方式组织，如所有相同的数据类型放在一起，或者按字母顺序组织。例如，在他们要用的不同包中，将所有常量放在一个类里，这增加了不必要的程序复杂性。指导原则应该是按相关性分组从而隐藏复杂性。

15、始终在签入之前运行测试：这条准则帮助你满足“不要破坏构建”准则。

16、过早的优化时万恶之源：引用高德纳被证实的话：代码应编写良好以避免微观层面的浪费，但独立方法层次以外的优化应等待整个程序基于真实的最终用户使用情景的压力测试的进行。仅仅基于对代码的静态理解，直觉地判断对整体性能什么是重要的，结论几乎总是错误的。相反，度量整个系统的行为，辨别1%真正影响性能的代码，并专注于此。

17、减少积压未完成的编码任务：当开发人员开始一个用例，会发生成本，跟已修改却未完成和测试的代码相关联。留着未完成的变化几天或几个星期会累积成巨大的重做风险。考虑每个估算需要一天的三个任务，同时开始这三个任务，并在3天内同时进行，意味着9个单位的累计成本。但是顺序进行每个任务，完成一个再开始下一个，意味着只有3个单位的成本。这个不是直觉，直觉告诉我们，在工作完成之前，我们不妨同时做三件事情。但软件不像物理构造。短小，快速和完整的工作不仅减少认知的负担，而且减少未完成工作与他人未完成工作之间冲突的可能。

18、不要过度强调代码的通用性：这就是著名的“YAGNI-你不会需要它”。当编写一个特定类的时候，程序员总喜欢认为该类可能用于其它用途。如果现在的用例需要这些用途，这很好，但是，程序员经常考虑未被提及的用途，或者那些实际上永远不需要的。（这常常让我联想到经典的周六现场滑稽短剧，关于某产品既是地板蜡，也是糕点上的甜食。）

19、两行代码能行，就不要用三行：有人阅读时，简洁的代码总能获得回报。但不要将代码压缩到难以阅读。更小的，编写良好的代码比之冗长的，编写华丽的代码更容易维护，也更容易发现错误。始终尽可能简化，但别过分。

20、不要用行数来度量代码：完成特定任务所需的代码行数，不同的程序员之间和编码风格之间差异很大。代码行数不能告诉你代码完成和质量的些许东西。代码质量可以相差200倍，这足以抵消代码行数的作用。应该统计功能用例的数目。

21、持续地重新设计和重构：谨慎地使用这条准则，因为有些代码脆弱而难以改变，但通常你不应害怕更改代码以符合实际使用情况。一个数据成员过去可能是整数，但是当一个用例要求它是一个浮点数时不要害怕去改变它。

22、删除死代码：涉及到大量不能很好理解的代码是，有个倾向是不自找麻烦。一个例子就是往类中增加新的方法去替换另一个，开发人员常常会留下旧的方法以防万一。必须努力检查方法是否必须，如果没有证据表明它是必须的，那就删除它。最糟糕的就是注释掉大量的代码，并把它留在那儿。注释掉的代码应在测试通过后尽快删除，当然应在签入之前。因此，某个时候你发现一些东西可能并不需要，付出小小的努力去验证并消除此代码能让代码基线更易维护。

23、不要发明新语言：程序员喜爱使用文本文件配置在运行时驱动功能。没有配置文件能够不编译而改变程序的行为。XML的出现推动了无休止的专门定制“脚本语言”的浪潮，以使功能能被最终用户定制而不需要编译。这种推理的缺陷在于，离开某个特定实施的环境，操作行为几乎从来没能很好地精确定义，同时，那些脚本语言只对那些对问题领域代码的内部运行有深入了解的人有用。因此，不具备详尽内部知识的真实最终用户永远不可能知道预料复杂的命令组合的效果需要什么。脚本语言有用，也不能被消除，但是设计者必须采取非常非常保守的态度，尽可能使用现有的语言，避免新的发明。

24、在你准备实现并测试前，别做设计：你应该有行进的总体思路和对系统架构的概览，但是，直到开发迭代允许设计被实现和测试前，不要做详细设计，不要编写功能实现的详细说明。详细设计应当只涉及到处理目前的用例。软件开发中最大的浪费源于将时间花在设计那些不需要，或者因为某些错误的设计假定而需要重新设计的事情之上。

25、设计是可塑的：不像物理制造，软件可以很容易地获得显著改变。事实上，有大量证据证明软件本身比描述软件的设计说明书更容易改变。此外，软件比说明书更有效地传达设计。因此，你应该把时间用于直接实现设计，让客户能看见设计的细节。如果你犯错并改变设计，改变软件比改变规格更容易。但最重要的是，客户看到代码运行后，你关于客户想要什么的信息大为完善。

26、花时间编写发现和报告异常情况的代码中的问题的完整描述：程序员往往很懒惰，抛出粗浅描述错误的异常。认为他们永远是唯一会看到这个问题的人，并且他们从含糊的描述会记得这个问题的意思。但实际上，在客户支持环境，不准确或者不完整的错误报告比其它原因浪费更多的时间。编写每个错误消息，就好像你正向某个正好走进房间并且没有此代码经验的人解释状况。客户和客户支持团队毕竟没有此代码的经验。

这些介绍没有特定的顺序，欢迎讨论我忽略的原则，或者（如果是这种情况）你不认同的敏捷开发原则。

原文：26 Hints for Agile Software Development 作者：Keith Swenson

原译文标题：给敏捷软件开发的26条建议 译者：射覆

二、墨菲定律：凡事可能出错的事，准会出错。

三、对防御性编程的误解：检查错误、测试、调试不是防御性编程

四、欲速则不达。每敲一个字，都要想清楚你要输入的是什么，不要仓促的编写代码

五、不要相信任何人，包括你自己都可能把缺陷引入到你的程序逻辑中。用怀疑的眼光审视所有的输入和所有的结果，直到你证明它们是正确的。

六、简单就是一种美，不要让你的代码过于复杂；编码的目标是清晰，而不是简洁。

七、编译时打开所有警告开关；经常使用静态分析工具分析你的代码。

八、大多数难以觉察的错误都是因为程序员没有检查函数返回值而引起的。

九、重视所有稀有资源，慎重的管理他们的获取和释放。

十、初始化所有变量。

十一、变量声明的位置和使用它的位置尽可能接近，防止它干扰代码的其他部分。

十二、不要在多个地方重用同一个临时变量

十三、慎重处理默认行为，如switch语句的default case语句，没有else的if语句等。

十四、对程序的设想加上前置条件和后置条件，关键地方加上断言，并确保断言不会带来副作用

• Grails — a Groovy-based web framework inspired by Ruby on Rails
• GORM — the Grails Object-Relational Mapping persistence framework
• Griffon — a Groovy-based desktop framework inspired by Grails
• GroovyPlugin — A Groovy plugin for JSPWiki
• OCM Groovy — A Object Content Mapping implemented in Groovy leveraging the Java Content Repository (JCR)
• Tellurium — A test framework built on top of the Selenium test framework implemented in Groovy
• Gradle — The next generation build system

Children (31)

Hide Children | View in Hierarchy

GMaven
Groovy Transforms
COM Scripting
Gant
GFreeMarker
Google Data Support
Gram
GraphicsBuilder
Grapplet
Griffon
Groosh
Groovy Jabber-RPC
GroovyJMS
GroovyLab
Groovy Monkey
GroovyRestlet
Groovy Science
Groovy SOAP
GroovySWT
GroovyWS
GSP
GSQL
HTTP Builder
JideBuilder
MetaBuilder
Native Launcher
Proxy-o-Matic
Windows NSIS-Installer
Windows Services
WingSBuilder
XMLRPC

assert 'hello'.padRight(8,'+').padLeft(10,'+') == '++hello+++'
assert 'hello'.padLeft(7).padRight(10) == '  hello   '
assert 'hello'.center(10, '+').center(14, ' ') == '  ++hello+++  '

We can split a string into tokens:

assert 'he she\t it'.tokenize() == ['he', 'she', 'it']
    //tokens for split are ' \t\n\r\f'
assert 'he she\t it'.tokenize() ==
    new StringTokenizer('he she\t it').collect{ it }

assert 'he,she;it,;they'.tokenize(',;') == ['he', 'she', 'it', 'they']
    //supply our own tokens
assert new StringTokenizer('he,she;it,;they', ',;').collect{ it } ==
    'he,she;it,;they'.tokenize(',;')

assert new StringTokenizer('he,she,;it', ',;', true).collect{ it } ==
    ['he', ',', 'she', ',', ';', 'it']
  //long form provides extra option to return the tokens with the split-up data

Some additional methods:

assert 'abcde'.find{ it > 'b' } == 'c' //first one found
assert 'abcde'.findAll{ it > 'b' } == ['c', 'd', 'e'] //all found
assert 'abcde'.findIndexOf{ it > 'c' } == 3 //first one found

assert 'abcde'.every{ it < 'g' } && ! 'abcde'.every{ it < 'c' }
assert 'abcde'.any{ it > 'c' } && ! 'abcde'.any{ it > 'g' }

assert 'morning'.replace('n','t') == 'mortitg' &&
       'boo'.replace('o', 'at') == 'batat' &&
       'book'.replace('oo','ie') == 'biek'

assert 'EggS'.toLowerCase() == 'eggs' && 'EggS'.toUpperCase() == 'EGGS'
assert '   Bacon   '.trim() == 'Bacon'
assert 'noodles'.startsWith('nood') && 'noodles'.endsWith('dles')
assert 'corn soup'.startsWith('rn', 2) //2 is offset

assert 'abc'.concat('def') == 'abcdef'
assert 'abcdefg'.contains('def')
assert ''.isEmpty() && ! 'abc'.isEmpty()

assert 'morning'.indexOf('n') == 3
assert 'morning'.indexOf('n', 4) == 5 //ignore first 4 characters
assert 'morning'.indexOf('ni') == 3
assert 'morning'.indexOf('ni', 4) == -1 //not found
assert 'morning'.lastIndexOf('n') == 5
assert 'morning'.lastIndexOf('n', 4) == 3 //only search first 4 characters
assert 'morning'.lastIndexOf('ni') == 3
assert 'morning'.lastIndexOf('ni', 4) == 3
    //only search first 4 characters for first char of search string

We can use operators on strings:

assert 'hello, ' + 'balloon' - 'lo' == 'hel, balloon'
    //'-' subtracts one instance at most of string
assert 'hello, balloon' - 'abc' == 'hello, balloon'
assert 'hello, '.plus('balloon').minus('lo') == 'hel, balloon'
    //alternative method syntax
assert 'value is ' + true == 'value is true' &&
       'value is ' + 1.54d == 'value is 1.54' &&
            //first converts double to String (without info loss)
       'value is ' + 7 == 'value is 7' //we can add on various types of values
assert 7 + ' is value' == '7 is value'
assert 'telling true lies' - true == 'telling  lies' &&
       'week has 7 days' - 7 == 'week has  days'
            //we can subtract various types of values
assert 'a' * 3 == 'aaa' && 'a'.multiply(3) == 'aaa'

assert 'hello'.reverse() == 'olleh'
assert 'hello'.count('l') == 2

assert 'abc'.collect{ it * 2 } == ['aa', 'bb', 'cc']
def s= [], t= [:]
'abc'.each{ s << it }
'abc'.eachWithIndex{ elt, i-> t[i]= elt }
assert s == ['a', 'b', 'c'] && t == [0:'a', 1:'b', 2:'c']
assert 'abcde'.toList() == ['a', 'b', 'c', 'd', 'e']

assert 'abc'.next() == 'abd' && 'abc'.previous() == 'abb'

We can subscript strings just as we can lists, except of course strings are read-only:

assert 'abcdefg'[ 3 ] == 'd'
assert 'abcdefg'.getAt( 3 ) == 'd' //equivalent method name
assert 'abcdefg'.charAt( 3 ) == 'd' //alternative method name
assert 'abcdefg'[ 3..5 ] == 'def'
assert 'abcdefg'.getAt( 3..5 ) == 'def'
assert 'abcdefg'[ 1, 3, 5, 6 ] == 'bdfg'
assert 'abcdefg'[ 1, *3..5 ] == 'bdef'
assert 'abcdefg'[ 1, 3..5 ] == 'bdef'
    //range in subscript flattened automatically
assert 'abcdefg'[-5..-2] == 'cdef'
assert 'abcdefg'.getAt( [ 1, *3..5 ] ) == 'bdef'
assert 'abcdefg'.getAt( [ 1, 3..5 ] ) == 'bdef'

assert 'abcde' == 'ab' + 'c' + 'de'
assert 'abcde'.equals('ab' + 'c' + 'de') //equivalent method name
assert 'abcde'.contentEquals('ab' + 'c' + 'de') //alternative method name
assert 'AbcdE'.equalsIgnoreCase('aBCDe')
assert 'abcde' < 'abcdf' && 'abcde' < 'abcdef'
assert 'abcde'.compareTo('abcdf') == -1 && 'abcde'.compareTo('abcdef') == -1
                                                      //equivalent method
assert 'AbcdEF'.compareToIgnoreCase('aBCDe') == 1
assert 'AbcdE'.compareToIgnoreCase('aBCDef') == -1

assert Collections.max( 'abC'.toList(), String.CASE_INSENSITIVE_ORDER ) == 'C'
assert Collections.min(
            ['abC', 'ABd', 'AbCd'], String.CASE_INSENSITIVE_ORDER ) == 'abC'

assert 'abcde'.regionMatches(2, 'ccccd', 3, 2)
    //match from index 2 in 'abcde' to 2 chars from index 3 in 'ccccd'
assert 'abcDE'.regionMatches(true, 2, 'CCCCd', 3, 2)
    //if first arg is true, ignores case

We can format values into a string, using format():

//Strings (conversion type 's')
assert String.format('%1$8s', 'hello') == '   hello'
    //width (here, 8) is minimum characters to be written
assert String.format('%2$6s,%1$2s', 'a', 'hello') == ' hello, a'
    //we can re-order arguments
assert String.format('%1$2s', 7, 'd') == ' 7'
    //we can give any type of input; we can ignore arguments
assert String.format('%1s,%2s', null, 'null') == 'null,null'
    //null treated as 'null'
assert String.format('%1$2.4s', 'hello') == 'hell'
    //precision (here, 4) is maximum characters to be written

//Characters ('c')
assert String.format('%1$c,%2$3c', 65, 66 as byte) == 'A,  B'
    //convert argument to character; 2nd value 3 chars wide
assert String.format('%-3c', 67 as short) == 'C  '
    //left-justified with '-' flag; we needn't specify parameter number (1$, etc)
assert String.format('%c', 'D' as char) == 'D'

//Special conversion types:
assert String.format('hello %n world %%') == 'hello \r\n world %'
    //platform-specific newline; double % to quote it

//Boolean ('b')
assert String.format('%b, %b, %b, %b, %b, %b',
                     null, true, false, 0, 1, new Object()) ==
    'false, true, false, true, true, true'

def sb1= new StringBuffer(),
    sb2= new StringBuffer('Hello'),
    sb3= new StringBuffer(sb2)
assert sb1.toString() == '' &&
       sb2.toString() == 'Hello' &&
       sb2.toString() == sb3.toString()

def sb= new StringBuffer('abcdefg')
assert sb.size() == 7 && sb.length() == 7 //different ways to find size
sb.length= 6 //change size
assert sb.toString() == 'abcdef'
assert sb.reverse().toString() == 'fedcba'
assert sb.toString() == 'fedcba' //reverse() method reverses order permanently
assert sb.substring(2) == 'dcba' //substring from index 2
assert sb.substring(2, 5) == 'dcb' //substring from index 2 to <5
assert sb.subSequence(2, 5) == 'dcb' //substring from index 2 to <5
assert sb + 'zyx' == 'fedcbazyx'

def sb1= new StringBuffer()
sb1 << 'abc'
sb1 << 'def' << 'ghi' //can chain two << operators
sb1.leftShift('jkl') //equivalent method name
sb1.append('mno') //alternative method name
sb1.append( ['p', 'q', 'r'] as char[] )
sb1.append( ['r', 's', 't', 'u', 'v'] as char[], 1, 3 )
assert sb1.toString() == 'abcdefghijklmnopqrstu'

def s= 'foo'
s= s << 'bar'
assert s.class == StringBuffer && s.toString() == 'foobar'

def sb= new StringBuffer('abcdefg')
assert sb[ 3 ] == 'd'
assert sb[ 3 ].class == String
assert sb.getAt( 3 ) == 'd' //equivalent method name
assert sb.charAt( 3 ) == 'd' //alternative method name
assert sb[ 3..5 ] == 'def'
assert sb[ 1, 3, 5, 6 ] == 'bdfg'
assert sb[ 1, 3..5 ] == 'bdef'
assert sb[-5..-2] == 'cdef'
sb[ 3..5 ] = 'xy' //use subscripts to update StringBuffer
assert sb.toString() == 'abcxyg'
sb.putAt( 2..4, 'z' ) //equivalent method name
assert sb.toString() == 'abzg'
sb.setCharAt(1, 'm' as char) //alternative method name
assert sb.toString() == 'amzg'

def sb= new StringBuffer('hello park')
sb.delete(4, 7)
assert sb.toString() == 'hellark'
sb.deleteCharAt(3)
assert sb.toString() == 'helark'
def ca= new char[6]
sb.getChars(2, 5, ca, 1)
    //for indexes 2 to <5, copy into ca beginning from index 1
(['\0', 'l', 'a', 'r', '\0', '\0'] as char[]).
    eachWithIndex{ elt, i-> assert ca[i] == elt }

sb.insert(4, 'se')
assert sb.toString() == 'helaserk'
sb.insert(4, new StringBuffer('ct ') )
assert sb.toString() == 'helact serk'
sb.insert(10, ['i', 'c'] as char[] )
assert sb.toString() == 'helact serick'
sb.insert(6, ['m', 'a', 'l', 't'] as char[], 1, 2)
    //insert 2 chars from subscript 1
assert sb.toString() == 'helactal serick'
sb.insert(10, 'snapla', 3, 5) //insert chars from subscript 3 to <5
assert sb.toString() == 'helactal splerick'
sb.replace(4, 13, 'dor') //replace chars from subscript 4 to <13
assert sb.toString() == 'heladorrick'

def sb= new StringBuffer('hello elm')
assert sb.indexOf('el') == 1
assert sb.indexOf('el', 3) == 6 //first occurence of 'el' from index 3
assert sb.lastIndexOf('el') == 6
assert sb.lastIndexOf('el', 3) == 1 //last occurence of 'el' up to index 3

def s= new String( new StringBuffer('abcdefg') )
assert s == 'abcdefg'
assert s.contains('def')
assert s.contentEquals('abcdefg')
assert s.contentEquals( new StringBuffer('abcdefg') )
def s2= s.replace('def', 'xyz')
assert s2 == 'abcxyzg'

def minLowSurr= Character.MIN_LOW_SURROGATE,
    minHighSurr= Character.MIN_HIGH_SURROGATE

def s1= 'abc'+ minHighSurr + minLowSurr +'efg'
assert s1.codePointAt(3) == 0x10000 //if high surrogate, add on low surrogate
assert s1.codePointAt(4) == minLowSurr //if low surrogate, use it only
assert s1.codePointAt(5) == 'e' as int
assert s1.codePointBefore(4) == minHighSurr
assert s1.codePointBefore(5) == 0x10000
    //if low surrogate, look back more for high one, and use both
assert s1.codePointCount(1, 5) == 3
    //number of code points in a substring with indexes >=1 and <5
assert s1.offsetByCodePoints(1, 3) == 5
    //index from 1 that's offset by 3 code points

def sb= new StringBuffer( 'abc'+ minHighSurr + minLowSurr +'efg' )
    //also, for StringBuffers
assert sb.codePointAt(5) == 'e' as int
assert sb.codePointBefore(4) == minHighSurr
assert sb.codePointCount(1, 5) == 3
assert sb.offsetByCodePoints(1, 3) == 5

sb.appendCodePoint(0x10000)
assert sb.toString() ==
    'abc'+ minHighSurr + minLowSurr +'efg'+ minHighSurr + minLowSurr

def sb1= new StringBuffer() //default initial capacity is 16
assert sb1.capacity() == 16

def sb2= new StringBuffer(5) //we can specify initial capacity
assert sb2.capacity() == 5
sb2<< 'abc'
assert sb2.capacity() == 5 && sb2.size() == 3
sb2.trimToSize()
assert sb2.capacity() == 3
sb2.ensureCapacity(10)
assert sb2.capacity() == 10

def sb3= new StringBuffer(0) //capacity approximately doubles when required
def cap= 0, caps=[]
100.times{
  if((sb3<< 'a').capacity() != cap) caps<< (cap= sb3.capacity())
}
assert caps == [2, 6, 14, 30, 62, 126]

---注：意思很明显，微软将不会再OracleClient上投入更多精力来更新版本了，而是交给了社区和合作伙伴，有点令人失望，我们有大量的程序都是基于OracleClient，根据社区的反应ODP.NET 不太稳定，问题多多。

不过看Oracle自己的网站上的对比，ODP.NET确实功能比较强劲，加以时日应该能成为主流

这么重大的事件，我居然才知道，看来确实孤陋寡闻了！
英文原文:
System.Data.OracleClient will be available in the upcoming 4.0 release of .NET Framework; however, it will be marked as deprecated. This will have no impact to existing applications and these applications will continue to work as expected. Developing new applications which use OracleClient will be supported; however, warnings will be raised if the applications are compiled against .Net 4.0. Once compiled, no warnings or errors will be generated while running these applications. We strongly recommend customers to use our partners’ ADO.NET Provider for Oracle instead of continuing to use Microsoft’s OracleClient for new application development.

Microsoft will continue to provide hotfixes for critical issues in System.Data.OracleClient as per the standard support policy for .Net Framework 4.0. We will also continue to make critical bug fixes in future service packs for .Net Framework 4.0.

Thank you,

Himanshu Vasishth
Program Manager, ADO.NET OracleClient

http://blogs.msdn.com/adonet/archive/2009/06/15/system-data-oracleclient-update.aspx

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Anno {
   
String value() default ""
}

class Foo {
   
@Anno("A cool method!")
   
void method() {}
}

def f = new Foo()

def method = Foo.getMethod("method", [] as Class[])
assert method.isAnnotationPresent(Anno)
assert method.getAnnotation(Anno).value() == "A cool method!"