Batch

package at.aydin.lab.batch.legacy;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

// Design Pattern: Template Method (manuell angedeutet)
// Zweck: Lesen, Überspringen, Parsen und Schreiben bilden einen festen Batch-Ablauf.
public final class LegacyBatchImporter {
    private final CsvOrderParser parser = new CsvOrderParser();
    public List<OrderRow> importFile(Path path) throws IOException {
        try (var lines = Files.lines(path)) {
            return lines.skip(1).filter(line -> !line.isBlank()).map(parser::parse).toList();
        }
    }
}

package at.aydin.lab.batch.legacy;

import java.math.BigDecimal;

// Design Pattern: Mapper
// Zweck: Transportformat CSV wird in ein fachliches Objekt übersetzt.
public final class CsvOrderParser {
    public OrderRow parse(String line) {
        String[] columns = line.split(",", -1);
        if (columns.length != 3) throw new IllegalArgumentException("Ungültige CSV-Zeile: " + line);
        return new OrderRow(Long.parseLong(columns[0].trim()), columns[1].trim(), new BigDecimal(columns[2].trim()));
    }
}

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.batch.legacy;

import java.math.BigDecimal;

public record OrderRow(long id, String customer, BigDecimal amount) {
}

package at.aydin.lab.batch.modern;

import java.math.BigDecimal;

public record OrderRow(long id, String customer, BigDecimal amount) {
}

package at.aydin.lab.batch.legacy;

import java.nio.file.Path;

public final class BatchLegacyApplication {
    private BatchLegacyApplication() {
    }

    public static void main(String[] args) throws Exception {
        Path input = args.length == 0 ? Path.of("src/main/resources/sample-orders.csv") : Path.of(args[0]);
        new LegacyBatchImporter().importFile(input).forEach(System.out::println);
    }
}

package at.aydin.lab.batch.modern;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BatchModernApplication {
    public static void main(String[] args) {
        SpringApplication.run(BatchModernApplication.class, args);
    }
}