Spring Batch - Data Transformation with ItemProcessors

@Bean
public Step myStep(ItemReader<InputType> reader,
                   ItemProcessor<InputType, OutputType> processor,
                   ItemWriter<OutputType> writer) {
    return stepBuilderFactory.get("myStep")
            .<InputType, OutputType>chunk(10)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            .build();
}

package com.geeksforgeeks.model;

import java.util.Date;

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

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

/**
 * Represents a programming tutorial entity.
 *
 * This class is annotated with JPA annotations for entity mapping. Lombok
 * annotations are used to generate getters, setters, and constructors.
 * Hibernate annotations are used to handle timestamp creation and updates.
 *
 * @author rahul.chauhan
 */
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProgrammingTutorial {
    /**
     * Unique identifier for the tutorial.
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * Title of the programming tutorial.
     */
    @Column
    private String title;

    /**
     * Programming language covered in the tutorial.
     */
    @Column
    private String language;

    /**
     * Content of the programming tutorial.
     */
    @Column
    private String content;

    /**
     * Author of the programming tutorial.
     */
    @Column
    private String author;

    /**
     * Timestamp representing the creation time of the tutorial. Automatically
     * populated by Hibernate.
     */
    @CreationTimestamp
    private Date createTime;

    /**
     * Timestamp representing the last update time of the tutorial. Automatically
     * updated by Hibernate.
     */
    @UpdateTimestamp
    private Date lastUpdateTime;
}

package com.geeksforgeeks.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.geeksforgeeks.model.ProgrammingTutorial;

public interface TutorialRepository extends JpaRepository<ProgrammingTutorial, Long> {
}

/*
BatchConfiguration.java
*/
package com.geeksforgeeks.batch;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

import com.geeksforgeeks.model.ProgrammingTutorial;

@Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;
    private final JobLauncher jobLauncher;
    private final JobCompletionNotificationListener notificationListener;
    private final TutorialItemReader tutorialItemReader;
    private final TutorialItemProcessor tutorialItemProcessor;
    private final TutorialItemWriter tutorialItemWriter;

    @Autowired
    public BatchConfiguration(
            JobBuilderFactory jobBuilderFactory,
            StepBuilderFactory stepBuilderFactory,
            JobLauncher jobLauncher,
            JobCompletionNotificationListener notificationListener,
            TutorialItemReader tutorialItemReader,
            TutorialItemProcessor tutorialItemProcessor,
            TutorialItemWriter tutorialItemWriter
    ) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
        this.jobLauncher = jobLauncher;
        this.notificationListener = notificationListener;
        this.tutorialItemReader = tutorialItemReader;
        this.tutorialItemProcessor = tutorialItemProcessor;
        this.tutorialItemWriter = tutorialItemWriter;
    }

    @Bean
    public Job processContentJob() {
        return jobBuilderFactory.get("processContentJob")
                .incrementer(new RunIdIncrementer())
                .listener(notificationListener)
                .flow(processContentStep())
                .end()
                .build();
    }

    @Bean
    public Step processContentStep() {
        return stepBuilderFactory.get("processContentStep")
                .<ProgrammingTutorial, ProgrammingTutorial>chunk(10)
                .reader(tutorialItemReader)
                .processor(tutorialItemProcessor)
                .writer(tutorialItemWriter)
                .build();
    }
}

/*
JobCompletionNotificationListener.java
*/
package com.geeksforgeeks.batch;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.stereotype.Component;

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {

    @Override
    public void afterJob(JobExecution jobExecution) {
        if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
            System.out.println("Batch Job Completed Successfully! Time to verify the results.");
        }
    }
}

/*
TutorialItemProcessor.java
*/
package com.geeksforgeeks.batch;

import org.springframework.batch.item.ItemProcessor;
import org.springframework.stereotype.Component;

import com.geeksforgeeks.model.ProgrammingTutorial;

@Component
public class TutorialItemProcessor implements ItemProcessor<ProgrammingTutorial, ProgrammingTutorial> {

    @Override
    public ProgrammingTutorial process(ProgrammingTutorial tutorial) throws Exception {
        // Your transformation logic here
        tutorial.setTitle("Transformed: " + tutorial.getTitle());
        tutorial.setContent(transformContent(tutorial.getContent()));
        return tutorial;
    }

    private String transformContent(String content) {
        // Your content transformation logic here
        // For example, perform language-specific adjustments
        return content.toUpperCase();
    }
}

/*
TutorialItemReader.java
*/
package com.geeksforgeeks.batch;

import java.util.Iterator;
import java.util.List;

import org.springframework.batch.item.ItemReader;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.geeksforgeeks.model.ProgrammingTutorial;
import com.geeksforgeeks.repository.TutorialRepository;

@Component
public class TutorialItemReader implements ItemReader<ProgrammingTutorial> {

    @Autowired
    private TutorialRepository tutorialRepository;

    private Iterator<ProgrammingTutorial> tutorialIterator;

    @Override
    public ProgrammingTutorial read() throws Exception {
        if (tutorialIterator == null || !tutorialIterator.hasNext()) {
            initializeIterator();
        }
        return tutorialIterator.hasNext() ? tutorialIterator.next() : null;
    }

    private void initializeIterator() {
        List<ProgrammingTutorial> tutorials = tutorialRepository.findAll();
        tutorialIterator = tutorials.iterator();
    }
}

/*
TutorialItemWriter.java
*/
package com.geeksforgeeks.batch;

import java.util.List;

import org.springframework.batch.item.ItemWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.geeksforgeeks.model.ProgrammingTutorial;
import com.geeksforgeeks.repository.TutorialRepository;

@Component
public class TutorialItemWriter implements ItemWriter<ProgrammingTutorial> {

    @Autowired
    private TutorialRepository tutorialRepository;

    @Override
    public void write(List<? extends ProgrammingTutorial> tutorials) throws Exception {
        tutorialRepository.saveAll(tutorials);
    }
}

package com.geeksforgeeks.controller;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/content")
public class ContentProcessingController {

    private final JobLauncher jobLauncher;
    private final Job processContentJob;

    public ContentProcessingController(JobLauncher jobLauncher, Job processContentJob) {
        this.processContentJob = processContentJob;
        this.jobLauncher = jobLauncher;
    }

    @PostMapping("/process")
    public ResponseEntity<String> processContent() {
        try {
            JobParameters jobParameters = new JobParametersBuilder()
                    .addString("jobParam1", String.valueOf(System.currentTimeMillis())).toJobParameters();

            JobExecution jobExecution = jobLauncher.run(processContentJob, jobParameters);

            return ResponseEntity.ok("Content processing job initiated successfully. Job ID: " + jobExecution.getId());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("Error initiating content processing job: " + e.getMessage());
        }
    }
}