Java 开发者 Golang 速成指南

欢迎，Java 开发者！

本指南专为熟悉 Java/Spring Boot 的您设计，旨在通过对比快速掌握 Golang 的核心概念。

目标读者： 熟悉 Java/Spring Boot 的开发者

环境： Windows 11

前置知识： OOP、HTTP、并发基础

请使用左侧导航开始您的 Go 学习之旅。本应用将帮助您在不同主题间快速切换，并通过交互式代码对比，加速您的思维转变。

1. 核心思维转变 (Mindset Shift)

在开始写代码之前，您需要接受几个来自 Go 的“文化冲击”。最大的区别在于 OOP 的实现、错误处理方式和并发模型。

特性	Java (Spring Boot)	Go (Golang)
运行方式	编译为字节码 (.class) -> JVM 解释/JIT	编译为机器码 (.exe) -> 直接运行 (无虚拟机)
面向对象	Class, extends, implements, @Override	Struct (结构体), 组合, 隐式接口
异常处理	Try-Catch-Finally, Throw	多返回值, `if err != nil`
并发模型	Thread, Runnable, ExecutorService	Goroutine (协程), Channel (通信)
访问控制	`public`, `private`, `protected`	首字母大写(Public), 首字母小写(Private)
依赖管理	Maven (`pom.xml`) / Gradle	Go Modules (`go.mod`)

2. 环境搭建 (Windows 11)

2.1 安装 Go

推荐使用包管理器 `winget`。打开 PowerShell (管理员) 执行：

winget install GoLang.Go

安装完成后，重启终端，输入 `go version` 验证。

2.2 IDE 选择

IntelliJ IDEA 用户: 强烈推荐 GoLand (JetBrains 全家桶，快捷键一致)。
免费方案: VS Code + "Go" 插件 (Google 官方出品)。

2.3 初始化项目 (类比 Maven)

在 Java 中您习惯用 `pom.xml`。在 Go 中使用 `go.mod`：

# 创建项目目录
mkdir my-go-demo
cd my-go-demo

# 初始化模块 (类似创建 pom.xml)
# 模块名通常是代码仓库地址，类似 Java 的 groupId + artifactId
go mod init github.com/plaguewzk/my-go-demo

3. 语法速查：Java vs Go

3.1 变量与类型

Go 支持类型推断（使用 `:=`），这有点像 Java 10+ 的 `var`。点击下方标签页查看对比。

String name = "Plague";
final int age = 21;
// 或者是
var list = new ArrayList<String>();

name := "Plague" // := 只能在函数内部使用，自动推断类型
var age int = 21
const Pi = 3.14  // 常量

// Go 也是强类型，但没有 null (除了指针/接口/切片等)，
// 字符串默认是 ""，数字默认是 0

3.2 循环与控制

Go 只有 `for` 循环，它通过不同形式实现了 `while` 和 `foreach` 的功能。

// Foreach
for (String item : items) { ... }

// While
while (condition) { ... }

// Foreach (index, value)
for i, item := range items {
    fmt.Println(i, item)
}

// 模拟 While
for condition {
    // 逻辑
}

// 死循环
for {
    // 逻辑
}

4. 面向对象：没有 Class 的世界

这是 Java 开发者最容易卡壳的地方。Go **没有** `class` 关键字，只有 `struct`（结构体）。

4.1 定义对象 (Struct)

Go 使用结构体 (`struct`) 封装数据，并使用 `func (receiver *Type)` 的方式为结构体绑定方法。

public class User {
    private String name;
    public int Age;
    
    public User(String name) { this.name = name; }
    public void sayHello() { ... }
}

// 首字母大写 User = public class (包外可见)
type User struct {
    name string // 首字母小写 = private field (包外不可见)
    Age  int    // 首字母大写 = public field
}

// 构造函数只是一个普通工厂函数
func NewUser(name string) *User {
    return &User{name: name}
}

// 方法定义 (Receiver)
// (u *User) 类似 Java 的 this，将函数绑定到 User 结构体上
func (u *User) SayHello() {
    fmt.Printf("Hi, I am %s\n", u.name)
}

4.2 接口 (隐式实现)

Go 的接口是“隐式”的。您不需要像 Java 一样显式声明 `implements`。只要一个 `struct` 实现了接口要求的所有方法，它就自动实现了该接口。

interface Animal { void speak(); }
class Dog implements Animal { ... } // 必须写 implements

type Animal interface {
    Speak()
}

type Dog struct {}

// 不需要写 implements Animal
func (d Dog) Speak() {
    fmt.Println("Woof!")
}

func main() {
    var a Animal = Dog{} // 自动识别为实现了 Animal
    a.Speak()
}

5. 错误处理：告别 Try-Catch

Go 认为错误是正常的业务逻辑，而不是“异常”。Go 函数通常返回两个值：` (result, error)`。如果 `error` 不为 `nil`，则表示发生了错误。

try {
    String content = readFile("file.txt");
} catch (IOException e) {
    e.printStackTrace();
}

// 函数可以返回多个值 (结果, 错误)
content, err := os.ReadFile("file.txt")
if err != nil {
    // 处理错误
    log.Println("读取失败:", err)
    return
}
// 正常处理 content

提示：刚开始您会觉得写 `if err != nil` 很烦，但这样能确保代码不会莫名其妙崩在某个未捕获的异常上。

6. 杀手级特性：Goroutine 与 Channel

这是 Go 最大的卖点。在 Java 中开启线程 (`new Thread()`) 成本很高（MB 级栈内存），而 Goroutine 非常轻量（KB 级），可以轻松开启上万个。

6.1 启动并发 (Java vs Go)

启动一个 Goroutine 极其简单，只需在函数调用前加上 `go` 关键字。

new Thread(() -> {
    doWork();
}).start();

go doWork() // 就这么简单，前面加个 go

6.2 通信 (Channel)

Java 通常使用共享内存（锁、Atomic）来通信。Go 提倡“通过通信来共享内存”，也就是使用 Channel。

func main() {
    // 创建一个通道，传输 int 类型
    ch := make(chan int)

    // 开启一个协程
    go func() {
        fmt.Println("计算中...")
        ch <- 100 // 将数据发送进通道
    }()

    // 主线程阻塞，直到从通道收到数据
    result := <-ch 
    fmt.Println("收到结果:", result)
}

7. Web 开发：SpringBoot vs Gin

您一定熟悉 Spring MVC 的 Controller/Service/Dao。Go 的 Web 开发更加直接。我们用 Go 最流行的框架 Gin (类似 SpringMVC 但更轻) 写一个 Hello World。

首先安装依赖：

go get -u github.com/gin-gonic/gin

main.go:

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

// 模拟 POJO
type Student struct {
    Name string `json:"name"` // 类似 Jackson 的 @JsonProperty
    Age  int    `json:"age"`
}

func main() {
    r := gin.Default() // 类似 SpringApplication

    // @GetMapping("/ping")
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "pong",
        })
    })

    // @PostMapping("/student")
    r.POST("/student", func(c *gin.Context) {
        var student Student
        // @RequestBody 绑定
        if err := c.ShouldBindJSON(&student); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        
        // 业务逻辑...
        c.JSON(200, student)
    })

    r.Run(":8080") // 启动 Tomcat/Netty
}

8. 项目结构建议

不要把所有文件放在根目录。Go 社区有一个标准布局 (Standard Go Project Layout)，类似 Maven 的 `src/main/java` 结构：

/my-project
  /cmd
    /myapp
      main.go      # 程序入口 (PSVM)
  /internal        # 私有代码 (其他项目无法引用)
    /controller    # 类似 Spring Controller
    /service       # 类似 Spring Service
  /pkg             # 公共代码 (工具类，Utils)
  go.mod           # Maven pom.xml
  go.sum           # 依赖版本锁定 (类似 package-lock.json)

9. 总结：给 Java 选手的建议

从 Java 切换到 Go，最大的障碍是思维模式。请记住以下几点：

忘记继承：多用组合（Embedding）。如果需要复用逻辑，把结构体 A 放进结构体 B 里。
拥抱指针：Go 里的 `*User` 意味着您在传递引用（避免拷贝大对象），不带 `*` 意味着值拷贝。Java 中所有对象默认都是引用传递，但在 Go 中您需要显式选择。
大写就是 Public：不需要写 getter/setter，除非您需要逻辑控制。直接访问字段在 Go 中很常见。
不要过度设计：Spring 习惯于依赖注入（DI）和各种设计模式。Go 代码通常更直白、更“扁平”。

祝您在 Go 的世界里玩得开心！