Java & Spring Boot: Spaß trotz Java

Vorwort (oder: „Ich mag Java nicht, aber…“)

Wenn Du Java nicht magst, bist Du in bester Gesellschaft. Java ist wie ein schwerer Einsatzrucksack: nicht hübsch, gnadenlos unbequem, aber wenn’s ernst wird, willst Du genau dieses Ding dabei haben.

Und dann kommt Spring Boot.

Spring Boot ist quasi das Tragesystem, das plötzlich alles richtig sitzen lässt: weniger Schrauben, weniger Gefluche, mehr „läuft einfach“.

Ziel dieses Artikels:

Java grob verstehen (ohne Trauma)
Spring Boot verstehen (mit Lust auf mehr)
praxisnah starten (REST + DB + Migration + Betrieb)
sehen, warum Spring Boot „reines Java“ massiv entschärft

Java in 10 Minuten (ohne dass es weh tut)

Was Java eigentlich ist

Java ist Sprache + Laufzeitumgebung (JVM). Du kompilierst Quellcode zu Bytecode, der auf der JVM läuft. Das bringt zwei sehr praktische Dinge:

Portabilität: läuft überall, wo eine JVM läuft.
Reife: Tooling, Libraries, Betrieb, Monitoring – alles ist seit Jahren da und überall erprobt.

Java ist selten „cool“. Java ist „verlässlich“. Und bei langen Lebenszyklen ist Verlässlichkeit eine Superkraft.

Was Java nervig macht

viel Boilerplate (Getter/Setter, Konstruktoren, DTOs…)
„Warum brauche ich dafür drei Klassen?“
ohne Framework musst Du Infrastruktur selbst bauen

Spring Boot ist die Antwort auf genau diese Schmerzpunkte.

Spring vs. Spring Boot (kurz, klar, lebensnah)

Spring (Framework)

Spring liefert Dir u. a.:

Dependency Injection: weniger new, mehr Logik
Komponentenmodell: Services, Repositories, Controller
saubere Patterns für Architektur (wenn man sie nutzt)

Spring Boot (Aufsatz)

Spring Boot liefert Dir u. a.:

Autokonfiguration („Konvention vor Konfiguration“)
Starter-Abhängigkeiten („Web? DB? Security? Nimm Starter.“)
eingebetteten Server (Du startest eine JAR, fertig)
Actuator (Health/Info/Metrics Endpunkte)
DevTools (Auto-Restart im Dev-Betrieb)

Spring Boot macht Spring für Normalsterbliche:

„Du willst eine App? Hier ist die App. Und jetzt ab in die Logik.“

Starten ohne Leid: Spring Initializr

Du erzeugst Dein Projekt am bequemsten mit Spring Initializr:

https://start.spring.io/

Empfohlene Auswahl zum Start:

Project: Maven (oder Gradle)
Language: Java
Dependencies:
- Spring Web
- Spring Data JPA
- Validation
- Actuator
- (optional) DevTools
- (optional) Flyway Migration

Dann ZIP herunterladen und in Deine IDE importieren.

Dein erster Erfolg in 3 Minuten: eine Mini-REST-API

1) Controller

import java.time.Instant;
import java.util.Map;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/ping")
public class PingController {

@GetMapping
public Map<String, Object> ping() {
return Map.of(
"status", "ok",
"timestamp", Instant.now().toString()
);
}
}

2) Starten

Maven Wrapper: ./mvnw spring-boot:run
Test: GET http://localhost:8080/api/ping

Und ja: Du hast gerade eine Web-App gestartet, ohne Tomcat zu installieren. Genau darum geht’s.

Der „Das ist ja unfair“-Moment: Datenbank ohne SQL-Orgie

Ein Helfer hatte es schon begeistert beschrieben:

„Ich code nur den Tabellenzugriff, und die Tabelle entsteht automatisch.“

Das ist genau der Punkt, an dem Spring Boot plötzlich Spaß macht.

1) Entity (Datenobjekt)

import jakarta.persistence.*;

@Entity
@Table(name = "asset")
public class Asset {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(nullable = false)
private String name;

private String status;

public Long getId() { return id; }
public void setId(Long id) { this.id = id; }

public String getName() { return name; }
public void setName(String name) { this.name = name; }

public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
}

Ja, Boilerplate ist immer noch da. Aber: Wir sind gleich bei den entscheidenden Vorteilen.

2) Repository (Tabellenzugriff ohne DAO, ohne SQL)

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AssetRepository extends JpaRepository<Asset, Long> {
List<Asset> findByStatus(String status);
}

Das ist der Magic-Moment:

kein DAO-Gerüst
kein SQL für Standardfälle
keine Implementierungsklasse

Du definierst nur ein Interface, Spring liefert den Rest.

3) Service (Logik)

import java.util.List;
import org.springframework.stereotype.Service;

@Service
public class AssetService {

private final AssetRepository repo;

public AssetService(AssetRepository repo) {
this.repo = repo;
}

public List<Asset> list() {
return repo.findAll();
}
}

Hier siehst Du DI (Dependency Injection) in schön:

Du baust keine Instanzen zusammen
Du beschreibst Abhängigkeiten
Spring verkabelt das zur Laufzeit

Schema automatisch erzeugen (Dev-Modus)

Wenn Du „Tabelle automatisch erstellen“ willst, geht das im Entwicklungsbetrieb z. B. so:

spring:
jpa:
hibernate:
ddl-auto: update

Was passiert:

Hibernate schaut auf Deine Entities
und versucht, das Schema anzupassen

Wichtig:

Das ist im Dev-Betrieb super.
Für Produktion ist es riskant.

Im Produktivbetrieb willst Du kontrollierte Migrationen.

„Automatische Updates beim Start“ (professionell): Flyway

Wenn Du möchtest, dass Datenbankänderungen sauber und nachvollziehbar laufen, nimm Migrationen.

Mit Flyway:

Du legst SQL-Dateien an
Spring Boot führt sie beim Start in Reihenfolge aus
Flyway merkt sich, was schon gelaufen ist

Beispiel: src/main/resources/db/migration/V1__init.sql

create table asset (
id bigserial primary key,
name text not null,
status text
);

Das ist die erwachsene Version von „macht die DB schon irgendwie“:

reproduzierbar
auditierbar
rollback- und release-freundlich

Betrieb: eine JAR, fertig

Spring Boot kann als einzelne JAR ausgeliefert werden.

Build:

./mvnw clean package

Start:

java -jar target/deinprojekt.jar`

Das passt hervorragend zu:

Offline-Deployment (USB, internes Repo)
on-prem Betrieb (Debian/Windows)
klaren Versionen und Rollbacks

Actuator: „Läuft das Ding noch?“

Mit spring-boot-starter-actuator bekommst Du Endpunkte wie:

/actuator/health
/actuator/info

Das ist für Betrieb und Monitoring ein echter Gamechanger:

Health Checks
Metriken
schnelle Diagnose

Profiles: ein System, mehrere Welten

Du willst oft:

Dev: viel Logging, schnelle Iteration
Prod: harte Defaults, saubere Logs, stabile DB

Mit Profiles:

application.yml:

spring:
profiles:
active: dev

application-prod.yml:

spring:
datasource:
url: jdbc:postgresql://...

So bleibt die App gleich, aber Umgebung und Betrieb können wechseln.

Warum Spring Boot „Spaß machen“ kann

Weil Du schnell bei echten Ergebnissen bist:

REST-API in Minuten
DB-Zugriff ohne SQL-Orgie
Start/Stop wie ein normales Programm
Betrieb ist „normal“ (Logs, Health, Config)

Java bleibt Java.

Aber Spring Boot nimmt Dir einen großen Teil von dem weg, was „Java nervig“ macht.

Mini-Roadmap zum Selbermachen

Projekt per Initializr anlegen (Web + JPA + Actuator)
Eine Entity + Repository + Controller bauen
ddl-auto=update im Dev nutzen
Sobald es „ernst“ wird: Flyway aktivieren
Actuator in Monitoring hängen
Release als JAR bauen, offline verteilen

Deutschsprachige Video-Tutorials (Beispiele)

Hinweis: Das sind Beispiele für Einstieg und Setup. Such Dir den Stil raus, der Dir liegt.

Spring Boot Tutorial 2021 (Deutsch) – Einführung (Christian Trutz) https://www.youtube.com/watch?v=_LXnzOJD5zI
Spring-Boot Tutorial #1 (Deutsch) – Projekt erstellen (Desert Boat) https://www.youtube.com/watch?v=wt_ymD8wrRw

Lesestoff (Deutsch)

Wenn Du lieber Buch statt Video willst:

Spring Boot 3 – So geht moderne Java-Entwicklung (dpunkt.verlag) https://dpunkt.de/produkt/spring-boot-3/

Schlusswort

Du musst Java nicht lieben.

Du musst nur akzeptieren, dass langlebige on-prem Systeme selten aus „Hype“ gebaut werden, sondern aus Werkzeugen, die im Betrieb funktionieren.

Spring Boot macht Java nicht sexy.

Aber es macht Java praktisch.

Und praktisch gewinnt.