Java Master-Handbuch: Modulstruktur Edition · seb4u Package Standard

Zeigt Invarianten, exhaustive switch-Verarbeitung und fachliche Varianten ohne Stringly-Typed-Code.

package com.seb4u.demo.domain;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.util.Currency;
import java.util.Objects;
import java.util.UUID;

public final class PaymentModel {
    public record PaymentId(UUID value) {
        public PaymentId {
            Objects.requireNonNull(value, "payment id");
        }
        public static PaymentId newId() { return new PaymentId(UUID.randomUUID()); }
    }

    public record Money(BigDecimal amount, Currency currency) implements Comparable<Money> {
        public Money {
            Objects.requireNonNull(amount, "amount");
            Objects.requireNonNull(currency, "currency");
            amount = amount.setScale(currency.getDefaultFractionDigits(), RoundingMode.HALF_EVEN);
            if (amount.signum() < 0) throw new IllegalArgumentException("amount must be >= 0");
        }
        public Money plus(Money other) {
            requireSameCurrency(other);
            return new Money(amount.add(other.amount), currency);
        }
        public Money minus(Money other) {
            requireSameCurrency(other);
            if (amount.compareTo(other.amount) < 0) throw new IllegalStateException("insufficient amount");
            return new Money(amount.subtract(other.amount), currency);
        }
        public boolean isZero() { return amount.signum() == 0; }
        private void requireSameCurrency(Money other) {
            if (!currency.equals(other.currency)) {
                throw new IllegalArgumentException("currency mismatch: " + currency + " vs " + other.currency);
            }
        }
        @Override public int compareTo(Money other) {
            requireSameCurrency(other);
            return amount.compareTo(other.amount);
        }
    }

    public enum PaymentRail {
        SEPA(100_000), CARD(10_000), INTERNAL(Integer.MAX_VALUE);
        private final int maxAmount;
        PaymentRail(int maxAmount) { this.maxAmount = maxAmount; }
        boolean supports(Money money) { return money.amount().intValueExact() <= maxAmount; }
    }

    public sealed interface PaymentCommand permits AuthorizePayment, CapturePayment, RefundPayment, CancelPayment {
        PaymentId id();
        Instant requestedAt();
    }

    public record AuthorizePayment(PaymentId id, Money amount, PaymentRail rail, Instant requestedAt)
            implements PaymentCommand {
        public AuthorizePayment {
            Objects.requireNonNull(amount); Objects.requireNonNull(rail); Objects.requireNonNull(requestedAt);
            if (amount.isZero()) throw new IllegalArgumentException("payment amount must be positive");
            if (!rail.supports(amount)) throw new IllegalArgumentException("amount not supported by rail " + rail);
        }
    }
    public record CapturePayment(PaymentId id, Money amount, Instant requestedAt) implements PaymentCommand {}
    public record RefundPayment(PaymentId id, Money amount, String reason, Instant requestedAt) implements PaymentCommand {}
    public record CancelPayment(PaymentId id, String reason, Instant requestedAt) implements PaymentCommand {}

    public static String auditLine(PaymentCommand command) {
        return switch (command) {
            case AuthorizePayment c -> "AUTH " + c.id().value() + " " + c.amount().amount() + " " + c.rail();
            case CapturePayment c   -> "CAPTURE " + c.id().value() + " " + c.amount().amount();
            case RefundPayment c    -> "REFUND " + c.id().value() + " reason=" + c.reason();
            case CancelPayment c    -> "CANCEL " + c.id().value() + " reason=" + c.reason();
        };
    }
}

Ein Zustandsautomat verhindert ungültige Übergänge und macht Terminalzustände explizit.

package com.seb4u.demo.domain;

import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public final class OrderStateMachine {
    public enum OrderStatus {
        DRAFT, SUBMITTED, PAID, FULFILLED, CANCELLED;
        boolean terminal() { return this == FULFILLED || this == CANCELLED; }
    }

    public sealed interface OrderEvent permits OrderSubmitted, PaymentReceived, OrderFulfilled, OrderCancelled {}
    public record OrderSubmitted(Instant at) implements OrderEvent {}
    public record PaymentReceived(String transactionId, Instant at) implements OrderEvent {
        public PaymentReceived { Objects.requireNonNull(transactionId); }
    }
    public record OrderFulfilled(String shipmentId, Instant at) implements OrderEvent {}
    public record OrderCancelled(String reason, Instant at) implements OrderEvent {}

    public record OrderSnapshot(String orderId, OrderStatus status, List<OrderEvent> history) {
        public OrderSnapshot {
            Objects.requireNonNull(orderId); Objects.requireNonNull(status);
            history = List.copyOf(history);
        }
        public OrderSnapshot apply(OrderEvent event) {
            if (status.terminal()) throw new IllegalStateException("terminal order cannot change: " + status);
            OrderStatus next = switch (event) {
                case OrderSubmitted ignored when status == OrderStatus.DRAFT -> OrderStatus.SUBMITTED;
                case PaymentReceived ignored when status == OrderStatus.SUBMITTED -> OrderStatus.PAID;
                case OrderFulfilled ignored when status == OrderStatus.PAID -> OrderStatus.FULFILLED;
                case OrderCancelled ignored -> OrderStatus.CANCELLED;
                default -> throw new IllegalStateException("illegal transition: " + status + " + " + event);
            };
            var nextHistory = new ArrayList<>(history);
            nextHistory.add(event);
            return new OrderSnapshot(orderId, next, nextHistory);
        }
    }
}

Nützlich für Event Sourcing, Messaging und Audit-Logs, wenn Events über mehrere Versionen hinweg lesbar bleiben müssen.

package com.seb4u.demo.domain;

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

public final class VersionedEvents {
    public enum EventVersion {
        V1, V2;
        static EventVersion from(String raw) {
            return raw == null ? V1 : EventVersion.valueOf(raw.toUpperCase());
        }
    }

    public sealed interface AccountEvent permits AccountOpened, EmailChanged, LimitChanged {
        UUID accountId();
        Instant occurredAt();
        EventVersion version();
    }

    public record AccountOpened(UUID accountId, String ownerName, String email, Instant occurredAt, EventVersion version)
            implements AccountEvent {}
    public record EmailChanged(UUID accountId, String email, Instant occurredAt, EventVersion version)
            implements AccountEvent {}
    public record LimitChanged(UUID accountId, int dailyLimit, Instant occurredAt, EventVersion version)
            implements AccountEvent {}

    public static AccountEvent fromEnvelope(Map<String, String> envelope) {
        String type = Objects.requireNonNull(envelope.get("type"), "event type");
        UUID id = UUID.fromString(envelope.get("accountId"));
        Instant at = Instant.parse(envelope.getOrDefault("occurredAt", Instant.EPOCH.toString()));
        EventVersion version = EventVersion.from(envelope.get("version"));
        return switch (type) {
            case "AccountOpened" -> new AccountOpened(id, envelope.get("ownerName"), envelope.get("email"), at, version);
            case "EmailChanged" -> new EmailChanged(id, envelope.get("email"), at, version);
            case "LimitChanged" -> new LimitChanged(id, Integer.parseInt(envelope.get("dailyLimit")), at, version);
            default -> throw new IllegalArgumentException("unknown event type: " + type);
        };
    }

    public static Map<String, String> toEnvelope(AccountEvent event) {
        return switch (event) {
            case AccountOpened e -> Map.of(
                    "type", "AccountOpened", "version", e.version().name(),
                    "accountId", e.accountId().toString(), "ownerName", e.ownerName(),
                    "email", e.email(), "occurredAt", e.occurredAt().toString());
            case EmailChanged e -> Map.of(
                    "type", "EmailChanged", "version", e.version().name(),
                    "accountId", e.accountId().toString(), "email", e.email(),
                    "occurredAt", e.occurredAt().toString());
            case LimitChanged e -> Map.of(
                    "type", "LimitChanged", "version", e.version().name(),
                    "accountId", e.accountId().toString(), "dailyLimit", Integer.toString(e.dailyLimit()),
                    "occurredAt", e.occurredAt().toString());
        };
    }
}

Demonstriert Zugriffreihenfolge, Kapazitätsbegrenzung und testbare Zeit über Clock.

package com.seb4u.demo.collections;

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;

public final class ExpiringLruCache<K, V> {
    private final int maxSize;
    private final Duration ttl;
    private final Clock clock;
    private final LinkedHashMap<K, Entry<V>> entries;

    private record Entry<V>(V value, Instant expiresAt) {
        boolean expired(Instant now) { return !expiresAt.isAfter(now); }
    }

    public ExpiringLruCache(int maxSize, Duration ttl, Clock clock) {
        if (maxSize < 1) throw new IllegalArgumentException("maxSize must be positive");
        this.maxSize = maxSize;
        this.ttl = ttl;
        this.clock = clock;
        this.entries = new LinkedHashMap<>(16, 0.75f, true) {
            @Override protected boolean removeEldestEntry(Map.Entry<K, Entry<V>> eldest) {
                return size() > ExpiringLruCache.this.maxSize;
            }
        };
    }

    public synchronized Optional<V> get(K key) {
        Entry<V> entry = entries.get(key);
        if (entry == null) return Optional.empty();
        if (entry.expired(clock.instant())) {
            entries.remove(key);
            return Optional.empty();
        }
        return Optional.of(entry.value());
    }

    public synchronized void put(K key, V value) {
        entries.put(key, new Entry<>(value, clock.instant().plus(ttl)));
    }

    public synchronized int cleanup() {
        Instant now = clock.instant();
        int before = entries.size();
        entries.entrySet().removeIf(e -> e.getValue().expired(now));
        return before - entries.size();
    }
}

Ein realistisches In-Memory-Modell mit mehreren sekundären Indizes und konsistenter Indexpflege.

package com.seb4u.demo.collections;

import java.time.Instant;
import java.util.*;

public final class MultiIndexOrderBook {
    public record OrderId(String value) {}
    public enum Status { NEW, PAID, SHIPPED, CANCELLED }
    public record Order(OrderId id, String customerId, Status status, Instant createdAt, long cents) {}

    private final Map<OrderId, Order> byId = new HashMap<>();
    private final Map<String, Set<OrderId>> byCustomer = new HashMap<>();
    private final EnumMap<Status, Set<OrderId>> byStatus = new EnumMap<>(Status.class);
    private final NavigableMap<Instant, Set<OrderId>> byCreatedAt = new TreeMap<>();

    public MultiIndexOrderBook() {
        for (Status s : Status.values()) byStatus.put(s, new LinkedHashSet<>());
    }

    public void upsert(Order order) {
        Objects.requireNonNull(order);
        Order old = byId.put(order.id(), order);
        if (old != null) removeFromIndexes(old);
        addToIndexes(order);
    }

    public Optional<Order> find(OrderId id) { return Optional.ofNullable(byId.get(id)); }

    public List<Order> byCustomer(String customerId) {
        return byCustomer.getOrDefault(customerId, Set.of()).stream().map(byId::get).toList();
    }

    public List<Order> byStatus(Status status) {
        return byStatus.getOrDefault(status, Set.of()).stream().map(byId::get).toList();
    }

    public List<Order> createdBetween(Instant from, Instant to) {
        return byCreatedAt.subMap(from, true, to, true).values().stream()
                .flatMap(Set::stream)
                .map(byId::get)
                .sorted(Comparator.comparing(Order::createdAt))
                .toList();
    }

    private void addToIndexes(Order o) {
        byCustomer.computeIfAbsent(o.customerId(), ignored -> new LinkedHashSet<>()).add(o.id());
        byStatus.get(o.status()).add(o.id());
        byCreatedAt.computeIfAbsent(o.createdAt(), ignored -> new LinkedHashSet<>()).add(o.id());
    }

    private void removeFromIndexes(Order o) {
        remove(byCustomer, o.customerId(), o.id());
        byStatus.get(o.status()).remove(o.id());
        remove(byCreatedAt, o.createdAt(), o.id());
    }

    private static <K, V> void remove(Map<K, Set<V>> index, K key, V value) {
        Set<V> bucket = index.get(key);
        if (bucket == null) return;
        bucket.remove(value);
        if (bucket.isEmpty()) index.remove(key);
    }
}

Zeigt, wie Maps, Sets und Queues zusammen ein algorithmisches Problem sauber lösen.

package com.seb4u.demo.collections;

import java.util.*;

public final class DependencyPlanner {
    public record Task(String name, Set<String> dependsOn) {
        public Task { dependsOn = Set.copyOf(dependsOn); }
    }

    public static List<String> topologicalOrder(Collection<Task> tasks) {
        Map<String, Set<String>> remainingDeps = new LinkedHashMap<>();
        Map<String, Set<String>> dependents = new HashMap<>();

        for (Task task : tasks) {
            remainingDeps.put(task.name(), new LinkedHashSet<>(task.dependsOn()));
            for (String dep : task.dependsOn()) {
                dependents.computeIfAbsent(dep, ignored -> new LinkedHashSet<>()).add(task.name());
            }
        }

        ArrayDeque<String> ready = new ArrayDeque<>();
        remainingDeps.forEach((task, deps) -> { if (deps.isEmpty()) ready.add(task); });

        List<String> ordered = new ArrayList<>();
        while (!ready.isEmpty()) {
            String done = ready.removeFirst();
            ordered.add(done);
            for (String dependent : dependents.getOrDefault(done, Set.of())) {
                Set<String> deps = remainingDeps.get(dependent);
                deps.remove(done);
                if (deps.isEmpty()) ready.addLast(dependent);
            }
        }

        if (ordered.size() != remainingDeps.size()) {
            Map<String, Set<String>> cycle = new LinkedHashMap<>();
            remainingDeps.forEach((task, deps) -> { if (!deps.isEmpty()) cycle.put(task, Set.copyOf(deps)); });
            throw new IllegalStateException("cycle detected: " + cycle);
        }
        return ordered;
    }
}

Verhindert, dass UserId, InvoiceId und andere technische Strings versehentlich vertauscht werden.

package com.seb4u.demo.generics;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public final class TypedRepositories {
    public sealed interface EntityId permits UserId, InvoiceId { String value(); }
    public record UserId(String value) implements EntityId {}
    public record InvoiceId(String value) implements EntityId {}

    public interface Entity<ID extends EntityId> { ID id(); }
    public record User(UserId id, String email) implements Entity<UserId> {}
    public record Invoice(InvoiceId id, long cents) implements Entity<InvoiceId> {}

    public interface Repository<ID extends EntityId, E extends Entity<ID>> {
        Optional<E> find(ID id);
        void save(E entity);
        List<E> findAll();
    }

    public static final class InMemoryRepository<ID extends EntityId, E extends Entity<ID>>
            implements Repository<ID, E> {
        private final Map<ID, E> store = new ConcurrentHashMap<>();
        @Override public Optional<E> find(ID id) { return Optional.ofNullable(store.get(id)); }
        @Override public void save(E entity) { store.put(entity.id(), entity); }
        @Override public List<E> findAll() { return List.copyOf(store.values()); }
    }

    public static void demo() {
        Repository<UserId, User> users = new InMemoryRepository<>();
        users.save(new User(new UserId("u-1"), "dev@example.com"));

        Repository<InvoiceId, Invoice> invoices = new InMemoryRepository<>();
        invoices.save(new Invoice(new InvoiceId("i-1"), 12_99));

        // users.find(new InvoiceId("i-1")); // kompiliert nicht: genau das ist der Nutzen.
    }
}

Ein fortgeschrittenes Pattern für Konfiguration, Plugin-Kontexte und typisierte Metadaten.

package com.seb4u.demo.generics;

import java.util.*;
import java.util.function.Function;

public final class TypeSafeRegistry {
    public static final class Key<T> {
        private final String name;
        private final Class<T> type;
        private Key(String name, Class<T> type) { this.name = name; this.type = type; }
        public static <T> Key<T> of(String name, Class<T> type) { return new Key<>(name, type); }
        T cast(Object value) { return type.cast(value); }
        @Override public boolean equals(Object o) { return o instanceof Key<?> k && name.equals(k.name) && type.equals(k.type); }
        @Override public int hashCode() { return Objects.hash(name, type); }
    }

    private final Map<Key<?>, Object> values = new HashMap<>();

    public <T> void put(Key<T> key, T value) {
        values.put(key, key.cast(value));
    }

    public <T> Optional<T> get(Key<T> key) {
        return Optional.ofNullable(values.get(key)).map(key::cast);
    }

    public <T, R> Optional<R> map(Key<T> key, Function<? super T, ? extends R> mapper) {
        return get(key).map(mapper);
    }

    public static void demo() {
        Key<Integer> port = Key.of("server.port", Integer.class);
        Key<String> host = Key.of("server.host", String.class);
        var registry = new TypeSafeRegistry();
        registry.put(port, 8080);
        registry.put(host, "localhost");
        String endpoint = registry.map(host, h -> "http://" + h + ":" + registry.get(port).orElseThrow()).orElseThrow();
        System.out.println(endpoint);
    }
}

Zeigt generische Felder, typsichere Prädikate und flexible Filterlogik.

package com.seb4u.demo.generics;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public final class CriteriaDsl {
    public record Customer(String id, String segment, int age, long lifetimeValue) {}

    public interface Criterion<T> extends Predicate<T> {
        default Criterion<T> and(Criterion<? super T> other) {
            return value -> this.test(value) && other.test(value);
        }
        default Criterion<T> or(Criterion<? super T> other) {
            return value -> this.test(value) || other.test(value);
        }
    }

    public static final class Field<T, V extends Comparable<? super V>> {
        private final String name;
        private final java.util.function.Function<T, V> extractor;
        public Field(String name, java.util.function.Function<T, V> extractor) {
            this.name = name; this.extractor = extractor;
        }
        public Criterion<T> greaterThan(V value) { return row -> extractor.apply(row).compareTo(value) > 0; }
        public Criterion<T> equalTo(V value) { return row -> extractor.apply(row).compareTo(value) == 0; }
        @Override public String toString() { return name; }
    }

    public static <T> List<T> filter(Iterable<T> source, Criterion<? super T> criterion) {
        List<T> result = new ArrayList<>();
        for (T item : source) if (criterion.test(item)) result.add(item);
        return result;
    }

    public static void demo(List<Customer> customers) {
        Field<Customer, Integer> age = new Field<>("age", Customer::age);
        Field<Customer, Long> ltv = new Field<>("lifetimeValue", Customer::lifetimeValue);
        Field<Customer, String> segment = new Field<>("segment", Customer::segment);
        var vipAdults = age.greaterThan(17).and(ltv.greaterThan(100_000L).or(segment.equalTo("VIP")));
        System.out.println(filter(customers, vipAdults));
    }
}

Zeigt Supplier, Accumulator, Combiner und Finisher mit fachlicher Rundung.

package com.seb4u.demo.streams;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collector;

public final class MoneyCollectors {
    public record Invoice(String customerId, BigDecimal net, BigDecimal tax) {}
    public record CustomerTotals(BigDecimal net, BigDecimal tax, BigDecimal gross, int count) {}

    private static final class Accumulator {
        BigDecimal net = BigDecimal.ZERO;
        BigDecimal tax = BigDecimal.ZERO;
        int count;
        void add(Invoice invoice) {
            net = net.add(invoice.net());
            tax = tax.add(invoice.tax());
            count++;
        }
        Accumulator merge(Accumulator other) {
            net = net.add(other.net);
            tax = tax.add(other.tax);
            count += other.count;
            return this;
        }
        CustomerTotals finish() {
            BigDecimal gross = net.add(tax).setScale(2, RoundingMode.HALF_EVEN);
            return new CustomerTotals(net.setScale(2, RoundingMode.HALF_EVEN),
                                      tax.setScale(2, RoundingMode.HALF_EVEN),
                                      gross,
                                      count);
        }
    }

    public static Collector<Invoice, ?, CustomerTotals> totals() {
        return Collector.of(Accumulator::new, Accumulator::add, Accumulator::merge, Accumulator::finish);
    }

    public static Map<String, CustomerTotals> totalsByCustomer(List<Invoice> invoices) {
        return invoices.stream().collect(java.util.stream.Collectors.groupingBy(Invoice::customerId, totals()));
    }
}

Importiert Zeilen, trennt gültige und ungültige Datensätze und erzeugt einen Report statt Exceptions pro Zeile.

package com.seb4u.demo.streams;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Stream;

public final class EtlPipeline {
    public sealed interface Parsed permits ValidRow, InvalidRow { int lineNo(); }
    public record ValidRow(int lineNo, String account, long cents) implements Parsed {}
    public record InvalidRow(int lineNo, String raw, String reason) implements Parsed {}
    public record ImportReport(List<ValidRow> valid, List<InvalidRow> invalid, long totalCents) {}

    public static Parsed parse(int lineNo, String raw) {
        String[] parts = raw.split(";");
        if (parts.length != 2) return new InvalidRow(lineNo, raw, "expected account;cents");
        try {
            long cents = Long.parseLong(parts[1]);
            if (cents <= 0) return new InvalidRow(lineNo, raw, "amount must be positive");
            return new ValidRow(lineNo, parts[0].trim(), cents);
        } catch (NumberFormatException ex) {
            return new InvalidRow(lineNo, raw, "invalid cents: " + parts[1]);
        }
    }

    public static ImportReport importLines(List<String> lines) {
        List<Parsed> parsed = Stream.iterate(0, i -> i + 1)
                .limit(lines.size())
                .map(i -> parse(i + 1, lines.get(i)))
                .toList();

        List<ValidRow> valid = parsed.stream()
                .flatMap(p -> p instanceof ValidRow v ? Stream.of(v) : Stream.empty())
                .toList();
        List<InvalidRow> invalid = parsed.stream()
                .flatMap(p -> p instanceof InvalidRow e ? Stream.of(e) : Stream.empty())
                .toList();
        long total = valid.stream().mapToLong(ValidRow::cents).sum();
        return new ImportReport(valid, invalid, total);
    }

    public static <T, K> Map<K, List<T>> stableGroup(List<T> input, Function<T, K> key) {
        return input.stream().collect(
                LinkedHashMap::new,
                (map, item) -> map.computeIfAbsent(key.apply(item), ignored -> new ArrayList<>()).add(item),
                (left, right) -> right.forEach((k, v) -> left.merge(k, v, (a, b) -> { a.addAll(b); return a; }))
        );
    }
}

Verarbeitet große Datenquellen chunkweise, ohne die komplette Eingabe im Speicher zu halten.

package com.seb4u.demo.streams;

import java.util.Iterator;
import java.util.List;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public final class BatchStreams {
    public static <T> Stream<List<T>> batches(Iterator<T> source, int batchSize) {
        if (batchSize < 1) throw new IllegalArgumentException("batchSize must be positive");
        Spliterator<List<T>> spliterator = new Spliterators.AbstractSpliterator<>(Long.MAX_VALUE, Spliterator.ORDERED) {
            @Override public boolean tryAdvance(Consumer<? super List<T>> action) {
                if (!source.hasNext()) return false;
                java.util.ArrayList<T> batch = new java.util.ArrayList<>(batchSize);
                while (source.hasNext() && batch.size() < batchSize) {
                    batch.add(source.next());
                }
                action.accept(List.copyOf(batch));
                return true;
            }
        };
        return StreamSupport.stream(spliterator, false);
    }

    public static void processLargeImport(Iterator<String> lines) {
        batches(lines, 1_000)
                .map(EtlPipeline::importLines)
                .forEach(report -> {
                    if (!report.invalid().isEmpty()) {
                        System.err.println("invalid rows: " + report.invalid().size());
                    }
                    System.out.println("posting cents: " + report.totalCents());
                });
    }
}

Trennt interne Fehlerklassen von externen API-Fehlerantworten.

package com.seb4u.demo.errors;

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

public final class ErrorContracts {
    public enum ErrorCode {
        VALIDATION_FAILED(400), NOT_FOUND(404), CONFLICT(409), RATE_LIMITED(429), INTERNAL(500);
        private final int httpStatus;
        ErrorCode(int httpStatus) { this.httpStatus = httpStatus; }
        public int httpStatus() { return httpStatus; }
    }

    public static abstract class DomainException extends RuntimeException {
        private final ErrorCode code;
        protected DomainException(ErrorCode code, String message) {
            super(message);
            this.code = code;
        }
        public ErrorCode code() { return code; }
    }

    public static final class ValidationException extends DomainException {
        private final Map<String, String> fieldErrors;
        public ValidationException(Map<String, String> fieldErrors) {
            super(ErrorCode.VALIDATION_FAILED, "validation failed");
            this.fieldErrors = Map.copyOf(fieldErrors);
        }
        public Map<String, String> fieldErrors() { return fieldErrors; }
    }

    public static final class ConflictException extends DomainException {
        public ConflictException(String message) { super(ErrorCode.CONFLICT, message); }
    }

    public record ApiError(String id, String code, int status, String message, Instant timestamp, Map<String, String> details) {}

    public static ApiError toApiError(Throwable throwable) {
        return switch (throwable) {
            case ValidationException ex -> new ApiError(UUID.randomUUID().toString(), ex.code().name(),
                    ex.code().httpStatus(), ex.getMessage(), Instant.now(), ex.fieldErrors());
            case DomainException ex -> new ApiError(UUID.randomUUID().toString(), ex.code().name(),
                    ex.code().httpStatus(), ex.getMessage(), Instant.now(), Map.of());
            default -> new ApiError(UUID.randomUUID().toString(), ErrorCode.INTERNAL.name(),
                    500, "internal server error", Instant.now(), Map.of("type", throwable.getClass().getName()));
        };
    }
}

Retry nur für explizit erlaubte Fehlerarten; nicht für Validierungsfehler oder nicht-idempotente Operationen.

package com.seb4u.demo.errors;

import java.time.Duration;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Predicate;

public final class RetryPolicy {
    public record RetryConfig(int maxAttempts, Duration firstDelay, double multiplier) {}

    public static <T> T retry(Callable<T> operation, RetryConfig config, Predicate<Throwable> retryable) throws Exception {
        Throwable last = null;
        Duration delay = config.firstDelay();
        for (int attempt = 1; attempt <= config.maxAttempts(); attempt++) {
            try {
                return operation.call();
            } catch (Throwable ex) {
                last = ex;
                if (attempt == config.maxAttempts() || !retryable.test(ex)) break;
                sleepWithJitter(delay);
                delay = Duration.ofMillis((long) (delay.toMillis() * config.multiplier()));
            }
        }
        if (last instanceof Exception e) throw e;
        if (last instanceof Error e) throw e;
        throw new IllegalStateException(last);
    }

    private static void sleepWithJitter(Duration base) throws InterruptedException {
        long jitter = ThreadLocalRandom.current().nextLong(0, Math.max(1, base.toMillis() / 3));
        Thread.sleep(base.plusMillis(jitter));
    }

    public static Predicate<Throwable> retryOn(Class<?>... types) {
        Set<Class<?>> retryable = Set.of(types);
        return ex -> retryable.stream().anyMatch(type -> type.isAssignableFrom(ex.getClass()));
    }
}

Zeigt, wie mehrere Fehler gesammelt und trotzdem diagnostizierbar gehalten werden.

package com.seb4u.demo.errors;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public final class ValidationAggregate {
    public record UserRegistration(String email, String password, int age) {}

    public static void validate(UserRegistration form) {
        Map<String, String> errors = collectErrors(form);
        if (!errors.isEmpty()) throw new ErrorContracts.ValidationException(errors);
    }

    public static Map<String, String> collectErrors(UserRegistration form) {
        java.util.LinkedHashMap<String, String> errors = new java.util.LinkedHashMap<>();
        if (form.email() == null || !form.email().contains("@")) errors.put("email", "must be a valid email");
        if (form.password() == null || form.password().length() < 12) errors.put("password", "minimum length is 12");
        if (form.age() < 18) errors.put("age", "must be at least 18");
        return errors;
    }

    public static RuntimeException aggregate(String message, List<? extends Throwable> failures) {
        RuntimeException combined = new RuntimeException(message + " (" + failures.size() + " failures)");
        failures.forEach(combined::addSuppressed);
        return combined;
    }

    public static void importUsers(List<UserRegistration> forms) {
        List<Throwable> failures = new ArrayList<>();
        for (UserRegistration form : forms) {
            try {
                validate(form);
                // save(form)
            } catch (RuntimeException ex) {
                failures.add(ex);
            }
        }
        if (!failures.isEmpty()) throw aggregate("user import failed", failures);
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.security.*;
import java.time.Instant;
import java.util.HexFormat;
import java.util.function.Consumer;
import java.util.stream.Stream;

public final class SecureImportPipeline {
    private final Path root;
    private final Path inbox;
    private final Path archive;
    private final Path quarantine;

    public SecureImportPipeline(Path root) throws IOException {
        this.root = root.toAbsolutePath().normalize();
        this.inbox = create("inbox");
        this.archive = create("archive");
        this.quarantine = create("quarantine");
    }

    public void importOne(String externalName, Consumer<String> processor) throws IOException {
        Path source = resolveInside(inbox, externalName);
        Path work = source.resolveSibling(source.getFileName() + ".work");
        Files.move(source, work, StandardCopyOption.ATOMIC_MOVE);
        String checksum = "unknown";
        try {
            checksum = sha256(work);
            try (Stream<String> lines = Files.lines(work, StandardCharsets.UTF_8)) {
                lines.filter(line -> !line.isBlank())
                     .map(String::trim)
                     .forEach(processor);
            }
            Path target = archive.resolve(Instant.now().toEpochMilli() + "-" + checksum + ".txt");
            Files.move(work, target, StandardCopyOption.ATOMIC_MOVE);
        } catch (RuntimeException | IOException ex) {
            Path bad = quarantine.resolve(Instant.now().toEpochMilli() + "-" + checksum + ".bad");
            Files.move(work, bad, StandardCopyOption.REPLACE_EXISTING);
            throw ex;
        }
    }

    private Path create(String name) throws IOException {
        Path p = root.resolve(name).normalize();
        if (!p.startsWith(root)) throw new SecurityException("invalid root segment: " + name);
        return Files.createDirectories(p);
    }

    private static Path resolveInside(Path allowedRoot, String name) {
        Path resolved = allowedRoot.resolve(name).normalize().toAbsolutePath();
        if (!resolved.startsWith(allowedRoot.toAbsolutePath().normalize())) {
            throw new SecurityException("Path traversal rejected: " + name);
        }
        return resolved;
    }

    private static String sha256(Path file) throws IOException {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            try (InputStream in = Files.newInputStream(file)) {
                byte[] buf = new byte[8192];
                for (int n; (n = in.read(buf)) > 0; ) digest.update(buf, 0, n);
            }
            return HexFormat.of().formatHex(digest.digest());
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException(e);
        }
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.time.Instant;
import static java.nio.file.StandardOpenOption.*;

public final class DurableAuditLog implements AutoCloseable {
    private final FileChannel channel;

    public DurableAuditLog(Path file) throws IOException {
        Files.createDirectories(file.toAbsolutePath().getParent());
        this.channel = FileChannel.open(file, CREATE, WRITE, APPEND, DSYNC);
    }

    public synchronized void append(String actor, String action, String resource) throws IOException {
        String jsonLine = "{\"ts\":\"" + Instant.now() + "\","
                + "\"actor\":\"" + esc(actor) + "\","
                + "\"action\":\"" + esc(action) + "\","
                + "\"resource\":\"" + esc(resource) + "\"}\n";
        ByteBuffer buffer = StandardCharsets.UTF_8.encode(jsonLine);
        while (buffer.hasRemaining()) channel.write(buffer);
        channel.force(false); // Daten auf Storage-Barriere bringen
    }

    private static String esc(String s) {
        return s.replace("\\", "\\\\").replace("\"", "\\\"");
    }

    @Override public void close() throws IOException { channel.close(); }
}

import java.io.IOException;
import java.nio.file.*;
import java.util.concurrent.*;

public final class BoundedFileImporter implements AutoCloseable {
    private final BlockingQueue<Path> queue = new ArrayBlockingQueue<>(500);
    private final ExecutorService workers = Executors.newFixedThreadPool(4);
    private volatile boolean running = true;

    public BoundedFileImporter() {
        for (int i = 0; i < 4; i++) workers.submit(this::workerLoop);
    }

    public void submit(Path file) throws InterruptedException {
        if (!running) throw new RejectedExecutionException("Importer is stopping");
        queue.put(file); // blockiert bewusst: Producer bekommt Backpressure
    }

    private void workerLoop() {
        while (running || !queue.isEmpty()) {
            try {
                Path file = queue.poll(300, TimeUnit.MILLISECONDS);
                if (file != null) process(file);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            } catch (Exception e) {
                System.err.println("Import failed: " + e.getMessage());
            }
        }
    }

    private void process(Path file) throws IOException {
        long size = Files.size(file);
        if (size == 0 || size > 50_000_000L) throw new IOException("invalid size: " + size);
        // hier: parse, validate, persist, archive
    }

    @Override public void close() {
        running = false;
        workers.shutdown();
    }
}

import java.time.*;
import java.util.*;

public final class BusinessCalendar {
    private final ZoneId zone;
    private final LocalTime cutoff;
    private final Set<LocalDate> holidays;
    private final Clock clock;

    public BusinessCalendar(ZoneId zone, LocalTime cutoff, Set<LocalDate> holidays, Clock clock) {
        this.zone = Objects.requireNonNull(zone);
        this.cutoff = Objects.requireNonNull(cutoff);
        this.holidays = Set.copyOf(holidays);
        this.clock = Objects.requireNonNull(clock);
    }

    public LocalDate bookingDate() {
        ZonedDateTime now = ZonedDateTime.now(clock).withZoneSameInstant(zone);
        LocalDate candidate = now.toLocalTime().isAfter(cutoff)
                ? now.toLocalDate().plusDays(1)
                : now.toLocalDate();
        return nextBusinessDay(candidate);
    }

    public LocalDate nextBusinessDay(LocalDate date) {
        LocalDate d = date;
        while (isWeekend(d) || holidays.contains(d)) d = d.plusDays(1);
        return d;
    }

    public Duration untilCutoff() {
        ZonedDateTime now = ZonedDateTime.now(clock).withZoneSameInstant(zone);
        ZonedDateTime nextCutoff = now.toLocalDate().atTime(cutoff).atZone(zone);
        if (!nextCutoff.isAfter(now)) nextCutoff = nextCutoff.plusDays(1);
        return Duration.between(now, nextCutoff);
    }

    private static boolean isWeekend(LocalDate d) {
        return d.getDayOfWeek() == DayOfWeek.SATURDAY || d.getDayOfWeek() == DayOfWeek.SUNDAY;
    }
}

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.*;

public final class InvoiceRenderer {
    private static final Map<Locale, Map<String, String>> TEXT = Map.of(
        Locale.GERMANY, Map.of("title", "Rechnung", "due", "Fällig am", "total", "Summe"),
        Locale.US, Map.of("title", "Invoice", "due", "Due date", "total", "Total")
    );

    public String render(Invoice invoice, Locale locale, ZoneId zone) {
        Map<String, String> t = TEXT.getOrDefault(locale, TEXT.get(Locale.US));
        NumberFormat money = NumberFormat.getCurrencyInstance(locale);
        money.setCurrency(invoice.currency());
        DateTimeFormatter date = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale);
        LocalDate dueLocal = invoice.dueAt().atZone(zone).toLocalDate();
        return """
            %s #%s
            %s: %s
            %s: %s
            """.formatted(
                t.get("title"), invoice.number(),
                t.get("due"), date.format(dueLocal),
                t.get("total"), money.format(invoice.total())
            );
    }

    public record Invoice(String number, Instant dueAt, BigDecimal total, Currency currency) {}
}

import java.time.*;
import java.util.ArrayList;
import java.util.List;

public final class RecurringSchedule {
    public enum Mode { CALENDAR_DAYS, EXACT_HOURS }

    public static List<ZonedDateTime> nextRuns(ZonedDateTime start, int count, Mode mode) {
        List<ZonedDateTime> result = new ArrayList<>();
        ZonedDateTime current = start;
        for (int i = 0; i < count; i++) {
            result.add(current);
            current = switch (mode) {
                case CALENDAR_DAYS -> current.plus(Period.ofDays(1)); // lokale Uhrzeit bleibt Ziel
                case EXACT_HOURS -> current.plus(Duration.ofHours(24)); // exakt 24h, DST kann Uhrzeit verschieben
            };
        }
        return result;
    }
}

import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Supplier;

public final class VirtualThreadBulkhead implements AutoCloseable {
    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
    private final Semaphore permits;

    public VirtualThreadBulkhead(int maxConcurrent) {
        this.permits = new Semaphore(maxConcurrent);
    }

    public <T> T call(Duration timeout, Supplier<T> task) throws Exception {
        if (!permits.tryAcquire(timeout)) throw new TimeoutException("bulkhead full");
        Future<T> future = executor.submit(() -> {
            try { return task.get(); }
            finally { permits.release(); }
        });
        try {
            return future.get(timeout.toMillis(), TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            future.cancel(true); // Interrupt an den Virtual Thread
            throw e;
        }
    }

    public <T> List<T> callAll(Collection<Supplier<T>> tasks, Duration timeout) throws Exception {
        List<Future<T>> futures = new ArrayList<>();
        for (Supplier<T> task : tasks) {
            permits.acquire();
            futures.add(executor.submit(() -> {
                try { return task.get(); }
                finally { permits.release(); }
            }));
        }
        List<T> out = new ArrayList<>();
        long deadline = System.nanoTime() + timeout.toNanos();
        for (Future<T> f : futures) {
            long left = deadline - System.nanoTime();
            if (left <= 0) throw new TimeoutException("batch timeout");
            out.add(f.get(left, TimeUnit.NANOSECONDS));
        }
        return out;
    }

    @Override public void close() { executor.close(); }
}

import java.util.*;
import java.util.concurrent.*;

public final class ImportQueue<T> implements AutoCloseable {
    private final BlockingQueue<Item<T>> queue;
    private final ExecutorService workers;
    private final List<Throwable> errors = Collections.synchronizedList(new ArrayList<>());
    private final Item<T> stop = new Item<>(null, true);

    public ImportQueue(int capacity, int workerCount, CheckedConsumer<T> consumer) {
        this.queue = new ArrayBlockingQueue<>(capacity);
        this.workers = Executors.newFixedThreadPool(workerCount);
        for (int i = 0; i < workerCount; i++) {
            workers.submit(() -> loop(consumer));
        }
    }

    public void submit(T item) throws InterruptedException {
        queue.put(new Item<>(Objects.requireNonNull(item), false));
    }

    private void loop(CheckedConsumer<T> consumer) {
        try {
            while (true) {
                Item<T> item = queue.take();
                if (item.stop()) return;
                try { consumer.accept(item.value()); }
                catch (Throwable t) { errors.add(t); }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public List<Throwable> errors() { return List.copyOf(errors); }

    @Override public void close() throws InterruptedException {
        for (int i = 0; i < 4; i++) queue.put(stop);
        workers.shutdown();
    }

    private record Item<T>(T value, boolean stop) {}
    public interface CheckedConsumer<T> { void accept(T value) throws Exception; }
}

import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicReference;

public final class RuntimeConfig {
    private final AtomicReference<Snapshot> current = new AtomicReference<>(new Snapshot(50, Duration.ofSeconds(2), true));

    public Snapshot get() { return current.get(); }

    public void update(Snapshot next) {
        current.set(Objects.requireNonNull(next)); // atomarer Austausch, keine halbfertige Config sichtbar
    }

    public boolean tryUpdate(int expectedVersion, Snapshot next) {
        Snapshot old = current.get();
        return old.version() == expectedVersion && current.compareAndSet(old, next);
    }

    public record Snapshot(int maxConcurrent, Duration timeout, boolean featureEnabled, int version) {
        public Snapshot(int maxConcurrent, Duration timeout, boolean featureEnabled) {
            this(maxConcurrent, timeout, featureEnabled, 1);
        }
        public Snapshot {
            if (maxConcurrent < 1 || maxConcurrent > 10_000) throw new IllegalArgumentException("maxConcurrent");
            if (timeout.isNegative() || timeout.isZero()) throw new IllegalArgumentException("timeout");
        }
    }
}

import java.time.Duration;
import java.util.concurrent.*;

public final class AsyncDecisionService {
    private final Executor executor;
    private final CustomerClient customers;
    private final RiskClient risk;
    private final InventoryClient inventory;

    public AsyncDecisionService(Executor executor, CustomerClient customers, RiskClient risk, InventoryClient inventory) {
        this.executor = executor;
        this.customers = customers;
        this.risk = risk;
        this.inventory = inventory;
    }

    public CompletableFuture<Result<Decision>> decide(OrderRequest request) {
        CompletableFuture<Customer> customerF = supply(() -> customers.load(request.customerId()), "customer");
        CompletableFuture<RiskScore> riskF = customerF.thenCompose(c -> supply(() -> risk.score(c), "risk"));
        CompletableFuture<Boolean> stockF = supply(() -> inventory.available(request.sku(), request.quantity()), "inventory")
                .completeOnTimeout(false, 500, TimeUnit.MILLISECONDS);

        return customerF.thenCombine(riskF, Context::new)
                .thenCombine(stockF, (ctx, stock) -> {
                    if (!stock) return Result.ok(new Decision(false, "out_of_stock"));
                    if (ctx.risk().value() > 70) return Result.ok(new Decision(false, "risk_rejected"));
                    return Result.ok(new Decision(true, "accepted"));
                })
                .orTimeout(1200, TimeUnit.MILLISECONDS)
                .exceptionally(ex -> Result.fail("decision_failed", ex));
    }

    private <T> CompletableFuture<T> supply(Callable<T> callable, String stage) {
        return CompletableFuture.supplyAsync(() -> {
            try { return callable.call(); }
            catch (Exception e) { throw new CompletionException(stage + " failed", e); }
        }, executor);
    }

    public record OrderRequest(String customerId, String sku, int quantity) {}
    public record Customer(String id) {}
    public record RiskScore(int value) {}
    public record Context(Customer customer, RiskScore risk) {}
    public record Decision(boolean accepted, String reason) {}

    public sealed interface Result<T> permits Result.Ok, Result.Fail {
        record Ok<T>(T value) implements Result<T> {}
        record Fail<T>(String code, Throwable cause) implements Result<T> {}
        static <T> Result<T> ok(T value) { return new Ok<>(value); }
        static <T> Result<T> fail(String code, Throwable cause) { return new Fail<>(code, cause); }
    }

    interface CustomerClient { Customer load(String id) throws Exception; }
    interface RiskClient { RiskScore score(Customer customer) throws Exception; }
    interface InventoryClient { boolean available(String sku, int quantity) throws Exception; }
}

import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.util.List;
import java.util.concurrent.*;

public final class HedgedHttpClient {
    private final HttpClient client = HttpClient.newHttpClient();
    private final ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();

    public CompletableFuture<String> getFastest(List<URI> replicas, Duration hedgeDelay) {
        CompletableFuture<String> winner = new CompletableFuture<>();
        CopyOnWriteArrayList<CompletableFuture<?>> running = new CopyOnWriteArrayList<>();

        for (int i = 0; i < replicas.size(); i++) {
            URI uri = replicas.get(i);
            long delayMs = hedgeDelay.toMillis() * i;
            timer.schedule(() -> {
                if (winner.isDone()) return;
                CompletableFuture<String> f = send(uri);
                running.add(f);
                f.whenComplete((body, ex) -> {
                    if (ex == null) winner.complete(body);
                    else if (running.stream().allMatch(CompletableFuture::isDone)) winner.completeExceptionally(ex);
                });
            }, delayMs, TimeUnit.MILLISECONDS);
        }

        winner.whenComplete((v, ex) -> running.forEach(f -> f.cancel(true)));
        return winner.orTimeout(2, TimeUnit.SECONDS);
    }

    private CompletableFuture<String> send(URI uri) {
        HttpRequest req = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(1)).GET().build();
        return client.sendAsync(req, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body);
    }
}

import java.util.*;
import java.util.concurrent.*;
import java.util.function.Function;

public final class AsyncBatch {
    public static <I, O> CompletableFuture<BatchResult<I, O>> run(
            List<I> input, Function<I, CompletableFuture<O>> fn) {
        List<CompletableFuture<ItemResult<I, O>>> futures = input.stream()
                .map(item -> fn.apply(item)
                        .thenApply(value -> ItemResult.ok(item, value))
                        .exceptionally(ex -> ItemResult.fail(item, ex)))
                .toList();

        return CompletableFuture.allOf(futures.toArray(CompletableFuture[]::new))
                .thenApply(ignored -> new BatchResult<>(futures.stream().map(CompletableFuture::join).toList()));
    }

    public record BatchResult<I, O>(List<ItemResult<I, O>> items) {
        public boolean hasFailures() { return items.stream().anyMatch(i -> i instanceof ItemResult.Fail<I, O>); }
    }

    public sealed interface ItemResult<I, O> permits ItemResult.Ok, ItemResult.Fail {
        I input();
        record Ok<I, O>(I input, O value) implements ItemResult<I, O> {}
        record Fail<I, O>(I input, Throwable error) implements ItemResult<I, O> {}
        static <I, O> ItemResult<I, O> ok(I input, O value) { return new Ok<>(input, value); }
        static <I, O> ItemResult<I, O> fail(I input, Throwable error) { return new Fail<>(input, error); }
    }
}

import java.time.*;
import java.util.*;
import java.util.function.Function;

public final class TtlLruCache<K, V> {
    private final int maxEntries;
    private final Duration ttl;
    private final Clock clock;
    private final LinkedHashMap<K, Entry<V>> map;

    public TtlLruCache(int maxEntries, Duration ttl, Clock clock) {
        if (maxEntries < 1) throw new IllegalArgumentException("maxEntries");
        this.maxEntries = maxEntries;
        this.ttl = ttl;
        this.clock = clock;
        this.map = new LinkedHashMap<>(16, 0.75f, true) {
            @Override protected boolean removeEldestEntry(Map.Entry<K, Entry<V>> eldest) {
                return size() > TtlLruCache.this.maxEntries;
            }
        };
    }

    public synchronized V get(K key, Function<K, V> loader) {
        Instant now = clock.instant();
        Entry<V> entry = map.get(key);
        if (entry != null && entry.expiresAt().isAfter(now)) return entry.value();
        V loaded = Objects.requireNonNull(loader.apply(key));
        map.put(key, new Entry<>(loaded, now.plus(ttl)));
        return loaded;
    }

    public synchronized void purgeExpired() {
        Instant now = clock.instant();
        map.entrySet().removeIf(e -> !e.getValue().expiresAt().isAfter(now));
    }

    public synchronized int size() { return map.size(); }
    private record Entry<V>(V value, Instant expiresAt) {}
}

import java.lang.ref.WeakReference;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Consumer;

public final class ListenerRegistry<E> {
    private final CopyOnWriteArrayList<WeakReference<Consumer<E>>> listeners = new CopyOnWriteArrayList<>();

    public AutoCloseable subscribe(Consumer<E> listener) {
        WeakReference<Consumer<E>> ref = new WeakReference<>(Objects.requireNonNull(listener));
        listeners.add(ref);
        return () -> listeners.remove(ref);
    }

    public void publish(E event) {
        for (WeakReference<Consumer<E>> ref : listeners) {
            Consumer<E> listener = ref.get();
            if (listener == null) listeners.remove(ref);
            else listener.accept(event);
        }
    }

    public int approximateSubscriberCount() {
        listeners.removeIf(ref -> ref.get() == null);
        return listeners.size();
    }
}

import java.lang.management.*;
import java.time.Instant;

public final class MemoryProbe {
    private final MemoryMXBean memory = ManagementFactory.getMemoryMXBean();

    public Snapshot snapshot(String label) {
        MemoryUsage heap = memory.getHeapMemoryUsage();
        MemoryUsage nonHeap = memory.getNonHeapMemoryUsage();
        return new Snapshot(label, Instant.now(), heap.getUsed(), heap.getCommitted(), heap.getMax(), nonHeap.getUsed());
    }

    public void printDelta(Snapshot before, Snapshot after) {
        System.out.printf("%s -> %s heap delta: %,d bytes%n",
                before.label(), after.label(), after.heapUsed() - before.heapUsed());
    }

    public record Snapshot(String label, Instant ts, long heapUsed, long heapCommitted, long heapMax, long nonHeapUsed) {}
}

// module com.seb4u.demo.payments.api
module com.seb4u.demo.payments.api {
    exports com.seb4u.demo.payments.api;
}

// package com.seb4u.demo.payments.api
package com.seb4u.demo.payments.api;

import java.math.BigDecimal;
import java.util.Currency;

public interface PaymentProvider {
    String name();
    PaymentResult authorize(PaymentRequest request);
}

public record PaymentRequest(String orderId, BigDecimal amount, Currency currency) {}
public record PaymentResult(boolean accepted, String providerReference, String reason) {}

// module com.seb4u.demo.payments.fake
module com.seb4u.demo.payments.fake {
    requires com.seb4u.demo.payments.api;
    provides com.seb4u.demo.payments.api.PaymentProvider
        with com.seb4u.demo.payments.fake.FakePaymentProvider;
}

package com.seb4u.demo.checkout.bootstrap;

import com.seb4u.demo.payments.api.PaymentProvider;
import java.util.*;

public final class PaymentProviderRegistry {
    private final Map<String, PaymentProvider> providers;

    public PaymentProviderRegistry(ServiceLoader<PaymentProvider> loader) {
        Map<String, PaymentProvider> tmp = new TreeMap<>();
        for (PaymentProvider provider : loader) {
            PaymentProvider previous = tmp.putIfAbsent(provider.name(), provider);
            if (previous != null) throw new IllegalStateException("duplicate provider: " + provider.name());
        }
        this.providers = Map.copyOf(tmp);
    }

    public PaymentProvider require(String name) {
        PaymentProvider provider = providers.get(name);
        if (provider == null) throw new NoSuchElementException("payment provider not found: " + name);
        return provider;
    }

    public Set<String> names() { return providers.keySet(); }
}

package com.seb4u.demo.application;

import com.seb4u.demo.domain.*;
import java.util.Objects;

public final class PlaceOrderUseCase {
    private final OrderRepository orders;
    private final PaymentPort payments;
    private final DomainEventPublisher events;

    public PlaceOrderUseCase(OrderRepository orders, PaymentPort payments, DomainEventPublisher events) {
        this.orders = Objects.requireNonNull(orders);
        this.payments = Objects.requireNonNull(payments);
        this.events = Objects.requireNonNull(events);
    }

    public OrderId place(PlaceOrder command) {
        Order order = Order.draft(command.customerId());
        command.lines().forEach(line -> order.add(line.sku(), line.quantity()));
        PaymentReceipt receipt = payments.authorize(order.id(), order.total());
        order.markPaid(receipt.reference());
        orders.save(order);
        events.publishAll(order.pullEvents());
        return order.id();
    }

    public interface OrderRepository { void save(Order order); }
    public interface PaymentPort { PaymentReceipt authorize(OrderId id, Money total); }
    public interface DomainEventPublisher { void publishAll(java.util.List<DomainEvent> events); }
}

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>dev.master</groupId>
  <artifactId>commerce-core</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>25</maven.compiler.release>
    <project.build.outputTimestamp>2026-01-01T00:00:00Z</project.build.outputTimestamp>
  </properties>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-enforcer-plugin</artifactId>
        <version>3.6.1</version>
        <executions><execution><goals><goal>enforce</goal></goals></execution></executions>
        <configuration>
          <rules>
            <requireJavaVersion><version>[25,26)</version></requireJavaVersion>
            <dependencyConvergence />
          </rules>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

plugins {
    java
    application
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(25))
    }
}

tasks.withType<Test>().configureEach {
    useJUnitPlatform()
    testLogging {
        events("failed", "skipped")
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
    }
}

tasks.jar {
    manifest {
        attributes(
            "Implementation-Title" to project.name,
            "Implementation-Version" to project.version,
            "Built-By" to "reproducible-build"
        )
    }
}

import java.io.IOException;
import java.io.InputStream;
import java.time.Instant;
import java.util.Properties;

public final class BuildInfo {
    private final Properties props = new Properties();

    public static BuildInfo load() {
        BuildInfo info = new BuildInfo();
        try (InputStream in = BuildInfo.class.getResourceAsStream("/build-info.properties")) {
            if (in != null) info.props.load(in);
        } catch (IOException e) {
            throw new IllegalStateException("Cannot load build-info.properties", e);
        }
        return info;
    }

    public String version() { return props.getProperty("version", "dev"); }
    public String commit() { return props.getProperty("commit", "unknown"); }
    public Instant buildTime() { return Instant.parse(props.getProperty("time", "1970-01-01T00:00:00Z")); }

    public String asJson() {
        return "{\"version\":\"" + version() + "\",\"commit\":\"" + commit() + "\",\"time\":\"" + buildTime() + "\"}";
    }
}

import java.io.IOException;
import java.nio.file.*;
import java.security.*;
import java.util.*;
import java.util.HexFormat;
import java.util.stream.Stream;

public final class DependencyFingerprint {
    public static Map<String, String> fingerprint(Path libDir) throws IOException {
        Map<String, String> result = new TreeMap<>();
        try (Stream<Path> files = Files.list(libDir)) {
            for (Path jar : files.filter(p -> p.toString().endsWith(".jar")).toList()) {
                result.put(jar.getFileName().toString(), sha256(jar));
            }
        }
        return result;
    }

    private static String sha256(Path file) throws IOException {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(Files.readAllBytes(file));
            return HexFormat.of().formatHex(md.digest());
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException(e);
        }
    }
}