Spring Boot 4 Microservices & REST APIs · Aula

Leitores, processadores e gravadores

Crie o fluxo de processamento em lote orientado a blocos.

Leitores, processadores e gravadores é uma aula grátis de Spring Boot 4 Microservices & REST APIs no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Spring Boot 4 Microservices & REST APIs, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Spring Boot 4 Microservices & REST APIs inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

The read-process-write triad

A chunk step has three collaborators:

ItemReader - supplies items one at a time
ItemProcessor - transforms or filters an item
ItemWriter - persists a chunk of items

ItemReader interface

ItemReader.read() returns the next item, or null when the input is exhausted. Spring Batch keeps calling it until it returns null.

public interface ItemReader<T> {
    T read() throws Exception;
}

FlatFileItemReader

For CSV files, FlatFileItemReader reads lines and maps them to objects via a line mapper.

@Bean
public FlatFileItemReader<Person> reader() {
    return new FlatFileItemReaderBuilder<Person>()
            .name("personReader")
            .resource(new ClassPathResource("people.csv"))
            .delimited()
            .names("firstName", "lastName")
            .targetType(Person.class)
            .build();
}

JdbcCursorItemReader

To read from a database, use JdbcCursorItemReader or JdbcPagingItemReader. Paging is preferred for very large result sets to avoid holding a long cursor.

@Bean
public JdbcCursorItemReader<Person> dbReader(DataSource ds) {
    return new JdbcCursorItemReaderBuilder<Person>()
            .name("dbReader")
            .dataSource(ds)
            .sql("SELECT first_name, last_name FROM people")
            .rowMapper(new PersonRowMapper())
            .build();
}

ItemProcessor interface

ItemProcessor transforms an input item into an output item. The input and output types can differ.

public interface ItemProcessor<I, O> {
    O process(I item) throws Exception;
}

Writing a processor

Here a processor uppercases names. Returning a transformed object is the common case.

public class UpperCaseProcessor implements ItemProcessor<Person, Person> {
    @Override
    public Person process(Person p) {
        return new Person(p.getFirstName().toUpperCase(),
                          p.getLastName().toUpperCase());
    }
}

Filtering with the processor

If a processor returns null, the item is filtered out and never reaches the writer. This is how you skip records based on business rules.

public Person process(Person p) {
    if (p.getLastName().isBlank()) {
        return null; // drop this record
    }
    return p;
}

ItemWriter interface

ItemWriter receives a chunk of items at once, not single items. This lets it batch the write into one efficient operation.

public interface ItemWriter<T> {
    void write(Chunk<? extends T> chunk) throws Exception;
}

JdbcBatchItemWriter

JdbcBatchItemWriter performs a batched SQL insert/update for the whole chunk, which is far faster than row-by-row writes.

@Bean
public JdbcBatchItemWriter<Person> writer(DataSource ds) {
    return new JdbcBatchItemWriterBuilder<Person>()
            .dataSource(ds)
            .sql("INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)")
            .beanMapped()
            .build();
}

Wiring them into a step

The step ties the triad together with a chunk size. Items flow reader -> processor -> writer in chunks.

return new StepBuilder("step1", repo)
        .<Person, Person>chunk(50, tx)
        .reader(reader())
        .processor(new UpperCaseProcessor())
        .writer(writer(ds))
        .build();

Custom readers and writers

You can implement the interfaces directly for custom sources (a REST API, a queue). Spring also offers ItemStream so your component can save and restore its position for restarts.

Quick Check

Verify your understanding of the triad.

Recap

You assembled a chunk pipeline:

ItemReader.read() returns items until null
ItemProcessor transforms; returning null filters
ItemWriter writes a whole Chunk at once
The step binds all three with a chunk size

Perguntas Frequentes

A aula “Leitores, processadores e gravadores” é grátis?

Sim — o texto completo de “Leitores, processadores e gravadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Spring Boot 4 Microservices & REST APIs, atualize para CoddyKit PRO. O curso de Spring Boot 4 Microservices & REST APIs inclui 4 aulas no total.

O que vou aprender em “Leitores, processadores e gravadores”?

Crie o fluxo de processamento em lote orientado a blocos. Você pratica Spring Boot 4 Microservices & REST APIs com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Spring Boot 4 Microservices & REST APIs?

Nenhuma experiência prévia é necessária. Spring Boot 4 Microservices & REST APIs no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Leitores, processadores e gravadores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Spring Boot 4 Microservices & REST APIs?

Sim. Cada aula de Spring Boot 4 Microservices & REST APIs inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Spring Boot 4 Microservices & REST APIs