《MMO 服务器开发》10.1 跨栈对照矩阵：Go vs Java 最佳实践与选型标准

// file: internal/matrix/scorer.go
// tier: L1
// verify: go test ./internal/matrix/
// Package matrix scores the Go-vs-Java decision for an MMO backend. Section
// 10.1 lays out the full comparison matrix across concurrency, memory and GC,
// serialisation, the network stack, deployment, ecosystem and maintainability.
// This file turns that matrix into a function: feed it a team and scenario
// profile, get a recommended stack plus the reasons behind the call. The rules
// below are the article's judgement calls, written down so they can be argued
// with and tested rather than left as prose nobody re-reads.
package matrix

import (
	"fmt"
	"strings"
)

// Stack is one of the two stacks this book compares.
type Stack string

const (
	// GoStack is the Go runtime: goroutines, the concurrent GC, a single static
	// binary.
	GoStack Stack = "Go"
	// JavaStack is the JVM: virtual threads on JDK 21+, the JVM GC family, a jar
	// plus a runtime.
	JavaStack Stack = "Java"
)

// Profile is the scorer's input: a team's situation and the scenario's shape.
type Profile struct {
	Name string

	// Team
	TeamSize        int
	GoExperience    bool
	JavaExperience  bool
	JDK21           bool // the team's Java is JDK 21 or newer
	HiringJavaHeavy bool
	HiringGoHeavy   bool

	// Scenario
	PeakConns           int
	TailLatencyMatters  bool // the P99 budget is tight
	SyncDownstreamCalls bool // handlers call the DB / an RPC synchronously
	LegacyJavaServices  bool // existing account / billing services are Java
	FastIteration       bool // many deploys per day are expected
	LongSessions        bool // MMO-style long-lived sessions
}

// Verdict is the scorer's output: the winning stack, both point totals, and the
// rule-by-rule reasons so the call can be audited.
type Verdict struct {
	Stack   Stack
	GoPts   int
	JavaPts int
	Reasons []string
}

// Recommend applies the 10.1 rules and returns the winning stack. A tie goes to
// the stack the team already runs; if the team runs both (or neither), Go wins
// the tie, because a marginal difference is never worth a rewrite.
func Recommend(p Profile) Verdict {
	var goPts, javaPts int
	var reasons []string

	add := func(stack Stack, pts int, why string) {
		if stack == GoStack {
			goPts += pts
		} else {
			javaPts += pts
		}
		reasons = append(reasons, fmt.Sprintf("%s +%d：%s", stack, pts, why))
	}

	// Concurrency: goroutines and virtual threads are the same order of
	// magnitude (2.3 measured ~2053 B vs ~1006 B per unit). The differentiator
	// is not the model but whether the JVM is new enough to have virtual
	// threads at all.
	if p.PeakConns >= 10_000 {
		if p.JDK21 {
			add(JavaStack, 1, "高连接数：JDK 21 虚拟线程与 goroutine 同量级")
		} else {
			add(GoStack, 3, "高连接数且 JDK < 21：平台线程撑不住十万连接")
		}
	}

	// Tail latency: Go's concurrent GC keeps a smaller heap and shorter pauses
	// by default; the JVM needs ZGC / G1 tuning to match.
	if p.TailLatencyMatters {
		add(GoStack, 2, "P99 敏感：Go 默认堆小、停顿短，JVM 需额外调优")
	}

	// Synchronous downstream calls: both stacks have heap-allocated execution
	// units, so this no longer forces Netty. It is a wash, recorded as context.
	if p.SyncDownstreamCalls {
		add(GoStack, 1, "同步调用下游：两栈都有栈，goroutine / 虚拟线程都安全")
	}

	// Existing Java estate: integration cost dominates everything else.
	if p.LegacyJavaServices {
		add(JavaStack, 3, "存量账号 / 计费是 Java：同栈集成省掉跨栈序列化与联调")
	}

	// Iteration speed and deployment shape.
	if p.FastIteration {
		add(GoStack, 2, "快速迭代：单静态二进制、编译秒级、容器镜像小")
	}

	// Hiring pool.
	if p.HiringJavaHeavy {
		add(JavaStack, 2, "招聘以 Java 为主：招得到人比语言偏好更重要")
	}
	if p.HiringGoHeavy {
		add(GoStack, 2, "招聘以 Go 为主：招得到人比语言偏好更重要")
	}

	// Existing team experience.
	if p.GoExperience {
		add(GoStack, 2, "团队已有 Go 经验")
	}
	if p.JavaExperience {
		add(JavaStack, 2, "团队已有 Java 经验")
	}

	// Long sessions: one goroutine per connection, memory stays predictable.
	if p.LongSessions {
		add(GoStack, 1, "长连接长会话：每连接一个 goroutine、内存可控")
	}

	winner := GoStack
	switch {
	case javaPts > goPts:
		winner = JavaStack
	case javaPts == goPts && p.JavaExperience && !p.GoExperience:
		winner = JavaStack
	}

	return Verdict{Stack: winner, GoPts: goPts, JavaPts: javaPts, Reasons: reasons}
}

// Explain renders a verdict as a short human-readable block.
func (v Verdict) Explain() string {
	var b strings.Builder
	fmt.Fprintf(&b, "推荐栈：%s（Go %d 分 / Java %d 分）\n", v.Stack, v.GoPts, v.JavaPts)
	for _, r := range v.Reasons {
		fmt.Fprintf(&b, "  - %s\n", r)
	}
	return b.String()
}

// file: internal/matrix/scorer_test.go
// tier: L1
// verify: go test ./internal/matrix/
package matrix

import "testing"

func TestHighConnectionsWithoutJDK21PrefersGo(t *testing.T) {
	v := Recommend(Profile{Name: "老 JVM 网关", PeakConns: 50_000, JDK21: false})
	if v.Stack != GoStack {
		t.Fatalf("stack = %s, want Go", v.Stack)
	}
}

func TestLegacyJavaEstatePrefersJava(t *testing.T) {
	v := Recommend(Profile{Name: "存量 Java", LegacyJavaServices: true, JavaExperience: true})
	if v.Stack != JavaStack {
		t.Fatalf("stack = %s, want Java", v.Stack)
	}
}

func TestFastIterationGoTeamPrefersGo(t *testing.T) {
	v := Recommend(Profile{
		Name:               "Go 小团队",
		FastIteration:      true,
		GoExperience:       true,
		PeakConns:          20_000,
		JDK21:              true,
		TailLatencyMatters: true,
	})
	if v.Stack != GoStack {
		t.Fatalf("stack = %s, want Go", v.Stack)
	}
}

func TestTieGoesToExistingStack(t *testing.T) {
	v := Recommend(Profile{Name: "平局", GoExperience: true, JavaExperience: true})
	if v.GoPts != v.JavaPts {
		t.Fatalf("expected a tie, got Go=%d Java=%d", v.GoPts, v.JavaPts)
	}
	if v.Stack != GoStack {
		t.Fatalf("stack = %s, want Go on a tie with Go experience", v.Stack)
	}
}

// TestDawnRealmVerdict prints a full verdict for the book's running game, so the
// article can quote a real run instead of an invented one.
func TestDawnRealmVerdict(t *testing.T) {
	v := Recommend(Profile{
		Name:                "《晨曦大陆》新服",
		TeamSize:            8,
		GoExperience:        true,
		JDK21:               true,
		PeakConns:           30_000,
		TailLatencyMatters:  true,
		SyncDownstreamCalls: true,
		LegacyJavaServices:  true,
		FastIteration:       true,
		LongSessions:        true,
	})
	t.Logf("\n%s", v.Explain())
}

推荐栈：Go（Go 8 分 / Java 4 分）
  - Java +1：高连接数：JDK 21 虚拟线程与 goroutine 同量级
  - Go +2：P99 敏感：Go 默认堆小、停顿短，JVM 需额外调优
  - Go +1：同步调用下游：两栈都有栈，goroutine / 虚拟线程都安全
  - Java +3：存量账号 / 计费是 Java：同栈集成省掉跨栈序列化与联调
  - Go +2：快速迭代：单静态二进制、编译秒级、容器镜像小
  - Go +2：团队已有 Go 经验
  - Go +1：长连接长会话：每连接一个 goroutine、内存可控