#Enterprise-Java-Technologien verstehen

# EJB Analyse: <Klassenname>

## Typ
- Stateless / Stateful / Singleton / MDB:

## Interfaces
- Local:
- Remote:
- No-interface:

## Transaktion
- Default:
- Annotationen:
- REQUIRES_NEW:
- NOT_SUPPORTED:
- setRollbackOnly:
- UserTransaction:

## Dependencies
- @EJB:
- @Resource:
- @PersistenceContext:
- SOAP:
- JMS:
- JNDI:
- Andere:

## Fachliche Verantwortung
- Use Cases:
- Tabellen:
- Events:
- externe Systeme:

## Risiken
- Transaktion:
- externe Calls:
- Side Effects:
- Tests fehlen:
- Migration schwierig wegen:

## Modernisierungsziel
- bleibt vorerst EJB:
- wird dünne Fassade:
- Fachlogik wandert nach:
- Adapter nötig für:

@Stateless
public class OrderServiceBean {

    @PersistenceContext
    private EntityManager em;

    @EJB
    private AuditServiceBean auditService;

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void createOrder(CreateOrderRequest request) {
        OrderEntity order = new OrderEntity();
        order.setCustomerId(request.getCustomerId());
        order.setStatus("NEW");

        em.persist(order);
        auditService.write("ORDER_CREATED");
    }
}

public class CreateOrderUseCase {

    private final OrderRepository orderRepository;
    private final AuditPort auditPort;

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

    public OrderId execute(CreateOrderCommand command) {
        Order order = Order.create(command.customerId());
        orderRepository.save(order);
        auditPort.orderCreated(order.id());
        return order.id();
    }
}

@Stateless
public class OrderServiceBean {

    @PersistenceContext
    private EntityManager em;

    @EJB
    private AuditServiceBean auditServiceBean;

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public OrderId createOrder(CreateOrderRequest request) {
        CreateOrderUseCase useCase = new CreateOrderUseCase(
                new JpaOrderRepository(em),
                new EjbAuditAdapter(auditServiceBean)
        );

        return useCase.execute(mapToCommand(request));
    }
}

# Transaction Map: <Use Case>

## Main Transaction

Start:
- Klasse/Methode:
- TransactionAttribute:

Beteiligte Ressourcen:
- Datasource:
- Persistence Unit:
- JMS Queue/Topic:
- SOAP Calls:
- File/Mail:

DB Writes:
- Tabelle 1:
- Tabelle 2:

Nested Transactions:
- Klasse/Methode:
- Typ:
- Warum?

Rollback:
- RuntimeException:
- Checked Exception:
- @ApplicationException:
- setRollbackOnly:
- manuelles rollback:

Risiken:
- externer Call innerhalb TX:
- lange Locks:
- REQUIRES_NEW:
- XA:
- unklare Exception-Behandlung:

TransactionAttributeType.REQUIRED
    → @Transactional(propagation = Propagation.REQUIRED)

TransactionAttributeType.REQUIRES_NEW
    → @Transactional(propagation = Propagation.REQUIRES_NEW)

TransactionAttributeType.NOT_SUPPORTED
    → @Transactional(propagation = Propagation.NOT_SUPPORTED)

TransactionAttributeType.MANDATORY
    → @Transactional(propagation = Propagation.MANDATORY)

TransactionAttributeType.SUPPORTS
    → @Transactional(propagation = Propagation.SUPPORTS)

TransactionAttributeType.NEVER
    → @Transactional(propagation = Propagation.NEVER)

@Transactional(rollbackFor = PaymentFailedException.class)
public void pay(...) {
    ...
}

# Queue Map

| Queue/Topic | Producer | Consumer | Message Type | Retry | DLQ | Fachlicher Zweck |
|---|---|---|---|---|---|---|
| OrderCreatedQueue | OrderServiceBean | InvoiceMDB | XML | ja? | ja? | Rechnung erzeugen |

@MessageDriven
public class InvoiceMDB implements MessageListener {

    @EJB
    private InvoiceServiceBean invoiceServiceBean;

    @Override
    public void onMessage(Message message) {
        invoiceServiceBean.createInvoice(message);
    }
}

public class InvoiceMessageHandler {

    private final CreateInvoiceUseCase createInvoiceUseCase;

    public InvoiceMessageHandler(CreateInvoiceUseCase createInvoiceUseCase) {
        this.createInvoiceUseCase = createInvoiceUseCase;
    }

    public void handle(OrderCreatedMessage message) {
        createInvoiceUseCase.execute(
                new CreateInvoiceCommand(message.orderId())
        );
    }
}

@MessageDriven
public class InvoiceMDB implements MessageListener {

    private InvoiceMessageHandler handler;

    @Override
    public void onMessage(Message message) {
        OrderCreatedMessage parsed = OrderCreatedMessageMapper.fromJms(message);
        handler.handle(parsed);
    }
}

| Message | Idempotency Key | Prüfung | Aktion bei Duplikat |
|---|---|---|---|
| OrderCreated | orderId | Invoice exists? | ignorieren |
| PaymentCaptured | paymentId | Payment exists? | ignorieren |
| CustomerUpdated | customerId + version | newer version? | alte Version ignorieren |

# SOAP Services

| Service | Richtung | Klasse | WSDL/XSD | Auth | Timeout | Risiko |
|---|---|---|---|---|---|---|
| CustomerService | Inbound | CustomerEndpoint | customer.wsdl | WS-Security | n/a | hoch |
| PaymentProvider | Outbound | PaymentSoapClient | payment.wsdl | Zertifikat | 30s? | hoch |

@WebServiceRef
private PaymentService paymentService;

public void pay(Order order) {
    paymentService.getPaymentPort().charge(...);
}

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

public class SoapPaymentGateway implements PaymentGateway {

    private final PaymentPort port;

    public SoapPaymentGateway(PaymentPort port) {
        this.port = port;
    }

    @Override
    public PaymentResult charge(PaymentCommand command) {
        try {
            return map(port.charge(map(command)));
        } catch (SOAPFaultException ex) {
            throw new PaymentProviderException(ex);
        }
    }
}

# JSP Risikoanalyse

| JSP | Zweck | Businesslogik? | Nutzt Session? | Ruft EJB/DAO? | Risiko |
|---|---|---|---|---|---|
| createOrder.jsp | Bestellung anlegen | ja | ja | ja | hoch |
| orderList.jsp | Liste anzeigen | nein | ja | nein | niedrig |

JSP mit Scriptlets
    ↓
Servlet/Controller übernimmt Logik
    ↓
JSP wird reine View
    ↓
Application Service wird genutzt
    ↓
REST/API möglich
    ↓
moderne UI möglich

<%
OrderService service = ...
List<Order> orders = service.findOrders();
%>

@WebServlet("/orders")
public class OrderServlet extends HttpServlet {

    private OrderQueryService orderQueryService;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        req.setAttribute("orders", orderQueryService.findOrders());
        req.getRequestDispatcher("/WEB-INF/views/orders.jsp")
           .forward(req, resp);
    }
}

# Database Ownership

| Tabelle | Genutzt von | Schreibzugriffe | Kritisch? | Modernisierungsrisiko |
|---|---|---|---|---|
| ORDERS | OrderService, InvoiceMDB | viele | ja | hoch |
| AUDIT_LOG | AuditService | append-only | mittel | niedrig |
| CUSTOMER | CustomerService, CRM Sync | viele | ja | hoch |

@Entity
@Table(name = "ORDERS")
public class OrderEntity {

    @Id
    private String id;

    private String status;
    private String customerId;
}

public class Order {

    private final OrderId id;
    private final CustomerId customerId;
    private OrderStatus status;

    public static Order create(CustomerId customerId) {
        return new Order(OrderId.newId(), customerId, OrderStatus.NEW);
    }

    public void cancel() {
        if (status == OrderStatus.SHIPPED) {
            throw new OrderCannotBeCancelledException(id);
        }
        this.status = OrderStatus.CANCELLED;
    }
}

# Security Map

| Funktion | Rolle | Prüfung wo? | Mechanismus | Risiko |
|---|---|---|---|---|
| Bestellung anzeigen | USER | web.xml | Container | mittel |
| Bestellung freigeben | MANAGER | EJB SessionContext | manuell | hoch |
| Admin-Seite | ADMIN | JSP/Filter | gemischt | hoch |

Wenn EJB entfernt wird, gehen eventuell automatisch verloren:
- CallerPrincipal
- Rollenprüfung
- Security Context Propagation
- JAAS Realm Integration