Enterprise Java als echtes Lesebuch.

<properties>
    <!-- Enterprise-Regel: eine Java-Version bewusst festlegen, nicht implizit vom lokalen JDK erben. -->
    <maven.compiler.release>21</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.14.1</version>
        </plugin>
    </plugins>
</build>

public record PlaceOrderCommand(CustomerId customerId, List<Line> lines) {
    public PlaceOrderCommand {
        Objects.requireNonNull(customerId, "customerId");
        lines = List.copyOf(lines);
        if (lines.isEmpty()) throw new IllegalArgumentException("lines must not be empty");
    }

    public record Line(String sku, int quantity) {}
}

public sealed interface OrderFailure permits ValidationFailure, BusinessFailure, TechnicalFailure {}

public record ValidationFailure(String field, String message) implements OrderFailure {}
public record BusinessFailure(String code, String message) implements OrderFailure {}
public record TechnicalFailure(String system, String message, boolean retryable) implements OrderFailure {}

// Pattern: Result Object - erwartbare Fehler werden explizit modelliert statt als Zufalls-Exception geworfen.
public record Result<T>(T value, OrderFailure failure) {
    public static <T> Result<T> ok(T value) { return new Result<>(value, null); }
    public static <T> Result<T> fail(OrderFailure failure) { return new Result<>(null, failure); }
    public boolean isOk() { return failure == null; }
}

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

order-platform
├── order-domain          # reine Fachlichkeit, keine Frameworks
├── order-application     # Use Cases, Ports, Transaktionsabstraktion
├── order-adapter-jpa     # JPA/Hibernate Implementierung
├── order-adapter-rest    # REST Controller / DTO Mapping
└── order-boot            # Runtime, DI, Konfiguration, Startklasse

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;

@ApplicationScoped
public class InvoiceApplicationService {
    @Inject InvoiceRepository invoices;
    @Inject OrderClient orders;
    @Inject DomainEventPublisher events;

    // Pattern: Transaction Script an der Use-Case-Grenze - bewusst hier, nicht im Controller.
    @Transactional
    public InvoiceId createInvoiceFor(OrderId orderId) {
        OrderSnapshot order = orders.load(orderId);
        Invoice invoice = Invoice.from(order);
        invoices.persist(invoice);
        events.publish(new InvoiceCreated(invoice.id(), orderId));
        return invoice.id();
    }
}

@Path("/invoices")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class InvoiceResource {
    @Inject InvoiceApplicationService service;

    @POST
    public Response create(CreateInvoiceRequest request) {
        InvoiceId id = service.createInvoiceFor(request.orderId());
        return Response.created(URI.create("/invoices/" + id.value()))
            .entity(new CreateInvoiceResponse(id.value()))
            .build();
    }
}

@RestController
@RequestMapping("/api/orders")
class OrderController {
    private final PlaceOrderUseCase placeOrder;

    OrderController(PlaceOrderUseCase placeOrder) {
        this.placeOrder = placeOrder;
    }

    @PostMapping
    ResponseEntity<OrderResponse> create(@Valid @RequestBody PlaceOrderRequest request) {
        OrderId id = placeOrder.handle(request.toCommand());
        URI location = URI.create("/api/orders/" + id.value());
        return ResponseEntity.created(location).body(new OrderResponse(id.value()));
    }
}

@Configuration
class OrderModuleConfiguration {
    @Bean
    PlaceOrderUseCase placeOrderUseCase(
            OrderRepository repository,
            DomainEventPublisher eventPublisher,
            PricingPolicy pricingPolicy) {
        return new PlaceOrderUseCase(repository, eventPublisher, pricingPolicy);
    }

    @Bean
    PricingPolicy pricingPolicy(ProductCatalogClient catalog) {
        // Pattern: Adapter + Strategy - Preisstrategie kann pro Kontext ausgetauscht werden.
        return new CatalogBackedPricingPolicy(catalog);
    }
}

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  endpoint:
    health:
      probes:
        enabled: true
      show-details: when_authorized

@Path("/orders")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class OrderResource {
    @Inject PlaceOrderUseCase placeOrder;

    @POST
    @Transactional
    public Response create(@Valid PlaceOrderRequest request) {
        OrderId id = placeOrder.handle(request.toCommand());
        return Response.created(URI.create("/orders/" + id.value())).build();
    }
}

@ApplicationScoped
public class PartnerRatingClient {
    @Inject
    @RestClient PartnerApi partnerApi;

    @Retry(maxRetries = 3, delay = 250)
    @Timeout(1000)
    @Fallback(fallbackMethod = "fallbackRating")
    public PartnerRating loadRating(String partnerId) {
        return partnerApi.rating(partnerId);
    }

    PartnerRating fallbackRating(String partnerId) {
        return PartnerRating.unknown(partnerId);
    }
}

@Controller("/orders")
class OrderController {
    private final PlaceOrderUseCase placeOrder;

    OrderController(PlaceOrderUseCase placeOrder) {
        this.placeOrder = placeOrder;
    }

    @Post
    HttpResponse<OrderResponse> create(@Body @Valid PlaceOrderRequest request) {
        OrderId id = placeOrder.handle(request.toCommand());
        return HttpResponse.created(new OrderResponse(id.value()));
    }
}

package com.example.order.domain;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.UUID;

// Pattern: Aggregate Root - Order schützt die Konsistenz der Positionsliste und Statusübergänge.
public class Order {
    private final OrderId id;
    private final CustomerId customerId;
    private final List<OrderLine> lines = new ArrayList<>();
    private OrderStatus status = OrderStatus.DRAFT;

    public Order(OrderId id, CustomerId customerId) {
        this.id = Objects.requireNonNull(id);
        this.customerId = Objects.requireNonNull(customerId);
    }

    public static Order draftFor(CustomerId customerId) {
        return new Order(new OrderId(UUID.randomUUID()), customerId);
    }

    public void addLine(String sku, int quantity, BigDecimal unitPrice) {
        if (status != OrderStatus.DRAFT) {
            throw new IllegalStateException("Only draft orders can be changed");
        }
        if (quantity <= 0 || unitPrice.signum() < 0) {
            throw new IllegalArgumentException("Quantity and price must be valid");
        }
        lines.add(new OrderLine(sku, quantity, unitPrice));
    }

    public void place() {
        if (lines.isEmpty()) throw new IllegalStateException("Order must contain at least one line");
        status = OrderStatus.PLACED;
    }

    public BigDecimal total() {
        return lines.stream()
            .map(OrderLine::lineTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

// Problem: N+1 Queries, wenn jede Order später lazy ihre Lines lädt.
List<OrderEntity> orders = entityManager
    .createQuery("select o from OrderEntity o", OrderEntity.class)
    .getResultList();

orders.forEach(o -> log.info("{} lines", o.getLines().size()));

// Besser für Lese-Use-Case: gezielte Fetch-Strategie oder Projektion.
List<OrderSummary> summaries = entityManager
    .createQuery("""
        select new com.example.OrderSummary(o.id, c.name, sum(l.quantity * l.unitPrice))
        from OrderEntity o
        join o.customer c
        join o.lines l
        group by o.id, c.name
        """, OrderSummary.class)
    .getResultList();

-- V30260707_01__create_order_tables.sql
create table orders (
    id uuid primary key,
    customer_id uuid not null,
    status varchar(30) not null,
    version bigint not null default 0,
    created_at timestamp not null
);

create table order_lines (
    id uuid primary key,
    order_id uuid not null references orders(id),
    sku varchar(80) not null,
    quantity integer not null check (quantity > 0),
    unit_price numeric(19,2) not null check (unit_price >= 0)
);

public class OrderPlacedConsumer {
    private final KafkaConsumer<String, OrderPlacedEvent> consumer;
    private final BillingService billing;

    public void pollLoop() {
        while (true) {
            ConsumerRecords<String, OrderPlacedEvent> records = consumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, OrderPlacedEvent> record : records) {
                try {
                    billing.createInvoice(record.value());
                    consumer.commitSync(Map.of(record.topicPartition(), new OffsetAndMetadata(record.offset() + 1)));
                } catch (RecoverableBillingException ex) {
                    // Pattern: Retry / Dead Letter - nicht endlos denselben Datensatz blockieren.
                    retryOrSendToDlq(record, ex);
                }
            }
        }
    }
}

@Transactional
public void placeOrder(PlaceOrderCommand command) {
    Order order = orderFactory.create(command);
    order.place();
    orderRepository.save(order);

    // Pattern: Transactional Outbox - Event wird in derselben DB-Transaktion festgehalten.
    outboxRepository.append(new OutboxMessage(
        "OrderPlaced",
        order.id().value().toString(),
        json.serialize(OrderPlaced.from(order))
    ));
}

@WebService(targetNamespace = "urn:partner:rating:v1", name = "PartnerRatingPort")
public interface PartnerRatingPort {
    @WebMethod(operationName = "GetPartnerRating")
    PartnerRatingResponse getPartnerRating(PartnerRatingRequest request);
}

@WebService(endpointInterface = "com.example.partner.PartnerRatingPort")
public class PartnerRatingEndpoint implements PartnerRatingPort {
    private final PartnerRatingService service;

    @Override
    public PartnerRatingResponse getPartnerRating(PartnerRatingRequest request) {
        // Bind: SOAP/XML wurde bereits in Java-DTOs gemappt.
        // Process: hier beginnt die fachliche Verarbeitung.
        return PartnerRatingResponse.from(service.calculate(request.partnerId()));
    }
}

public interface PartnerRatingGateway {
    PartnerRating loadRating(PartnerId partnerId);
}

// Pattern: Anti-Corruption Layer - fremde SOAP-Strukturen bleiben außerhalb der Domain.
public class SoapPartnerRatingGateway implements PartnerRatingGateway {
    private final PartnerRatingPort port;

    @Override
    public PartnerRating loadRating(PartnerId partnerId) {
        PartnerRatingRequest request = PartnerRatingRequestMapper.toSoap(partnerId);
        PartnerRatingResponse response = port.getPartnerRating(request);
        return PartnerRatingMapper.toDomain(response);
    }
}

@Bean
SecurityFilterChain apiSecurity(HttpSecurity http) throws Exception {
    return http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers(HttpMethod.GET, "/actuator/health").permitAll()
            .requestMatchers("/api/admin/**").hasAuthority("SCOPE_admin")
            .requestMatchers("/api/orders/**").hasAuthority("SCOPE_orders")
            .anyRequest().authenticated())
        .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
        .csrf(csrf -> csrf.disable())
        .build();
}

public class CustomerAccessPolicy {
    // Pattern: Policy Object - fachliche Zugriffsregel ist testbar und nicht in Controller verstreut.
    public boolean canReadCustomer(UserPrincipal user, CustomerId customerId) {
        return user.hasScope("customers:read") &&
               (user.isEmployee() || user.customerIds().contains(customerId));
    }
}

public class OrderTracingService {
    private final Tracer tracer;

    public void placeOrder(PlaceOrderCommand command) {
        Span span = tracer.spanBuilder("order.place")
            .setAttribute("customer.id", command.customerId().value().toString())
            .startSpan();
        try (Scope ignored = span.makeCurrent()) {
            // Fachlogik bleibt gleich; Trace-Kontext wandert über HTTP/Kafka weiter.
            handle(command);
        } catch (Exception ex) {
            span.recordException(ex);
            span.setStatus(StatusCode.ERROR);
            throw ex;
        } finally {
            span.end();
        }
    }
}

@Testcontainers
class OrderRepositoryIT {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");

    @Test
    void persistsOrderWithLines() {
        OrderRepository repository = repositoryFor(postgres.getJdbcUrl());
        Order order = Order.draftFor(new CustomerId(UUID.randomUUID()));
        order.addLine("SKU-1", 2, new BigDecimal("19.90"));
        order.place();

        repository.save(order);

        assertThat(repository.findById(order.id())).isPresent();
    }
}

@AnalyzeClasses(packages = "com.example.order")
class ArchitectureRulesTest {
    @ArchTest
    static final ArchRule domain_is_framework_free = noClasses()
        .that().resideInAPackage("..domain..")
        .should().dependOnClassesThat().resideInAnyPackage(
            "org.springframework..", "jakarta.persistence..", "jakarta.ws.rs.."
        );

    @ArchTest
    static final ArchRule adapters_do_not_call_each_other = noClasses()
        .that().resideInAPackage("..adapter..")
        .should().dependOnClassesThat().resideInAPackage("..adapter..");
}

FROM eclipse-temurin:21-jre
WORKDIR /app
COPY target/order-service.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75", "-jar", "app.jar"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  selector:
    matchLabels: { app: order-service }
  template:
    metadata:
      labels: { app: order-service }
    spec:
      containers:
        - name: app
          image: registry.example.com/order-service:1.0.0
          ports: [{ containerPort: 8080 }]
          readinessProbe:
            httpGet: { path: /actuator/health/readiness, port: 8080 }
          livenessProbe:
            httpGet: { path: /actuator/health/liveness, port: 8080 }
          resources:
            requests: { cpu: "250m", memory: "512Mi" }
            limits: { cpu: "1", memory: "1024Mi" }

public InvoiceId createInvoice(CreateInvoiceRequest request) {
    validate(request);
    OrderSnapshot order = orderGateway.load(request.orderId());
    Invoice invoice = invoiceFactory.from(order);
    invoiceRepository.save(invoice);
    outbox.append(InvoiceCreated.from(invoice));
    return invoice.id();
}

public class OrderFacade {
    private final LegacyOrderService legacy;
    private final ModernOrderService modern;
    private final MigrationSwitch migrationSwitch;

    // Pattern: Facade + Strangler Fig - Aufrufer bleiben stabil, Implementierung wandert schrittweise.
    public OrderResponse placeOrder(PlaceOrderRequest request) {
        if (migrationSwitch.useModernPath(request.customerSegment())) {
            return modern.placeOrder(request);
        }
        return legacy.placeOrder(request);
    }
}

<properties>
  <maven.compiler.release>21</maven.compiler.release>
</properties>

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-toolchains-plugin</artifactId>
      <version>3.2.0</version>
      <executions>
        <execution>
          <goals><goal>toolchain</goal></goals>
        </execution>
      </executions>
      <configuration>
        <toolchains>
          <jdk>
            <version>21</version>
            <vendor>any</vendor>
          </jdk>
        </toolchains>
      </configuration>
    </plugin>
  </plugins>
</build>

public sealed interface MigrationRisk permits BuildRisk, RuntimeRisk, LibraryRisk {}

public record BuildRisk(String plugin, String reason) implements MigrationRisk {}
public record RuntimeRisk(String component, String reason) implements MigrationRisk {}
public record LibraryRisk(String dependency, String reason) implements MigrationRisk {}

public static String owner(MigrationRisk risk) {
    return switch (risk) {
        case BuildRisk ignored -> "Build/CI Team";
        case RuntimeRisk ignored -> "Platform Team";
        case LibraryRisk ignored -> "Application Team";
    };
}

java \
  -XX:StartFlightRecording=filename=/var/log/order/startup.jfr,dumponexit=true \
  -Xlog:gc*:file=/var/log/order/gc.log:time,uptime,level,tags \
  -XX:MaxRAMPercentage=75 \
  -jar order-service.jar

// Anti-Pattern: alle Datensätze laden und im Speicher filtern.
List<Order> all = orderRepository.findAll();
return all.stream().filter(Order::isOpen).toList();

// Besser: fachliche Query mit Limit und Sortierung.
return orderRepository.findOpenOrders(PageRequest.of(0, 100));

public interface OrderListProjection {
    UUID getId();
    String getCustomerNumber();
    BigDecimal getTotalAmount();
    Instant getCreatedAt();
}

interface OrderJpaRepository extends JpaRepository<OrderEntity, UUID> {
    List<OrderListProjection> findByStatusOrderByCreatedAtDesc(OrderStatus status);
}

public List<OrderListView> findOpenOrdersForDashboard() {
    return jdbcClient.sql("""
        select o.id, c.customer_number, o.total_amount, o.created_at
          from orders o
          join customers c on c.id = o.customer_id
         where o.status = :status
         order by o.created_at desc
         limit 100
        """)
        .param("status", "OPEN")
        .query(OrderListView.class)
        .list();
}

@RegisterRestClient(configKey = "customer-api")
public interface CustomerClient {
    @GET
    @Path("/customers/{id}")
    @Timeout(1000)
    @Retry(maxRetries = 2, delay = 100)
    CustomerDto find(@PathParam("id") String id);
}

@Readiness
@ApplicationScoped
public class DatabaseReadiness implements HealthCheck {
    public HealthCheckResponse call() {
        boolean ok = database.ping(Duration.ofSeconds(1));
        return HealthCheckResponse.named("database").status(ok).build();
    }
}

@Controller("/orders")
public class OrderController {
    private final PlaceOrderUseCase placeOrder;

    public OrderController(PlaceOrderUseCase placeOrder) {
        this.placeOrder = placeOrder;
    }

    @Post
    HttpResponse<IdResponse> place(@Body PlaceOrderRequest request) {
        OrderId id = placeOrder.place(request.toCommand());
        return HttpResponse.created(new IdResponse(id.value()));
    }
}

@ConfigurationProperties("partner.billing")
public record BillingConfiguration(
    URI baseUrl,
    Duration timeout,
    int maxRetries
) {}

{
  "type": "https://errors.example.com/order/credit-limit-exceeded",
  "title": "Credit limit exceeded",
  "status": 409,
  "detail": "Customer C-4711 cannot place an order above 5000 EUR.",
  "traceId": "4f7b9c0e6d2a",
  "violations": []
}

public IdResponse place(String idempotencyKey, PlaceOrderRequest request) {
    return idempotencyStore.executeOnce(idempotencyKey, () -> {
        OrderId id = placeOrder.place(request.toCommand());
        return new IdResponse(id.value());
    });
}

<xs:complexType name="PlaceOrderRequest">
  <xs:sequence>
    <xs:element name="customerNumber" type="xs:string" />
    <xs:element name="orderLine" type="tns:OrderLine" minOccurs="1" maxOccurs="unbounded" />
  </xs:sequence>
</xs:complexType>

public final class SoapBillingAdapter implements BillingPort {
    private final BillingSoapClient client;

    // Pattern: Adapter - SOAP-Vertrag bleibt außerhalb des Use Case.
    public InvoiceId createInvoice(Order order) {
        CreateInvoiceResponse response = client.createInvoice(SoapMapper.toRequest(order));
        return new InvoiceId(response.getInvoiceNumber());
    }
}

public record OrderPlacedEvent(
    UUID eventId,
    UUID orderId,
    String customerNumber,
    BigDecimal totalAmount,
    Instant occurredAt,
    int schemaVersion
) {}

public void onOrderPlaced(OrderPlacedEvent event) {
    if (processedEvents.exists(event.eventId())) {
        return;
    }
    billingService.createInvoice(event.orderId());
    processedEvents.markProcessed(event.eventId());
}

@PreAuthorize("hasAuthority('ORDER_APPROVE') and @orderSecurity.canAccess(#id)")
public void approve(OrderId id) {
    approveOrderUseCase.approve(id);
}

public CurrentUser currentUser(Jwt jwt) {
    return new CurrentUser(
        jwt.getSubject(),
        jwt.getClaimAsStringList("groups"),
        jwt.getAudience()
    );
}

Span span = Span.current();
span.setAttribute("business.operation", "place-order");
span.setAttribute("order.id", order.id().value().toString());
span.setAttribute("customer.id", order.customerId().value());

log.info("order_placed order={} customer={} total={} traceId={}",
    order.id().value(), order.customerId().value(), order.total(), MDC.get("traceId"));

resilience4j:
  timelimiter:
    instances:
      payment:
        timeout-duration: 2s
  retry:
    instances:
      payment:
        max-attempts: 2
        wait-duration: 100ms
  circuitbreaker:
    instances:
      payment:
        failure-rate-threshold: 50
        sliding-window-size: 20

public PaymentDecision reservePayment(Order order) {
    try {
        return paymentClient.reserve(order.paymentRequest());
    } catch (TimeoutException ex) {
        return PaymentDecision.pending("PAYMENT_TIMEOUT");
    }
}

@Bean
Step invoiceExportStep(JobRepository jobs, PlatformTransactionManager tx) {
    return new StepBuilder("invoiceExport", jobs)
        .<Invoice, ExportLine>chunk(500, tx)
        .reader(invoiceReader())
        .processor(invoiceProcessor())
        .writer(exportWriter())
        .faultTolerant()
        .skip(InvalidInvoiceException.class)
        .skipLimit(100)
        .build();
}

public record BatchItemKey(String jobName, String businessKey, LocalDate businessDate) {}

public record PriceCacheKey(String tenantId, String sku, String currency) {}

@Cacheable(cacheNames = "prices", key = "#tenantId + ':' + #sku + ':' + #currency")
public Money price(String tenantId, String sku, String currency) {
    return priceClient.load(tenantId, sku, currency);
}

public boolean shouldUseNewRiskCheck(Customer customer) {
    return flags.enabled("new-risk-check")
        && customer.region().equals(Region.EU)
        && customer.createdAt().isAfter(Instant.parse("2025-01-01T00:00:00Z"));
}

@Test
void domain_must_not_depend_on_frameworks() {
    noClasses().that().resideInAPackage("..domain..")
        .should().dependOnClassesThat().resideInAnyPackage(
            "org.springframework..", "jakarta.persistence..", "jakarta.ws.rs..")
        .check(importedClasses);
}

stages:
  - compile
  - unit-test
  - architecture-test
  - integration-test
  - dependency-scan
  - package
  - deploy-dev

criteria:
  team_experience: 5
  platform_fit: 5
  startup_time: 3
  memory_usage: 3
  standard_apis: 4
  ecosystem: 5
  migration_effort: 5

candidates:
  spring_boot: { score: 31, note: "breites Ökosystem" }
  jakarta_ee: { score: 28, note: "Standard und App-Server" }
  quarkus: { score: 29, note: "Cloud-native und Build-Time" }
  micronaut: { score: 26, note: "Compile-time DI" }

@RestController
@RequestMapping(path = "/api/orders", produces = MediaType.APPLICATION_JSON_VALUE)
@Validated
public class OrderController {
    @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE)
    @ResponseStatus(HttpStatus.CREATED)
    public IdResponse place(@Valid @RequestBody PlaceOrderRequest request) {
        return service.place(request);
    }
}

@Entity
@Table(name = "orders")
public class OrderEntity {
    @Id
    private UUID id;

    @Version // Optimistic Locking gegen verlorene Updates
    private long version;

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
    private List<OrderLineEntity> lines = new ArrayList<>();
}

| Pattern | Zweck | Einsatzort | Begründung |
|---|---|---|---|
| Adapter | Externes System kapseln | HttpPaymentAdapter | Use Case kennt kein HTTP |
| Repository | Persistenz verstecken | OrderRepository | Domain bleibt DB-unabhängig |
| Outbox | Events zuverlässig publizieren | OutboxPublisher | Kein verlorenes Event |
| Saga | Verteilten Prozess steuern | OrderSaga | Kompensation statt 2PC |

public final class PlaceOrderUseCase {
    private final OrderRepository orders;       // Pattern: Repository Port
    private final InventoryPort inventory;      // Pattern: Port
    private final TransactionRunner tx;         // Pattern: Unit of Work Boundary
    private final OutboxPort outbox;            // Pattern: Transactional Outbox

    public PlaceOrderUseCase(OrderRepository orders, InventoryPort inventory,
                             TransactionRunner tx, OutboxPort outbox) {
        this.orders = orders;
        this.inventory = inventory;
        this.tx = tx;
        this.outbox = outbox;
    }

    public OrderId handle(PlaceOrderCommand command) {
        return tx.required(() -> {
            inventory.reserve(command.customerId(), command.lines());
            Order order = Order.place(command.customerId(), command.lines()); // Factory Method
            orders.save(order);
            outbox.appendAll(order.pullEvents()); // Outbox: Event wird mit Order atomar gespeichert
            return order.id();
        });
    }
}