Best Practices & Clean Code

// ===== 1) VORHER: zu lang, zu viele Verantwortlichkeiten =====
import java.util.logging.*;

public class BuchungsServiceVorher {
  private static final Logger LOG = Logger.getLogger(BuchungsServiceVorher.class.getName());

  public double buchenUndBenachrichtigen(String kundenId, String kursTitel, boolean online, double basisPreis) {
    // Validierung
    if (kundenId == null || kundenId.isBlank()) throw new IllegalArgumentException("Kunden-ID fehlt");
    if (kursTitel == null || kursTitel.isBlank()) throw new IllegalArgumentException("Kurs-Titel fehlt");
    if (basisPreis < 0) throw new IllegalArgumentException("Basispreis muss >= 0 sein");

    // Preislogik
    double preis = online ? basisPreis * 0.90 : basisPreis;

    // Persistenz (hier nur Demo)
    // ... INSERT booking

    // Logging
    LOG.info(() -> "Buchung ok | kunde=" + kundenId + " | kurs=" + kursTitel + " | preis=" + preis);

    // Benachrichtigung (Demo)
    // ... E-Mail senden

    return preis;
  }
}

// ===== 2) NACHHER: Responsibility Split + testbar =====
import java.util.logging.*;

public class BuchungsServiceNachher {
  private static final Logger LOG = Logger.getLogger(BuchungsServiceNachher.class.getName());

  private final PreisService preisService;
  private final BuchungsRepository repo;

  public BuchungsServiceNachher(PreisService preisService, BuchungsRepository repo) {
    this.preisService = preisService;
    this.repo = repo;
  }

  public double buchenUndBenachrichtigen(String kundenId, String kursTitel, boolean online, double basisPreis) {
    validieren(kundenId, kursTitel, basisPreis);

    double preis = preisBerechnen(online, basisPreis);
    speichern(kundenId, kursTitel, preis);
    erfolgLoggen(kundenId, kursTitel, preis);

    // Benachrichtigung wäre eine separate Abhängigkeit (z.B. NotificationService)
    return preis;
  }

  private void validieren(String kundenId, String kursTitel, double basisPreis) {
    if (kundenId == null || kundenId.isBlank()) throw new IllegalArgumentException("Kunden-ID fehlt");
    if (kursTitel == null || kursTitel.isBlank()) throw new IllegalArgumentException("Kurs-Titel fehlt");
    if (basisPreis < 0) throw new IllegalArgumentException("Basispreis muss >= 0 sein");
  }

  private double preisBerechnen(boolean online, double basisPreis) {
    RabattTyp typ = online ? RabattTyp.ONLINE_10_PROZENT : RabattTyp.KEINER;
    return preisService.endpreis(basisPreis, typ);
  }

  private void speichern(String kundenId, String kursTitel, double preis) {
    repo.speichern(new Buchung(kundenId, kursTitel, preis));
  }

  private void erfolgLoggen(String kundenId, String kursTitel, double preis) {
    LOG.info(() -> "Buchung ok | kunde=" + kundenId + " | kurs=" + kursTitel + " | preis=" + preis);
  }
}

record Buchung(String kundenId, String kursTitel, double preis) {}
enum RabattTyp { KEINER, ONLINE_10_PROZENT }

interface BuchungsRepository { void speichern(Buchung b); }

class PreisService {
  double endpreis(double basisPreis, RabattTyp typ) {
    if (basisPreis < 0) throw new IllegalArgumentException("Basispreis muss >= 0 sein");
    return (typ == RabattTyp.ONLINE_10_PROZENT) ? basisPreis * 0.90 : basisPreis;
  }
}

// ===== 3) Tests: Happy Path + Fehlerfall =====
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.*;

class BuchungsServiceNachherTest {

  @Test
  void buchen_online_hat10ProzentRabatt_undSpeichert() {
    FakeRepo repo = new FakeRepo();
    BuchungsServiceNachher svc = new BuchungsServiceNachher(new PreisService(), repo);

    double preis = svc.buchenUndBenachrichtigen("K-100", "Java Fortgeschritten", true, 1000.0);

    assertEquals(900.0, preis, 0.0001);
    assertNotNull(repo.last);
    assertEquals("K-100", repo.last.kundenId());
    assertEquals("Java Fortgeschritten", repo.last.kursTitel());
    assertEquals(900.0, repo.last.preis(), 0.0001);
  }

  @Test
  void buchen_wirftWennKundenIdFehlt() {
    FakeRepo repo = new FakeRepo();
    BuchungsServiceNachher svc = new BuchungsServiceNachher(new PreisService(), repo);

    assertThrows(IllegalArgumentException.class,
      () -> svc.buchenUndBenachrichtigen(" ", "Java Fortgeschritten", false, 1000.0)
    );
  }

  static class FakeRepo implements BuchungsRepository {
    Buchung last;
    public void speichern(Buchung b) { this.last = b; }
  }
}

// ===== 4) Review-Checkliste (pragmatisch) =====
1) Methoden machen genau eine Sache (klein, fokussiert).
2) Namen erklären die Absicht (keine kryptischen Kürzel, keine Magic Numbers).
3) Kritische Logik ist getestet (Happy Path + mind. ein Fehlerfall).
4) Logging ist kontextreich, aber sparsam (richtiges Level, keine sensiblen Daten).
5) Abhängigkeiten bleiben klein (keine unnötige Kopplung, klare Schnittstellen).

Gate-Idee:
- Tests müssen grün sein (CI), sonst kein Merge.