// Go：一眼看懂，LLM 一次生成正确
func ProcessOrder(ctx context.Context, orderID string) error {
    order, err := getOrder(ctx, orderID)
    if err != nil {
        return fmt.Errorf("获取订单失败: %w", err)
    }
    return processPayment(ctx, order)
}

// Java：需要理解异常层次、泛型、注解...
@Transactional(rollbackFor = Exception.class)
public OrderDTO processOrder(@NonNull String orderId)
    throws OrderNotFoundException, PaymentException {
    try {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        return paymentService.process(order);
    } catch (DataAccessException e) {
        throw new PaymentException("处理失败", e);
    }
}

// Go：所有依赖显式传递，LLM 能完整推断数据流
type UserService struct {
    repo   UserRepository
    cache  Cache
    logger Logger
}

func NewUserService(repo UserRepository, cache Cache, logger Logger) *UserService {
    return &UserService{repo: repo, cache: cache, logger: logger}
}

// Java：@Autowired 魔法，LLM 需要理解整个 Spring 上下文
@Service
public class UserService {
    @Autowired private UserRepository repo;
    @Autowired private CacheManager cache;
    @Autowired private Logger logger;
    // LLM 很难推断这些依赖从哪来，何时初始化
}

// Go：标准库就能完成
import (
    "net/http"      // HTTP 服务器
    "encoding/json" // JSON 处理
    "context"       // 上下文传递
    "time"          // 时间处理
)

// LLM 生成的代码 99% 情况下能直接运行

// Java：必须依赖外部库，LLM 容易生成错误的依赖
import org.springframework.web.bind.annotation.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.micrometer.core.instrument.MeterRegistry;
// LLM 可能生成过时的库、错误的版本、不兼容的依赖

# LLM 生成 Go 代码后，立即编译验证
$ go build
# 编译错误会精确指出问题：
# main.go:15:2: undefined: processOrder
# main.go:23:10: cannot use order (type *Order) as type Order

# 把错误粘贴给 LLM，它能精确修复

# Java 的编译错误往往更复杂，LLM 难以理解
$ mvn compile
# [ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.8.1:compile
# [ERROR] /src/main/java/UserService.java:[42,8] incompatible types:
#         inference variable T has incompatible bounds
#         equality constraints: Order
#         lower bounds: Serializable,Comparable<?>

// Go：LLM 生成的并发代码通常是正确的
func ProcessItems(items []Item) {
    var wg sync.WaitGroup
    for _, item := range items {
        wg.Add(1)
        go func(item Item) {
            defer wg.Done()
            process(item)
        }(item)
    }
    wg.Wait()
}

// Java：LLM 容易生成有 bug 的并发代码
ExecutorService executor = Executors.newFixedThreadPool(10);
List<Future<Result>> futures = new ArrayList<>();
for (Item item : items) {
    futures.add(executor.submit(() -> process(item)));
    // 忘记关闭 executor？忘记处理异常？忘记超时？
}
// LLM 经常遗漏 shutdown、awaitTermination 等关键步骤

// Java：需要配置 JUnit/TestNG + Maven/Gradle
// pom.xml
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.2</version> // LLM 容易生成错误版本
</dependency>

// Go：内置测试框架，零配置
// user_test.go
func TestGetUser(t *testing.T) {
    got := GetUser("123")
    if got == nil {
        t.Error("expected user, got nil")
    }
}

// 运行测试
$ go test ./...  // LLM 生成这个命令 100% 正确

// user.go
//go:generate mockgen -source=user.go -destination=mock/user_mock.go

type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
}

# 运行代码生成
$ go generate ./...

# 自动生成 mock 代码
// mock/user_mock.go（由 mockgen 生成）
type MockUserRepository struct {
    ctrl     *gomock.Controller
    recorder *MockUserRepositoryMockRecorder
}

# Go：内置代码格式化和静态分析
$ go fmt ./...   # 自动格式化所有代码
$ go vet ./...   # 检查常见错误

# Java：需要配置多个工具
$ mvn spotless:apply  # Spotless 插件（需要配置）
$ mvn checkstyle:check # Checkstyle（需要 XML 配置文件）
$ mvn pmd:check        # PMD（需要额外配置）

public class Test
{
	
    public void generate(){
        int a = obtainVaraible("a");
        int b=obtainVaraible("b");
        if(a == 96) {
            System.out.println("foo");
        } else {
            System.out.println("bar");
        }
        
        if (b == 97) {
            
        }
        // println b
       	else {
            System.out.println("b")
        }
    }
    
} 

// LLM 生成的代码可能格式不统一
func GetUser(id string)(*User,error){
return&User{ID:id},nil
}

// 运行 go fmt 后自动修复
func GetUser(id string) (*User, error) {
    return &User{ID: id}, nil
}

# Go：添加依赖只需 import，go mod 自动处理
import "github.com/gin-gonic/gin"

$ go mod tidy  # 自动下载依赖、清理未使用的包

# Java：需要手动编辑 pom.xml/build.gradle
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>  // LLM 容易生成过时版本
</dependency>

# Go：一条命令生成可执行文件
$ go build -o myapp
$ ./myapp  # 单个二进制文件，无需 JRE

# Java：需要打包、配置 MANIFEST.MF
$ mvn package
$ java -jar target/myapp-1.0.0-jar-with-dependencies.jar  # 需要 JRE

# Go：LLM 生成的完整工作流（零配置）
go mod init myapp
go get github.com/gin-gonic/gin
go test ./...
go build -o myapp
./myapp

# Java：LLM 需要理解多个工具和配置文件
mvn archetype:generate -DgroupId=com.example -DartifactId=myapp  # 复杂参数
# 编辑 pom.xml 添加依赖
mvn test
mvn package
java -jar target/myapp.jar

// Go: LLM 生成内存高效的并发代码
func processUsers(users []User) {
    for _, user := range users {
        go calculatePosition(user) // 仅 2-4KB 开销
    }
}

// Java: LLM 生成线程池代码（更复杂，内存开销大）
ExecutorService executor = Executors.newFixedThreadPool(100);
for (User user : users) {
    executor.submit(() -> calculatePosition(user)); // 每个线程 1-2MB
}

// Go: LLM 随便生成都不会太慢
for i := 0; i < 1_000_000; i++ {
    go processTask(i) // 即使百万协程也只用少量内存
}

// Java: 需要精心设计线程池（LLM 容易生成错误配置）
var executor = Executors.newVirtualThreadPerTaskExecutor(); // Java 21+
for (int i = 0; i < 1_000_000; i++) {
    executor.submit(() -> processTask(i));
}
// 需要考虑：线程池大小、队列长度、拒绝策略...

# Go: LLM 生成代码 → 验证循环（秒级）
$ go run main.go  # 编译+启动 < 1 秒
# 发现问题，LLM 修复
$ go run main.go  # 再次验证 < 1 秒

# Java: LLM 生成代码 → 验证循环（分钟级）
$ mvn spring-boot:run  # Maven 构建 10-30 秒 + JVM 预热 5-10 秒
# 发现问题，LLM 修复
$ mvn spring-boot:run  # 再次等待 15-40 秒

# Go: 完整构建流程（AI 生成的命令）
$ go mod tidy        # 依赖解析 < 1 秒
$ go test ./...      # 测试 1-5 秒
$ go build -o app    # 编译 1-3 秒
$ ./app              # 运行
总计：< 10 秒

# Java: 完整构建流程（AI 生成的命令）
$ mvn clean          # 清理 2-5 秒
$ mvn test           # 测试 10-30 秒（包括 JVM 启动）
$ mvn package        # 打包 10-20 秒
$ java -jar target/app.jar  # 运行（JVM 预热 3-5 秒）
总计：30-60 秒（干净构建）

// Go: LLM 生成的 gRPC 代码（简单且正确）
conn, err := grpc.Dial("localhost:50051")
if err != nil {
    log.Fatal(err) // 连接失败立即发现
}
client := pb.NewUserServiceClient(conn)

// Java: LLM 生成的 gRPC 代码（容易出错）
ManagedChannel channel = ManagedChannelBuilder
    .forAddress("localhost", 50051)
    .usePlaintext()
    .build(); // 连接是懒加载的！
UserServiceGrpc.UserServiceBlockingStub stub =
    UserServiceGrpc.newBlockingStub(channel);
// 此时可能还没真正连接，需要手动调用 getState() 检查

# Go: LLM 生成的 Dockerfile（100% 成功率）
FROM scratch
COPY app /app
CMD ["/app"]
# 镜像大小：5-20 MB，启动 < 100ms

# Java: LLM 生成的 Dockerfile（经常出错）
FROM openjdk:17-slim  # 需要选择正确的 JDK 版本
COPY target/*.jar app.jar  # 需要正确的 Maven 输出路径
ENTRYPOINT ["java", "-jar", "/app.jar"]  # 可能需要 JVM 参数调优
# 镜像大小：200-500 MB，启动 3-5 秒（预热更久）

// Rust: LLM 生成的代码（看起来对，但编译不过）
fn process_users(users: Vec<User>) -> Vec<String> {
    users.iter().map(|u| {
        let name = u.name; // 错误：cannot move out of borrowed content
        format!("Hello, {}", name)
    }).collect()
}
// 修复需要理解借用规则...

// Go: LLM 生成的等价代码（直接运行）
func processUsers(users []User) []string {
    results := make([]string, 0, len(users))
    for _, u := range users {
        results = append(results, fmt.Sprintf("Hello, %s", u.Name))
    }
    return results
}

# Python: LLM 生成的并发代码（受 GIL 限制）
import threading

def process_task(i):
    # CPU 密集任务在多线程下无法并行！
    result = heavy_computation(i)

threads = []
for i in range(1000):
    t = threading.Thread(target=process_task, args=(i,))
    threads.append(t)
    t.start()
# 由于 GIL，实际上是单核运行

# Go: 真正的并发
for i := 0; i < 1000; i++ {
    go processTask(i) // 真正的并行执行
}

// TypeScript: LLM 生成的代码（类型标注可能错误）
interface User {
    id: string;
    age: number;
}

function getUser(id: string): User {
    const user = fetchFromDB(id); // 运行时可能返回 null
    return user; // 编译通过，但运行时崩溃！
}

// Go: 编译时强制错误处理
func getUser(id string) (*User, error) {
    user, err := fetchFromDB(id)
    if err != nil {
        return nil, err // 必须处理错误
    }
    return user, nil
}

// C++: LLM 生成的代码（隐藏的内存问题）
std::vector<User*> getUsers() {
    std::vector<User*> users;
    for (int i = 0; i < 10; i++) {
        User u = createUser(i); // 栈对象
        users.push_back(&u);    // 悬空指针！
    }
    return users; // 运行时崩溃或未定义行为
}

// Go: 无需担心内存管理
func getUsers() []*User {
    users := make([]*User, 0)
    for i := 0; i < 10; i++ {
        u := createUser(i) // GC 自动管理
        users = append(users, &u)
    }
    return users // 完全安全
}

# Python: 原始代码（LLM 轻松生成）
def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 性能慢，需要用 Cython 优化...

# Cython: 优化后（LLM 生成困难）
cdef long fibonacci_c(long n):  # 需要 C 类型标注
    if n <= 1:
        return n
    return fibonacci_c(n-1) + fibonacci_c(n-2)

def fibonacci(n):
    return fibonacci_c(n)

# 问题：
# 1. 需要额外的 .pyx 文件和构建配置
# 2. C 扩展与纯 Python 库的兼容性问题
# 3. 调试时需要 gdb（LLM 无法处理）
# 4. 不同 Python 版本/平台的兼容性维护

// Go: 简单且快速（LLM 轻松生成）
func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

// 性能已接近 C，无需任何优化
// 编译成单一二进制，零兼容性问题

// Java ZGC: 通过 JVM 参数启用
java -XX:+UseZGC -Xmx16G -jar app.jar

// 效果：
// - 即使 16GB 堆，暂停时间仍 < 10ms
// - P99 延迟降至亚毫秒级
// - 对应用吞吐量影响极小（< 5%）

// Go: 高频场景（每秒处理 10 万笔订单）
func processOrders() {
    for {
        order := &Order{} // 频繁创建对象
        order.Parse(data)
        order.Validate()
        result := order.Execute() // 又创建了返回对象
        // 大量短命对象 → GC 压力巨大
    }
}

// 问题：
// 1. 每秒创建/销毁数十万对象
// 2. 触发频繁 GC → 延迟尖刺
// 3. 无法通过对象池完全解决（代码复杂度剧增）

// Java: 同样场景，但有更强的优化手段
public void processOrders() {
    while (true) {
        Order order = new Order(); // JIT 可能栈上分配
        order.parse(data);
        order.validate();
        Result result = order.execute();
    }
}

// 优化手段：
// 1. 逃逸分析 → 栈上分配（无 GC 压力）
// 2. ZGC → 即使堆分配，暂停时间 < 1ms
// 3. 分代 GC → 短命对象快速回收
// 4. 可调整堆大小 → 减少 GC 频率

# Java: 一堆"祈祷参数"（复杂且效果不确定）
java -jar app.jar \
  -XX:+UseZGC \                        # 使用 ZGC
  -Xmx16G -Xms16G \                    # 堆大小 16GB
  -XX:MaxGCPauseMillis=10 \            # 期望暂停 < 10ms
  -XX:ParallelGCThreads=8 \            # GC 并发线程数
  -XX:ConcGCThreads=4 \                # 并发标记线程数
  -XX:ZCollectionInterval=5 \          # ZGC 间隔
  -XX:ZAllocationSpikeTolerance=2 \    # 分配尖刺容忍度
  -XX:+UseLargePages \                 # 使用大页内存
  -XX:LargePageSizeInBytes=2M \        # 大页大小
  -XX:+AlwaysPreTouch \                # 预分配内存
  -XX:+TieredCompilation \             # 分层编译
  -XX:ReservedCodeCacheSize=512M \     # 代码缓存
  -XX:+UseStringDeduplication \        # 字符串去重
  -XX:InitiatingHeapOccupancyPercent=30  # GC 触发阈值

# 问题：
# 1. 参数太多，不知道哪些真正有效
# 2. 不同场景需要不同参数（像"祈祷"一样试）
# 3. 参数之间可能冲突
# 4. 生产环境验证成本高

# Go: 只有一个主要参数
export GOGC=50  # 降低 GC 触发阈值（默认 100）

# 就这么简单！但效果有限...

// 问题代码：频繁创建对象 → GC Spike
func handleRequest(r *Request) *Response {
    buf := make([]byte, 4096) // 每次请求都分配
    // ... 处理逻辑
    return &Response{Data: buf}
}

// 解决方案 1：使用 sync.Pool（对象池）
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 4096)
    },
}

func handleRequestOptimized(r *Request) *Response {
    buf := bufferPool.Get().([]byte) // 从池中获取
    defer bufferPool.Put(buf)         // 归还到池中

    // ... 处理逻辑
    return &Response{Data: buf}
}

// 解决方案 2：预分配切片容量
func processItems(items []Item) []Result {
    // 错误：频繁扩容
    results := []Result{}

    // 正确：预分配
    results := make([]Result, 0, len(items))

    for _, item := range items {
        results = append(results, process(item))
    }
    return results
}

// 解决方案 3：复用对象（手动管理生命周期）
type Worker struct {
    buffer []byte
    temp   *TempData
}

func NewWorker() *Worker {
    return &Worker{
        buffer: make([]byte, 4096),
        temp:   &TempData{},
    }
}

func (w *Worker) Process(r *Request) *Response {
    // 复用 w.buffer 和 w.temp，减少分配
    w.temp.Reset()
    // ... 处理逻辑
}

// 用户：帮我优化这个 Go 函数的 GC 问题

// LLM 生成（常见错误）：
var pool = sync.Pool{
    New: func() interface{} {
        return &MyStruct{} // ❌ 返回指针，每次仍会堆分配
    },
}

func process() {
    obj := pool.Get().(*MyStruct)
    defer pool.Put(obj) // ❌ defer 有性能开销

    // ❌ 没有重置 obj 状态，可能导致数据污染
    obj.field1 = "new value"
}

// 正确的实现（LLM 很少生成）：
var pool = sync.Pool{
    New: func() interface{} {
        return &MyStruct{
            buffer: make([]byte, 4096), // 预分配
        }
    },
}

func process() {
    obj := pool.Get().(*MyStruct)
    obj.Reset() // 重置状态！

    // ... 业务逻辑

    pool.Put(obj) // 不用 defer，减少开销
}

func (m *MyStruct) Reset() {
    m.field1 = ""
    m.field2 = 0
    m.buffer = m.buffer[:0] // 重置切片长度但保留容量
}

// LLM 经常生成这样的代码（频繁分配）
func handleRequest(r *Request) *Response {
    user := &User{} // 堆分配
    user.Parse(r.Body)

    result := []string{} // 切片分配
    for _, item := range user.Items {
        result = append(result, process(item)) // 多次扩容
    }

    return &Response{Data: result} // 又一次堆分配
}

// 这种代码在高并发下会导致 Go GC Spike
// 但人类开发者可能不会立即发现问题（本地测试负载低）

// 写完代码后，让 AI 审查
// 提示词：
"我是 Java 开发者刚学 Go，请审查这段代码，指出：
1. 哪些地方是'用 Go 语法写的 Java 代码'
2. 哪些地方不符合 Go 惯用法
3. 给出改进后的代码和解释"

// 你的代码
type UserService struct{}

func (s *UserService) GetUser(id string) (*User, error) {
    if id == "" {
        return nil, errors.New("id cannot be empty")
    }
    // ...
}

// AI 会指出：
// ❌ 不需要创建空 struct 的指针接收者
// ❌ 错误消息应该用 fmt.Errorf 包装
// ✅ 改进版本：
func GetUser(id string) (*User, error) {
    if id == "" {
        return nil, fmt.Errorf("invalid user id: %q", id)
    }
    // ...
}

// ❌ Java 思维：在实现方定义大接口
type MessageStore interface {
    Save(msg Message) error
    Get(id int) (Message, error)
    Delete(id int) error
    List() ([]Message, error)
    Search(query string) ([]Message, error)
    Count() int
    // ... 15 个方法
}

// ✅ Go 思维：在消费者端定义小接口
type InMemoryMessageStore struct{} // 具体类型，没有接口
func (s *InMemoryMessageStore) Save(msg Message) error { ... }
func (s *InMemoryMessageStore) Get(id int) (Message, error) { ... }

// 消费者只定义它需要的
type MessageSaver interface {
    Save(msg Message) error
}

func ProcessMessage(saver MessageSaver, msg Message) error {
    return saver.Save(msg)
}

// ❌ 把 panic/recover 当异常处理用
func processOrder(orderID string) (result string, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("处理失败: %v", r)
        }
    }()

    order := getOrder(orderID)
    if order == nil {
        panic("订单不存在")  // ❌ 这不应该是 panic！
    }
    // ...
}

// ✅ 错误作为值返回
func processOrder(orderID string) (string, error) {
    order, err := getOrder(orderID)
    if err != nil {
        return "", fmt.Errorf("获取订单失败: %w", err)
    }
    if order == nil {
        return "", ErrOrderNotFound  // 预定义的哨兵错误
    }
    // ...
}

// ❌ Java 式：构造函数做太多事
func NewDatabaseClient(config Config) (*Client, error) {
    client := &Client{config: config}
    if err := client.connect(); err != nil {
        return nil, err
    }
    if err := client.ping(); err != nil {
        return nil, err
    }
    return client, nil
}

// ✅ Go 式：分离创建和初始化
func NewDatabaseClient(config Config) *Client {
    return &Client{config: config}  // 只创建
}

func (c *Client) Connect(ctx context.Context) error {
    // 连接逻辑
}

// ❌ Java 习惯
type User struct {
    name string
    age  int
}

func (u *User) GetName() string { return u.name }
func (u *User) SetName(name string) { u.name = name }

// ✅ Go 风格：直接访问字段
type User struct {
    Name string  // 导出字段，直接访问
    Age  int
}

// ❌ Java 风格
import "github.com/company/project/internal/core/domain/model/entity/user"

// ✅ Go 风格：扁平化
import "github.com/company/project/user"

// ❌ "以防万一"的接口
type UserRepository interface {
    Create(user User) error
    Update(user User) error
    Delete(id int) error
    FindByID(id int) (*User, error)
}

// 然后只有一个实现...

// ✅ 从具体开始，需要时再抽象
type PostgresUserStore struct {
    db *sql.DB
}

func (s *PostgresUserStore) Create(user User) error { ... }

// ❌ 隐藏的并发——调用者不知道有 goroutine
func SendEmail(to, subject, body string) error {
    go func() {
        smtp.Send(to, subject, body)
    }()
    return nil  // 总是返回 nil
}

// ✅ 让并发对调用者透明
func SendEmail(ctx context.Context, to, subject, body string) error {
    return smtp.Send(ctx, to, subject, body)  // 同步
}

// 调用者决定是否异步
go func() {
    if err := SendEmail(ctx, to, subject, body); err != nil {
        log.Printf("发送邮件失败: %v", err)
    }
}()

// 嵌入示例
type Engine struct {
    Power int
}

func (e Engine) Start() {
    fmt.Println("引擎启动")
}

type Car struct {
    Engine        // 嵌入——方法被"提升"
    Model  string
}

func main() {
    car := Car{
        Engine: Engine{Power: 200},
        Model:  "Tesla",
    }
    car.Start()  // 直接调用，实际是 car.Engine.Start()
}

// Go
user, err := userService.FindByID(ctx, id)
if err != nil {
    if errors.Is(err, ErrUserNotFound) {
        return fmt.Errorf("用户不存在: %w", err)
    }
    return fmt.Errorf("查询用户失败: %w", err)
}

order, err := orderService.Create(ctx, user)
if err != nil {
    return fmt.Errorf("创建订单失败: %w", err)
}

// Go：手动依赖注入
type UserService struct {
    repo   UserRepository
    email  EmailSender
    cache  Cache
}

func NewUserService(repo UserRepository, email EmailSender, cache Cache) *UserService {
    return &UserService{
        repo:  repo,
        email: email,
        cache: cache,
    }
}

// 在 main.go 中组装
func main() {
    db := postgres.NewDB(config.DatabaseURL)
    repo := postgres.NewUserRepository(db)
    emailClient := sendgrid.NewClient(config.SendGridKey)

    userService := NewUserService(repo, emailClient, redisCache)

    server := http.NewServer(userService)
    server.Run()
}

// Go：Context 显式传递
type contextKey string

const userKey contextKey = "user"

func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user := validateToken(r.Header.Get("Authorization"))
        ctx := context.WithValue(r.Context(), userKey, user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func (s *Service) CreateOrder(ctx context.Context, orderReq OrderRequest) error {
    user := ctx.Value(userKey).(*User)
    return s.repo.Save(ctx, order)
}

// Go：零值即可用
type Counter struct {
    count int  // 零值是 0
}

func (c *Counter) Increment() {
    c.count++
}

// 无需构造函数
var counter Counter  // 零值就能用
counter.Increment()  // 正常工作

// ✅ Go 思维：只写需要的
type FileStore struct {
    dir string
}

func (f *FileStore) Save(key string, value []byte) error {
    return os.WriteFile(filepath.Join(f.dir, key), value, 0644)
}

func (f *FileStore) Load(key string) ([]byte, error) {
    return os.ReadFile(filepath.Join(f.dir, key))
}

// Spring Cloud 全家桶，开箱即用
@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
@EnableConfigServer
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

// 自动服务注册、配置中心、熔断、负载均衡、链路追踪
// 一个注解搞定

// Go：需要手动组装各种组件
func main() {
    // 服务注册（Consul）
    consul := consulapi.NewClient(consulConfig)
    registration := &consulapi.AgentServiceRegistration{...}
    consul.Agent().ServiceRegister(registration)

    // 配置中心（需要自己实现或用 Viper）
    viper.SetConfigName("config")
    viper.ReadInConfig()

    // 熔断器（需要引入 go-hystrix 或 gobreaker）
    breaker := gobreaker.NewCircuitBreaker(...)

    // 负载均衡（需要自己实现）
    // 链路追踪（需要手动集成 Jaeger/Zipkin）
    // ...
}

// CloudWeGo：字节跳动开源的微服务框架
// Kitex（RPC）+ Hertz（HTTP）+ Netpoll（网络库）

// Kitex 支持 Thrift 和 gRPC
// 服务定义（Thrift IDL）
service UserService {
    User GetUser(1: i64 user_id)
    bool CreateUser(1: User user)
}

// 生成代码
$ kitex -module example.com/userservice -service userservice user.thrift

// 服务实现
type UserServiceImpl struct{}

func (s *UserServiceImpl) GetUser(ctx context.Context, userID int64) (*User, error) {
    // 业务逻辑
}

// 场景：老系统用 HTTP，新系统用 gRPC，怎么互通？

// 方案 1：gRPC Gateway（HTTP → gRPC）
// 需要额外配置，增加复杂度

// 方案 2：写适配层
type UserServiceAdapter struct {
    grpcClient userpb.UserServiceClient
}

func (a *UserServiceAdapter) GetUser(userID int64) (*User, error) {
    // HTTP 请求转 gRPC 调用
    resp, err := a.grpcClient.GetUser(context.Background(), &userpb.GetUserRequest{
        UserId: userID,
    })
    // 转换数据结构...
}

// 方案 3：全部重写（成本最高，但最彻底）

// Spring Cloud：HTTP/JSON 开箱即用，无需适配
@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
}

// gRPC 支持？引入 grpc-spring-boot-starter
// Thrift 支持？生态很弱，几乎没有

// Hibernate/JPA：功能强大
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders;

    @ManyToMany
    @JoinTable(name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> roles;
}

// 自动处理：级联操作、懒加载、N+1 问题、二级缓存
List<User> users = userRepository.findByAgeGreaterThan(18);

// GORM：功能有限，性能开销大
type User struct {
    ID     uint
    Orders []Order `gorm:"foreignKey:UserID"`
    Roles  []Role  `gorm:"many2many:user_roles"`
}

// 级联操作需要手动处理
db.Preload("Orders").Preload("Roles").Find(&users)

// 复杂查询容易写成 N+1
// 缓存策略需要手动实现
// 性能优化需要深入理解 GORM 内部机制

// Spring Boot：零配置启动
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// application.yml 简单配置即可
spring:
  datasource:
    url: jdbc:postgresql://localhost/mydb
  jpa:
    hibernate:
      ddl-auto: update

// 自动配置：数据源、JPA、事务、日志、监控...

// Go：所有配置都要手写
func main() {
    // 加载配置
    config := loadConfig()

    // 初始化数据库
    db, err := sql.Open("postgres", config.DatabaseURL)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 配置连接池
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)

    // 初始化日志
    logger := zap.NewProduction()

    // 初始化路由
    router := gin.Default()

    // 手动注册中间件
    router.Use(LoggingMiddleware(logger))
    router.Use(RecoveryMiddleware())
    router.Use(CORSMiddleware())

    // 手动依赖注入
    userRepo := postgres.NewUserRepository(db)
    userService := service.NewUserService(userRepo, logger)
    userHandler := handler.NewUserHandler(userService)

    // 手动注册路由
    router.GET("/users", userHandler.List)
    router.POST("/users", userHandler.Create)

    // 手动配置优雅关闭
    srv := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }

    go func() {
        if err := srv.ListenAndServe(); err != nil {
            log.Fatal(err)
        }
    }()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatal(err)
    }
}

// Spring：依赖注入自动完成
@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final CacheManager cacheManager;
    private final MetricsRegistry metricsRegistry;

    @Autowired  // 甚至这个注解都可以省略（构造函数注入）
    public UserService(UserRepository userRepository,
                       EmailService emailService,
                       CacheManager cacheManager,
                       MetricsRegistry metricsRegistry) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.cacheManager = cacheManager;
        this.metricsRegistry = metricsRegistry;
    }
}

// 测试时自动 mock
@SpringBootTest
class UserServiceTest {
    @MockBean
    private UserRepository userRepository;

    @Autowired
    private UserService userService;
}

// Go：手动传递所有依赖
type UserService struct {
    userRepo UserRepository
    email    EmailSender
    cache    Cache
    metrics  MetricsCollector
}

func NewUserService(
    userRepo UserRepository,
    email EmailSender,
    cache Cache,
    metrics MetricsCollector,
) *UserService {
    return &UserService{
        userRepo: userRepo,
        email:    email,
        cache:    cache,
        metrics:  metrics,
    }
}

// main.go 中手动组装（依赖多了非常痛苦）
func main() {
    db := initDB()
    cache := initCache()
    email := initEmail()
    metrics := initMetrics()

    userRepo := postgres.NewUserRepository(db)
    orderRepo := postgres.NewOrderRepository(db)
    productRepo := postgres.NewProductRepository(db)

    userService := service.NewUserService(userRepo, email, cache, metrics)
    orderService := service.NewOrderService(orderRepo, userService, email, metrics)
    productService := service.NewProductService(productRepo, cache, metrics)

    // 10+ 个 service，依赖关系复杂，main 函数几百行...
}

// Wire（Google）：代码生成，但需要写大量声明
// +build wireinject

func InitializeUserService() (*UserService, error) {
    wire.Build(
        NewDatabase,
        NewCache,
        NewEmail,
        NewMetrics,
        NewUserRepository,
        NewUserService,
    )
    return nil, nil
}

// Dig（Uber）：运行时反射，性能开销 + 不如编译时检查

// Java：泛型功能强大
public class Repository<T extends Entity> {
    public List<T> findAll() { ... }
    public Optional<T> findById(Long id) { ... }
    public <U extends Comparable<U>> List<T> sortBy(Function<T, U> keyExtractor) { ... }
}

// 类型擦除 + 反射 = 灵活性
Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass()
    .getGenericSuperclass()).getActualTypeArguments()[0];

// Go 1.18+ 泛型：功能受限
type Repository[T any] struct {
    db *sql.DB
}

func (r *Repository[T]) FindAll() ([]T, error) { ... }

// ❌ 无法获取 T 的运行时类型信息
// ❌ 无法约束 T 必须有某些字段（只能约束方法）
// ❌ 无法实现像 Java 那样的通用 CRUD

// 实际项目中仍然大量重复代码：
type UserRepository struct { db *sql.DB }
type OrderRepository struct { db *sql.DB }
type ProductRepository struct { db *sql.DB }
// 每个 Repository 都要重复写 CRUD 方法

// Spring AOP：横切关注点优雅处理
@Transactional(rollbackFor = Exception.class)
@Cacheable(value = "users", key = "#id")
@PreAuthorize("hasRole('ADMIN')")
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
public User getUserById(Long id) {
    return userRepository.findById(id).orElseThrow();
}

// 事务、缓存、权限、重试全部通过注解声明

// Go：所有逻辑必须显式写出
func (s *UserService) GetUserById(ctx context.Context, id int64) (*User, error) {
    // 1. 检查权限（手动）
    if !s.authz.HasRole(ctx, "ADMIN") {
        return nil, ErrUnauthorized
    }

    // 2. 检查缓存（手动）
    cacheKey := fmt.Sprintf("user:%d", id)
    if cached, err := s.cache.Get(ctx, cacheKey); err == nil {
        var user User
        json.Unmarshal(cached, &user)
        return &user, nil
    }

    // 3. 开启事务（手动）
    tx, err := s.db.BeginTx(ctx, nil)
    if err != nil {
        return nil, err
    }
    defer tx.Rollback()

    // 4. 查询数据库（带重试，手动）
    var user *User
    for attempt := 0; attempt < 3; attempt++ {
        user, err = s.repo.FindById(ctx, tx, id)
        if err == nil {
            break
        }
        time.Sleep(time.Second * time.Duration(attempt+1))
    }
    if err != nil {
        return nil, err
    }

    // 5. 提交事务（手动）
    if err := tx.Commit(); err != nil {
        return nil, err
    }

    // 6. 写入缓存（手动）
    userJSON, _ := json.Marshal(user)
    s.cache.Set(ctx, cacheKey, userJSON, 5*time.Minute)

    return user, nil
}

// Spring MVC 是事实标准，90%+ 项目使用
@RestController
@RequestMapping("/api/users")
public class UserController {
    // 所有 Java 开发者都熟悉这个模式
}

// 每个公司、每个项目可能用不同框架
// Gin（最流行，但不是官方）
router := gin.Default()
router.GET("/users", handler)

// Echo（性能更好）
e := echo.New()
e.GET("/users", handler)

// Fiber（像 Express.js）
app := fiber.New()
app.Get("/users", handler)

// Chi（stdlib 风格）
r := chi.NewRouter()
r.Get("/users", handler)

// 标准库 net/http（最原始）
http.HandleFunc("/users", handler)

// 简洁（虽然隐藏了错误路径）
public User createUser(UserRequest req) {
    User user = userRepository.save(req.toEntity());
    emailService.sendWelcome(user.getEmail());
    return user;
}

// 冗长（虽然显式）
func (s *UserService) CreateUser(ctx context.Context, req UserRequest) (*User, error) {
    user, err := s.repo.Save(ctx, req.ToEntity())
    if err != nil {
        return nil, fmt.Errorf("save user: %w", err)
    }

    if err := s.email.SendWelcome(ctx, user.Email); err != nil {
        return nil, fmt.Errorf("send welcome email: %w", err)
    }

    return user, nil
}

// 30% 的代码是 if err != nil

// Spring Cloud Sleuth：自动埋点，零侵入
@RestController
public class OrderController {
    @GetMapping("/order/{id}")
    public Order getOrder(@PathVariable Long id) {
        // Sleuth 自动注入 TraceId、SpanId
        // 日志自动包含 [appname,traceId,spanId]
        log.info("Getting order {}", id);
        return orderService.findById(id);
    }
}

// 跨服务调用自动传播 TraceId
@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;  // Sleuth 自动注入 header

    public Order findById(Long id) {
        // TraceId 自动通过 HTTP header 传递给下游服务
        User user = restTemplate.getForObject("http://user-service/users/{id}", User.class, id);
        return order;
    }
}

// Go：必须手动传递 Context，容易遗漏
import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/trace"
)

func (h *OrderHandler) GetOrder(w http.ResponseWriter, r *http.Request) {
    // 1. 从 HTTP header 中提取 TraceContext（手动）
    ctx := otel.GetTextMapPropagator().Extract(r.Context(),
        propagation.HeaderCarrier(r.Header))

    // 2. 创建 Span（手动）
    ctx, span := tracer.Start(ctx, "GetOrder")
    defer span.End()

    // 3. 必须显式传递 ctx，忘记就断链！
    order, err := h.orderService.FindByID(ctx, id)  // ✅ 传了 ctx
    if err != nil {
        span.RecordError(err)  // 手动记录错误
        span.SetStatus(codes.Error, err.Error())  // 手动设置状态
        return
    }
}

func (s *OrderService) FindByID(ctx context.Context, id int64) (*Order, error) {
    // 调用下游服务，必须传 ctx
    user, err := s.userClient.GetUser(ctx, userID)  // ✅ 传了 ctx

    // ❌ 常见错误：忘记传 ctx，TraceId 断链
    // product, err := s.productClient.GetProduct(productID)

    // 数据库查询也要传 ctx
    order, err := s.repo.FindByID(ctx, id)  // ✅ 传了 ctx
    return order, err
}

func (c *UserClient) GetUser(ctx context.Context, id int64) (*User, error) {
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)

    // 必须手动注入 TraceContext 到 HTTP header
    otel.GetTextMapPropagator().Inject(ctx, propagation.HeaderCarrier(req.Header))

    resp, err := c.httpClient.Do(req)
    // ...
}