🍃
Spring Batch 치트시트

Spring Boot 3/Batch 5 최신 설정, Job & Step 구조, Chunk 프로세싱, Paging Reader/Writer, JobParameters, Skip & Retry, 웹 API 온디맨드 Jar 실행 및 파티셔닝 가이드
#spring-batch#spring#spring-boot#batch#chunk#job#step#itemreader#itemwriter#processbuilder#backend#java최종 업데이트: 2026-10-03
Spring Batch 치트시트 핵심 명령어 및 실전 가이드

Spring Boot 3/Batch 5 최신 설정, Job & Step 구조, Chunk 프로세싱, Paging Reader/Writer, JobParameters, Skip & Retry, 웹 API 온디맨드 Jar 실행 및 파티셔닝 가이드
## 1. Spring Batch 아키텍처 & 핵심 도메인 개념
대용량 데이터(수백만~수억 건)를 안정적이고 일괄적으로 처리하기 위해 설계된 엔터프라이즈 배치 프레임워크입니다.
```text
[Spring Batch 계층 구조]
Job (전체 배치 작업 단위)
 └── Step 1 (독립적인 배치 단계)
      └── Chunk-Oriented Task (Reader -> Processor -> Writer)
 └── Step 2 (후속 단계 또는 Tasklet 단일 작업)

[핵심 도메인 객체]
• JobInstance       : Job 이름과 식별 JobParameters의 고유한 조합 (논리적 실행 단위)
• JobExecution      : JobInstance의 1회 실제 실행 시도 기록 (성공, 실패, 진행 중 상태 보유)
• StepExecution     : 개별 Step의 실행 상태, 읽기/쓰기/커밋/롤백 카운트 저장
• ExecutionContext  : Step 또는 Job 수준에서 실패 복구를 위한 상태(재시작 지점 등)를 공유하는 Key-Value 저장소
• JobRepository     : 모든 배치 메타데이터(시작/종료시간, 상태, 카운터)를 DB에 CRUD하는 저장소
```

### 🗄️ 메타데이터 핵심 테이블 6개
```sql
-- 배치 실행 이력을 관리하는 필수 테이블 (Spring Boot 시작 시 자동 생성 가능)
BATCH_JOB_INSTANCE          -- Job 이름과 파라미터 해시 키 매핑 (동일 파라미터 재실행 방지)
BATCH_JOB_EXECUTION         -- Job 실행 상태, 시작/종료 일시, ExitCode
BATCH_JOB_EXECUTION_PARAMS  -- 전달된 파라미터 타입 및 값 목록
BATCH_JOB_EXECUTION_CONTEXT -- Job 수준의 ExecutionContext (직렬화된 상태값)
BATCH_STEP_EXECUTION        -- Step 단위 성공/실패, READ_COUNT, WRITE_COUNT, COMMIT_COUNT
BATCH_STEP_EXECUTION_CONTEXT-- Step 수준 실패 복구 지점 데이터
```

## 2. Spring Boot 3 (Batch 5) 최신 설정 & 마이그레이션
Spring Boot 3.x에서는 기존 Spring Batch 4의 팩토리 클래스(`JobBuilderFactory`, `StepBuilderFactory`)가 **완전 제거(Deprecated/Removed)**되었습니다.
```java
package com.lucky.batch.config;

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

@Configuration
// ⚠️ 주의: Spring Boot 3에서는 @EnableBatchProcessing을 붙이지 마세요!
// 붙이면 자동 구성(BatchAutoConfiguration)이 비활성화되어 Runner 등록 등이 번거로워집니다.
public class BatchConfig {

    // 🚀 [Spring Batch 5 최신 표준 문법]
    // JobRepository와 PlatformTransactionManager를 직접 주입받아 빌더를 생성합니다.
    @Bean
    public Job sampleJob(JobRepository jobRepository, Step sampleStep) {
        return new JobBuilder("sampleJob", jobRepository)
                .start(sampleStep)
                .build();
    }

    @Bean
    public Step sampleStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
        return new StepBuilder("sampleStep", jobRepository)
                .tasklet((contribution, chunkContext) -> {
                    System.out.println("Spring Batch 5 Step 실행 완료!");
                    return org.springframework.batch.repeat.RepeatStatus.FINISHED;
                }, transactionManager)
                .build();
    }
}
```

### `application.yml` 필수 설정
```yaml
spring:
  batch:
    job:
      name: ${job.name:NONE} # 특정 Job만 골라서 실행 (지정 안 하면 전체 Job 실행 방지)
    jdbc:
      initialize-schema: always # DB에 메타데이터 테이블 자동 생성 (always | embedded | never)
```

## 3. 청크 지향 프로세싱 (Chunk-Oriented Processing)
대용량 데이터를 청크(Chunk, 덩어리) 단위로 트랜잭션을 분할 커밋하여 OOM(Out of Memory)을 방지하고 빠른 성능을 보장합니다.
```java
@Bean
public Step chunkStep(
        JobRepository jobRepository,
        PlatformTransactionManager transactionManager,
        ItemReader<User> userReader,
        ItemProcessor<User, DormantUser> userProcessor,
        ItemWriter<DormantUser> userWriter) {

    // 📦 청크 크기 1000 설정: 1000개 읽고 -> 가공 후 -> 한 번에 트랜잭션 커밋
    return new StepBuilder("dormantUserStep", jobRepository)
            .<User, DormantUser>chunk(1000, transactionManager)
            .reader(userReader)
            .processor(userProcessor)
            .writer(userWriter)
            .build();
}

/*
 * 💡 [황금 규칙: ChunkSize == PageSize]
 * ItemReader의 pageSize와 ChunkSize는 반드시 동일하게 맞추는 것이 정석입니다.
 * PageSize(100) != ChunkSize(1000) 일 경우:
 * 청크 1개를 채우기 위해 쿼리가 10번 실행되어 비효율이 발생합니다.
 */
```

## 4. 다양한 DB ItemReader 구현체 (Paging Reader)
메모리 부하를 줄이기 위해 커서(Cursor) 방식보다 **페이징(Paging) 방식**을 압도적으로 선호합니다.
```java
// 🍃 [1] JpaPagingItemReader (JPA / Hibernate 환경)
@Bean
@StepScope
public JpaPagingItemReader<User> jpaUserReader(EntityManagerFactory emf) {
    Map<String, Object> params = new HashMap<>();
    params.put("status", UserStatus.ACTIVE);

    return new JpaPagingItemReaderBuilder<User>()
            .name("jpaUserReader")
            .entityManagerFactory(emf)
            .pageSize(1000)
            .queryString("SELECT u FROM User u WHERE u.status = :status ORDER BY u.id ASC")
            .parameterValues(params)
            .build();
}

// ⚡ [2] JdbcPagingItemReader (순수 JDBC / 초고속 대용량)
@Bean
@StepScope
public JdbcPagingItemReader<User> jdbcUserReader(
        DataSource dataSource,
        PagingQueryProvider queryProvider) {

    return new JdbcPagingItemReaderBuilder<User>()
            .name("jdbcUserReader")
            .dataSource(dataSource)
            .pageSize(1000)
            .queryProvider(queryProvider)
            .rowMapper(new BeanPropertyRowMapper<>(User.class))
            .build();
}

// JdbcPaging용 QueryProvider (DB 방언별 페이징 SQL 자동 생성)
@Bean
public SqlPagingQueryProviderFactoryBean queryProvider(DataSource dataSource) {
    SqlPagingQueryProviderFactoryBean provider = new SqlPagingQueryProviderFactoryBean();
    provider.setDataSource(dataSource);
    provider.setSelectClause("id, username, email, status");
    provider.setFromClause("from users");
    provider.setWhereClause("where status = 'ACTIVE'");
    
    // ⚠️ 정렬 키(SortKeys)는 고유 식별자(PK)로 반드시 지정해야 누락/중복이 없습니다.
    Map<String, Order> sortKeys = new HashMap<>();
    sortKeys.put("id", Order.ASCENDING);
    provider.setSortKeys(sortKeys);
    return provider;
}
```

## 5. ItemProcessor 데이터 가공 & 필터링 패턴
비즈니스 로직을 적용하여 데이터를 변환하거나, 조건에 맞지 않는 불필요한 데이터를 필터링합니다.
```java
// 🔄 [1] 단일 데이터 변환 및 필터링
@Bean
public ItemProcessor<User, DormantUser> dormantUserProcessor() {
    return user -> {
        // 1. 특정 조건 필터링: null을 반환하면 ItemWriter로 전달되지 않고 스킵됨!
        if (user.isVip()) {
            return null; // VIP 회원은 휴면 처리 대상에서 제외
        }

        // 2. 가공 및 새 Entity 변환
        return DormantUser.builder()
                .userId(user.getId())
                .dormantAt(LocalDateTime.now())
                .reason("1년 이상 미접속")
                .build();
    };
}

// 🔗 [2] 복합 프로세서 (CompositeItemProcessor: 파이프라인 체이닝)
@Bean
public CompositeItemProcessor<User, FinalDto> compositeProcessor() {
    CompositeItemProcessor<User, FinalDto> processor = new CompositeItemProcessor<>();
    processor.setDelegates(Arrays.asList(
            new ValidationProcessor(),   // 1단계 유효성 검사
            new MaskingProcessor(),      // 2단계 개인정보 마스킹
            new TransformationProcessor()// 3단계 최종 DTO 변환
    ));
    return processor;
}
```

## 6. 다양한 ItemWriter 구현체 & 고속 벌크 연산
가공된 청크 단위의 컬렉션을 데이터베이스에 한 번에 일괄 영속화합니다.
```java
// 🍃 [1] JpaItemWriter (JPA 기반 자동 merge)
@Bean
public JpaItemWriter<DormantUser> jpaUserWriter(EntityManagerFactory emf) {
    return new JpaItemWriterBuilder<DormantUser>()
            .entityManagerFactory(emf)
            .build();
}

// ⚡ [2] JdbcBatchItemWriter (초고속 Batch Insert / Update - 가장 강력 추천!)
@Bean
public JdbcBatchItemWriter<DormantUser> jdbcBatchWriter(DataSource dataSource) {
    return new JdbcBatchItemWriterBuilder<DormantUser>()
            .dataSource(dataSource)
            .sql("INSERT INTO dormant_users (user_id, dormant_at, reason) VALUES (:userId, :dormantAt, :reason)")
            .beanMapped() // DTO 객체의 getter 이름을 네임드 파라미터(:userId)에 자동 바인딩
            .build();
}

// 📄 [3] FlatFileItemWriter (CSV 파일 생성)
@Bean
public FlatFileItemWriter<ReportDto> csvWriter() {
    return new FlatFileItemWriterBuilder<ReportDto>()
            .name("csvWriter")
            .resource(new FileSystemResource("output/report.csv"))
            .delimited()
            .delimiter(",")
            .names("id", "username", "amount")
            .build();
}
```

## 7. JobParameters & @StepScope 지연 로딩
배치 실행 시 동적 파라미터를 넘기고, 실행 시점에 Bean을 생성하여 안전하게 파라미터를 주입받습니다.
```java
// 🎯 [1] SpEL을 활용한 JobParameters 파라미터 바인딩
// ⚠️ 주의: JobParameters를 주입받으려면 해당 Bean에 반드시 @StepScope가 선언되어야 합니다!
@Bean
@StepScope
public JpaPagingItemReader<Order> orderReader(
        EntityManagerFactory emf,
        @Value("#{jobParameters['requestDate']}") String requestDate,
        @Value("#{jobParameters['amount']}") Long minAmount) {

    return new JpaPagingItemReaderBuilder<Order>()
            .name("orderReader")
            .entityManagerFactory(emf)
            .queryString("SELECT o FROM Order o WHERE o.orderDate = :reqDate AND o.amount >= :amount")
            .parameterValues(Map.of("reqDate", requestDate, "amount", minAmount))
            .pageSize(500)
            .build();
}

// 🔁 [2] RunIdIncrementer: 동일 파라미터로 매번 새로운 JobInstance 생성 허용
@Bean
public Job dailySettlementJob(JobRepository jobRepository, Step settlementStep) {
    return new JobBuilder("dailySettlementJob", jobRepository)
            .incrementer(new RunIdIncrementer()) // run.id 파라미터를 1씩 증가시켜 자동 전달
            .start(settlementStep)
            .build();
}
```

## 8. 예외 처리, 재시도 & 건너뛰기 (Fault Tolerance)
일부 데이터에 에러가 발생해도 전체 배치가 중단되지 않도록 건너뛰거나(Skip) 재시도(Retry)합니다.
```java
@Bean
public Step tolerantStep(
        JobRepository jobRepository,
        PlatformTransactionManager tm,
        ItemReader<User> reader,
        ItemProcessor<User, Target> processor,
        ItemWriter<Target> writer) {

    return new StepBuilder("tolerantStep", jobRepository)
            .<User, Target>chunk(500, tm)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            // 🛡️ 내결함성(Fault Tolerant) 설정 활성화
            .faultTolerant()
            
            // ⏭️ [Skip] 특정 예외 발생 시 최대 10건까지 건너뛰고 계속 진행
            .skip(IllegalArgumentException.class)
            .skip(DataFormatException.class)
            .skipLimit(10)
            .noSkip(FatalDatabaseException.class) // 치명적 DB 오류는 건너뛰지 않고 즉시 중단

            // 🔁 [Retry] 일시적 장애(데드락, 네트워크) 발생 시 최대 3회 재시도
            .retry(DeadlockLoserDataAccessException.class)
            .retry(TransientDataAccessException.class)
            .retryLimit(3)
            .build();
}
```

## 9. 다중 스텝 흐름 제어 (Flow & Decider)
Step의 성공/실패 결과 코드(ExitStatus)에 따라 다음 작업 경로를 유연하게 분기합니다.
```java
@Bean
public Job conditionalJob(
        JobRepository jobRepository,
        Step mainStep,
        Step successStep,
        Step alertStep) {

    return new JobBuilder("conditionalJob", jobRepository)
            .start(mainStep)
                .on("FAILED")           // mainStep 실패 시
                .to(alertStep)          // 관리자 슬랙 알림 Step 실행
                .on("*")                // 알림 후
                .end()                  // 종료
            .from(mainStep)
                .on("*")                // mainStep 성공 시
                .to(successStep)        // 정상 후속 Step 실행
                .next(completeStep())
            .end()
            .build();
}

// 🔀 커스텀 분기 판별자 (JobExecutionDecider)
public class OddEvenDecider implements JobExecutionDecider {
    @Override
    public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
        int count = getTodayCount();
        return (count % 2 == 0) ? new FlowExecutionStatus("EVEN") : new FlowExecutionStatus("ODD");
    }
}
```

## 10. 대용량 성능 최적화: 멀티스레드 & 파티셔닝
단일 스레드의 처리 한계를 넘어 CPU 자원을 극대화하는 병렬 처리 기술입니다.
```java
// 🚀 [방법 1] Multi-Threaded Step (청크 처리를 여러 스레드가 분담)
@Bean
public Step multiThreadedStep(
        JobRepository jobRepository,
        PlatformTransactionManager tm,
        PagingItemReader<User> reader,
        ItemWriter<User> writer) {

    return new StepBuilder("multiThreadedStep", jobRepository)
            .<User, User>chunk(1000, tm)
            .reader(reader) // ⚠️ 주의: PagingReader는 Thread-Safe하지만 CursorReader는 Thread-Safe하지 않음!
            .writer(writer)
            .taskExecutor(batchTaskExecutor()) // 멀티스레드 풀 연결
            .throttleLimit(8)                  // 동시 실행 스레드 수
            .build();
}

@Bean
public TaskExecutor batchTaskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(8);
    executor.setMaxPoolSize(16);
    executor.setThreadNamePrefix("batch-thread-");
    executor.initialize();
    return executor;
}

// 🧩 [방법 2] Partitioning (데이터를 범위별로 물리 분할하여 독립 Worker Step 병렬 실행)
@Bean
public Step masterStep(JobRepository jobRepository, Step workerStep) {
    return new StepBuilder("masterStep", jobRepository)
            .partitioner("workerStep", new IdRangePartitioner()) // ID 1~10만, 10만~20만 분할기
            .step(workerStep)
            .gridSize(4) // 4개 파티션으로 병렬 처리
            .taskExecutor(batchTaskExecutor())
            .build();
}
```

## 11. 배치 리스너 (Listeners) & 모니터링
배치 전후 로깅, 처리 시간 측정, 실패 알림(Slack Webhook)을 리스너로 캡슐화합니다.
```java
// 📢 [1] Job 실행 생명주기 리스너
public class JobPerformanceListener implements JobExecutionListener {
    private static final Logger log = LoggerFactory.getLogger(JobPerformanceListener.class);

    @Override
    public void beforeJob(JobExecution jobExecution) {
        log.info("▶ 배치 Job [{}] 시작 일시: {}", jobExecution.getJobInstance().getJobName(), LocalDateTime.now());
    }

    @Override
    public void afterJob(JobExecution jobExecution) {
        long duration = Duration.between(jobExecution.getStartTime(), jobExecution.getEndTime()).toMillis();
        
        if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
            log.info("✔ 배치 완료! 소요 시간: {}ms", duration);
        } else {
            log.error("❌ 배치 실패! ExitStatus: {}", jobExecution.getExitStatus().getExitDescription());
            sendSlackAlert(jobExecution); // 슬랙 알림 발송
        }
    }
}

// 🎯 Step 빌더에 리스너 등록
// .listener(new JobPerformanceListener())
// .listener(new CustomItemWriteListener())
```

## 12. 실전 트러블슈팅 & 핵심 주의사항
실무에서 가장 빈번하게 발생하는 Spring Batch 오류와 해결책입니다.
```text
[자주 겪는 실수 & 해결책]
1. PagingItemReader Update 시 데이터 누락 (Off-by-one 버그)
   - 원인: status='WAIT'를 읽어서 'COMPLETE'로 UPDATE하면, 2페이지 조회 시 앞의 데이터가 빠져 건너뜀 발생
   - 해결책: 페이지 번호를 항상 0으로 고정하거나(Zero-Paging), ID 기준으로 커서 범위를 좁혀가며 조회

2. OOM (Out Of Memory) 발생
   - 원인: CursorItemReader 사용 시 fetchSize 미지정, 또는 Chunk 처리 중 List 컬렉션에 참조 유지
   - 해결책: PagingItemReader 사용 및 ChunkSize 일치, 불필요한 Entity 1차 캐시 clear (EntityManager.clear)

3. 동일 JobParameter 재실행 불가 (JobInstanceAlreadyCompleteException)
   - 원인: 성공한 JobInstance는 동일 파라미터로 다시 실행되지 않음 (배치 안정성 설계)
   - 해결책: 실행 시마다 고유 파라미터(예: time=System.currentTimeMillis()) 추가 또는 RunIdIncrementer 적용

4. Reader/Writer에서 @StepScope 누락
   - 원인: JobParameters나 StepExecutionContext를 SpEL(#{...})로 주입받을 때 @StepScope가 없으면 애플리케이션 기동 시점 바인딩 실패 에러 발생
   - 해결책: 동적 파라미터가 필요한 모든 Reader, Processor, Writer Bean에 @StepScope 명시
```

## 13. 웹 서비스(REST API)에서 온디맨드 배치 Jar 동적 실행 패턴
웹 서버(Spring Boot Web)는 상시 가동하고, HTTP 요청이 인입될 때만 **외부 배치 Jar를 독립 OS 프로세스(새 JVM)로 실행**한 뒤 종료 시 자원을 100% 반환하는 실무 표준 아키텍처입니다.

```text
[웹 서버] ──(POST /api/batch/run)──> [BatchLauncherService (@Async)]
                                              │
                                              ▼ ProcessBuilder
                               [java -jar my-batch.jar] (독립 JVM)
                                              │
                                              ▼ 작업 완료 시
                                   [프로세스 자동 종료 & 메모리 반환]
```

```java
// 🚀 [1] 비동기 배치 Jar 런처 서비스 (ProcessBuilder)
package com.lucky.web.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

@Service
public class ExternalBatchLauncherService {
    private static final Logger log = LoggerFactory.getLogger(ExternalBatchLauncherService.class);

    // 동시 실행 가능한 최대 배치 프로세스 수 제한 (서버 CPU/RAM 고갈 방지)
    private final Semaphore semaphore = new Semaphore(2);

    @Async("batchTaskExecutor") // 별도 전용 스레드 풀
    public CompletableFuture<Integer> runBatchJar(String jobName, String requestDate) {
        if (!semaphore.tryAcquire()) {
            log.warn("이미 최대 실행 가능한 배치 수가 가동 중입니다.");
            return CompletableFuture.failedFuture(new IllegalStateException("서버 용량 초과: 잠시 후 다시 시도해주세요."));
        }

        try {
            List<String> command = new ArrayList<>();
            command.add("java");
            command.add("-Xms512m");
            command.add("-Xmx2g"); // 배치 전용 메모리 할당 (웹 서버와 완전 격리)
            command.add("-jar");
            command.add("/app/batch/my-batch-app.jar"); // 외부 JAR 경로
            
            // Spring Batch 전용 실행 인자 전달
            command.add("--spring.batch.job.name=" + jobName);
            command.add("requestDate=" + requestDate);
            command.add("run.id=" + System.currentTimeMillis()); // 중복 실행 방지

            ProcessBuilder pb = new ProcessBuilder(command);
            pb.directory(new File("/app/batch"));
            pb.redirectErrorStream(true); // 에러 스트림을 표준 출력과 병합

            Process process = pb.start();
            long pid = process.pid();
            log.info("배치 서브 프로세스 생성 완료 (PID: {})", pid);

            // 실시간 로그 수집
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    log.info("[BATCH-LOG:{}] {}", pid, line);
                }
            }

            // 최대 30분 대기 후 초과 시 프로세스 강제 종료
            boolean finished = process.waitFor(30, TimeUnit.MINUTES);
            if (!finished) {
                process.destroyForcibly();
                log.error("배치 실행 시간 초과로 강제 종료 (PID: {})", pid);
                return CompletableFuture.completedFuture(-1);
            }

            int exitCode = process.exitValue();
            log.info("배치 프로세스 정상 종료 (PID: {}, ExitCode: {})", pid, exitCode);
            return CompletableFuture.completedFuture(exitCode);

        } catch (Exception e) {
            log.error("배치 실행 중 예외 발생", e);
            return CompletableFuture.failedFuture(e);
        } finally {
            semaphore.release();
        }
    }
}
```

```java
// 🌐 [2] REST 컨트롤러 (클라이언트 즉시 응답 반환)
@RestController
@RequestMapping("/api/batch")
public class BatchTriggerController {
    private final ExternalBatchLauncherService launcherService;

    public BatchTriggerController(ExternalBatchLauncherService launcherService) {
        this.launcherService = launcherService;
    }

    @PostMapping("/run")
    public ResponseEntity<?> trigger(@RequestParam String jobName, @RequestParam String date) {
        // HTTP 요청 스레드를 블로킹하지 않고 비동기 접수 후 즉시 응답
        launcherService.runBatchJar(jobName, date);

        return ResponseEntity.ok(Map.of(
            "status", "ACCEPTED",
            "message", "배치 실행 작업이 백그라운드에 등록되었습니다.",
            "jobName", jobName,
            "date", date
        ));
    }
}
```

```text
[실행 방식 비교 가이드]
• ProcessBuilder (외부 Jar 실행) : 웹/배치 JVM 완전 분리, OOM 발생 시 웹 서버 영향 제로, 배치 종료 시 RAM 100% 회수 (강력 권장)
• JobLauncher (동일 JVM 내 실행)  : 같은 프로젝트일 때 간편하나 대용량 배치 시 웹 서버 전체 OOM 다운 위험 존재
• Kubernetes Job (컨테이너 배포) : 클라우드 환경에서 HTTP 요청 시 일회성 Pod 생성 후 종료하는 완전 서버리스 패턴
```
💬
Spring Batch 치트시트

의견 및 질문

댓글 수정

댓글 삭제
