Go: Mehr als nur ein Hype? – Ein Erfahrungsbericht aus der Java-Welt

Die Welt der Backend-Entwicklung wird von etablierten und mächtigen Programmiersprachen wie C# oder Java mit Frameworks wie Spring Boot dominiert. Doch auch neue Sprachen werden veröffentlicht und versprechen innovative Ansätze. Eine davon ist Go (oder Golang) von Google. Eine Programmiersprache, die für ihre Einfachheit, Performance und exzellente Unterstützung für nebenläufige Prozesse bekannt ist.

Doch wie fühlt sich der Praxistest einer/eines erfahrenen Java-Entwickler:in an? Was sind die Stärken und Hürden von Go, für welche Szenarien eignet es sich und was bleibt als Fazit?

Der Sprung ins kalte Wasser: Stärken und überraschende Hürden

Um es vorwegzunehmen: Go ist aktuell kein direkter Konkurrent von Java, aber es besitzt einzigartige Stärken, die es für bestimmte Anwendungsfälle im Vergleich zu Java sehr interessant machen.

Obwohl Java durch sein riesiges Ökosystem in vielen Bereichen vorne liegt, gibt es drei Aspekte, in denen Go besonders glänzt:

• Deployment als ultra-schlankes Docker-Image: Dies ist das herausragende Merkmal von Go im DevOps-Umfeld. Go-Anwendungen werden zu einer einzigen, statisch gelinkten Binärdatei kompiliert. Das bedeutet: keine JVM, keine riesigen Basis-Images, keine Abhängigkeitskonflikte zur Laufzeit. Die Ergebnisse sind minimale Docker-Images (oft unter 20 MB), die extrem schnell starten und wenig Ressourcen verbrauchen (siehe Listing 3). Im Vergleich zu einem typischen Java-Container ist das ein gewaltiger Effizienzgewinn.
• Einfache und performante REST-Schnittstellen: Mit der mächtigen Standardbibliothek (net/http) und leichtgewichtigen Routing-Bibliotheken wie gorilla/mux lassen sich performante REST-APIs mit minimalem Code-Aufwand erstellen. Anders als bei großen Frameworks verzichtet Go hier bewusst auf intransparente Konventionen. Anstatt auf Annotations zu vertrauen, die viel Funktionalität im Hintergrund verbergen, wird jede Route explizit mit einer Handler-Funktion verknüpft (siehe Listing 1). Die Resultate sind nicht nur performante, sondern auch außergewöhnlich gut wart- und debugbare Services, da der Kontrollfluss stets klar und nachvollziehbar bleibt.
• Unkompliziertes Datenbankmanagement: Das database/sql-Standardpaket bietet eine robuste und einheitliche Grundlage für Datenbankinteraktionen. Zwar existieren auch für Go ORM-Bibliotheken, doch fühlt sich deren Einsatz im Vergleich zur Java-Welt oft weniger ausgereift an. Wo in Java mächtige Werkzeuge wie QueryDSL typsichere und flüssige Abfragen ermöglichen, ist in Go das Schreiben von purem SQL häufig der direktere und wartbarere Weg. Dieser Ansatz vermeidet eine zusätzliche Abstraktionsebene (die in Go nach meiner Erfahrung mehr Reibung erzeugen als nutzen würde) und gibt die volle Kontrolle über die Performance der Abfragen zurück an den Entwickler:innen.

// main.go
r := mux.NewRouter()
basePath := fmt.Sprintf("/changelog_%s", cfg.EnvironmentName)
subrouter := r.PathPrefix(basePath).Subrouter()

subrouter.HandleFunc("/changelog/{appName}", app.getChangelogHandler).Methods("GET")
subrouter.HandleFunc("/health", app.healthHandler).Methods("GET") 

Listing 1: Definition von API-Routen in Go 

Java profitiert von seiner jahrzehntelangen Entwicklung und einem riesigen Ökosystem. Folgende sind die Bereiche, in denen der Umstieg von Java auf Go eine Umgewöhnung erfordert:

• Fehlerbehandlung ohne try-catch: Dies ist die größte philosophische Hürde. Statt Ausnahmen (Exceptions) abzufangen, geben Go-Funktionen explizit einen error-Wert zurück. Das führt zum allgegenwärtigen if err != nil-Muster (siehe Listing 2). Anfangs wirkt dies repetitiv und umständlich im Vergleich zur Eleganz von try-catch-Blöcken. Es erzwingt jedoch eine bewusste und sofortige Auseinandersetzung mit jedem potenziellen Fehler, was die Code-Robustheit erhöhen kann.
• Pragmatische Patterns statt komplexer Abstraktionen: Die Java-Kultur, insbesondere im Enterprise-Umfeld, neigt zur Nutzung elaborierter Design-Patterns, die oft zu tiefen Abstraktionsebenen führen. Go hingegen leitet Entwickler:innen durch seine Sprachfeatures zu einfacheren und direkteren Lösungen. Anstelle komplexer Vererbungshierarchien wird Komposition durch das Einbetten von Structs bevorzugt. Ein gängiges Muster ist die zentrale Bündelung von Abhängigkeiten in einer einzigen App-Struktur, die beim Programmstart explizit initialisiert wird. Dies schafft einen klaren und leicht nachvollziehbaren Abhängigkeitsgraphen, der ohne die Komplexität eines externen Frameworks auskommt.
• Testing und Mocking: Go besitzt ein solides, integriertes Testing-Framework. Für komplexere Szenarien wie das Mocking von externen Diensten (z. B. der GitLab-API) sind jedoch externe Bibliotheken wie testify/mock notwendig. Das Zusammenspiel fühlt sich im Vergleich zum etablierten Duo JUnit und Mockito in der Java-Welt weniger nahtlos an. Das Erstellen von Mocks erfordert mehr Boilerplate-Code und eine präzise Definition von Interfaces.
• Fehlendes Ökosystem für Enterprise-Features: Für viele Standardprobleme im Unternehmensumfeld (z. B. komplexe Security-Frameworks, verteilte Transaktionen, grafische Admin-Oberflächen) bietet das Java-Ökosystem fertige, ausgereifte Lösungen. In Go muss man oft auf spezialisierte Bibliotheken zurückgreifen oder mehr Funktionalität selbst implementieren.

git, err := gitlab.NewClient(token, options...)
if err != nil {
    return nil, fmt.Errorf("failed to create gitlab client: %w", err)
}
return git, nil  

Listing 2: Typisches Muster der Fehlerbehandlung in Go

Praktische Einsatzszenarien: Wann ist Go die richtige Wahl?

Basierend auf dieser Analyse ergeben sich klare Szenarien, in denen Go eine überlegenswerte Option ist:

• Performance-kritische Microservices und Netzwerkdienste: Wenn es auf geringe Latenz, hohe Nebenläufigkeit und minimalen Ressourcenverbrauch ankommt, spielt Go seine Stärken voll aus.
• Kommandozeilen-Tools (CLI): Die Kompilierung zu einer einzigen Binärdatei macht Go zur perfekten Wahl für die Erstellung von plattformübergreifenden CLI-Tools.
• DevOps und Infrastruktur-nahe Projekte: Der kleine Footprint der Docker-Images und die schnelle Startzeit sind ideal für den Einsatz in CI/CD-Pipelines, als Proxy oder in Serverless-Umgebungen.
• Projekte, bei denen Einfachheit und Lesbarkeit wichtiger sind als ein riesiges, komplexes Framework: Go zwingt Entwickler:innen zu einem klaren und expliziten Stil, der die Wartbarkeit fördert.

Go ist hingegen weniger geeignet für große, monolithische Unternehmensanwendungen, bei denen ein umfangreiches, integriertes Framework wie Spring Boot die Entwicklungsgeschwindigkeit durch Konventionen und ein riesiges Ökosystem beschleunigt.

Fazit: Ein mächtiges Werkzeug, das man im Repertoire haben sollte

Go ist eine beeindruckende Sprache, die ihre Design-Ziele – Einfachheit, Performance und Effizienz im Bereich Nebenläufigkeit – konsequent umsetzt. Es ist keine Kopie von Java, sondern eine eigenständige Lösung mit einem klaren Fokus auf schlanke, performante Netzwerkdienste und Systemprogrammierung, die stark von C beeinflusst ist.

Aktuell ist Java mit seiner Vielzahl an umfangreichen und stabilen Frameworks, wie Spring Boot, für viele komplexe Unternehmensanwendungen die reifere und umfassendere Wahl. Doch für die richtigen Nischen – Microservices, CLI-Tools und DevOps-Projekte – bietet Go schon heute eine wirklich gute Alternative.

Die endgültige Empfehlung lautet daher: Go ist kein Ersatz, sondern eine wertvolle Ergänzung. Für Java-Entwickler:innen lohnt sich der Blick über den Tellerrand, um zu verstehen, wann der pragmatische und ressourcenschonende Ansatz von Go die bessere Lösung für ein Problem darstellt. Damit etabliert sich Go nicht nur als eine weitere Option, sondern als strategische Wahl für die Anforderungen der Cloud-native-Ära, in der Effizienz und Performance entscheidende Wettbewerbsvorteile sind.

Seminarempfehlungen