Spring Batch
Spring Batch Flow
[Spring] 1. Spring Batch์ ๊ธฐ๋ณธ ๊ฐ๋
Job > Step > Task ๊ตฌ์กฐ
Job์ Step์ ๊ฐ๊ณ ์๊ณ , Step์ Tasklet ์ธํฐํ์ด์ค๋ฅผ ํตํด ์ํ ์์ ์ ๊ฐ๊ณ ์๋ค.
Task๋ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ์ ์ ์ ํ์๊ณผ read/process/write (RPW) ํ์์ด ์กด์ฌํ๋ค.
Spring Batch Metadata
[Spring] 1. Spring Batch์ ๊ธฐ๋ณธ ๊ฐ๋
Spring Batch๋ DB๋ฅผ ํตํด ์๋ฃ/์คํจ ๋ฑ ์ํ๊ด๋ฆฌ๋ฅผ ํ๋ค. ํฌ๊ฒ 4๊ฐ์ง์ ์ํ๋ฅผ ์ ์ฅํ๋ค.
์ด์ ์คํ job history
์คํจํ batch์ parameter / ์ฑ๊ณตํ job
์คํ ์ฌ๊ฐ ์ง์
Job ๊ธฐ์ค step ํํฉ๊ณผ ์ฑ๊ณต / ์คํจ ์ฌ๋ถ
์ฌ๋ฌ ๊ฐ์ง ํ
์ด๋ธ์ด DB์ ์์ฑ๋๋๋ฐ, H2 DB ์ฌ์ฉ์ ์๋์ผ๋ก ์์ฑ๋๋ ๊ทธ์ธ DB๋ ์ง์ ์์ฑํด์ผ ํ๋ค. DDL ์ฟผ๋ฆฌ๋ org.springframework.batch.core
์ ํฌํจ๋์ด ์๋ค.
Spring Batch ์ ๋ฆฌ
spring-starter-batch
dependency ์ถ๊ฐtask scheduling ๋์ฒด๊ฐ ์๋, scheduler์ ํจ๊ป ์๋ํ๋๋ก ๋ง๋ค์ด์ง
์ ์ฆ ์ผ์ด์ค
๋ฐ์ดํฐ๋ฒ ์ด์ค, ํ์ผ, ํ๋ก๋ถํฐ ์ปค๋ค๋ ์์ ๋ ์ฝ๋๋ฅผ ์ฝ์ด๋ค์
๋ฐ์ดํฐ ์ฒ๋ฆฌ
์กฐ์ํ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์์ฑ
์ฃผ๊ธฐ์ ์ผ๋ก ๋ฐฐ์น ํ๋ก์ธ์ค๋ฅผ ์คํํ๊ฑฐ๋, ๋ณ๋ ฌ์ ์ผ๋ก ์์ ์ ์ฒ๋ฆฌํ๊ฑฐ๋, ๋ฉ์์ง ์ฃผ๋์ ์ผ๋ก ์์ ์ ์ฒ๋ฆฌํ๋ ๋ฑ์ ๋น์ฆ๋์ค ์๋๋ฆฌ์ค๋ ์กด์ฌํ๋ค.
์คํ๋ง ๋ฐฐ์น ๊ณ์ธต ๊ตฌ์กฐ (Spring Batch Layered Architecture)

Application์ ๋ชจ๋ ๋ฐฐ์น ์์ ๊ณผ ์คํ๋ง ๋ฐฐ์น๋ก ์์ฑํ ๊ฐ๋ฐ์์ ์ฝ๋๋ฅผ ๋ด๊ณ ์๋ค.
Batch Core๋ ๋ฐฐ์น ์์ ์ ์คํํ๊ณ ๊ด๋ฆฌํ๊ธฐ ์ํ ์ฃผ์ ๋ฐํ์ ํด๋์ค๋ฅผ ๋ด๊ณ ์๋ค.
JobLauncher
,Job
,Step
์ ๊ตฌํ์ฒด๋ฅผ ํฌํจํ๋ค.Application๊ณผ Core ๋ ๋ค ๋์ผํ infrastructure ์์์ ์๋ํ๋ค. Infrastructure์ ๊ฐ๋ฐ์๋ค์ด ์ฌ์ฉํ ์ ์๋ ๊ณตํต reader (์๋ฅผ ๋ค๋ฉด
ItemReader
)์ writer (์๋ฅผ ๋ค๋ฉดItemWriter
), service (์๋ฅผ ๋ค์ดRetryTemplate
)๋ฅผ ํฌํจํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ฝ์ด ํ๋ ์์ํฌ๋ฅผ ํฌํจํ๋ค. (์ฝ์ด ํ๋ ์์ํฌ ์์ฒด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค.)๊ฐ์ด๋๋ผ์ธ
์ฌ์ฉํ ๋ฐ์ดํฐ๋ฅผ ๋ฐฐ์น์ ๊ฐ๊น์ด ๋์. ์ฆ, ์ฒ๋ฆฌ๋ฅผ ํ ๊ณณ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊น์ด ๋์ ๋ป.
I/O๋ฅผ ์ค์ด๊ณ ๋ด์ฅ ๋ฉ๋ชจ๋ฆฌ ์์์ ์์ ์ ๋ง์ด ํ์.
๋ชจ๋ ํธ๋์ญ์ ์ ๋ํด์ ๋งค๋ฒ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ง ๋ง๊ณ ํ๋ฒ์ ์ฝ๊ณ ์บ์๋ฅผ ํด๋๋์ง ์์ ์ค์ธ ์ ์ฅ์์ ๋ณด๊ดํด๋์.
๊ฐ์ ๋ฐฐ์น ์์ ์ ๋ ๋ฒ ์คํํ์ง ๋ง์.
์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์ฌํ ๋น์ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด์ ์ ์ด์ ๋ฐฐ์น ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๋นํ ํ ๋นํด๋์.
SpEL (Spring Expression Language)
Spring Expression Language(SpEL) ์ ๋ํด
SpEL (Spring Expression Language)
์ ๋ฐํ์์์ ๊ฐ์ฒด์ ๋ํ ์ฟผ๋ฆฌ(query)์ ์กฐ์(manipulation)์ ์ง์ํ๋ ๊ฐ๋ ฅํ ํํ ์ธ์ด์ด๋ค.
SpEL ํํ์์ #
๊ธฐํธ๋ก ์์ํ๋ฉฐ ์ค๊ดํธ๋ก ๋ฌถ์ด์ ํํํ๋ค. #{ํํ์}
์์ฑ ๊ฐ์ ์ฐธ์กฐํ ๋๋ $
๊ธฐํธ์ ์ค๊ดํธ๋ก ๋ฌถ์ด์ ํํํ๋ค. ${property.name}
Spring Batch
๋ฐฐ์น์ ์ผ๋ฐ์ ์ธ ์๋๋ฆฌ์ค๋ ์ฝ๊ธฐ - ์ฒ๋ฆฌ - ์ฐ๊ธฐ๋ก ๋๋์ด์ง๋ค.
๋ฐฐ์น ๊ด๋ จ ๊ฐ์ฒด ๊ด๊ณ๋

Job
๊ณผ Step
์ 1:M, Step
๊ณผ ItemReader
, ItemProcessor
, ItemWriter
๋ 1:1 ๊ด๊ณ๋ฅผ ๊ฐ๋๋ค.
Job
์ด๋ผ๋ ํ๋์ ํฐ ์ผ๊ฐ(Job
)์ ์ฌ๋ฌ ๋จ๊ณ(Step
)๋ฅผ ๋๊ณ , ๊ฐ ๋จ๊ณ๋ฅผ ๋ฐฐ์น์ ๊ธฐ๋ณธ ํ๋ฆ๋๋ก ๊ตฌํํ๋ค.
Job
Job
์ ๋ฐฐ์น ์ฒ๋ฆฌ ๊ณผ์ ์ ํ๋์ ๋จ์๋ก ๋ง๋ค์ด ํํํ ๊ฐ์ฒด์ด๋ค. ์ ์ฒด ๋ฐฐ์น ์ฒ๋ฆฌ์ ์์ด ํญ์ ์ต์๋จ ๊ณ์ธต์ ์๋ค. Job
๊ฐ์ฒด๋ ์ฌ๋ฌ Step
์ธ์คํด์ค๋ฅผ ํฌํจํ๋ ์ปจํ
์ด๋๋ค.
Job
๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๋น๋๋ ์ฌ๋ฌ ๊ฐ๊ฐ ์๋ค. JobBuilderFactory
๋ก ์ํ๋ Job
์ ๋ง๋ค ์ ์๋ค. JobBuilderFactory
์ get()
๋ฉ์๋๋ก JobBuilder
๋ฅผ ์์ฑํ๊ณ ์ด๋ฅผ ์์ฉํ๋ฉด ๋๋ค. org.springframework.batch.core.Configuration.annotation.JobBuilderFactory
์ ๋ด๋ถ ์ฝ๋์ด๋ค. (๊ธธ๋ค ๊ธธ์ด!)
// org.springframework.batch.core.Configuration.annotation.JobBuilderFactory
public class JobBuilderFactory {
private JobRepository jobRepository;
public JobBuilderFactory(JobRepository jobRepository) {
this.jobRepository = jobRepository;
}
public JobBuilder get(String name) {
JobBuilder builder = new JobBuilder(name).repository(jobRepository);
return builder;
}
}
get()
๋ฉ์๋๋ฅผ ํธ์ถํ ๋๋ง๋ค ์๋ก์ด JobBuilder
์ธ์คํด์ค๋ฅผ ๋ฐํํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋งค๋ฒ ์์ฑํ ๋๋ง๋ค JobBuilderFactory
๋ฅผ ์์ฑํ ๋ ์ฃผ์
๋ฐ์ JobRepository
๋ฅผ ์ฌ์ฉํ repository๋ก ์ค์ ํ๋ค. ์ฆ, ํด๋น JobBuilderFactory
์์ ์์ฑ๋๋ ๋ชจ๋ JobBuilder
๊ฐ ๋์ผํ ๋ฆฌํฌ์งํ ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค.
์๋๋ JobBuilder
์ฝ๋ ์ผ๋ถ์ด๋ค.
// org.springframework.batch.core.job.builder.JobBuilder
// ...
public SimpleJobBuilder start(Step step) {
return new SimpleJobBuilder(this).start(step);
}
public JobFlowBuilder start(Flow flow) {
return new JobFlowBuilder(this).start(flow);
}
public JobFlowBuilder flow(Step step) {
return new JobFlowBuilder(this).start(step);
}
// ...
๊ณตํต์ ์ ๋ชจ๋ ๋น๋๋ฅผ ๋ฐํํ๋ค๋ ์ ์ด๋ค. JobBuilder
์ Job
์ ์ง์ ์์ฑํ๋ ๊ฒ์ด ์๋ ๋ณ๋์ ๊ตฌ์ฒด์ ์ธ ๋น๋๋ฅผ ๋ง๋ค์ด ๋ฐํํ๋ค. ์ด๋ ๊ฒ ๋น๋๋ฅผ ์์ฑํ๊ฒ๋ ํ๋ ์ด์ ๋, ๊ฒฝ์ฐ์ ๋ฐ๋ผ Job
์์ฑ ๋ฐฉ๋ฒ์ด ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค. ๊ตฌ์ฒด์ ์ธ ๋น๋๋ฅผ ๊ตฌํํ๊ณ ์ด๋ฅผ ํตํด Job
์์ฑ์ด ์ด๋ฃจ์ด์ง๊ฒ ํ๋ ์๋๋ก ํ์
๋๋ค.
๋น๋๋ฅผ ๋ฐ์ ์ฌ์ฉํด์ผ ํ๋ฏ๋ก ๋ถํธํด๋ณด์ด์ง๋ง, ๋ฉ์๋ ์ฒด์ธ ๋ฐฉ์์ ์ด์ฉํ๋ฉด ๊ตฌ์ฒด์ ์ธ ๋น๋์ ์กด์ฌ๋ฅผ ์๊ฐํ์ง ์์๋ ๋ ๋งํผ ์์ฝ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค.
๋ฉ์๋๋ฅผ ์ดํด๋ณด๋ฉด Job
์ ์์ฑํ๊ธฐ ์ํ Step
๋๋ Flow
๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ๋ฐ์ ๊ตฌ์ฒด์ ์ธ ๋น๋๋ฅผ ์์ฑํ๊ณ ์๋ค. Job
์ Step
๋๋ Flow
์ธ์คํด์ค์ ์ปจํ
์ด๋ ์ญํ ์ ํ๊ธฐ ๋๋ฌธ์ ์์ฑํ๊ธฐ ์ ์ ์ธ์คํด์ค๋ฅผ ์ ๋ฌ๋ฐ๋๋ค.
๋ค์์ Job
์์ฑ ์์ ์ฝ๋์ด๋ค.
@Autowired
private JobBuilderFactory jobBuilderFactory;
@Bean
public Job simpleJob() {
return jobBuilderFactory.get("simpleJob") // 'simpleJob' ์ด๋ผ๋ ์ด๋ฆ์ ๊ฐ์ง Job์ ์์ฑํ ์ ์๋ `JobBuilder` ๊ฐ์ฒด ์ธ์คํด์ค ๋ฐํ
.start(simpleStep()) // `simpleStep()`์ ๊ฐ๋จํ `Step` ์ธ์คํด์ค๋ฅผ ์์ฑํด ๋ฐํํ๋ ๋ฉ์๋๋ผ ๊ฐ์ ํ๋ค. `start()` ๋ฉ์๋๋ก ์ธํด ์์ฑ๋๋ ๋น๋๋ `SimpleJobBuilder`
.build(); // 'simpleJob'์ด๋ผ๋ ์ด๋ฆ์ ๊ฐ์ง `Job`์ด ์์ฑ๋์ด ๋ฐํ
}
JobInstance
JobInstance
๋ ๋ฐฐ์น์์ Job
์ด ์คํ๋ ๋ ํ๋์ Job
์คํ ๋จ์์ด๋ค. ๋ง์ฝ ํ๋ฃจ์ ํ ๋ฒ์ฉ ๋ฐฐ์น์ Job
์ด ์คํ๋๋ค๋ฉด, ์ด์ ์ ์ค๋ ์คํํ ๊ฐ๊ฐ์ Job
์ JobInstance
๋ผ๊ณ ๋ถ๋ฅผ ์ ์๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ฐ๊ฐ์ JobInstance
๋ ํ๋์ JobExecution
(JobInstance
์ ๋ํ ํ ๋ฒ์ ์คํ์ ๋ํ๋ด๋ ๊ฐ์ฒด)์ ๊ฐ๊ณ ์์๊น? ๊ทธ๋ ์ง ์๋ค.
์ค๋ Job
์ ์คํํ๋๋ฐ ์คํจํ๋ค๋ฉด ๋ค์๋ ๋์ผํ JobInstance
๋ฅผ ๊ฐ์ง๊ณ ๋ ์คํํ๋ค. Job
์คํ์ด ์คํจํ๋ฉด JobInstance
๊ฐ ๋๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ฌ๋ฉด JobInstance
๋ ์ด์ ์ ์คํจํ JobExecution
๊ณผ ์ค๋ ์ฑ๊ณตํ JobExecution
๋ ๊ฐ๋ฅผ ๊ฐ๊ฒ ๋๋ค. ์ฆ, JobExecution
์ ์ฌ๋ฌ ๊ฐ ๊ฐ์ง ์ ์๋ค.
JobExecution
JobExecution
์ JobInstance
์ ๋ํ ํ ๋ฒ์ ์คํ์ ๋ํ๋ด๋ ๊ฐ์ฒด์ด๋ค.
์์ ์์ ๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ์ ์ค๋ช
ํ์๋ฉด, ๋ง์ฝ ์ค๋์ Job
์ด ์คํจํด ๋ด์ผ ๋ค์ ๋์ผํ Job
์ ์คํํ๋ฉด ์ค๋, ๋ด์ผ์ ์คํ ๋ชจ๋ ๊ฐ์ JobInstance
๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๋ค. ๋จ, ์ค๋, ๋ด์ผ์ ์คํ์ ๊ฐ๊ธฐ ๋ค๋ฅธ JobExecution
์ ์์ฑํ๋ค.
JobExecution
์ธํฐํ์ด์ค๋ฅผ ๋ณด๋ฉด Job
์คํ์ ๋ํ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ ๋๋ฉ์ธ ๊ฐ์ฒด๋ผ๋ ๊ฒ์ ์ ์ ์๋ค. JobExecution
์ JobInstance
, ๋ฐฐ์น ์คํ ์ํ, ์์ ์๊ฐ, ๋๋ ์๊ฐ, ์คํจํ์ ๋์ ๋ฉ์์ง ๋ฑ์ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ค.
๋ค์์ JobExecution
๋ด๋ถ์ ์ฝ๋์ด๋ค.
// org.springframework.batch.core.JobExecution
public class JobExecution extends Entity {
private final JobParameters jobParameters;
private JobInstance jobInstance;
private volatile Collection<StepExecution> stepExecutions = Collections.synchronizedSet(new LinkedHashSet<>());
private volatile BatchStatus status = BatchStatus.STARTING;
private volatile Date startTime = null;
private volatile Date createTime = new Date(System.currentTimeMillis());
private volatile Date endTime = null;
private volatile Date lastUpdated = null;
private volatile ExitStatus exitStatus = ExitStatus.UNKNOWN;
private volatile ExecutionContext executionContext = new ExecutionContext();
private transient volatile List<Throwable> failureExceptions = new CopyOnWriteArrayList<>();
private final String jobConfigurationName;
// ...
}
jobParameters
:Job
์คํ์ ํ์ํ ๋งค๊ฐ๋ณ์ ๋ฐ์ดํฐ.jobInstance
:Job
์คํ์ ๋จ์๊ฐ ๋๋ ๊ฐ์ฒด.stepExecutions
:StepExecution
์ ์ฌ๋ฌ ๊ฐ ๊ฐ์ง ์ ์๋ Collection ํ์ .status
:Job
์ ์คํ ์ํ. (COMPLETED
,STARTING
,STARTED
,STOPPING
,STOPPED
,FAILED
,ABANDONED
,UNKNOWN
๋ฑ์ด ์๋ค. default๋STARTING
)startTime
:Job
์ด ์คํ๋ ์๊ฐ.null
์ด๋ฉด ์์ํ์ง ์์๋ค๋ ๋ป.createTime
:JobExecution
์ด ์์ฑ๋ ์๊ฐ.endTime
:JobExecution
์ด ๋๋ ์๊ฐ.lastUpdated
: ๋ง์ง๋ง์ผ๋ก ์์ ๋ ์๊ฐ.exitStatus
:Job
์คํ ๊ฒฐ๊ณผ์ ๋ํ ์ํ. (UNKNOWN
,EXECUTING
,COMPLETED
,NOOP
,FAILED
,STOPPED
๋ฑ์ด ์๋ค. default๋UNKNOWN
)executionContext
:Job
์คํ ์ฌ์ด์ ์ ์งํด์ผ ํ๋ ์ฌ์ฉ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด ์๋ค.failureExceptions
:Job
์คํ ์ค ๋ฐ์ํ ์์ธ๋ฅผList
์ ๋ฃ์ด๋๋ค.jobConfigurationName
:Job
์ค์ ์ด๋ฆ.
JobParameters
JobParameters
๋ Job
์ด ์คํ๋ ๋ ํ์ํ ํ๋ผ๋ฏธํฐ๋ค์ Map
ํ์
์ผ๋ก ์ ์ฅํ๋ ๊ฐ์ฒด์ด๋ค.
JobParameters
๋ JobInstance
๋ฅผ ๊ตฌ๋ถํ๋ ๊ธฐ์ค์ด ๋๊ธฐ๋ ํ๋ค. ์๋ฅผ ๋ค์ด Job
ํ๋๋ฅผ ์์ฑํ ๋, ์์ ์๊ฐ ๋ฑ์ ์ ๋ณด๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ํด์ ํ๋์ JobInstance
๋ฅผ ์์ฑํ๋ค.
์ฆ, JobInstance
์ JobParameters
๋ 1:1 ๊ด๊ณ์ด๋ค. ํ๋ผ๋ฏธํฐ์ ํ์
์ผ๋ก๋ String
, Long
, Date
, Double
์ ์ฌ์ฉํ ์ ์๋ค.
Step
Step
์ ์ค์ง์ ์ธ ๋ฐฐ์น ์ฒ๋ฆฌ๋ฅผ ์ ์ํ๊ณ ์ ์ดํ๋ ๋ฐ ํ์ํ ๋ชจ๋ ์ ๋ณด๊ฐ ๋ค์ด ์๋ ๋๋ฉ์ธ ๊ฐ์ฒด์ด๋ค. Job
์ ์ฒ๋ฆฌํ๋ ์ค์ง์ ์ธ ๋จ์๋ก ์ฐ์ธ๋ค.
๋ชจ๋ Job
์๋ 1๊ฐ ์ด์์ Step
์ด ์์ด์ผ ํ๋ค.
StepExecution
Job
์ JobExecution
์ด๋ผ๋ Job
์คํ ์ ๋ณด๊ฐ ์๋ค๋ฉด, Step
์๋ StepExecution
์ด๋ผ๋ Step
์คํ ์ ๋ณด๋ฅผ ๋ด๋ ๊ฐ์ฒด๊ฐ ์๋ค. ๊ฐ๊ฐ์ Step
์ด ์คํ๋ ๋๋ง๋ค StepExecution
์ด ์์ฑ๋๋ค.
๋ค์์ StepExecution
ํด๋์ค์ด๋ค.
public class StepExecution extends Entity {
private final JobExecution jobExecution;
private final String stepName;
private volatile BatchStatus status = BatchStatus.STARTING;
private volatile long readCount = 0;
private volatile long writeCount = 0;
private volatile long commitCount = 0;
private volatile long rollbackCount = 0;
private volatile long readSkipCount = 0;
private volatile long processSkipCount = 0;
private volatile long writeSkipCount = 0;
private volatile Date startTime = null;
private volatile Date createTime = new Date(System.currentTimeMillis());
private volatile Date endTime = null;
private volatile Date lastUpdated = null;
private volatile ExecutionContext executionContext = new ExecutionContext();
private volatile ExitStatus exitStatus = ExitStatus.EXECUTING;
private volatile boolean terminateOnly;
private volatile long filterCount;
private transient volatile List<Throwable> failureExceptions = new CopyOnWriteArrayList<>();
// ...
}
jobExecution
: ํ์ฌ์JobExecution
์ ๋ณด.stepName
:Step
์ ์ด๋ฆ.status
:Step
์ ์คํ ์ํ. (COMPLETED
,STARTING
,STARTED
,STOPPING
,STOPPED
,FAILED
,ABANDONED
,UNKNOWN
๋ฑ์ด ์๋ค. default๋STARTING
.)readCount
: ์ฑ๊ณต์ ์ผ๋ก ์ฝ์ ๋ ์ฝ๋ ์.writeCount
: ์ฑ๊ณต์ ์ผ๋ก ์ด ๋ ์ฝ๋ ์.commitCount
:Step
์ ์คํ์ ๋ํด ์ปค๋ฐ๋ ํธ๋์ญ์ ์.rollbackCount
:Step
์ ์คํ์ ๋ํด ๋กค๋ฐฑ๋ ํธ๋์ญ์ ์.readSkipCount
: ์ฝ๊ธฐ์ ์คํจํด ๊ฑด๋๋ด ๋ ์ฝ๋ ์.processSkipCount
: ํ๋ก์ธ์ค๊ฐ ์คํจํด ๊ฑด๋๋ด ๋ ์ฝ๋ ์.writeSkipCount
: ์ฐ๊ธฐ์ ์คํจํด ๊ฑด๋๋ด ๋ ์ฝ๋ ์.startTime
:Step
์ด ์คํ๋ ์๊ฐ.null
์ด๋ฉด ์์ํ์ง ์์๋ค๋ ๋ป.endTime
:Step
์ ์คํ ์ฑ๊ณต ์ฌ๋ถ์ ๊ด๋ จ ์์ดStep
์ด ๋๋ ์๊ฐ.lastUpdated
: ๋ง์ง๋ง์ผ๋ก ์์ ๋ ์๊ฐ.executionContext
:Step
์คํ ์ฌ์ด์ ์ ์งํด์ผ ํ๋ ์ฌ์ฉ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด ์๋ค.exitStatus
:Step
์คํ ๊ฒฐ๊ณผ์ ๋ํ ์ํ. (UNKNOWN
,EXECUTING
,COMPLETED
,NOOP
,FAILED
,STOPPED
๋ฑ์ด ์๋ค. default๋UNKNOWN
.)terminateOnly
:Job
์คํ ์ค์ง ์ฌ๋ถ.filterCount
: ์คํ์์ ํํฐ๋ง๋ ๋ ์ฝ๋ ์.failureExceptions
:Step
์คํ ์ค ๋ฐ์ํ ์์ธ๋ฅผList
ํ์ ์ผ๋ก ์ ์ฅํ๋ค.
JobRepository
JobRepository
๋ ๋ฐฐ์น ์ฒ๋ฆฌ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ ๋ฉ์ปค๋์ฆ์ด๋ค. ์ด๋ค Job
์ด ์คํ๋์์ผ๋ฉฐ, ๋ช ๋ฒ ์คํ๋์๊ณ , ์ธ์ ๋๋ฌ๋์ง ๋ฑ ๋ฐฐ์น ์ฒ๋ฆฌ์ ๋ํ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค.
์๋ฅผ ๋ค์ด Job
ํ๋๊ฐ ์คํ๋๋ฉด JobRepository
์์๋ ๋ฐฐ์น ์คํ์ ๊ด๋ จ๋ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ ๋๋ฉ์ธ์ธ JobExecution
์ ์์ฑํ๋ค.
JobRepository
๋ Step
์ ์คํ ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋ StepExecution
๋ ์ ์ฅ์์ ์ ์ฅํ๋ฉฐ, ์ ์ฒด ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ ๋ฐ ๊ด๋ฆฌํ๋ ์ญํ ์ ํ๋ค.
JobLauncher
JobLauncher
๋ Job
, JobParameters
์ ํจ๊ป ๋ฐฐ์น๋ฅผ ์คํํ๋ ์ธํฐํ์ด์ค์ด๋ค. ์ธํฐํ์ด์ค๋ run()
ํ๋์ด๋ค.
// org.springframework.batch.core.launch.JobLauncher
public interface JobLauncher {
public JobExecution run(Job job, JobParameters jobParameters) throws ...
}
๋งค๊ฐ๋ณ์๋ก Job
๊ณผ JobParameters
๋ฅผ ๋ฐ์ JobExecution
์ ๋ฐํํ๋ค. ๋งค๊ฐ๋ณ์๊ฐ ์ด์ ๊ณผ ๋์ผํ๋ฉด์ ์ด์ ์ JobExecution
์ด ์ค๋จ๋ ์ ์๋ค๋ฉด ๋์ผํ JobExecution
์ ๋ฐํํ๋ค.
ItemReader
ItemReader
๋ Step
์ ๋์์ด ๋๋ ๋ฐฐ์น ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ค๋ ์ธํฐํ์ด์ค์ด๋ค. ํ์ผ, XML, CSV, DB ๋ฑ ์ฌ๋ฌ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ ์ ์๋ค.
// org.springframework.batch.item.ItemReader
public interface ItemReader<T> {
T read() throws Exception, UnexpectedException, ParseException, NonTransientResourceException;
}
ItemReader
์์ read()
๋ฉ์๋์ ๋ฐํ ํ์
์ ์ ๋ค๋ฆญ <T>
์ผ๋ก ๊ตฌ์ฑํ๊ธฐ ๋๋ฌธ์ ์ง์ ํ์
์ ์ง์ ํ ์ ์๋ค.
์์์ ์ค๋ช ํ ์ฝ๊ธฐ-์ฒ๋ฆฌ-์ฐ๊ธฐ์์ ์ฝ๊ธฐ๋ฅผ ๋ด๋นํ๋ค๊ณ ๋ณผ ์ ์๊ฒ ๋ค!
ItemProcessor
ItemProcessor
๋ ItemReader
๋ก ์ฝ์ด์จ ๋ฐฐ์น ๋ฐ์ดํฐ๋ฅผ ๋ณํํ๋ ์ญํ ์ ์ํํ๋ค.
์ฝ๊ธฐ-์ฒ๋ฆฌ-์ฐ๊ธฐ ์์ ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ค๊ณ ๋ณผ ์ ์๊ฒ ๋ค.
๊ตณ์ด ItemWriter
๊ฐ ์๋๋ผ ItemProcessor
๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ๋ถ๋ฆฌํ ์ด์ ๋ ๋ ๊ฐ์ง๋ค.
๋น์ฆ๋์ค ๋ก์ง์ ๋ถ๋ฆฌํ๊ธฐ ์ํด์์ด๋ค. ๊ฐ๊ฐ ์ฝ๊ธฐ-์ฒ๋ฆฌ-์ฐ๊ธฐ๋ฅผ ๋ด๋นํ๊ฒ ํด ์ญํ ์ ๋ช ํํ ๋ถ๋ฆฌํ๋ค.
Input์ ํ์ ๊ณผ Output์ ํ์ ์ด ๋ค๋ฅผ ์ ์๋ค. Input๊ณผ Output์ ํ์ ์ด ItemProcesor์ ์ ๋ค๋ฆญ
<I, O>
์ ๋ค์ด๊ฐ๊ฒ ๋๋ ๋ ์ง๊ด์ ์ด๋ค.
// org.springframework.batch.item.ItemProcesor
public interface ItemProcessor<I, O> {
O process(I item) throws Exception;
}
ItemWriter
ItemWriter
๋ ๋ฐฐ์น ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ค. ์ผ๋ฐ์ ์ผ๋ก DB ๋๋ ํ์ผ์ ์ ์ฅํ๋ค.
์ฝ๊ธฐ-์ฒ๋ฆฌ-์ฐ๊ธฐ์์ ๋ง์ง๋ง ๋จ๊ณ์ธ ์ฐ๊ธฐ๋ฅผ ๋ด๋นํ๋ค.
// org.springframework.batch.item.ItemWriter
public interface ItemWriter<T> {
void write(List<? extends T> items) throws Exception;
}
ItemWriter
์ ItemReader
์ ๋น์ทํ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ฉด ๋๋ค.
write()
๋ฉ์๋๋ List
์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด ์ง์ ํ ํ์
์ ๋ฆฌ์คํธ๋ฅผ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ๋๋ค. ๋ฆฌ์คํธ์ ๋ฐ์ดํฐ ์๋ ์ค์ ํ ์ฒญํฌ (chunk) ๋จ์๋ก ๋ถ๋ฌ์จ๋ค.
write()
๋ฉ์๋๋ void
ํจ์๋ผ์ ๋ฐํ ๊ฐ์ ๋ฐ๋ก ์๋ค. ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ก์ง๋ง์ ๊ตฌํํ๋ฉด ๋๋ค.
์ง์ฐ ์์ฑ (Lazy Initialization)
๋ฉ๋ชจ๋ฆฌ ์ ์ฝ ๋ฐฉ๋ฒ.
์ง์ฐ ์ด๊ธฐํ: ์ฌ์ฉ์๊ฐ ์ค์ ๋ก ํ์ํ ๋๋ง ๋ก๋ฉ์ ํ์ฌ ๋ฐ์ดํฐ ๋ญ๋น๋ฅผ ์ค์ด๋ ๋ฐฉ๋ฒ์ด๋ค. ์ฆ, ๊ฐ์ฒด๋ฅผ ์ฒ์ ์ฌ์ฉํ ๋๊น์ง ์์ฑ์ ์ง์ฐ์ํจ๋ค๋ ์๋ฏธ์ด๋ค. Lazy Loading โ Eager Loading
์ฐธ์กฐํ ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ๋ณ์๋ฅผ ์ ์ธํ๋ ์์ ์ ํ์ง ์๊ณ ์ฒ์ ์ฌ์ฉ๋๋ ์์ ์ ํ๋๊ฒ
e.g., ์คํ๋ง์์ ๊ธฐ๋ณธ ๋น ์์ฑ์ ์ฑ๊ธํด์ธ๋ฐ, Spring Batch๋ฅผ ์ฌ์ฉํ ๋ @StepScope๋ฅผ ์ฌ์ฉํ๋ฉด ํด๋น ๋ฉ์๋๋ Step์ ์ฃผ๊ธฐ์ ๋ฐ๋ผ ์๋ก์ด ๋น์ ์์ฑํ๋ค. ์ฆ, Step์ ์คํ๋ง๋ค ์๋ก ๋น์ ๋ง๋ค๊ธฐ ๋๋ฌธ์ ์ง์ฐ ์์ฑ์ด ๊ฐ๋ฅํ๋ค. โ ์ฒ์ ๋ฐฐ์ฐ๋ ์คํ๋ง ๋ถํธ 2, p261
์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ (chunk oriented processing)
**์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ (chunk oriented processing)**์ด๋ ํธ๋์ญ์ ๊ฒฝ๊ณ ๋ด์์ ์ฒญํฌ ๋จ์๋ก ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ์์ฑํ๋ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ๋ฒ์ด๋ค.
**์ฒญํฌ(chunk)**๋ ์์ดํ ์ด ํธ๋์ญ์ ์์ ์ปค๋ฐ๋๋ ์๋ฅผ ๋ปํ๋ค.
readํ ๋ฐ์ดํฐ ์๊ฐ ์ง์ ํ ์ฒญํฌ ๋จ์(CHUNK_SIZE)์ ์ผ์นํ๋ฉด, write๋ฅผ ์ํํ๊ณ ํธ๋์ญ์ ์ ์ปค๋ฐํ๋ค.
์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ์ ์ด์ ์?
์ฒญํฌ๋ก ๋๋์ง ์์์ ๋๋ 1000๊ฐ ์ค ํ๋๋ง ์คํจํด๋ ๋๋จธ์ง 999๊ฐ์ ๋ฐ์ดํฐ๊ฐ ๋กค๋ฐฑ๋๋ค.
๊ทธ๋ฐ๋ฐ ์ฒญํฌ ๋จ์๋ฅผ 10์ผ๋ก ํด์ ๋ฐฐ์น ์ฒ๋ฆฌ๋ฅผ ํ๋ฉด ๋์ค์ ๋ฐฐ์น ์ฒ๋ฆฌ์ ์คํจํ๋๋ผ๋ ๋ค๋ฅธ ์ฒญํฌ๋ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
๋ฐ๋ผ์ ์คํ๋ง ๋ฐฐ์น์์๋ ์ฒญํฌ ๋จ์์ ํ๋ก๊ทธ๋๋ฐ์ ์งํฅํ๋ค.
์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ์ด ์๋ ๋ฐฉ์ โ Tasklet
Tasklet
์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ์ด ์๋ ๋ฐฉ์์ Tasklet
์ ์ด์ฉํ๋ ๋ฐฉ์์ด๋ค.
Tasklet
์ ์์์ Step
์ ์คํํ ๋ ํ๋์ ์์
์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ด๋ค.
์ฝ๊ธฐ, ์ฒ๋ฆฌ, ์ฐ๊ธฐ๋ก ๋๋ ๋ฐฉ์์ด ์ฒญํฌ ์งํฅ ํ๋ก์ธ์ฑ์ด๋ผ๋ฉด, ์ด๋ฅผ ๋จ์ผ ๊ฐ๋
์ผ๋ก ๋ง๋ ๊ฒ์ด Tasklet
์ด๋ผ๊ณ ํ ์ ์๋ค.
Tasklet
์ธํฐํ์ด์ค๋ ๋ด๋ถ์ execute()
๋ฉ์๋ ํ๋๋ง ์ง์ํ๋ค. ๋ด๋ถ์ ์ํ๋ ๋จ์ผ ์์
์ ๊ตฌํํ๊ณ ์์
์ด ๋๋๋ฉด RepeatStatus.FINISHED
๋ฅผ ๋ฐํํ๋ค. ์์
์ด ๊ณ์๋๋ค๋ฉด RepeatStatus.CONTINUABLE
์ ๋ฐํํ๋ค.
Flow ์ ์ด
์ฝ๊ธฐ-์ฒ๋ฆฌ-์ฐ๊ธฐ ๊ฐ ๋ถ์กฑํ ๋๊ฐ ์๋ค. ์ธ๋ถ์ ์ธ ์กฐ๊ฑด์ด ์ถ๊ฐ๋๊ฑฐ๋, ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ Step
์ ์คํ ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๊ณ ์ถ์ ๋ ์ธ ์ ์๋ ๊ฒ์ด ์๋๋ฐ, ๋ฐ๋ก ์คํ๋ง ๋ฐฐ์น์์ ํ๋ฆ์ ์ ์ดํ๊ธฐ ์ํด ์ ๊ณต๋๋ Flow
์ด๋ค.
๋ฉํฐ ์ค๋ ๋๋ก ์ฌ๋ฌ ๊ฐ์ Step ์คํํ๊ธฐ
๋ณดํต ๋ฐฐ์น ์ฒ๋ฆฌ๋น ์ค๋ ๋ ํ๋๋ง ์คํํ ๊ฒฝ์ฐ๊ฐ ๋๋ถ๋ถ์ด์ง๋ง, ์ํฉ์ ๋ฐ๋ผ ์ฌ๋ฌ Step
์ ๋์์ ์คํํ๋ ๊ฒฝ์ฐ๋ ์๋ค. ์คํ๋ง ๋ถํธ ๋ฐฐ์น๋ ๋ฉํฐ ์ค๋ ๋๋ก Step
์ ์คํํ๋ ์ฌ๋ฌ ์ ๋ต์ ์ ๊ณตํ๋ค.
TaskExecutor
๋ฅผ ์ฌ์ฉํด ์ฌ๋ฌStep
๋์์ํค๊ธฐ์ฌ๋ฌ ๊ฐ์
Flow
์คํ์ํค๊ธฐํํฐ์ ๋์ ์ด์ฉํ ๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ
REF
๊ทธ ์ธ ์ฝ์ด๋ณด๋ฉด ์ข์ ๊ธ์ ๋ชจ์๋ณธ๋ค.
Spring Batch์ Querydsl | ์ฐ์ํํ์ ๋ค ๊ธฐ์ ๋ธ๋ก๊ทธ
Last updated
Was this helpful?