[Spring] Spring Batch

대량의 데이터를 처리하거나 반복적인 작업을 실행하는 데 사용되는 스프링 배치에 대해서 알아보자.

아래의 책을 참고 하였다.

💡 스프링 배치 완벽 가이드 2/e

💡 Spring Batch ?

Spring Batch는 대량의 데이터 처리를 위한 경량화된 프레임워크로, 반복적인 작업을 수행하는 일괄 처리(Batch Processing) 작업을 효율적으로 처리할 수 있는 기능을 제공한다. 대용량 데이터 처리나 주기적인 업무 처리 등을 효율적으로 처리할 수 있고, 대용량 데이터 처리에 적합한 분산 방식의 처리를 지원한다.

Spring Batch의 특징

Spring Batch는 많은 양의 데이터를 효율적으로 처리할 수 있으며, 다양한 기능을 제공한다. 대용량 데이터 처리, 트랜잭션 관리, 재시도 기능 등이 이에 해당된다.

대용량 데이터 처리

Spring Batch는 방대한 양의 데이터를 처리할 수 있다. 데이터 처리 작업을 분산 처리할 수 있어서, 대용량 데이터 처리에 적합하다.

트랜잭션 관리

Spring Batch는 트랜잭션 관리를 지원한다. 데이터 처리 중 실패한 작업은 롤백하여 데이터 일관성을 유지할 수 있다.

재시도 기능

Spring Batch는 작업 중 실패한 경우, 작업을 재시도할 수 있는 기능을 제공한다. 또한, 재시도 횟수를 설정할 수 있다.

Spring Batch는 그 자체만으로 Job을 실행할 수 없다.
Configuration Bean을 통해 해당 Job이 실행될 경우에 어떤 일을 처리할지 세팅할 뿐 이를 실행 시켜주기 위해선 Batch Scheduler가 필요하다.

💡 스프링 배치 용어

JobRepository

JobRepository는 배치를 수행하는데 필요한 전반적인 Object를 모두 포함하고 있다. (Job, JobLauncher, Step, 등)

그리고 이를 통해 배치 수행과 관련된 수치 데이터와 Job의 Status를 유지/관리하며 배치와 관련된 CRUD 처리를 하는 역할을 수행한다.

Job

Job은 배치 처리 과정을 하나의 단위로 만들어 놓은 객체이다.

배치처리 과정에 있어 최상단 Object라고 볼 수 있다.

JobLauncher

JobLauncher는 말그대로 Job을 실행시키는 역할을 담당한다.

Job & JobParameters를 param으로 받고 배치 수행 후, JobExecution을 반환한다.

Spring Batch에서는 JobLauncherApplicationRunner 클래스가 자동으로 JobLauncher를 실행하기 때문에 우리가 직접 컨트롤할 일은 없다고 볼 수 있다.

Step

Step은 Job을 구성하는 독립적인 작업 단위이다. 실제 배치가 실행되는 처리를 정의하고 제어하는데 필요한 모든 정보를 가지고 있는 Object라고 볼 수 있다.

Step은 Tasklet / Chunk 기반으로 수행되며 이는 유저가 선택해서 사용하게 된다.

Tasklet vs Chunk

Tasklet: 한 가지 이상의 CRUD가 발생(=비즈니스 로직)하는 task에 대해 일괄적으로 처리하는 경우, 채택한다. (복잡한 로직을 수행해야 하는 job일 경우, 채택)

Chunk: chunk 단위로 처리할 모든 record를 쭉 읽어들인 후, 모두 읽어들이는데 성공하면 한번에 Write하는 방식 (대용량 데이터에 대해 단순 처리할 경우, 채택)

ItemReader

ItemReader는 말 그대로 배치를 수행하는데 있어 대상이 되는 데이터를 읽어들이는데 사용되는 Object이다. 데이터를 읽어들이는 방법에는 DB Connection을 통해 불러올 수도 있지만 File I/O를 통해 불러오기도 한다.

ItemProcessor

ItemProcessor는 Read와 Write의 중간 단계에서 가공(처리) 역할을 수행한다.

그리고 이 단계는 필수가 아니기도 하다. Read와 Write만으로 원하는 기능을 수행할 수 있다면 ItemProcessor는 과감히 Skip해도 된다.

ItemWriter

ItemWriter는 Batch의 마지막 단계이다. 말 그대로 우리가 처리하고자 하는 데이터에 대해 최종적으로 가공된 데이터를 출력하는 역할을 수행한다.

우리는 ItemWriter를 통해 다시 DB에 해당 내용을 저장할 수도 있고 해당 데이터를 다른 프로젝트로 API 호출시킬 수도, Kafka를 통해 msg 발행시킬 수도 있다.

Spring Batch Job 만들기

그럼 간단히 Spring Batch의 용어 정리도 해봤겠다 이제 소스코드를 만들어보기로 하자.

우선, 나는 Spring Initializr(https://start.spring.io)를 통해 SpringBoot 프로젝트를 하나 만들었으며 기본 Spec은 아래와 같다.

1. @EnbleBatchProcessing 추가

@SpringBootApplication
@EnableBatchProcessing
public class JobPracticeApplication {

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

}

프로젝트 생성 시, 최초 메인 Application 클래스에 위와 같이 @EnableBatchProcessing 애노테이션을 추가해준다.

@EnableBatchProcessing

: 배치 기능 활성화

2. JobConfig Class 생성

특정 Job을 수행하기 위한 클래스 파일을 생성하도록 하자.

@Slf4j
@Configuration
@RequiredArgsConstructor
public class MyFirstJobConfiguration {
					...
}

3. Job 생성

Spring Batch 5.0 부터 JobBuilderFactory는 deprecated되었다.

https://docs.spring.io/spring-batch/docs/current/api/deprecated-list.html

이로 인해 기존에 활용하던 방식은 사용하기 어렵게 되었다.

그래서 JobRepository를 활용하는 방식으로 바꿔줄 필요가 있다.

(AS-IS)

				...
    @Bean
    public Job myFirstJob(Step step) {
        return this.jobBuilderFactory.get("myFirstJob")
                .start(myFirstStep)
                .build();
    }
    			...

(TO-BE)

				...
    @Bean
    public Job myFirstJob(JobRepository jobRepository){
        return new JobBuilder("myFirstJob", jobRepository)
                .start(myFirstStep(jobRepository))
                .build();
    }
    			...

예제 속, job은 단일 Step으로 구성하도록 하겠다.

4. Step 생성

이제 Job에 포함되는 Step을 생성해야 한다.

StepBuilderFactory 역시 Spring Batch 5.0이상부터 deprecated되어 다른 방식으로 처리해야 한다.

(AS-IS)

				...
    public Step myFirstStep() {
        return stepBuilderFactory.get("myFirstStep")
                .<String, String>chunk(1000)
                .reader(itemReader())
                .writer(itemWriter())
                .build();
    }
				...

(TO-BE)

				...
    @Bean
    public Step myFirstStep(JobRepository jobRepository){
        return new StepBuilder("myFirstStep",jobRepository)
                .<String, String>chunk(1000,transactionManager)
                .reader(itemReader())
                .writer(itemWriter())
                .build();
    }
    			...

Step은 chunk 기반으로 동작하도록 구성하였고 한번에 들어올 수 있는 chunk size는 1000으로 설정했다.

5. ItemReader 생성

다음으로 Batch를 통해 처리하고자 하는 데이터를 Read하는 ItemReader 부분을 만들어보자.

				...
    @Bean
    public ItemReader<String> itemReader(){
        return new ItemReader<String>() {
            @Override
            public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
                return "Read OK";
            }
        };
    }
    			...

위와 같이 구성할 수 있고 실질적으로 DB 통신 / File I/O를 통해 처리할 경우, 이 부분에 로직을 구현하면 된다.

(아래는 MyBatis를 활용하는 경우, 예시이다.)

    			...
    public MyBatisCursorItemReader<Object> itemReader() {
        String strQueryId = "쿼리 경로 기재";

        return new MyBatisCursorItemReaderBuilder<Object>()
                .sqlSessionFactory(sqlSessionFactory)
                .queryId(strQueryId)
                .parameterValues(parameterValues)
                .saveState(false)
                .build();
    }
     			...

6. ItemWriter 생성

마지막으로 배치를 통해 처리된 데이터에 대한 출력을 담당하는 ItemWriter 부분이다.

     			...
    @Bean
    public ItemWriter<String> itemWriter(){
        return strList -> {
            strList.forEach(
                    str -> log.info("str: {}", str)
            );
        };
    }
     			...

ItemReader에서 처리한 데이터가 String List형태로 담겨 들어오면 해당 str를 로그 출력하는 형태로 간단히 구성해보았다.

실질적으로 활용하게 되다면 Writer 부분에서 해당 데이터가 필요한 곳으로 API 전송을 할 수도 있고 DB에 가공된 데이터를 저장할 수도 있겠다.

💡 JobInstance는 한 번 성공적으로 완료되면 다시 실행시킬 수 없다. JobInstance는 잡 이름과 전달된 식별 파라미터로 식별되므로, 동일한 식별 파라미터를 사용하는 잡은 한 번만 실행할 수 있다.

소스

더 많은 내용은 깃허브를 참고하자.

github : https://github.com/Jungmin-Dev/SpringBatch

💡기본적인 청크 구성

@Autowired
	private JobBuilderFactory jobBuilderFactory;

	@Autowired
	private StepBuilderFactory stepBuilderFactory;

	@Bean
	public Job chunkBasedJob() {
		return this.jobBuilderFactory.get("chunkBasedJob")
				.start(chunkStep())
				.build();
	}

	@Bean
	public Step chunkStep() {
		return this.stepBuilderFactory.get("chunkStep")
				.<String, String>chunk(1000)
				.reader(itemReader())
				.writer(itemWriter())
				.build();
	}

	@Bean
	public ListItemReader<String> itemReader() {
		List<String> items = new ArrayList<>(100000);

		for (int i = 0; i < 100000; i++) {
			items.add(UUID.randomUUID().toString());
		}

		return new ListItemReader<>(items);
	}

	@Bean
	public ItemWriter<String> itemWriter() {
		return items -> {
			for (String item : items) {
				System.out.println(">> current item = " + item);
			}
		};
	}

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

💡Tasklet, Chunk 간단 비교

Tasklet

💡 데이터 처리과정이 tasklet안에서 한번에 이뤄진다.

배치 처리과정이 쉬운 경우 쉽게 사용되며, 대량처리 경우 더 복잡해질 수 있다.

Chunksize

💡 chunksize 단위로 데이터가 페이징처럼 처리된다.

대용량 데이터를 처리할때 사용되며, reader / processor / writer 로 구분되어 처리된다.

(reader와 writer는 필수이며, processor는 사용안해도 된다.)

• reader

: (파일/DB) 데이터(item)를 읽어오며, reader안에서도 페이징처리가 가능한 bean들이 있다.

ItemReader, MybatisPagingItemReader, JpaPagingItemReader, ...

• processor

: reader에서 읽어온 데이터(item)를 필터/처리 하고 write로 보내는 역할.

item을 필터 도중 null로 리턴하면, 그 item은 write로 전달되지 못한다.

ex) 10개 read 후 processor에서 4개 필터링 해서 6개만 리턴하면 write에서는 6개만 처리한다.

• writer

: processor에서 처리된 데이터들(items : List)을 파일이나 DB에 적재하는 역할.

writer는 기본으로 List단위로 처리되며, List는 chunksize에 의해 처리된다.

Tasklet

private String JOBNAME = "testTaskChunkJob";

@Bean
public JobtestTaskChunkJob(){
return jobBuilderFactory.get(JOBNAME)
                .incrementer(new RunIdIncrementer())
                .start(this.taskStep1())
                .build();
    }

@Bean
public SteptaskStep1(){
return stepBuilderFactory.get("taskStep1")
                .tasklet(tasklet())
                .build();
    }

private Tasklettasklet(){//tasklet으로 모두 처리
return (contribution, chunkContext) -> {
            List<String> items = getItems();

            log.info("items : "+ items.toString());

return RepeatStatus.FINISHED;
        };
    }

private List<String>getItems() {
        List<String> items =new ArrayList<>();

for (int i = 0; i < 100; i++) {
            items.add(i + " test!");
        }

return items;
    }

단순하게 100개의 숫자를 가져와 log를 출력하는 tasklet이다.

tasklet은 함수안에서 모두 처리되서 1~100까지 모두 출력된다.

결과 :

items : [0 test!, 1 test!, 2 test!, 3 test!, ... 99 test!]

chunksize

private String JOBNAME = "testTaskChunkJob";

@Bean
public JobtestTaskChunkJob(){
return jobBuilderFactory.get(JOBNAME)
                .incrementer(new RunIdIncrementer())
                .start(this.taskStep1())//tasklet 처리
                .next(this.chunkStep1())//chunk 처리
                .build();
    }

// ...
@Bean
public StepchunkStep1() {//chunksize로 처리
return stepBuilderFactory.get("chunkStep1")
                .<String,String>chunk(10)
                .reader(itemReader())
                .processor(itemProcessor())
                .writer(itemWriter())
                .build();
    }

private ItemReader<String>itemReader() {
return new ListItemReader<>(getItems());
    }

private ItemProcessor<String, String>itemProcessor() {
return item -> item + " now processor!!";
    }

private ItemWriter<String>itemWriter() {
return items -> log.info("### writer : " + items.toString());
    }

chunksize로 처리 시, Step에 .chunksize(크기) 로 정의하며 앞에 처리될 타입을 정의한다.

.<String,String>chunk(10)

<String,String>

앞의 String은 reader에서 읽은 데이터의 타입이고

뒤의 String은 writer에서 받을 데이터의 타입이다.

따라서 processor 처리 함수에서는 앞/뒤 타입을 모두 선언해서 필터나 데이터 변형 처리가 가능하다.

• reader

private ItemReader<String>itemReader() {
returnnew ListItemReader<>(getItems());
}

reader에서 리턴으로 선언한 ListItemReader는 spring batch에서 제공하는 item처리 클래스이다.

getItems에서 가져온 List을 LIstItemReader에서 알아서 item반환해준다.

• processor

private ItemProcessor<String, String>itemProcessor() {
return item -> item + " now processor!!";
}

processor에서는 앞서 말한것과 같이 <reader에서 읽은 타입, writer에 보낼 타입> 으로 정의해 처리한다.

지금은 그냥 읽은 item에 문자열만 더해서 처리.

• writer

private ItemWriter<String>itemWriter() {
return items -> log.info("### writer : " + items.toString());
}

writer에서 이지만, List단위로 처리되며,

items를 받아 log를 출력하면 chunksize=10개씩 읽은 String이 List로 출력된다.

결과 :

writer : [0 test! now processor!!, 1 test! now processor!!, ... 9 test! now processor!!]
writer : [10 test! now processor!!, 11 test! now processor!!, ... 19 test! now processor!!]
...
writer : [90 test! now processor!!, 91 test! now processor!!, ... 99 test! now processor!!]

log를 총 10개 출력했으며, 각 로그는 items를 출력한다.

reader에서 10개씩 읽고 List 으로 items 가 writer에서 chunksize=10만큼 처리된다.

Tasklet으로 페이징 처리

@Bean
public JobtestTaskChunkJob(){
return jobBuilderFactory.get(JOBNAME)
                .incrementer(new RunIdIncrementer())
                .start(this.taskStep1())
                .next(this.chunkStep1())
                .next(this.taskPagingStep1())//tasklet으로 페이징 처리
                .build();
    }

//...

private TaskletpagingTasklet() {
        List<String> items = getItems();

return (contribution, chunkContext) -> {
//stepexecution : 읽은 item을 저장
            StepExecution stepExecution = contribution.getStepExecution();
int chunksize = 10;
int readCnt = stepExecution.getReadCount();
int idx = readCnt + chunksize;

if(idx > items.size()){
return RepeatStatus.FINISHED;
            }

//sublist : list 중간 데이터 읽기
            List<String> sublist = items.subList(readCnt,idx);

            log.info("### sublist size : " + sublist.toString());
            stepExecution.setReadCount(idx);//read count 읽은만큼 다시 저장return RepeatStatus.CONTINUABLE;
        };
    }

tasklet의 contributution에서 StepExecution 으로 step이 얼마나 처리되고 있는지의 정보를 알 수 있다.

(chunksize를 10으로 정의하고 readCount로 페이징을 처리)

tasklet으로 chunksize=10으로 정해 처리할 수 있지만, 소스가 길어지고 복잡해짐을 볼 수 있다.

결과 :

sublist size : [0 test!, 1 test!, 2 test!, ... 9 test!]
sublist size : [10 test!, 11 test!, 12 test!, ... 19 test!]
...
sublist size : [90 test!, 91 test!, 92 test!, ... 99 test!]

💡Spring Batch + Job 실행 예제

REST 방식으로 잡 실행

Controller

Kotlin

@RestController
class RestJobController(
    @Autowired
    private val jobLauncher: JobLauncher,
    @Autowired
    private val jobExplorer: JobExplorer,
    @Qualifier("job1") @Autowired
    private val job: Job,  // Job 빈을 직접 주입
) {
    @PostMapping(path = ["/run"])
    @Throws(Exception::class)
    fun runJob(@RequestBody request: RestJobDto): ExitStatus {
// JobParametersBuilder 의 getNextJobParameters 메서드는 파라미터를 증가 시킨다 ex) run.id=1 이후 run.id=2 ..
        val jobParameters = JobParametersBuilder(
            request.getJobParameters(),
            jobExplorer
        )
            .getNextJobParameters(job)
            .toJobParameters()
        return jobLauncher.run(job, jobParameters).exitStatus
    }
}

Java

@RestController
public class RestJobController {
    private JobLauncher jobLauncher;
    private JobExplorer jobExplorer;
    private Job job;

    @Autowired
    public RestJobController(
        JobLauncher jobLauncher,
        JobExplorer jobExplorer,
        @Qualifier("job1") Job job
    ) {
        this.jobLauncher = jobLauncher;
        this.jobExplorer = jobExplorer;
        this.job = job;
    }

    @PostMapping(path = ["/run"])
    public ExitStatus runJob(@RequestBody RestJobDto request) throws Exception {
        JobParameters jobParameters = new JobParametersBuilder(
            request.getJobParameters(),
            jobExplorer
        )
        .getNextJobParameters(job)
        .toJobParameters();

        return jobLauncher.run(job, jobParameters).getExitStatus();
    }
}

Dto

Kotlin

data class RestJobDto(
    @JsonProperty("name")
    var name: String? = null,
    @JsonProperty("jobParameters")
    var jobParamsProperties: Properties? = null
) {
    fun getJobParameters(): JobParameters {
        val jobParametersBuilder = JobParametersBuilder()
        // jobParamsProperties가 null이 아닌 경우에만 추가
        if (jobParamsProperties != null) {
            for ((key, value) in jobParamsProperties!!) {
                jobParametersBuilder.addString(key.toString(), value.toString())
            }
        }
        return jobParametersBuilder.toJobParameters()
    }
}

Java

@Data
@NoArgsConstructor
public class RestJobDto {
    @JsonProperty("name")
    private String name;
    @JsonProperty("jobParameters")
    private Properties jobParamsProperties;

    public JobParameters getJobParameters() {
        JobParametersBuilder jobParametersBuilder = new JobParametersBuilder();
        
        // jobParamsProperties가 null이 아닌 경우에만 추가
        if (jobParamsProperties != null) {
            for (Entry<Object, Object> entry : jobParamsProperties.entrySet()) {
                jobParametersBuilder.addString(entry.getKey().toString(), entry.getValue().toString());
            }
        }

        return jobParametersBuilder.toJobParameters();
    }
}

Job

전송 데이터 :

*{ 
	"name" : "job",
	"jobParameters" : { 
			"foo": "bar",
		  "baz": "quix",
		  "requestDate":"20231108" 
			}
}*

Kotlin

@Configuration
class RestJob1 {
    private final val chunkSize = 5

    @Bean(name = ["job1"])
    fun textJob1_batchBuild(jobRepository: JobRepository, transactionManager: PlatformTransactionManager): Job {
        return JobBuilder("job", jobRepository)
            // "Job"에는 일반적으로 job parameters를 생성하는 incrementer가 필요합니다. 이 incrementer는 batch job의 실행을 식별하는 데 사용됩니다.
            .incrementer(RunIdIncrementer())
            .start(textJob1_batchStep1(jobRepository, transactionManager))
            .build()
    }

    @Bean
    @Primary
    fun textJob1_batchStep1(jobRepository: JobRepository, transactionManager: PlatformTransactionManager): Step {
        return StepBuilder("textJob1", jobRepository)
            .allowStartIfComplete(true) // 반복 작업을 위한 스텝 설정
            .chunk<OneDto, OneDto>(chunkSize, transactionManager)
            .reader(textJob1_FileReader(null))
            .writer { oneDto ->
                oneDto.forEach { item ->
                    println(item.one)
                }
            }
            .build()
    }

    @Bean
    @StepScope
    fun textJob1_FileReader(@Value("#{jobParameters[requestDate]}") requestDate: String?): FlatFileItemReader<OneDto> {
        val flatFileItemReader: FlatFileItemReader<OneDto> = FlatFileItemReader<OneDto>()
        flatFileItemReader.setResource(ClassPathResource("sample/textJob1_input.txt"))
        flatFileItemReader.setLineMapper { line, lineNumber -> OneDto("$lineNumber == $line ${requestDate} ") }
        return flatFileItemReader
    }
}

Java

@Configuration
public class RestJob1 extends DefaultBatchConfigurer {

    private final int chunkSize = 5;

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean(name = "job1")
    @Primary
    public Job textJob1_batchBuild(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
        return jobBuilderFactory.get("job")
                .incrementer(new RunIdIncrementer())
                .start(textJob1_batchStep1(jobRepository, transactionManager))
                .build();
    }

    @Bean
    public Step textJob1_batchStep1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
        return stepBuilderFactory.get("textJob1")
                .allowStartIfComplete(true)
                .<OneDto, OneDto>chunk(chunkSize)
                .reader(textJob1_FileReader(null))
                .writer(oneDtoList -> oneDtoList.forEach(item -> System.out.println(item.getOne())))
                .build();
    }

    @Bean
    @StepScope
    public FlatFileItemReader<OneDto> textJob1_FileReader(@Value("#{jobParameters[requestDate]}") String requestDate) {
        FlatFileItemReader<OneDto> flatFileItemReader = new FlatFileItemReader<>();
        flatFileItemReader.setResource(new ClassPathResource("sample/textJob1_input.txt"));

        FixedLengthTokenizer tokenizer = new FixedLengthTokenizer();
        tokenizer.setColumns(new Range[] { new Range(1, 4), new Range(5, 8) });
        tokenizer.setNames("one", "two");
        tokenizer.setStrict(false);

        flatFileItemReader.setLineMapper((line, lineNumber) -> {
            OneDto oneDto = new OneDto();
            oneDto.setOne(line.substring(0, 4));
            oneDto.setTwo(line.substring(4, 8));
            oneDto.setRequestDate(requestDate);
            return oneDto;
        });

        return flatFileItemReader;
    }
}

@RestController
class RestJobController {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private JobExplorer jobExplorer;

    @Qualifier("job1")
    @Autowired
    private Job job;

    @PostMapping(path = "/run")
    public ExitStatus runJob(@RequestBody RestJobDto request) throws Exception {
        JobParameters jobParameters = new JobParametersBuilder(request.getJobParameters(), jobExplorer)
                .getNextJobParameters(job)
                .toJobParameters();
        return jobLauncher.run(job, jobParameters).getExitStatus();
    }
}

🪓SQLSyntaxErrorException 에러 해결

기본적으로 H2 DB를 사용할 경우엔 Boot가 실행될 때 자동으로 생성해주지만, MySQL이나 Oracle과 같은 DB를 사용할 때는 자동으로 생성되지 않는다. 나는 MySQL을 사용하였기 때문에 배치가 실패한 것이다.

MySQL을 사용하려면 메타 테이블을 직접 생성하면 된다.

아까 추가한 Spring Batch 라이브러리에 org.springframework.batch.core 폴더에 가보면 schema-mysql.sql 파일이 있을 것이다.


이 파일에 작성된 SQL을 그대로 실행하면 메타 테이블을 생성할 수 있다.

생성 후에 다시 애플리케이션을 실행해보면!

---

마무리

스프링 배치를 검색하는데 deprecated 된 JobBuilderFactory을 사용한 사례가 많았다. 많은 검색을 통해 JobRepository과 관련된 정보를 찾았고, 다음에 또 찾으려면 많은 검색이 필요할 것 같아서 벨로그에 기록한다. 그리고 코틀린 버전으로도 작성해두면 다음에 도움이 될 것 같아서 깃허브에 작성해두었다.

대용량 트래픽을 일으킬 수 있는 상황을 스프링 배치로 해결할 수 있을지도 모른다고 생각이 들었다. 추후 대량의 데이터를 처리하는일이나 반복적인 작업이 있는일이 있다면 스프링 배치를 떠올려 해결해 나가면 도움이 될 것 같다. 아직 직접적인 해결을 해본적이 많이 없다..

---

출처 : https://velog.io/@cho876/Spring-Batch-job-%EC%83%9D%EC%84%B1 - [Spring Batch] 개념 및 Job 생성

출처 : https://choisblog.tistory.com/80 - Spring Batch - Tasklet, Chunk 간단 비교

출처 : https://velog.io/@clevekim/Spring-Batch%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80 - Spring Batch란 무엇인가?