程序員技術選型：寫Go還是Java？

文章來源于公眾號：架構頭條 作者：John Griffin 譯者 |:無明

本文作者根據(jù)自己的使用體驗，詳細對比了 Go 和 Java 的使用差異，給了開發(fā)者們一個中肯的選用參考。

老實說，我很喜歡 Java。我在 Spiral Scout 工作的那幾年，使用了 EJB2、DB2 和 Oracle 等后端技術，積累了很多軟件開發(fā)方面的專業(yè)知識。過去幾年，我轉(zhuǎn)向基于自然語言處理的機器人項目，涉及的技術包括 Spring Boot、Redis、RabbitMQ、Open NLP、IBM Watson 和 UIMA。一直以來，我選擇的語言是 Java，它一直很高效，有時還會覺得它很有趣。

1. 初遇 Go

2017 年初，我接手了一個非常有趣的項目，一個用于監(jiān)控和種植水培植物的自動化編程系統(tǒng)。項目的原始代碼里包含了一個使用 CGo 開發(fā)的支持三個不同系統(tǒng)（Windows、MacOS 和 ARM）的網(wǎng)關。

因為對 Go 不熟悉，我一邊學習，一邊用它來實現(xiàn)功能。因為已有代碼庫的結構非常復雜，對我來說是難上加難。用 Go 開發(fā)的支持三種不同操作系統(tǒng)的程序意味著需要針對三種不同的系統(tǒng)進行部署、測試和運行維護。此外，代碼采用了單例設計模式，導致系統(tǒng)嚴重相互依賴，難以預測會出現(xiàn)什么問題，而且難以理解。最后，我選擇使用 Java 來實現(xiàn)新版本，但最終也變得非常丑陋和令人困惑。

在加入 Spiral Scout 后，我嘗試停止使用 Java。我決定擁抱 Go，并盡可能多地使用 Go 來開發(fā)。我發(fā)現(xiàn)它是一種創(chuàng)新且全面的語言，我們的團隊現(xiàn)在仍然每天在各種項目中使用它。

但是，與任何一門編程語言一樣，Go 也有它的缺點，而且我不想撒謊——有時候我真的很想念 Java。

如果說我的編程經(jīng)驗教會了我什么，那一定是——軟件開發(fā)沒有銀彈。我將在這篇文章里詳細分享我使用一門傳統(tǒng)語言和一門新語言的經(jīng)歷。

2. 簡潔性

Go 和 Java 都是 C 家族語言，所以它們具有相似的語法。因此，Java 開發(fā)人員可以很容易讀懂 Go 代碼，反之亦然。Go 不需要在語句末尾使用分號（';'），只有少數(shù)情況例外。對我來說，Go 的行分隔方式更清晰，更易讀。

Go 和 Java 都使用了我最喜歡的功能之一，即垃圾收集器（GC），用來幫助防止內(nèi)存泄漏。與 C++ 不同，C 家族的程序員需要處理內(nèi)存泄漏問題。垃圾回收器是自動化內(nèi)存管理的一個特性，減輕了程序員的負擔。

Go 的 GC 并未使用“弱世代假設”，但它的表現(xiàn)仍然非常出色，并且 STW（Stop-the-World）的時間非常短。在 1.5 版中，STW 降得更多，并且很穩(wěn)定，而在 1.8 版中，它降到了 1 毫秒以下。

Go 的 GC 只有少量的一些選項，即用于設置初始垃圾回收目標百分比的 GOGC 變量。而 Java 有 4 個不同的垃圾回收器，每個垃圾回收器都有大量的選項。

盡管 Java 和 Go 都被認為是跨平臺的，但 Java 需要 Java 虛擬機（JVM）來解釋編譯后的代碼，而 Go 是將代碼編譯成目標平臺的二進制文件。但我認為，與 Go 相比，Java 對平臺的依賴程度更低，因為 Go 每次都需要為新平臺編譯二進制文件。從測試和 DevOps 的角度來看，分別為不同的平臺編譯二進制文件非常耗時，并且跨平臺的 Go 編譯在某些情況下不起作用，尤其是在使用 CGo 時。而對于 Java，你可以在安裝了 JVM 的任何地方使用相同的 jar。Go 需要的 RAM 更小一些，并且不需要安裝和管理虛擬機。

反射。Java 的反射更方便、更流行也更常用，而 Go 的反射似乎更復雜。Java 是一種面向?qū)ο蟮木幊陶Z言，因此除原始類型之外的所有東西都被視為對象。如果要使用反射，可以創(chuàng)建一個類，并從類中獲取所需的信息，如下所示：

Class cls = obj.getClass();
Constructor constructor = cls.getConstructor();
Method[] methods = cls.getDeclaredFields();

這樣就可以訪問構造函數(shù)、方法和屬性，然后調(diào)用或?qū)λ鼈冑x值。

Go 沒有類的概念，并且結構體只包含了已聲明的字段。因此，我們需要借助“reflection”包來獲得所需的信息：

type Foo struct {
  A int `tag1:"First Tag"
  tag2:"Second Tag"`
  B string
}


f := Foo{A: 10, B: "Salutations"}
fType := reflect.TypeOf(f)
switch t.Kind(fType)
    case reflect.Struct:
        for i := 0; i < t.NumField(); i++ {
          f := t.Field(i)
          // ...
        }
}

我覺得這不是一個大問題，但由于 Go 中沒有結構體的構造函數(shù)，所以很多原始類型必須單獨處理，并且需要考慮到指針。在 Go 中，我們可以進行指針傳遞或值傳遞。Go 的結構體可以將函數(shù)作為字段。所有這些都讓 Go 的反射變得更加復雜。

可訪問性。Java 有 private、protected 和 public 修飾符，為數(shù)據(jù)、方法和對象提供了不同的訪問作用域。Go 有與 Java 的 public 和 private 相似的 exported/unexported，但沒有修飾符。以大寫字母開頭的所有內(nèi)容都將被導出，對其他包可見，未導出（小寫）的變量或函數(shù)僅在當前包中可見。

3. Go 與 Java 的大不同

Go 不是面向?qū)ο缶幊陶Z言。Go 沒有類似 Java 的繼承機制，因為它沒有通過繼承實現(xiàn)傳統(tǒng)的多態(tài)性。實際上，它沒有對象，只有結構體。它可以通過接口和讓結構體實現(xiàn)接口來模擬一些面向?qū)ο筇匦浴４送?，你可以在結構體中嵌入結構體，但內(nèi)部結構體無法訪問外部結構體的數(shù)據(jù)和方法。Go 使用組合而不是繼承將一些行為和數(shù)據(jù)組合在一起。

Go 是一種命令式語言，Java 是一種聲明式語言。Go 沒有依賴注入，我們需要顯式地將所有東西包裝在一起。因此，在使用 Go 時盡量少用“魔法”之類的東西。一切代碼對于代碼評審人員來說都應該是顯而易見的。Go 程序員應該了解 Go 代碼如何使用內(nèi)存、文件系統(tǒng)和其他資源。

Java 要求開發(fā)人員更多地地關注程序的業(yè)務邏輯，知道如何創(chuàng)建、過濾、修改和存儲數(shù)據(jù)。系統(tǒng)底層和數(shù)據(jù)庫方面的東西都是通過配置和注解來完成的（比如通過 Spring Boot 等通用框架）。我們盡可能把枯燥乏味的東西留給框架去做。這樣做很方便，但控制也反轉(zhuǎn)了，限制了我們優(yōu)化整個過程的能力。

變量定義的順序。在 Java 中，你可以這樣定義變量：

String name;

而在 Go 中，你得這么寫：

name string

在我剛開始使用 Go 時，這也是令我感到困惑的一個地方。

4. Go 好的方面

簡單優(yōu)雅的并發(fā)。Go 具有強大的并發(fā)模型，叫作“通信順序進程”或 CSP。Go 使用 n-to-m 分析器，允許在 n 個系統(tǒng)線程中執(zhí)行 m 個并發(fā)。啟動并發(fā)例程非常簡單，只需使用 Go 的一個關鍵字即可，例如：

go doMyWork()

這樣就可以并發(fā)執(zhí)行 doMyWork()。

進程之間的通信可以通過共享內(nèi)存（不推薦）和通道來完成。我們可以使用與環(huán)境變量 GOMAXPROCS 定義的進程數(shù)一樣多的核心，并帶來非常健壯和流暢的并行性。默認情況下，進程數(shù)等于核心數(shù)。

Go 提供了一種特殊模式來運行二進制文件，并可以檢測執(zhí)行竟態(tài)條件。我們可以通過這種方式測試并證明自己的程序是不是并發(fā)安全的。

go run -race myapp.go

應用程序?qū)⒃诰箲B(tài)檢測模式下運行。

Go 提供了很多開箱即用且非常有用的基本功能（https://golang.org/dl/），例如用于并發(fā)的“sync”包（https://golang.org/pkg/sync/）?！癘nce”類型的單例可以這么寫：

package singleton 
import ("sync")
type singleton struct { }
var instance *singleton 
var once sync.Once 
func GetInstance() *singleton {    
  once.Do(func() {        
    instance = &singleton{}    
  })    
  return instance 
}

sync 包還為并發(fā) map 實現(xiàn)、互斥鎖、條件變量和 WaitGroup 提供了一種結構體。atomic 包（https://golang.org/pkg/sync/atomic/） 支持并發(fā)安全轉(zhuǎn)換和數(shù)學運算——它們基本上是編寫并發(fā)代碼所需的一切。

指針。借助指針，Go 可以更好地控制如何分配內(nèi)存、垃圾回收器負載以及其他在 Java 中無法實現(xiàn)的性能調(diào)優(yōu)。與 Java 相比，Go 更像是一種低級的語言，并且支持更容易、更快的性能優(yōu)化。

鴨子類型（Duck Typing）。“如果它走路像鴨子，并且像鴨子一樣嘎嘎叫，那它一定就是鴨子”。在 Go 中就是這樣的：無需定義某種結構體是否實現(xiàn)了給定的接口，只要這個結構體具有與給定接口相同的方法簽名，那它就是實現(xiàn)了這個接口。這非常有用，作為代碼庫的調(diào)用端，你可以定義外部庫結構體所需的任意接口。而在 Java 中，對象必須顯式聲明實現(xiàn)了哪些接口。

性能分析器。Go 的性能分析工具讓性能問題分析變得便捷和輕松。Go 的分析器可以揭示程序的內(nèi)存分配和 CPU 使用情況，并在可視化圖形中展示出來，讓性能優(yōu)化變得非常容易。Java 也有很性能分析器，比如 Java VisualVM，但它們都比 Go 的復雜，而且依賴 JVM 的運行情況，因此它們提供的統(tǒng)計信息與垃圾回收器的運行相關。

CGO。Go 可以與 C 語言集成，因此你可以在 Go 項目中開發(fā)帶有 C 代碼片段的應用程序。開發(fā)人員可以使用 CGo 創(chuàng)建調(diào)用 C 代碼的 Go 程序包。Go 為 exclude/include 給定平臺的 C 代碼片段提供了各種構建選項。

將函數(shù)作為參數(shù)。Go 函數(shù)可以作為變量傳遞給另一個函數(shù)或作為結構體的字段。這種多功能性令人耳目一新。Java 8 引入了 lambda，但它們不是真正的函數(shù)，只是單函數(shù)對象。

清晰的代碼風格準則。Go 社區(qū)提供了很多示例和說明：

https://golang.org/doc/effective_go.html

函數(shù)可以返回多個參數(shù)，這個也非常有用。

package main 
import "fmt" 
func returnMany() (int, string, error) {     
  return 1, "example", nil 
}
func main() {     
  i, s, err := returnMany()     
  fmt.Printf("Returned %s %s %v", i, s, err) 
}

5. Go 不好的方面

沒有多態(tài)性（除非通過接口來實現(xiàn)）。在 Go 中，如果在同一個包中有兩個函數(shù)具有不同的參數(shù)但含義相同，必須給它們指定不同的名字。例如這段代碼：

func makeWorkInt(number int) {   
  fmt.Printf(“Work done number %d”, number) 
}
func makeWorkStr(title string) {   
  fmt.Printf(“Work done title %s”, title) 
}

這樣一來，你就會得到很多方法，它們做的事情差不多，但名字都不一樣，而且看起來很“丑”。

另外，Go 也沒有繼承多態(tài)性。被嵌入到結構體里的結構體只知道其自己的方法，對“宿主”結構體的方法一無所知。對于像我這樣的開發(fā)人員來說，這尤其具有挑戰(zhàn)性，因為我們是從其他 OOP 語言（最基本的概念之一就是繼承）過渡到 Go 的。

不過，隨著時間的推移，我開始意識到這種處理多態(tài)性的方法只是另一種思維方式，而且是有道理的，因為組合比繼承更加可靠，并且運行時間是可變的。

錯誤處理。在 Go 中，完全由你來決定返回什么錯誤以及如何返回錯誤，因此作為開發(fā)人員，你需要負責返回和傳遞錯誤。毫無疑問的是，錯誤可能會被隱藏掉，這是一個痛點。時刻要記得檢查錯誤并把它們傳遞出去，這有點煩人，而且不安全。

當然，你可以使用 linter 來檢查隱藏的錯誤，但這只是一種輔助手段，不是真正的解決方案。在 Java 中，處理異常要方便得多。如果是 RuntimeException，甚至不必將其添加到函數(shù)的簽名中。

public void causeNullPointerException() {
  throw new NullPointerException("demo");
}
/*
...
*/
try {
  causeNullPointerException();
} catch(NullPointerException e) {
  System.out.println("Caught inside fun().");
  throw e; // rethrowing the exception
}

沒有泛型。雖然泛型很方便，但它會增加復雜性，而且從類型系統(tǒng)和運行時方面來看，泛型的成本很高。在構建 Go 代碼時，你需要處理各種不同的類型或使用代碼生成。

沒有注解。盡管可以用代碼生成替換一部分編譯時注解，但運行時注解是不能替換的。這是有道理的，因為 Go 不是聲明式的，并且代碼里不應該包含任何“魔法”。我喜歡在 Java 中使用注解，因為它們讓代碼更優(yōu)雅、簡單和簡約。

在為 HTTP 服務器端點生成 swagger 文件時，注解會非常有用。目前在 Go 中需要手動編寫 swagger 文件，或者為端點提供特別的注釋。每次 API 發(fā)生改動時，這都是一件很痛苦的事情。但是，Java 中的注解就像是一種魔法一樣，人們通常都不用去關心它們是怎么實現(xiàn)的。

Go 的依賴管理。我之前曾寫過一篇關于如何使用 vgo 和 dep 在 Go 中進行依賴管理的文章。Go 的依賴管理的演變之路充滿了坎坷。最初，除了“ Gopgk”之外沒有其他依賴管理工具，后來發(fā)布了實驗性的“Vendor”，后被“vgo”取代，然后又被 1.10 版“go mod”取代。如今，我們可以手動或者使用各種 Go 命令（例如“go get”）來修改 go.mod 文件描述符，但這也讓依賴關系變得不穩(wěn)定。

Java 有 Maven 和 Gradle 之類的聲明式工具，用來進行依賴關系管理，也用于構建、部署和處理其他 CD/CI 任務。但是，在 Go 中，我們必須使用 Makefile、docker-composes 和 bash 腳本自定義構建所需的依賴管理，這只會使 CD/CI 的過程和穩(wěn)定性變得更加復雜。

包的名稱里包括了托管域名。例如：

import "github.com/pkg/errors"

這真的很奇怪，而且很不方便，因為你不能在不修改項目代碼庫導入的情況下用自己的實現(xiàn)替換別人的實現(xiàn)。

在 Java 中，導入通常以公司名稱開頭，例如：

import by.spirascout.public.examples.simple.Helper;

區(qū)別在于，在 Go 中，go get 會向 by.spirascout.public 獲取資源。在 Java 中，包名和域名不一定是相關聯(lián)的。

我希望所有與依賴管理有關的問題都是暫時的，將來會得到妥善的解決。

6. 寫在最后

Go 最有趣的一個地方是它所遵循的代碼命名規(guī)則——基于代碼可讀性心理學：

https://medium.com/@egonelbre/psychology-of-code-readability-d23b1ff1258a

你可以用各種方法寫出清晰且可維護的代碼，盡管 Go 是多單詞的編程語言，但寫出來的代碼仍然很清晰。

Go Web 開發(fā)經(jīng)驗讓我看到了 Go 的快速、強大和易于理解，它非常適用于小型服務和并發(fā)處理。對于大型復雜的系統(tǒng)、功能復雜的服務以及單服務器系統(tǒng)，Java 目前仍然是王者。

英文原文

https://dzone.com/articles/when-to-use-go-vs-java-one-programmers-take-on-two

以上就是W3Cschool編程獅關于程序員技術選型：寫Go還是Java？的相關介紹了，希望對大家有所幫助。