#Zielplattform Quarkus und Plattformvergleich

EJB-Monolith unverändert nach Quarkus kopieren

Legacy Entry Points und Container-Magie entfernen
        ↓
Plain-Java-Use-Cases behalten
        ↓
Quarkus als Runtime für REST, CDI, Persistence, Scheduler und Messaging verwenden
        ↓
Outbox, Payment Worker und idempotente Consumer sauber betreiben

Vorher:
EAR / EJB / JSP / SOAP / JMS / JTA

Zwischenstand:
Legacy EJB Fassade
Plain Java Use Cases
Ports und Adapter
Outbox Pattern
idempotenter Invoice Consumer

Quarkus-Ziel:
Quarkus REST Resource
CDI Application Services
Jakarta Transactions
Hibernate ORM / Panache oder klassisches Repository
Quarkus Scheduler
Quarkus Messaging oder JMS Adapter
Quarkus CXF / REST Client für externe Kommunikation

- Kubernetes oder Container sind Zielumgebung
- schnelle Startzeit ist relevant
- geringer Memory Footprint ist wichtig
- Services sollen kleiner und unabhängiger deployed werden
- CDI/Jakarta-Programmiermodell ist willkommen
- REST, Messaging, Scheduler und Persistence sollen in einer schlanken Runtime laufen
- du willst weg vom klassischen Application Server

- sehr viele Remote EJB Clients existieren
- das System massiv auf Stateful EJBs basiert
- XA/JMS/EJB-Semantik sehr stark und schwer testbar ist
- das Team bereits tief in Spring Boot investiert ist
- SOAP/WS-Security extrem komplex ist und auf App-Server-spezifischen Features basiert
- ein einfacher Jakarta-EE-Server-Upgrade weniger Risiko hat

Wenn du den fachlichen Kern schon sauber extrahiert hast,
ist Quarkus eine sehr gute Zielplattform.

Wenn du noch mitten in EJB/JNDI/JTA/JSP-Magie steckst,
ist Quarkus zu früh.

legacy-modernized-quarkus/
  pom.xml
  src/
    main/
      java/
        com/company/order/
          OrderApplication.java

          api/
            OrderResource.java
            CreateOrderHttpRequest.java
            CreateOrderHttpResponse.java

          application/
            CreateOrderApplicationService.java
            PaymentProcessingApplicationService.java
            OutboxPublishingService.java
            InvoiceMessageApplicationService.java

          domain/
            Order.java
            OrderId.java
            OrderStatus.java
            Money.java

          ports/
            OrderRepository.java
            PaymentGateway.java
            AuditPort.java
            OutboxPort.java
            InvoiceRepository.java
            ProcessedMessageRepository.java

          adapters/
            persistence/
              OrderEntity.java
              OrderJpaRepository.java
              JpaOrderRepositoryAdapter.java
              OutboxEventEntity.java
              JpaOutboxAdapter.java

            payment/
              QuarkusSoapPaymentGateway.java
              QuarkusRestPaymentGateway.java

            messaging/
              OrderPaidPublisher.java
              OrderPaidConsumer.java

            audit/
              JpaAuditAdapter.java

            scheduler/
              PaymentRequestedScheduler.java
              OrderPaidOutboxScheduler.java

      resources/
        application.properties
        import.sql

    test/
      java/
        com/company/order/
          CreateOrderUseCaseTest.java
          PaymentRequestedHandlerTest.java
          OrderResourceTest.java
          OutboxPublisherTest.java

api          = Inbound Adapter
application  = Transaktions- und Use-Case-Orchestrierung
 domain      = Fachmodell
ports        = Schnittstellen nach außen
adapters     = technische Implementierungen

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.company</groupId>
    <artifactId>legacy-modernized-quarkus</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
        <quarkus.platform.version>3.x.x</quarkus.platform.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>${quarkus.platform.artifact-id}</artifactId>
                <version>${quarkus.platform.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-rest</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-jackson</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-hibernate-orm-panache</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-jdbc-postgresql</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-narayana-jta</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-scheduler</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-smallrye-fault-tolerance</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-smallrye-health</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-micrometer</artifactId>
        </dependency>

        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-junit5</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>quarkus-maven-plugin</artifactId>
                <version>${quarkus.platform.version}</version>
                <extensions>true</extensions>
            </plugin>
        </plugins>
    </build>
</project>

quarkus.application.name=legacy-modernized-order
quarkus.http.port=8080

quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=order_app
quarkus.datasource.password=secret
quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/orderdb

quarkus.hibernate-orm.database.generation=validate
quarkus.hibernate-orm.log.sql=false

order.payment.scheduler.enabled=true
order.payment.scheduler.every=30s
order.outbox.publisher.every=20s

payment.provider.url=https://payment.example.internal/ws
payment.provider.timeout=10s

quarkus.log.category."com.company.order".level=INFO

Alt:
JNDI Datasource im Application Server
Queue im Admin Console Setup
Properties in Deployment Deskriptoren

Quarkus:
application.properties / Env Vars / Config Maps / Secrets

package com.company.order.api;

import com.company.order.application.CreateOrderApplicationService;
import jakarta.inject.Inject;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

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

    @Inject
    CreateOrderApplicationService createOrderApplicationService;

    @POST
    public Response createOrder(CreateOrderHttpRequest request) {
        String orderId = createOrderApplicationService.createOrder(request);

        return Response
                .accepted(new CreateOrderHttpResponse(orderId, "PAYMENT_PENDING"))
                .build();
    }
}

package com.company.order.api;

import java.math.BigDecimal;

public class CreateOrderHttpRequest {
    public String customerId;
    public BigDecimal amount;
}

package com.company.order.api;

public class CreateOrderHttpResponse {
    public String orderId;
    public String status;

    public CreateOrderHttpResponse(String orderId, String status) {
        this.orderId = orderId;
        this.status = status;
    }
}

HTTP DTO
  ↓
CreateOrderCommand
  ↓
CreateOrderUseCase

package com.company.order.application;

import com.company.order.api.CreateOrderHttpRequest;
import com.company.order.domain.OrderId;
import com.company.order.usecase.CreateOrderCommand;
import com.company.order.usecase.CreateOrderUseCase;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;

@ApplicationScoped
public class CreateOrderApplicationService {

    @Inject
    CreateOrderUseCase createOrderUseCase;

    @Transactional
    public String createOrder(CreateOrderHttpRequest request) {
        OrderId orderId = createOrderUseCase.execute(
                new CreateOrderCommand(request.customerId, request.amount)
        );

        return orderId.value();
    }
}

@Stateless + @TransactionAttribute(REQUIRED)
        ↓
@ApplicationScoped + @Transactional

Nicht blind übertragen.
Erst prüfen:
- REQUIRES_NEW
- NOT_SUPPORTED
- checked Exceptions
- Rollback-Regeln
- Self-Invocation
- Security Context

public class CreateOrderUseCase {
    private final OrderRepository orderRepository;
    private final AuditPort auditPort;
    private final OutboxPort outboxPort;

    public CreateOrderUseCase(
            OrderRepository orderRepository,
            AuditPort auditPort,
            OutboxPort outboxPort
    ) {
        this.orderRepository = orderRepository;
        this.auditPort = auditPort;
        this.outboxPort = outboxPort;
    }

    public OrderId execute(CreateOrderCommand command) {
        Order order = Order.create(command.customerId(), command.amount());
        orderRepository.save(order);
        auditPort.orderCreated(order.id());
        outboxPort.store(OutboxEvent.paymentRequested(order));
        return order.id();
    }
}

package com.company.order.config;

import com.company.order.ports.AuditPort;
import com.company.order.ports.OrderRepository;
import com.company.order.ports.OutboxPort;
import com.company.order.usecase.CreateOrderUseCase;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.inject.Produces;
import jakarta.inject.Inject;

@ApplicationScoped
public class UseCaseProducer {

    @Inject
    OrderRepository orderRepository;

    @Inject
    AuditPort auditPort;

    @Inject
    OutboxPort outboxPort;

    @Produces
    @ApplicationScoped
    CreateOrderUseCase createOrderUseCase() {
        return new CreateOrderUseCase(orderRepository, auditPort, outboxPort);
    }
}

@ApplicationScoped
public class CreateOrderUseCase {
    ...
}

Use Cases zuerst frameworkfrei halten.
CDI nur an den Rändern verwenden.

package com.company.order.adapters.persistence;

import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.math.BigDecimal;

@Entity
@Table(name = "orders")
public class OrderEntity extends PanacheEntityBase {

    @Id
    public String id;

    @Column(name = "customer_id", nullable = false)
    public String customerId;

    @Column(name = "amount", nullable = false)
    public BigDecimal amount;

    @Column(name = "status", nullable = false)
    public String status;
}

package com.company.order.adapters.persistence;

import com.company.order.domain.Order;
import com.company.order.domain.OrderId;
import com.company.order.ports.OrderRepository;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.Optional;

@ApplicationScoped
public class JpaOrderRepositoryAdapter implements OrderRepository {

    @Override
    public void save(Order order) {
        OrderEntity entity = OrderEntityMapper.toEntity(order);
        entity.persist();
    }

    @Override
    public void update(Order order) {
        OrderEntity entity = OrderEntity.findById(order.id().value());

        if (entity == null) {
            throw new IllegalStateException("Order not found: " + order.id().value());
        }

        entity.customerId = order.customerId();
        entity.amount = order.amount();
        entity.status = order.status().name();
    }

    @Override
    public Optional<Order> findById(OrderId orderId) {
        OrderEntity entity = OrderEntity.findById(orderId.value());

        if (entity == null) {
            return Optional.empty();
        }

        return Optional.of(OrderEntityMapper.toDomain(entity));
    }
}

package com.company.order.adapters.persistence;

import com.company.order.domain.Order;
import com.company.order.domain.OrderId;
import com.company.order.domain.OrderStatus;

public final class OrderEntityMapper {

    private OrderEntityMapper() {
    }

    public static OrderEntity toEntity(Order order) {
        OrderEntity entity = new OrderEntity();
        entity.id = order.id().value();
        entity.customerId = order.customerId();
        entity.amount = order.amount();
        entity.status = order.status().name();
        return entity;
    }

    public static Order toDomain(OrderEntity entity) {
        return Order.restore(
                OrderId.of(entity.id),
                entity.customerId,
                entity.amount,
                OrderStatus.valueOf(entity.status)
        );
    }
}

package com.company.order.adapters.persistence;

import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Lob;
import jakarta.persistence.Table;
import java.time.Instant;
import java.util.List;

@Entity
@Table(name = "outbox_event")
public class OutboxEventEntity extends PanacheEntityBase {

    @Id
    public String id;

    @Column(name = "aggregate_id", nullable = false)
    public String aggregateId;

    @Column(name = "aggregate_type", nullable = false)
    public String aggregateType;

    @Column(name = "event_type", nullable = false)
    public String eventType;

    @Lob
    @Column(name = "payload", nullable = false)
    public String payload;

    @Column(name = "status", nullable = false)
    public String status;

    @Column(name = "created_at", nullable = false)
    public Instant createdAt;

    @Column(name = "published_at")
    public Instant publishedAt;

    @Column(name = "retry_count", nullable = false)
    public int retryCount;

    @Lob
    @Column(name = "last_error")
    public String lastError;

    public static List<OutboxEventEntity> findPending(String eventType, int limit) {
        return find("status = ?1 and eventType = ?2 order by createdAt", "PENDING", eventType)
                .page(0, limit)
                .list();
    }
}

package com.company.order.adapters.persistence;

import com.company.order.outbox.OutboxEvent;
import com.company.order.ports.OutboxPort;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class JpaOutboxAdapter implements OutboxPort {

    @Override
    public void store(OutboxEvent event) {
        OutboxEventEntity entity = new OutboxEventEntity();
        entity.id = event.id();
        entity.aggregateId = event.aggregateId();
        entity.aggregateType = event.aggregateType();
        entity.eventType = event.eventType();
        entity.payload = event.payload();
        entity.status = "PENDING";
        entity.createdAt = event.createdAt();
        entity.retryCount = 0;
        entity.persist();
    }
}

OutboxEvent wird innerhalb derselben @Transactional-Methode persistiert
wie die fachliche Änderung.

public interface PaymentGateway {
    PaymentResult charge(PaymentCommand command);
}

package com.company.order.adapters.payment;

import com.company.order.ports.PaymentGateway;
import com.company.order.payment.PaymentCommand;
import com.company.order.payment.PaymentResult;
import jakarta.enterprise.context.ApplicationScoped;
import org.eclipse.microprofile.faulttolerance.CircuitBreaker;
import org.eclipse.microprofile.faulttolerance.Retry;
import org.eclipse.microprofile.faulttolerance.Timeout;

import java.time.temporal.ChronoUnit;

@ApplicationScoped
public class QuarkusRestPaymentGateway implements PaymentGateway {

    private final PaymentProviderClient client;

    public QuarkusRestPaymentGateway(PaymentProviderClient client) {
        this.client = client;
    }

    @Override
    @Timeout(value = 10, unit = ChronoUnit.SECONDS)
    @Retry(maxRetries = 2)
    @CircuitBreaker(requestVolumeThreshold = 10, failureRatio = 0.5, delay = 30, delayUnit = ChronoUnit.SECONDS)
    public PaymentResult charge(PaymentCommand command) {
        PaymentProviderResponse response = client.charge(
                new PaymentProviderRequest(
                        command.idempotencyKey(),
                        command.customerId(),
                        command.amount()
                )
        );

        if (response.successful()) {
            return PaymentResult.success(response.providerReference());
        }

        return PaymentResult.failure();
    }
}

@ApplicationScoped
public class QuarkusSoapPaymentGateway implements PaymentGateway {

    private final LegacyPaymentPort soapPort;

    public QuarkusSoapPaymentGateway(LegacyPaymentPort soapPort) {
        this.soapPort = soapPort;
    }

    @Override
    public PaymentResult charge(PaymentCommand command) {
        try {
            LegacyPaymentResponse response = soapPort.charge(
                    command.idempotencyKey(),
                    command.customerId(),
                    command.amount()
            );

            if (response.isSuccessful()) {
                return PaymentResult.success(response.getProviderReference());
            }

            return PaymentResult.failure();
        } catch (Exception e) {
            throw new PaymentProviderException("SOAP payment failed", e);
        }
    }
}

Auch in Quarkus darf Payment nicht wieder direkt im CreateOrder-Use-Case
innerhalb einer langen DB-Transaktion landen.

@Singleton + @Schedule

package com.company.order.adapters.scheduler;

import com.company.order.application.PaymentProcessingApplicationService;
import io.quarkus.scheduler.Scheduled;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

@ApplicationScoped
public class PaymentRequestedScheduler {

    @Inject
    PaymentProcessingApplicationService paymentProcessingApplicationService;

    @Scheduled(every = "{order.payment.scheduler.every}", identity = "payment-requested-scheduler")
    void processPaymentRequestedEvents() {
        paymentProcessingApplicationService.processPendingPaymentRequests();
    }
}

package com.company.order.application;

import com.company.order.adapters.persistence.OutboxEventEntity;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.List;

@ApplicationScoped
public class PaymentProcessingApplicationService {

    @Inject
    PaymentTransactionService paymentTransactionService;

    @Inject
    PaymentCallService paymentCallService;

    public void processPendingPaymentRequests() {
        List<OutboxEventEntity> events = OutboxEventEntity.findPending("PaymentRequested", 20);

        for (OutboxEventEntity event : events) {
            processOne(event);
        }
    }

    void processOne(OutboxEventEntity event) {
        paymentTransactionService.markPaymentInProgress(event.aggregateId);

        PaymentCallResult result = paymentCallService.callProvider(event.payload);

        if (result.successful()) {
            paymentTransactionService.markPaymentPaid(event.aggregateId, result.providerReference());
        } else if (result.unknown()) {
            paymentTransactionService.markPaymentUnknown(event.aggregateId, result.reason());
        } else {
            paymentTransactionService.markPaymentFailed(event.aggregateId);
        }

        paymentTransactionService.markOutboxEventPublished(event.id);
    }
}

package com.company.order.application;

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

@ApplicationScoped
public class PaymentTransactionService {

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void markPaymentInProgress(String orderId) {
        ...
    }

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void markPaymentPaid(String orderId, String providerReference) {
        ...
    }

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void markPaymentFailed(String orderId) {
        ...
    }

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void markPaymentUnknown(String orderId, String reason) {
        ...
    }

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void markOutboxEventPublished(String eventId) {
        ...
    }
}

Transaktionale Methoden müssen über den CDI Proxy aufgerufen werden.
Self-Invocation vermeiden.

@ApplicationScoped
public class PaymentService {

    public void process() {
        markPaid(); // interner Aufruf, Proxy kann umgangen werden
    }

    @Transactional(REQUIRES_NEW)
    void markPaid() {
        ...
    }
}

PaymentProcessingApplicationService
        ↓
PaymentTransactionService.markPaid()

package com.company.order.adapters.scheduler;

import com.company.order.application.OutboxPublishingService;
import io.quarkus.scheduler.Scheduled;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

@ApplicationScoped
public class OrderPaidOutboxScheduler {

    @Inject
    OutboxPublishingService outboxPublishingService;

    @Scheduled(every = "{order.outbox.publisher.every}", identity = "order-paid-outbox-publisher")
    void publishOrderPaidEvents() {
        outboxPublishingService.publishPendingOrderPaidEvents();
    }
}

package com.company.order.application;

import com.company.order.adapters.persistence.OutboxEventEntity;
import com.company.order.ports.OrderPaidPublisher;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import java.time.Instant;
import java.util.List;

@ApplicationScoped
public class OutboxPublishingService {

    @Inject
    OrderPaidPublisher orderPaidPublisher;

    public void publishPendingOrderPaidEvents() {
        List<OutboxEventEntity> events = OutboxEventEntity.findPending("OrderPaid", 50);

        for (OutboxEventEntity event : events) {
            publishOne(event);
        }
    }

    @Transactional(Transactional.TxType.REQUIRES_NEW)
    void publishOne(OutboxEventEntity event) {
        try {
            orderPaidPublisher.publish(event.payload);

            event.status = "PUBLISHED";
            event.publishedAt = Instant.now();
        } catch (Exception e) {
            event.retryCount = event.retryCount + 1;
            event.lastError = e.getMessage();

            if (event.retryCount >= 10) {
                event.status = "DEAD";
            }
        }
    }
}

OutboxPublishingService
        ↓
OutboxPublishTransactionService.publishOne(eventId)

1. Quarkus JMS Extension, wenn echte JMS-Kompatibilität gebraucht wird
2. SmallRye Reactive Messaging mit AMQP/Kafka/RabbitMQ
3. Camel Quarkus, wenn Integration Routes wichtig sind
4. HTTP Callback / REST, wenn Messaging fachlich ersetzt werden soll

Wenn alte Queues und Broker bleiben müssen:
Starte mit JMS-kompatiblem Adapter.

Wenn du ohnehin Plattformwechsel machst:
Prüfe AMQP/Kafka/RabbitMQ über Reactive Messaging.

public interface OrderPaidPublisher {
    void publish(String payload);
}

package com.company.order.adapters.messaging;

import com.company.order.ports.OrderPaidPublisher;
import io.smallrye.reactive.messaging.MutinyEmitter;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.reactive.messaging.Channel;

@ApplicationScoped
public class ReactiveOrderPaidPublisher implements OrderPaidPublisher {

    @Inject
    @Channel("order-paid-out")
    MutinyEmitter<String> emitter;

    @Override
    public void publish(String payload) {
        emitter.sendAndAwait(payload);
    }
}

mp.messaging.outgoing.order-paid-out.connector=smallrye-amqp
mp.messaging.outgoing.order-paid-out.address=OrderPaidQueue

package com.company.order.adapters.messaging;

import com.company.order.application.InvoiceMessageApplicationService;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.reactive.messaging.Incoming;

@ApplicationScoped
public class OrderPaidConsumer {

    @Inject
    InvoiceMessageApplicationService invoiceMessageApplicationService;

    @Incoming("order-paid-in")
    public void consume(String payload) {
        invoiceMessageApplicationService.handleOrderPaid(payload);
    }
}

mp.messaging.incoming.order-paid-in.connector=smallrye-amqp
mp.messaging.incoming.order-paid-in.address=OrderPaidQueue

package com.company.order.application;

import com.company.order.invoice.OrderPaidMessage;
import com.company.order.invoice.OrderPaidMessageParser;
import com.company.order.usecase.OrderPaidMessageHandler;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;

@ApplicationScoped
public class InvoiceMessageApplicationService {

    @Inject
    OrderPaidMessageHandler handler;

    @Transactional
    public void handleOrderPaid(String payload) {
        OrderPaidMessage message = OrderPaidMessageParser.parse(payload);
        handler.handle(message);
    }
}

public class OrderPaidMessageHandler {

    private final ProcessedMessageRepository processedMessageRepository;
    private final InvoiceRepository invoiceRepository;
    private final CreateInvoiceUseCase createInvoiceUseCase;

    public void handle(OrderPaidMessage message) {
        if (processedMessageRepository.alreadyProcessed(message.messageId())) {
            return;
        }

        if (invoiceRepository.existsForOrderId(message.orderId())) {
            processedMessageRepository.markProcessed(message.messageId());
            return;
        }

        createInvoiceUseCase.execute(new CreateInvoiceCommand(message.orderId()));
        processedMessageRepository.markProcessed(message.messageId());
    }
}

idempotenter Consumer,
egal ob MDB, Spring @JmsListener, Jakarta Messaging oder Quarkus Reactive Messaging.

package com.company.order.health;

import com.company.order.adapters.persistence.OutboxEventEntity;
import jakarta.enterprise.context.ApplicationScoped;
import org.eclipse.microprofile.health.HealthCheck;
import org.eclipse.microprofile.health.HealthCheckResponse;
import org.eclipse.microprofile.health.Readiness;

@Readiness
@ApplicationScoped
public class OutboxReadinessCheck implements HealthCheck {

    @Override
    public HealthCheckResponse call() {
        long deadCount = OutboxEventEntity.count("status", "DEAD");

        if (deadCount > 0) {
            return HealthCheckResponse
                    .named("outbox")
                    .down()
                    .withData("deadEvents", deadCount)
                    .build();
        }

        return HealthCheckResponse
                .named("outbox")
                .up()
                .build();
    }
}

- outbox.pending.count
- outbox.dead.count
- outbox.oldest.pending.age
- payment.unknown.count
- payment.success.count
- payment.failure.count
- invoice.duplicates.ignored.count
- message.processing.duration

Ohne Monitoring ist Outbox nur eine versteckte Queue in der Datenbank.

1. Erst JVM Mode stabil machen
2. Tests und Observability aufbauen
3. Reflection/JAXB/SOAP-Probleme identifizieren
4. Dann Native Image prüfen

- JAXB / SOAP / Reflection können zusätzliche Konfiguration brauchen
- alte Libraries sind eventuell nicht native-image-freundlich
- dynamische Classloading-Muster können brechen
- Performance-Profil ist anders

Quarkus-Migration ≠ sofort Native Image.
Quarkus im JVM Mode ist bereits ein sinnvoller Modernisierungsschritt.

Wenn du möglichst wenig Bruch willst:
Jakarta EE.

Wenn dein Team Spring kann und App-Server weg soll:
Spring Boot.

Wenn Cloud/Kubernetes, Startzeit und schlanke Services stark zählen:
Quarkus.

Phase 1: Plain Java Kern extrahieren
Phase 2: Outbox und Idempotenz einführen
Phase 3a: Spring Boot Adapter bauen
Phase 3b: Jakarta EE Adapter bauen
Phase 3c: Quarkus Adapter bauen
Phase 4: Plattform mit Tests und Betriebskriterien vergleichen

- domain/* übernehmen
- ports/* übernehmen
- usecase/* übernehmen
- Plain-Java-Tests übernehmen

Alle Kern-Tests laufen ohne Quarkus-spezifische Infrastruktur.

- OrderEntity
- JpaOrderRepositoryAdapter
- OutboxEventEntity
- JpaOutboxAdapter
- ProcessedMessageEntity
- InvoiceEntity

Repository-Integrationstests laufen gegen Testcontainer oder Dev Services.

- OrderResource
- Request/Response DTOs
- Fehler-Mapping
- Validation

POST /orders erzeugt Order mit PAYMENT_PENDING
und speichert PaymentRequested Outbox Event.

- PaymentRequestedScheduler
- PaymentProcessingApplicationService
- PaymentTransactionService
- PaymentGateway Adapter

Payment success → Order PAID + OrderPaid Outbox Event.
Payment failure → Order PAYMENT_FAILED.
Payment timeout → Order PAYMENT_UNKNOWN.

- OrderPaidOutboxScheduler
- OrderPaidPublisher
- Retry/Dead Status
- Metriken

OrderPaid Outbox Event wird an Broker/Queue publiziert.
Doppelte Publikation schadet nicht.

- OrderPaidConsumer
- InvoiceMessageApplicationService
- ProcessedMessageRepository
- Idempotenztest

Doppelte OrderPaid Message erzeugt nur eine Rechnung.

Legacy Flow läuft produktiv.
Quarkus Flow verarbeitet kopierte oder gespiegelte Requests.
Ergebnisse werden verglichen.

- Statusübergänge
- DB Writes
- Audits
- Events
- Fehlerfälle
- Performance

Nur ein kleiner Anteil oder ein interner Mandant läuft über Quarkus.
Rollback bleibt möglich.

Quarkus übernimmt Entry Point.
Legacy bleibt zunächst lesend oder als Fallback verfügbar.
Nach stabiler Laufzeit wird Legacy-Code entfernt.

- alte EJB-Fassaden entfernen
- JSP Entry Point abschalten
- alte JMS Producer entfernen
- JNDI-Konfiguration löschen
- Deployment-Pipeline vereinfachen

Quarkus ist nicht der erste Schritt der Modernisierung.
Quarkus ist ein guter Zielruntime-Schritt, nachdem du den Kern bereits modernisierbar gemacht hast.