Spring Boot vs. Plain Java: Den richtigen Backend-Stack wählen

Du musst einen Backend-Service in Java bauen. Solltest du zu Spring Boot greifen oder es einfach halten mit Plain Java und dem eingebauten HTTP-Server? Diese Wahl beeinflusst Startzeit, Speicherbedarf, Dependency-Management und wie schnell du ausliefern kannst. Dieser Artikel schlüsselt die Trade-offs auf, damit du das richtige Tool für dein Projekt wählst.

Was „Plain Java“ für ein Backend bedeutet

Plain Java bedeutet hier die Nutzung des im JDK eingebauten com.sun.net.httpserver.HttpServer oder einer leichtgewichtigen Bibliothek wie Javalin oder Spark, ohne ein vollständiges Framework. Du schreibst dein eigenes Routing, JSON-Parsing (z. B. mit Jackson) und Dependency-Wiring. Das Ergebnis ist eine minimale, schnell startende Anwendung mit wenigen Abhängigkeiten.

Was Spring Boot bietet

Spring Boot ist ein opinionated Framework, das Spring MVC, eingebettetes Tomcat, Auto-Konfiguration und ein riesiges Ökosystem (Spring Data, Spring Security, Spring Cloud) bündelt. Es übernimmt Routing, Dependency Injection, Konfiguration und produktionsreife Features wie Health Checks und Metriken out of the box.

Wichtige Unterschiede auf einen Blick

Wann du Spring Boot wählen solltest

Spring Boot glänzt, wenn deine Anwendung Folgendes braucht:

• Schnelle Entwicklung mit Auto-Konfiguration und Startern.
• Integration mit Datenbanken (JPA), Sicherheit (OAuth2) und Messaging (Kafka).
• Produktionsreife über Actuator-Endpunkte für Health, Metriken und Tracing.
• Zusammenarbeit in großen Teams mit konsistenten Konventionen.

Wenn du eine typische CRUD-API mit Authentifizierung baust, spart dir Spring Boot Wochen an Boilerplate.

Wann du Plain Java wählen solltest

Plain Java ist besser geeignet, wenn:

• Startzeit und Speicher kritisch sind (z. B. Serverless, Edge oder CLI-Tools).
• Du volle Kontrolle über jede Abhängigkeit und Konfiguration willst.
• Der Service klein und fokussiert ist, wie ein Webhook-Empfänger oder ein einfacher Proxy.
• Du Backend-Grundlagen lernst und keine Framework-Magie willst.

Code-Vergleich: Eine einfache JSON-API

Schauen wir, wie jeder Ansatz einen einfachen GET /hello-Endpunkt handhabt, der JSON zurückgibt.

Spring Boot

@RestController
public class HelloController {
    @GetMapping("/hello")
    public Map<String, String> hello() {
        return Map.of("message", "Hello, World!");
    }
}

Mit Spring Boot annotierst du einfach und startest. Das Framework übernimmt Serialisierung, Routing und Server-Setup.

Plain Java (com.sun.net.httpserver)

public class HelloServer {
    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
        server.createContext("/hello", exchange -> {
            String response = "{\"message\":\"Hello, World!\"}";
            exchange.getResponseHeaders().set("Content-Type", "application/json");
            exchange.sendResponseHeaders(200, response.length());
            try (OutputStream os = exchange.getResponseBody()) {
                os.write(response.getBytes());
            }
        });
        server.start();
    }
}

Plain Java erfordert manuelle JSON-String-Konstruktion und Response-Handling. Für komplexere APIs würdest du eine JSON-Bibliothek und einen Router hinzufügen.

Performance und Ressourcennutzung

Spring Boots eingebetteter Server und Auto-Konfiguration fügen Overhead hinzu. Eine minimale Spring-Boot-App nutzt typischerweise 200–500 MB Heap und startet in 1–5 Sekunden. Plain Java mit dem eingebauten HTTP-Server kann in unter 100 ms starten und nur 20–50 MB nutzen. Wenn du viele Instanzen deployst oder eine Serverless-Plattform nutzt, macht dieser Unterschied viel aus.

Ökosystem und Tooling

Spring Boot bietet ein reichhaltiges Ökosystem: Spring Data für Datenbanken, Spring Security für Auth, Spring Cloud für Microservices. Es integriert sich auch nahtlos in Build-Tools (Maven/Gradle) und IDEs. Plain Java überlässt es dir, deinen eigenen Stack zusammenzustellen, was befreiend, aber zeitaufwendig sein kann.

Entscheidungshilfe: Was solltest du wählen?

1. Bewerte die Projektkomplexität. Wenn du mehrere Integrationen brauchst (DB, Auth, Messaging), gewinnt Spring Boot.
2. Berücksichtige die Deployment-Umgebung. Für Serverless oder Edge ist der geringe Overhead von Plain Java vorteilhaft.
3. Bewerte die Team-Erfahrung. Teams, die mit Spring vertraut sind, werden damit produktiver sein.
4. Prototype beides. Baue einen kleinen Endpunkt in jedem Ansatz, um den Unterschied zu spüren.

FAQ

Kann ich Spring Boot für einen einfachen Microservice nutzen?

Ja, aber sei dir des Ressourcen-Overheads bewusst. Wenn der Service wirklich minimal ist und du einen schnellen Start brauchst, könnte Plain Java effizienter sein. Spring Boot ist immer noch eine valide Wahl, wenn du sein Ökosystem schätzt und den Footprint nicht mindest.

Ist Plain Java schnell genug für die Produktion?

Absolut. Javas eingebauter HTTP-Server ist für viele Anwendungsfälle produktionsreif, besonders in Kombination mit einem Reverse Proxy wie Nginx. Du musst jedoch Features wie Routing, JSON-Handling und Sicherheit selbst implementieren.

Wie migriere ich von Plain Java zu Spring Boot?

Beginne damit, deine Kernkomponenten zu identifizieren: HTTP-Handler, JSON-Serialisierung und Konfiguration. Spring Boots Starter können viel von deinem manuellen Code ersetzen. Migriere inkrementell, vielleicht indem du deine bestehende Logik in Spring-Controller packst.

Abschließende Gedanken

Es gibt keine Einheitslösung. Spring Boot beschleunigt die Entwicklung für komplexe Anwendungen, während Plain Java dir Kontrolle und Effizienz für einfachere, performance-sensitive Services gibt. Bewerte die Bedürfnisse deines Projekts, die Fähigkeiten deines Teams und die Deployment-Ziele, um die richtige Entscheidung zu treffen.

Wenn du bereit bist, deine Backend-Logs zu analysieren, probiere unseren Nginx Log Analyzer, um Einblicke in Traffic und Fehler zu gewinnen.