DevOps进化论与Java下一代：2013年10月开发月刊

需积分: 0 56 浏览量更新于2024-06-30 收藏 6.52MB PDF 举报

"51CTO电子杂志《开发月刊》2013年10月刊1聚焦于DevOps的进化、Java语言的未来发展以及一系列相关技术文章。本期特别关注Java的下一代语言Groovy、Scala和Clojure，探讨它们如何克服Java的局限，如无法重载操作符，并分析了这些语言的共性和特性。杂志还包含了热门技术资源、编程语言排行榜、原创译文等内容，旨在提供最新的技术动态和学习资源，促进开发者的技术进步和成长。" 在本期《开发月刊》中，首先提到了DevOps的演变，这是一个由软件工程独立主义到工程化再到产业链的完整过程。DevOps的核心在于促进开发和运维之间的紧密协作，以提高软件交付的效率和质量。作者探讨了DevOps的流行原因、本质特征以及如何在实际工作中落地实施。接着，文章探讨了Java的未来，特别是关于下一代语言如何解决Java的一些设计限制。其中一个关键议题是“没有继承性的扩展”，这可能意味着新的语言特性会更倾向于使用委托、组合或其他设计模式来实现代码复用，而不是依赖于传统的继承结构。专题报道深入研究了Groovy、Scala和Clojure这三种语言。它们都试图提供比Java更灵活和强大的语法，比如支持操作符重载。这部分内容分为两部分，详细阐述了这些语言的相似之处，包括对Java的改进和引入的新功能。此外，还介绍了Oracle公司对于下一代JavaME平台的更新计划。杂志中的原创译文涵盖了广泛的话题，如2014年最热门的IT技能预测、前沿编程实验、IndexedDB的学习指南，以及如何结合RESTful API和JSON进行开发。此外，还有一篇对本土数据库CTO的专访，讨论大数据市场的细分策略。最后，编程排行Billboard展示了Groovy在2013年10月的编程语言排行榜上首次进入前二十，反映了它在开发社区中的上升趋势。整期杂志通过丰富的技术内容，为读者提供了深入学习和了解最新技术动态的机会。

开发月刊 2013年10月号总第31期

专题报道

51CTO开发频道

Java 编程语言诞生时所面临的限制与如今的开

发人员所面临的条件有所不同。具体来讲，由于上

世纪 90 年代中期的硬件的性能和内存限制，Java

语言中存在原语类型。从那时起，Java 语言不断在

演化，通过自动装箱（autobox）消除了许多麻烦

操作，而下一代语言（Groovy、Scala 和

Clojure）更进一步，消除了每种语言中的不一致

性和冲突。

在这一期的文章中，我将展示下一代语言如何

消除一些常见的 Java 限制，无论是语法上还是默

认行为上。第一个限制是原语数据类型的存在。

原语的消亡

Java 语言最开始有 8 对原语和相应的类型包装

器类（最初用于解决性能和内存限制），并通过自

动装箱逐步地淡化了它们之间的区别。Java 下一代

语言更进一步，让开发人员觉得好像根本不存在差

别。

Groovy 完全隐藏了原语类型。例如，int 始终

表示 Integer，Groovy 自动处理数字类型的上变

换，防止出现数值溢出错误。例如，请查看清单 1

中的 Groovy shell 交互：

清单 1. Groovy 对原语的自动处理

1. groovy:000> 1.class

2. ===> class java.lang.Integer

3. groovy:000> 1e12.class

4. ===> class java.math.BigDecimal

在清单1中，Groovy shell 显示，即使是常量

也是通过底层的类来表示的。因为所有数字（和其

他伪装的原语）都是真正的类，所以可以使用元编

程技术。这些技术包括将方法添加到数字中（这通

常用于构建特定领域的语言，即 DSL），支持 3.

cm 这样的表达式。在后面介绍可扩展性的那期文

章中，我会更全面地介绍此功能。

与 Groovy 中一样，Clojure 自动屏蔽原语与包

装器之间的区别，允许对所有类型执行方法调用，

自动处理容量的类型转换。Clojure 封装了大量底

层优化，这已在语言文档中详细说明（参阅参考资

料）。在许多情况下，可提供类型 hints，使编译

器能够生成更快的代码。例如，无需使用 (defn

sum[x] ... ) 定义方法，可以添加一个类型提示，比

如 (defn sum[^float x] ... )，它会为临界区

(critical section) 生成更高效的代码。

Scala 也屏蔽了原语之间的区别，通常对代码的

时效性部件使用底层原语。它还允许在常量上调用

Java下一代:Groovy、Scala和Clojure共同点

第 2 部分

与 Java™ 语言相关的常见抱怨包括：简单的任务涉及到太多的步骤，默认设置有

时难以理解。所有 3 种 Java 下一代语言在这些领域都采取了更加明智的方法。这一

期 Java 下一代展示了 Groovy、Scala 和 Clojure 如何消除 Java 语言的瑕疵。

了解Java 下一代语言如何减少样板代码和降低复杂性

51CTO开发频道

开发频道：http://developer.51cto.com/

专题报道

方法，就像 2.toString 中一样。借助其混搭原语和

包装器的能力，比如 Integer，Scala 比 Java 自动

装箱更加透明。例如，Scala 中的 == 运算符可在

原语和对象引用上正确运行（比较值，而不是引

用），而不同于相同运算符的 Java 版本。Scala 还

包含一个 eq 方法（以及一个对称的 ne 方法），它

始终比较底层引用类型是否等效。基本而言，Scala

会智能地切换默认行为。在 Java 语言中，== 会对

引用数据进行比较，您几乎不需要这么做，可以使

用不太直观的 equals() 比较值。在 Scala 中，==

能正确运行（比较值），无论底层实现是什么，它

还提供了一个方法来执行不太常见的引用相等性检

查 (reference equality check)。

Scala 的这一特性表明，Java 下一代语言的一

个重要优势在于：将低级细节卸载到语言和运行

时，开发人员能够有更多的时间考虑更高级的问

题。

简化默认行为

人们的看法高度一致，大部分 Java 开发人员都

认为，在 Java 语言中常见的操作需要太多的语

法。例如，属性定义和其他样板代码使类定义变得

很杂乱，掩盖了重要的方法。所有 Java 下一代语

言都提供了简化创建和访问过程的途径。

Scala 中的类和 case 类

Scala 已简化了类定义，可为您自动创建存取函

数、赋值函数和构造函数。例如，请查看清单 2 中

的 Java 类：

清单 2. Java 中简单的 Person 类

1. class Person {

2. private String name;

3. private int age;

4. Person(String name, int age) {

5. this.name = name;

6. this.age = age;

7. }

8. public String getName() {

9. return name;

10. }

11. public int getAge() {

12. return age;

13. }

14. public void setAge(int age) {

15. this.age = age;

16. }

17. @Override

18. public String toString() {

19. return name + “ is “ + age + “

years old.”;

20. }

21. }

清单2中惟一的非样板代码是改写的 toString()

方法。构造函数和所有方法都由 IDE 生成。相比

快速生成代码，在以后轻松理解它更为重要。无用

的语法增加了您在理解底层含义之前必须使用的代

码量。

Scala Person 类

令人震惊的是，清单 3 中用 Scala 编写的简单

3 行定义就创建了一个等效的类：

开发月刊 2013年10月号总第31期

专题报道

51CTO开发频道

清单 3. Scala 中的等效类

1. class Person(val name: String, var age: Int) {

2. override def toString = name + “ is “ + age

+ “ years old.”

3. }

清单3中的 Person 类浓缩成了一个可变的 age

属性、一个不可变的 name 属性，以及一个包含两

个参数的构造函数，还有我改写的 toString() 方

法。很容易看到这个类的独特之处，因为有趣的部

分没有埋藏在语法中。

Scala 的设计强调了以最少的语法创建代码的能

力，它使许多语法成为可选语法。清单 4 中的简单

类演示了一个将字符串更改为大写字母的 Verbose

类：

清单 4. Verbose 类

1. class UpperVerbose {

2. def upper(strings: String*) : Seq[String] = {

3. strings.map((s:String) => s.toUpperCase())

4. }

5. }

清单4中的许多代码都是可选的。清单 5 给出了

相同的代码，现在使用了一个 object 而不是

class：

清单 5. 一个转换为大写的更简单的对象

1. object Up {

2. def upper(strings: String*) = strings.map(_.

toUpperCase())

3. }

对于等效于 Java 静态方法的 Scala 代码，可创

建一个 object（与独体实例等效的 Scala 内置实

体）而不是一个类。方法的返回类型、用于将单

行方法主体分开的括号，以及清单 4 中无用的 s

参数都从清单 5 中消失了。Scala 中的这种 “可

折叠语法” 有利有弊。使用可折叠语法，能够以

非常符合语言习惯的方式编写代码，但这让不熟

悉的人难以理解您的代码。

case 类

用作数据持有者的简单类在面向对象的系统中

很常见，尤其是必须与不同系统通信的系统。这

种类型的类的流行使得 Scala 项目向前推进了一

步，创造了 case 类。case 类自动提供了多种便

捷的语法：

可根据该类的名称创建一个工厂方法。例如，

可以在不使用 new 关键字的情况下构造一个新实

例：val bob = Person(“Bob”, 42)。

该类的参数列表中的所有参数都自动 val，也

就是说，它们是作为不可变的内部字段来维护

的。

编译器为您的类生成合理的默认 equals()

、hashCode() 和 toString() 方法。

编译器将一个 copy() 方法添加到类中，以便

您可返回某个副本来执行变体式更改。

Java 下一代语言不仅修复了语法瑕疵，还促

进了对现代软件工作原理的更准确的理解，朝这

个方向塑造它们的工具。

Groovy 的自动生成属性

在 Java 下一代语言中，Groovy 与 Java 语

法最接近，为常见情形提供了称为 “语法糖

(syntactic-sugar)” 的代码生成方法。参见清单

51CTO开发频道

开发频道：http://developer.51cto.com/

专题报道

6 中简单的 Groovy Person 类：

清单 6. Groovy Person 类

1. class Person {

2. private name

3. def age

4. def getName() {

5. name

6. }

7. @Override

8. String toString() {

9. “${name} is ${age} years old.”

10. }

11. }

12. def bob = new Person(name: “Bob”,

age:42)

13. println(bob.name)

在清单6的 Groovy 代码中，定义一个字段 def

会得到一个存取函数和赋值函数。如果仅喜欢其中

一个函数，可自行定义它，就像我对 name 属性所

做的那样。尽管该方法名为 getName()，但我仍然

可以通过更直观的 bob.name 语法访问它。

如果希望 Groovy 自动为您生成 equals() 和

hashCode() 方法对，可以向类中添加 @

EqualsAndHashCode 注释。该注释使用 Groovy

的抽象语法树 (Abstract Syntax Tree, AST) 转换

生成基于您的属性的方法（参阅参考资料）。在默

认情况下，此注释仅考虑属性（而不考虑字段）；

如果添加了 includeFields=true 修饰符，它也会考

虑字段。

Clojure 的映射式记录

可在 Clojure 中像其他语言中一样创建相同

Person 类，但这并不符合语言习惯。传统

上，Clojure 等语言依靠映射（名称-值对）数据

结构来持有这种类型的信息，并使用了一些处理该

结构的函数。尽管仍然可以在映射中建模结构化的

数据，但目前更常见的情形是使用记录。记录是

Clojure 对具有属性（常常是嵌套的）的类型名的

更加正式的封装，每个实例具有相同的语义含义。

（Clojure中的记录就像类 C 语言中的 struct。）

例如，请考虑以下人员定义：

1. (def mario {:fname “Mario”

2. :age “18”})

鉴于此结构，可以通过 (get mario :age) 访问

age。简单的访问是映射上的一个常见操作。借助

Clojure，可以利用使用键充当着映射上的存取函

数的语法糖，以便使用更有效的 (:age mario) 速

记法。Clojure 期望对映射进行操作，所以它提供

了大量语法糖来简化此操作。

Clojure 还拥有访问嵌套的映射元素的语法

糖，如清单 7 所示：

清单 7. Clojure 的速记式访问

1. (def hal {:fname “hal”

2. :age “17”

3. :address {:street “Enfield Tennis

Academy”

4. :city “Boston”

5. :state “MA”}})

6. (println (:fname hal))

7. (println (:city (:address hal)))

开发月刊 2013年10月号总第31期

专题报道

51CTO开发频道

JavaScript正凭借新型工具与功能提升以极

度夸张的速度吞噬整个世界。我们是否应该接受

这一无法逆转的趋势？

还记得那些旧日往事吗？很多用户因为担心安

全问题而在浏览器中禁用JavaScript。如今这样

的担忧已经显得相当可笑——JavaScript已经成

为统治网络世界的绝对王者。

8. (println (-> hal :address :city))

在清单7中，我定义了一个名为 hal 的嵌套数据

结构。对外部元素的访问按预期进行 ((:fname

hal))。如清单 7 中倒数第二行所示，Lisp 语法执

行 “内外” 评估。首先，必须从 hal 获取 address

记录，然后访问 city 字段。因为 “内外” 评估是

一种常见用法，所以 Clojure 提供了一个特殊运算

符（-> thread 运算符）来反转表达式，使它们更加

自然、更具可读性：(-> hal :address :city)。

可使用记录创建等效的结构，如清单 8 所示：

清单 8. 使用记录创建结构

1. (defrecord Person [fname lname address])

2. (defrecord Address [street city state])

3. (def don (Person. “Don” “Gately”

4. (Address. “Ennet House”

“Boston”, “MA”)))

5. (println (:fname don))

6. (println (-> don :address :city))

在清单 8 中，我使用 defrecord 创建了相同的

结构，得到了一种更加传统的类结构。借助

Clojure，可以通过熟悉的映射操作和方言在记录结

构中实现同样便捷的访问。

Clojure 1.2 围绕常见操作的记录定义通过两个

工厂函数添加了语法糖：

->类型名称, 接收字段的位置参数

->映射->类型名称, 字段值的关键字映射

使用符合语言习惯的函数，代码由清单 8 转换

成版本清单 9.

清单 9. Clojure 的漂亮的语法糖

1. (def don (->Person “Don” “Gately”

2. (->Address “Ennet House” “Boston”,

“MA”)))

在许多情况下，记录比映射和扁平结构更受欢

迎。首先，defrecord 创建了一个 Java 类，使它

更容易在多方法定义中使用。然后，defrecord

指定更多任务，在您定义记录时启用字段验证和其

他细微处理。第三，记录速度快得多，尤其在您拥

有一组固定的已知键的时候。

Clojure 结合使用记录和协议来构造代码。未

来的一期文章将介绍它们的关系。

结束语

与 Java 语言相比，所有 3 种 Java 下一代语

言都提供了更便捷的语法。Groovy 和 Scala 使构

建类和常见情形更加轻松，而 Clojure 使映射、记

录和类能够无缝地互操作。所有 Java 下一代语言

的一个共同主旨是消除不必要的样板代码。在下一

期文章中，我将继续探讨这个主题并讨论一些异

常。 ■

专题

JavaScript成为网络霸

主的“绯闻”

剩余120页未读，继续阅读

余青葭

粉丝: 44
资源: 303

DevOps进化论与Java下一代：2013年10月开发月刊

51CTO开发月刊001-009期

51CTO下载-开发月刊011期.pdf

51CTO博客月刊：精彩文章大全

51CTO

51cto博客月刊：洞悉IT职业发展与技术热点

51CTO学院iOS开发全程视频课程：从入门到高级

51CTO安卓开发入门教程：理解历史与演变

51cto iOS开发资源大全：从入门到进阶

精细金属掩模板(FMM)行业研究报告 显示技术核心部件FMM材料产业分析与市场应用

最新资源

精细金属掩模板(FMM)行业研究报告显示技术核心部件FMM材料产业分析与市场应用