Legacy ↔ Modern

package at.aydin.lab.di.modern;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class GreetingRunner implements CommandLineRunner {
    private final GreetingPort greetingPort;
    // Design Pattern: Constructor Injection
    // Zweck: Abhängigkeiten sind sichtbar, unveränderlich und leicht testbar.
    public GreetingRunner(GreetingPort greetingPort) {
        this.greetingPort = greetingPort;
    }

    @Override
    public void run(String ... args) {
        System.out.println(greetingPort.greet("Aydin"));
    }
}

package at.aydin.lab.di.modern;

import org.springframework.stereotype.Service;

@Service
public class GermanGreetingService implements GreetingPort {
    @Override
    public String greet(String name) {
        return "Willkommen, " + name + "!";
    }
}

package at.aydin.lab.aop.modern;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
// Design Pattern: Interceptor / Aspect
// Zweck: Monitoring bleibt getrennt von der Geschäftslogik.
public class TrackingAspect {
    @Around("@annotation(Tracked)")
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
        long started = System.nanoTime();
        try {
            return joinPoint.proceed();
        } finally {
            long micros = (System.nanoTime() - started) / 1_000;
            System.out.printf("%s dauerte %d µs%n", joinPoint.getSignature().toShortString(), micros);
        }
    }
}

package at.aydin.lab.aop.modern;

import org.springframework.stereotype.Service;

@Service
public class TrackedCalculator implements Calculator {
    @Override
    @Tracked
    public int add(int left, int right) {
        return left + right;
    }
}

package at.aydin.lab.rest.modern;

import jakarta.validation.Valid;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;
import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {
    private final BookService service;
    public BookController(BookService service) {
        this.service = service;
    }

    @GetMapping
    public List<Book> all() {
        return service.findAll();
    }

    @PostMapping
    public ResponseEntity<Book> create(@Valid @RequestBody Book book, UriComponentsBuilder uriBuilder) {
        Book created = service.create(book);
        return ResponseEntity.created(uriBuilder.path("/api/books/{id}").build(created.id())).body(created);
    }
}

package at.aydin.lab.rest.modern;

import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

@Repository
// Design Pattern: Repository
// Zweck: Der Controller kennt keine Details der Datenhaltung.
public class BookRepository {
    private final ConcurrentHashMap<Long, Book> books = new ConcurrentHashMap<>();
    private final AtomicLong sequence = new AtomicLong();
    public BookRepository() {
        save(new Book(0, "Modernes Enterprise Java"));
    }

    public List<Book> findAll() {
        return List.copyOf(books.values());
    }

    public Book save(Book input) {
        long id = input.id() == 0 ? sequence.incrementAndGet() : input.id();
        Book stored = new Book(id, input.title());
        books.put(id, stored);
        return stored;
    }
}

package at.aydin.lab.persistence.modern;

import org.springframework.data.jpa.repository.JpaRepository;

// Design Pattern: Repository
// Zweck: Spring Data erzeugt die technische Implementierung aus dem Interface.
public interface CustomerRepository extends JpaRepository<CustomerEntity, Long> {
}

package at.aydin.lab.persistence.modern;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "customer")
public class CustomerEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    protected CustomerEntity() {
    }

    public CustomerEntity(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    @Override
    public String toString() {
        return "CustomerEntity[id=" + id + ", name=" + name + ", email=" + email + "]";
    }
}

package at.aydin.lab.transactions.modern;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;

@Service
// Design Pattern: Service Layer + declarative Transaction Boundary
// Zweck: Rollback-Regeln werden vom Framework statt durch manuelles JDBC gesteuert.
public class TransferService {
    private final AccountRepository repository;
    public TransferService(AccountRepository repository) {
        this.repository = repository;
    }

    @Transactional
    public void transfer(long from, long to, BigDecimal amount, boolean simulateFailure) {
        repository.changeBalance(from, amount.negate());
        if (simulateFailure) throw new IllegalStateException("Simulierter Fehler");
        repository.changeBalance(to, amount);
    }
}

package at.aydin.lab.batch.modern;

import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.database.builder.JdbcBatchItemWriterBuilder;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.builder.FlatFileItemReaderBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.transaction.PlatformTransactionManager;

@Configuration
// Design Pattern: Pipeline
// Zweck: Reader, Processor und Writer sind austauschbare, getrennt testbare Batch-Stufen.
public class BatchConfiguration {
    @Bean
    FlatFileItemReader<OrderRow> orderReader() {
        return new FlatFileItemReaderBuilder<OrderRow>()
                .name("orderReader")
                .resource(new ClassPathResource("sample-orders.csv"))
                .linesToSkip(1)
                .delimited()
                .names("id", "customer", "amount")
                .fieldSetMapper(fieldSet -> new OrderRow(
                        fieldSet.readLong("id"),
                        fieldSet.readString("customer"),
                        fieldSet.readBigDecimal("amount")))
                .build();
    }

    @Bean
    ItemProcessor<OrderRow, OrderRow> positiveAmountProcessor() {
        return item -> item.amount().signum() > 0 ? item : null;
    }

    @Bean
    JdbcBatchItemWriter<OrderRow> orderWriter(DataSource dataSource) {
        return new JdbcBatchItemWriterBuilder<OrderRow>()
                .dataSource(dataSource)
                .sql("insert into imported_order(id,customer,amount) "
                        + "values (:id,:customer,:amount)")
                .itemSqlParameterSourceProvider(item -> new MapSqlParameterSource()
                        .addValue("id", item.id())
                        .addValue("customer", item.customer())
                        .addValue("amount", item.amount()))
                .build();
    }

    @Bean
    Step importOrders(
            JobRepository jobRepository,
            PlatformTransactionManager transactionManager,
            FlatFileItemReader<OrderRow> orderReader,
            ItemProcessor<OrderRow, OrderRow> positiveAmountProcessor,
            JdbcBatchItemWriter<OrderRow> orderWriter) {
        return new StepBuilder("importOrders", jobRepository)
                .<OrderRow, OrderRow>chunk(10, transactionManager)
                .reader(orderReader)
                .processor(positiveAmountProcessor)
                .writer(orderWriter)
                .build();
    }

    @Bean
    Job importOrderJob(JobRepository jobRepository, Step importOrders) {
        return new JobBuilder("importOrderJob", jobRepository)
                .start(importOrders)
                .build();
    }
}

package at.aydin.lab.messaging.modern;

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

@Component
// Design Pattern: Messaging Gateway
// Zweck: Fachcode muss weder Connection noch Session verwalten.
public class OrderMessagePublisher {
    private final JmsTemplate jmsTemplate;
    public OrderMessagePublisher(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    public void publish(String orderNumber) {
        jmsTemplate.convertAndSend("orders", orderNumber);
    }
}

package at.aydin.lab.xml.modern;

import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.Marshaller;
import java.io.StringWriter;

// Design Pattern: Mapper
// Zweck: Jakarta JAXB kapselt die XML-Serialisierung hinter einer klaren API.
public final class ModernXmlMapper {
    public String toXml(ModernCustomer customer) throws Exception {
        JAXBContext context = JAXBContext.newInstance(ModernCustomer.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        StringWriter writer = new StringWriter();
        marshaller.marshal(customer, writer);
        return writer.toString();
    }
}

package at.aydin.lab.web.modern;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;

@RestController
// Design Pattern: Front Controller + MVC Controller
// Zweck: Spring MVC übernimmt Routing, Konvertierung und HTTP-Infrastruktur.
public class StatusController {
    @GetMapping("/status")
    public Map<String, String> status() {
        return Map.of("status", "UP", "stack", "Spring MVC / jakarta.servlet");
    }
}

package at.aydin.lab.soap.modern;

import jakarta.jws.WebMethod;
import jakarta.jws.WebService;

@WebService(serviceName = "ModernCalculatorService")
// Design Pattern: Remote Facade
// Zweck: Der Vertrag bleibt stabil, während die Laufzeit auf Jakarta migriert wird.
public class ModernCalculatorEndpoint {
    @WebMethod
    public int add(int left, int right) {
        return left + right;
    }
}

package at.aydin.lab.basics.modern;

// Design Pattern: Value Object
// Zweck: Unveränderliche, validierte fachliche Daten mit wertbasierter Gleichheit.
public record Customer(long id, String name, CustomerStatus status) {
    public Customer {
        if (id <= 0) throw new IllegalArgumentException("id muss positiv sein");
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name fehlt");
        if (status == null) throw new IllegalArgumentException("status fehlt");
    }

    public String displayText() {
        return "%d: %s [%s]".formatted(id, name, status);
    }
}

package at.aydin.lab.collections.modern;

import java.util.*;

// Design Pattern: Snapshot
// Zweck: Gibt unveränderliche Momentaufnahmen statt interner mutabler Collections zurück.
public final class Inventory {
    private final LinkedHashMap<String, Integer> stock = new LinkedHashMap<>();
    public void add(String sku, int quantity) {
        Objects.requireNonNull(sku);
        if (quantity <= 0) throw new IllegalArgumentException("quantity");
        stock.merge(sku, quantity, Integer::sum);
    }

    public int quantity(String sku) {
        return stock.getOrDefault(sku, 0);
    }

    public Map<String, Integer> snapshot() {
        return Collections.unmodifiableMap(new LinkedHashMap<>(stock));
    }

    public List<String> orderedSkus() {
        return List.copyOf(stock.sequencedKeySet());
    }
}

package at.aydin.lab.generics.modern;

// Design Pattern: Generic Container
// Zweck: Der gespeicherte Typ wird zur Compile-Zeit festgelegt; Laufzeit-Casts entfallen.
public final class TypedBox<T> {
    private T value;
    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }
}

package at.aydin.lab.generics.modern;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class TypedBoxTest {
    @Test
    void preservesTheDeclaredType() {
        TypedBox<String> box = new TypedBox<>();
        box.set("text");
        assertEquals("text", box.get());
    }
}

package at.aydin.lab.annotations.modern;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

// Design Pattern: Command + Metadata Registry
// Zweck: Annotationen machen Namen explizit und entkoppeln sie von Methodenkonventionen.
public final class CommandRegistry {
    private record Handler(Object target, Method method) {}

    private final Map<String, Handler> handlers = new HashMap<>();

    public CommandRegistry(Object... targets) {
        for (Object target : targets) {
            for (Method method : target.getClass().getDeclaredMethods()) {
                Command command = method.getAnnotation(Command.class);
                if (command != null) {
                    handlers.put(command.value(), new Handler(target, method));
                }
            }
        }
    }

    public String execute(String command, String argument) {
        Handler handler = Optional.ofNullable(handlers.get(command))
                .orElseThrow(() -> new IllegalArgumentException(
                        "Unbekanntes Kommando: " + command));
        try {
            return (String) handler.method().invoke(handler.target(), argument);
        } catch (ReflectiveOperationException exception) {
            throw new IllegalStateException(exception);
        }
    }
}

package at.aydin.lab.annotations.modern;

public final class ModernCommands {
    @Command("hello")
    public String greet(String name) {
        return "Hallo " + name;
    }

    @Command("bye")
    public String farewell(String name) {
        return "Tschüss " + name;
    }
}

package at.aydin.lab.streams.modern;

import java.util.*;

// Design Pattern: Pipeline
// Zweck: Filter-, Mapping- und Reduktionsschritte werden deklarativ zusammengesetzt.
public final class OrderAnalytics {
    public List<String> paidCustomersOver(List<Order> orders, double limit) {
        return orders.stream().filter(Order::paid).filter(o -> o.total() > limit).map(Order::customer).distinct()
                .sorted().toList();
    }

    public double totalRevenue(List<Order> orders) {
        return orders.stream().filter(Order::paid).mapToDouble(Order::total).sum();
    }
}

package at.aydin.lab.concurrency.modern;

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

// Design Pattern: Task Executor
// Zweck: Ein Virtual Thread pro blockierender Aufgabe vereinfacht skalierbare Nebenläufigkeit.
public final class VirtualThreadTaskRunner {
    public List<String> run(List<Callable<String>> tasks) {
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futures = tasks.stream().map(executor::submit).toList();
            List<String> result = new ArrayList<>(futures.size());
            for (Future<String> future : futures) result.add(future.get());
            return List.copyOf(result);
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(ex);
        } catch (ExecutionException ex) {
            throw new IllegalStateException(ex.getCause());
        }
    }
}

package at.aydin.lab.io.modern;

import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.zip.*;

// Design Pattern: Adapter
// Zweck: Fachliche Dateioperationen werden hinter der modernen Path-/Files-API gebündelt.
public final class PathFileService {
    public long copy(Path source, Path target) throws IOException {
        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
        return Files.size(target);
    }

    public List<Path> find(Path root, String suffix) throws IOException {
        try (var paths = Files.walk(root)) {
            return paths.filter(Files::isRegularFile).filter(p -> p.getFileName().toString().endsWith(suffix)).sorted()
                    .toList();
        }
    }

    public void zip(Path source, Path zip) throws IOException {
        try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(zip))) {
            out.putNextEntry(new ZipEntry(source.getFileName().toString()));
            Files.copy(source, out);
            out.closeEntry();
        }
    }
}