기록의 탑

10. 스프링배치 플로우 컨트롤 하기

j0free — Tue, 10 Dec 2024 17:38:41 +0900

이전까지는 데이터를 읽고 저장하는 순서대로 처리하는 배치 작업에 대해 알아봤다. 이번에는 배치 작업에서 여러 step을 정의하고 조건에 따라 순서대로 실행하거나 특정 step을 건너 뛸 수 있는 Spring Batch의 Flow Controller에 대해 알아보자

Flow 컨트롤 방법

next: 현재 Step이 성공적으로 종료되면 다음 Step으로 이동한다.
from: 특정 Step에서 현재 Step으로 이동한다.
on: 특정 ExitStatus에 따라 다음 Step을 결정한다.
to: 특정 Step으로 이동한다.
stop: 현재 Flow를 종료한다.
end: FlowBuilder를 종료한다.

Flow 컨트롤

next는 Start 스텝이 수행하고 난 뒤, next 스텝으로 이동하게 된다.
next는 계속해서 추가 될 수 있으며, start --> next --> next ... 순으로 진행되도록 한다.

@Slf4j
@Configuration
@RequiredArgsConstructor
public class NextStepTaskJobConfiguration {

	public static final String NEXT_STEP_TASK = "NEXT_STEP_TASK";

	private final PlatformTransactionManager transactionManager;

	@Bean(name = "step01")
	public Step step01(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("step01", jobRepository)
			.tasklet((contribution, chunkContext) -> {
				log.info("Execute Step 01 Tasklet ...");
				return RepeatStatus.FINISHED;
			}, transactionManager)
			.build();
	}

	@Bean(name = "step02")
	public Step step02(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("step02", jobRepository)
			.tasklet((contribution, chunkContext) -> {
				log.info("Execute Step 02 Tasklet ...");
				return RepeatStatus.FINISHED;
			}, transactionManager)
			.build();
	}

	@Bean
	public Job nextStepJob(@Qualifier("step01") Step step01, @Qualifier("step02") Step step02, JobRepository jobRepository) {
		log.info("------------------ Init myJob -----------------");
		return new JobBuilder(NEXT_STEP_TASK, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(step01)
			.next(step02)
			.build();
	}
}

on

on 은 특정 스텝의 종료 조건에 따라 어떠한 스텝으로 이동할지 결정할 수 있도록 한다.
아래 예는 Step01을 먼저 수행하고, 해당 결과에 따라서 다음 스텝으로 이동하는 플로우를 보여준다.
- on("FAILED") 인경우 step03을 수행하도록 한다.
- from(step01).on("COMPLETED") 인경우 step01의 결과 완료인경우라면 step02를 수행하도록 한다.
이처럼 on과 from을 통해서 스텝의 종료 조건에 따라 원하는 플로우를 처리할 수 있다.

@Slf4j
@Configuration
@RequiredArgsConstructor
public class OnStepTaskJobConfiguration {

	public static final String ON_STEP_TASK = "ON_STEP_TASK";

	private final PlatformTransactionManager transactionManager;

	@Bean(name = "stepOn01")
	public Step stepOn01(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("stepOn01", jobRepository)
			.tasklet((contribution, chunkContext) -> {
				log.info("Execute Step 01 Tasklet ...");

				Random random = new Random();
				int randomValue = random.nextInt(1000);

				if (randomValue % 2 == 0) {
					return RepeatStatus.FINISHED;
				} else {
					throw new RuntimeException("Error This value is Odd: " + randomValue);
				}
			}, transactionManager)
			.build();
	}

	@Bean(name = "stepOn02")
	public Step stepOn02(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("stepOn02", jobRepository)
			.tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
					log.info("Execute Step 02 Tasklet ...");
					return RepeatStatus.FINISHED;
				}
			}, transactionManager)
			.build();
	}

	@Bean(name = "stepOn03")
	public Step stepOn03(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("stepOn03", jobRepository)
			.tasklet((contribution, chunkContext) -> {
				log.info("Execute Step 03 Tasklet ...");
				return RepeatStatus.FINISHED;
			}, transactionManager)
			.build();
	}

	@Bean
	public Job onStepJob(@Qualifier("stepOn01") Step stepOn01, @Qualifier("stepOn02") Step stepOn02, @Qualifier("stepOn03") Step stepOn03, JobRepository jobRepository) {
		log.info("------------------ Init myJob -----------------");
		return new JobBuilder(ON_STEP_TASK, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(stepOn01)
			.on("FAILED").to(stepOn03)
			.from(stepOn01).on("COMPLETED").to(stepOn02)
			.end()
			.build();
	}
}

stop

stop은 특정 step의 작업 결과의 상태를 보고 정지할지 결정한다.
아래 예제는 step1의 결과가 실패인경우 stop을 통해 배치 작업을 정지하고 있다.

@Slf4j
@Configuration
@RequiredArgsConstructor
public class StopStepTaskJobConfiguration {

	public static final String STOP_STEP_TASK = "STOP_STEP_TASK";

	private final PlatformTransactionManager transactionManager;

	@Bean(name = "stepStop01")
	public Step stepStop01(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("stepStop01", jobRepository)
			.tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
					log.info("Execute Step 01 Tasklet ...");

					Random random = new Random();
					int randomValue = random.nextInt(1000);

					if (randomValue % 2 == 0) {
						return RepeatStatus.FINISHED;
					} else {
						throw new RuntimeException("Error This value is Odd: " + randomValue);
					}
				}
			}, transactionManager)
			.build();
	}

	@Bean(name = "stepStop02")
	public Step stepStop02(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("stepStop02", jobRepository)
			.tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
					log.info("Execute Step 02 Tasklet ...");
					return RepeatStatus.FINISHED;
				}
			}, transactionManager)
			.build();
	}

	@Bean
	public Job stopStepJob(@Qualifier("stepStop01") Step stepOn01, @Qualifier("stepStop02") Step stepOn02, JobRepository jobRepository) {
		log.info("------------------ Init myJob -----------------");
		return new JobBuilder(STOP_STEP_TASK, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(stepOn01)
			.on("FAILED").stop()
			.from(stepOn01).on("COMPLETED").to(stepOn02)
			.end()
			.build();
	}
}

Flow Controller를 이용하면 Job의 여러 step을 조건에 따라 수행 할 수 있다.

9. 입맛에 맞는 배치 처리를 위한 Custom ItemReader/ItemWriter 구현

j0free — Tue, 10 Dec 2024 17:07:45 +0900

이전 글에서는 ItemReader와 ItemWriter를 구현하는 방법에 대해 다뤘습니다. 기본 제공되는 ItemReader와 ItemWriter로 충분하지 않거나 복합한 쿼리를 수행하는 경우, 비지니스 로직에 맞게 Custom ItemReader와 ItemWriter 구현이 필요합니다.

이럴 땐, QueryDsl을 이용하여 Custom하게 작성 할 수 있습니다. 허나 문제가 있습니다.

Spring Batch는 공식적으로 QuerydslItemReader를 지원하지 않습니다. 이를 위해서는 AbstractPagingItemReader를 상속하여 QuerydslPagingItemReader를 생성해야 합니다.

Spring Batch ItemReader/ItemWriter 지원 목록

QuerydslPagingItemReader

public class QuerydslPagingItemReader<T> extends AbstractPagingItemReader<T> {

	private EntityManager em;
	private final Function<JPAQueryFactory, JPAQuery<T>> querySupplier;

	private final Boolean alwaysReadFromZero;

	public QuerydslPagingItemReader(EntityManagerFactory entityManagerFactory, Function<JPAQueryFactory, JPAQuery<T>> querySupplier, int chunkSize) {
		this(ClassUtils.getShortName(QuerydslPagingItemReader.class), entityManagerFactory, querySupplier, chunkSize, false);
	}

	public QuerydslPagingItemReader(String name, EntityManagerFactory entityManagerFactory, Function<JPAQueryFactory, JPAQuery<T>> querySupplier, int chunkSize, Boolean alwaysReadFromZero) {
		super.setPageSize(chunkSize);
		setName(name);
		this.querySupplier = querySupplier;
		this.em = entityManagerFactory.createEntityManager();
		this.alwaysReadFromZero = alwaysReadFromZero;

	}

	@Override
	protected void doClose() throws Exception {
		if (em != null)
			em.close();
		super.doClose();
	}

	@Override
	protected void doReadPage() {
		initQueryResult();

		JPAQueryFactory jpaQueryFactory = new JPAQueryFactory(em);
		long offset = 0;
		if (!alwaysReadFromZero) {
			offset = (long) getPage() * getPageSize();
		}

		JPAQuery<T> query = querySupplier.apply(jpaQueryFactory).offset(offset).limit(getPageSize());

		List<T> queryResult = query.fetch();
		for (T entity: queryResult) {
			em.detach(entity);
			results.add(entity);
		}
	}

	private void initQueryResult() {
		if (CollectionUtils.isEmpty(results)) {
			results = new CopyOnWriteArrayList<>();
		} else {
			results.clear();
		}
	}
}

alwaysReadFromZero: 항상 0부터 페이징을 읽을지 여부를 지정한다. 만약 paging 처리된 데이터 자체를 수정하는경우 배치처리 누락이 발생할 수 있으므로 이를 해결하기 위한 방안으로 사용된다.
AbstractPagingItemReader은 어댑터 패턴으로, 상속받는 쪽은 doReadPage만 구현하여 페이징 처리하여 데이터를 가져올 수 있도록 한다.
doClose는 기본적으로 AbstractPagingItemReader를 자체 구현되어 있지만 EntityManager자원을 해제하기 위해서 em.close() 를 수행한다.

QuerydslPagingItemReader를 편하게 작성하기 위해 빌더 코드를 추가 해보자

public class QuerydslPagingItemReaderBuilder<T> {

	private EntityManagerFactory entityManagerFactory;
	private Function<JPAQueryFactory, JPAQuery<T>> querySupplier;

	private int chunkSize = 10;

	private String name;

	private Boolean alwaysReadFromZero;

	public QuerydslPagingItemReaderBuilder<T> entityManagerFactory(EntityManagerFactory entityManagerFactory) {
		this.entityManagerFactory = entityManagerFactory;
		return this;
	}

	public QuerydslPagingItemReaderBuilder<T> querySupplier(Function<JPAQueryFactory, JPAQuery<T>> querySupplier) {
		this.querySupplier = querySupplier;
		return this;
	}

	public QuerydslPagingItemReaderBuilder<T> chunkSize(int chunkSize) {
		this.chunkSize = chunkSize;
		return this;
	}

	public QuerydslPagingItemReaderBuilder<T> name(String name) {
		this.name = name;
		return this;
	}

	public QuerydslPagingItemReaderBuilder<T> alwaysReadFromZero(Boolean alwaysReadFromZero) {
		this.alwaysReadFromZero = alwaysReadFromZero;
		return this;
	}

	public QuerydslPagingItemReader<T> build() {
		if (name == null) {
			this.name = ClassUtils.getShortName(QuerydslPagingItemReader.class);
		}
		if (this.entityManagerFactory == null) {
			throw new IllegalArgumentException("EntityManagerFactory can not be null.!");
		}
		if (this.querySupplier == null) {
			throw new IllegalArgumentException("Function<JPAQueryFactory, JPAQuery<T>> can not be null.!");
		}
		if (this.alwaysReadFromZero == null) {
			alwaysReadFromZero = false;
		}
		return new QuerydslPagingItemReader<>(this.name, entityManagerFactory, querySupplier, chunkSize, alwaysReadFromZero);
	}
}

소스 샘플

@Slf4j
@Configuration
@RequiredArgsConstructor
public class QueryDSLPagingReaderJobConfig {

	/**
	 * CHUNK 크기를 지정한다.
	 */
	public static final int CHUNK_SIZE = 2;
	public static final String ENCODING = "UTF-8";
	public static final String QUERYDSL_PAGING_CHUNK_JOB = "QUERYDSL_PAGING_CHUNK_JOB";

	private final DataSource dataSource;
	private final EntityManagerFactory entityManagerFactory;

	//    @Bean
	//    public QuerydslPagingItemReader<Customer> customerQuerydslPagingItemReader() throws Exception {
	//
	//        Function<JPAQueryFactory, JPAQuery<Customer>> query = jpaQueryFactory -> jpaQueryFactory.select(QCustomer.customer).from(QCustomer.customer);
	//
	//        return new QuerydslPagingItemReader<>("customerQuerydslPagingItemReader", entityManagerFactory, query, CHUNK_SIZE, false);
	//    }


	@Bean
	public QuerydslPagingItemReader<Customer> customerQuerydslPagingItemReader() {
		return new QuerydslPagingItemReaderBuilder<Customer>()
			.name("customerQuerydslPagingItemReader")
			.entityManagerFactory(entityManagerFactory)
			.chunkSize(2)
			.querySupplier(jpaQueryFactory -> jpaQueryFactory.select(QCustomer.customer).from(QCustomer.customer).where(QCustomer.customer.age.gt(20)))
			.build();
	}

	@Bean
	public FlatFileItemWriter<Customer> customerQuerydslFlatFileItemWriter() {

		return new FlatFileItemWriterBuilder<Customer>()
			.name("customerQuerydslFlatFileItemWriter")
			.resource(new FileSystemResource("./customer_new_v2.csv"))
			.encoding(ENCODING)
			.delimited().delimiter("\t")
			.names("Name", "Age", "Gender")
			.build();
	}


	@Bean
	public Step customerQuerydslPagingStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) throws Exception {
		log.info("------------------ Init customerQuerydslPagingStep -----------------");

		return new StepBuilder("customerJpaPagingStep", jobRepository)
			.<Customer, Customer>chunk(CHUNK_SIZE, transactionManager)
			.reader(customerQuerydslPagingItemReader())
			.processor(new CustomerItemProcessor())
			.writer(customerQuerydslFlatFileItemWriter())
			.build();
	}

	@Bean
	public Job customerQueryDslJpaPagingJob(@Qualifier("customerQuerydslPagingStep") Step customerJdbcPagingStep, JobRepository jobRepository) {
		log.info("------------------ Init customerQueryDslJpaPagingJob -----------------");
		return new JobBuilder(QUERYDSL_PAGING_CHUNK_JOB, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(customerJdbcPagingStep)
			.build();
	}

}

CustomItemWriter

CustomItemWriter는 Spring Batch에서 제공하는 기본 ItemWriter 인터페이스를 구현하여 직접 작성한 ItemWriter 클래스이다.
기본 ItemWriter 클래스로는 제공되지 않는 특정 기능을 구현할 때 사용된다

구성 요소

ItemWriter 인터페이스 구현: write() 메소드를 구현하여 원하는 처리를 수행한다.
필요한 라이브러리 및 객체 선언: 사용할 라이브러리 및 객체를 선언한다.
데이터 처리 로직 구현: write() 메소드에서 데이터 처리 로직을 구현한다.

장점

유연성: 기본 ItemWriter 클래스로는 제공되지 않는 특정 기능을 구현할 수 있다.
확장성: 다양한 방식으로 데이터 처리를 확장할 수 있다.
제어 가능성: 데이터 처리 과정을 완벽하게 제어할 수 있다.

단점

개발 복잡성: 기본 ItemWriter 클래스보다 개발 과정이 더 복잡하다.
테스트 어려움: 테스트 작성이 더 어려울 수 있다.
디버깅 어려움: 문제 발생 시 디버깅이 더 어려울 수 있다.

CustomService

청크 아이템을 받아서 호출하는 서비스를 작성한다.

@Slf4j
@Component
public class CustomItemWriter implements ItemWriter<CustomerDto> {

	private final CustomService customService;

	public CustomItemWriter(CustomService customService) {
		this.customService = customService;
	}

	@Override
	public void write(Chunk<? extends CustomerDto> chunk) throws Exception {
		for (CustomerDto customer: chunk) {
			log.info("Call Porcess in CustomItemWriter...");
			customService.processToOtherService(customer);
		}
	}
}

전체코드

@Slf4j
@Configuration
@RequiredArgsConstructor
public class MybatisItemWriterJobConfig {

	/**
	 * CHUNK 크기를 지정한다.
	 */
	public static final int CHUNK_SIZE = 100;
	public static final String ENCODING = "UTF-8";
	public static final String MY_BATIS_ITEM_WRITER = "MY_BATIS_ITEM_CUSTOM_WRITER";

	private final DataSource dataSource;
	private final SqlSessionFactory sqlSessionFactory;
	private final CustomItemWriter customItemWriter;

	@Bean
	public FlatFileItemReader<CustomerDto> flatFileItemReader9() {

		return new FlatFileItemReaderBuilder<CustomerDto>()
			.name("flatFileItemReader9")
			.resource(new ClassPathResource("./customer.csv"))
			.encoding(ENCODING)
			.delimited().delimiter(",")
			.names("name", "age", "gender")
			.targetType(CustomerDto.class)
			.build();
	}

	@Bean
	public Step flatFileStep9(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init flatFileStep -----------------");

		return new StepBuilder("flatFileStep", jobRepository)
			.<CustomerDto, CustomerDto>chunk(CHUNK_SIZE, transactionManager)
			.reader(flatFileItemReader9())
			.writer(customItemWriter)
			.build();
	}

	@Bean
	public Job flatFileJob9(@Qualifier("flatFileStep9") Step flatFileStep, JobRepository jobRepository) {
		log.info("------------------ Init flatFileJob -----------------");
		return new JobBuilder(MY_BATIS_ITEM_WRITER, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(flatFileStep)
			.build();
	}
}

8. CompositeItemProcessor 으로 여러단계에 걸쳐 데이터 Transform하기

j0free — Mon, 2 Dec 2024 18:03:34 +0900

CompositeItemProcessor는 Spring Batch에서 제공하는 클래스로, 여러 ItemProcessor를 하나로 결합하여 순차적으로 데이터를 처리할 수 있게 해줍니다. CompositeItemProcessor를 사용하여 여러개의 ItemProcessor간의 체이닝이 가능합니다.

하나의 ItemProcessor에 여러 작업을 하도록 구현 할 수 있지만, Processor 하나에 역할이 커지고 책임이 많아 지기 때문에 작은 사이즈의 Processor로 구현 한 뒤에 CompositeItemProcessor로 체이닝을 통해 사용합니다.

또한, Processor를 재사용하여 다른 Job에서도 활용할 수 있습니다. 다양한 ItemProcessor를 조합하여 원하는 처리 과정을 구현할 수 있다는 장점도 있습니다.

LowerCaseItemProcessor 작성하기

package com.schooldevops.springbatch.batchsample.jobs.mybatis;

import com.schooldevops.springbatch.batchsample.jobs.models.Customer;
import org.springframework.batch.item.ItemProcessor;

/**
 * 이름, 성별을 소문자로 변경하는 ItemProcessor
 */
public class LowerCaseItemProcessor implements ItemProcessor<Customer, Customer> {
    @Override
    public Customer process(Customer item) throws Exception {
        item.setName(item.getName().toLowerCase());
        item.setGender(item.getGender().toLowerCase());
        return item;
    }
}

After20YearsItemProcessor 작성하기

package com.schooldevops.springbatch.batchsample.jobs.mybatis;

import com.schooldevops.springbatch.batchsample.jobs.models.Customer;
import org.springframework.batch.item.ItemProcessor;

/**
 * 나이에 20년을 더하는 ItemProcessor
 */
public class After20YearsItemProcessor implements ItemProcessor<Customer, Customer> {
    @Override
    public Customer process(Customer item) throws Exception {
        item.setAge(item.getAge() + 20);
        return item;
    }
}

CompositeItemProcess 구현하기

@Bean
    public CompositeItemProcessor<Customer, Customer> compositeItemProcessor() {
        return new CompositeItemProcessorBuilder<Customer, Customer>()
                .delegates(List.of(
                        new LowerCaseItemProcessor(),
                        new After20YearsItemProcessor()
                ))
                .build();
    }

CompositeItemProcessorBuilder를 이용하여 delegates를 통해서 ItemProcessor가 수행할 순서대로 배열을 만들어 전달했다.
compositeItemProcessor를 processor에 넣는다면 원하는 작업을 수행하는 것을 볼 수 있다.

7. MyBatisPagingItemReader로 DB내용을 읽고, MyBatisItemWriter로 DB에 쓰기

j0free — Mon, 18 Nov 2024 19:51:16 +0900

MyBatis는 자바 기반의 SQL Mapper로, 애플리케이션에서 데이터베이스와 상호작용하기 위한 도구입니다. 주로 SQL 문을 직접 작성하고 이를 자바 코드와 연결하는 데 사용됩니다.

1. MyBatisItemReader

MyBatisPagingItemReader Spring Mybatis에서 제공하는 ItemReader 인터페이스를 구현하는 클래스이다.

MyBatis의 Object Relation Mapper를 이용하며 다음과 같은 특징을 가지고 있다.

장점:

간편한 설정: MyBatis 쿼리 매퍼를 직접 활용하여 데이터를 읽을 수 있어 설정이 간편하다.
쿼리 최적화: MyBatis의 다양한 기능을 활용하여 최적화된 쿼리를 작성할 수 있다.
동적 쿼리 지원: 런타임 시 조건에 따라 동적으로 쿼리를 생성할 수 있다.

단점:

MyBatis 의존성: MyBatis 라이브러리에 의존해야 한다.
커스터마이징 복잡: Chunk-oriented Processing 방식과 비교했을 때 커스터마이징이 더 복잡할 수 있다.

2. MyBatisPagingItemReader 작성하기

	@Bean
	public MyBatisPagingItemReader<Customer> myBatisItemReader() throws Exception {

		return new MyBatisPagingItemReaderBuilder<Customer>()
			.sqlSessionFactory(sqlSessionFactory)
			.pageSize(CHUNK_SIZE)
			.queryId("com.schooldevops.springbatch.batchsample.jobs.selectCustomers")
			.build();
	}

SqlSessionFactory: MyBatis 설정 정보 및 SQL 쿼리 매퍼 정보를 담고 있는 객체이다.
QueryId: 데이터를 읽을 MyBatis 쿼리 ID이다.
- 실행 할 쿼리 xml의 mapper의 ID
PageSize: 페이징 쿼리를 위한 페이지 크기를 지정한다.

3. query 작성하기

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.schooldevops.springbatch.batchsample.jobs">

    <resultMap id="customerResult" type="com.schooldevops.springbatch.batchsample.config.Customer">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <result property="gender" column="gender"/>
    </resultMap>

    <select id="selectCustomers" resultMap="customerResult">
        SELECT id, name, age, gender
        FROM customer2
                 LIMIT #{_skiprows}, #{_pagesize}
    </select>
</mapper>

resultMap는 select 쿼리 실행 결과를 table column과 객체를 매핑한다.
_skiprows: 오프셋. 쿼리 별과에서 얼마나 스킵할지 지정. pageSize를 지정했다면 자동으로 계산
_pagesize: 한 번에 가져올 페이지 지정

4. 의존성 추가

implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3'
implementation 'org.mybatis:mybatis:3.5.16'
implementation 'org.mybatis:mybatis-spring:3.0.3'

build.gradle에 mybatis 의존성을 추가한다.

5. mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true" />
        <setting name="multipleResultSetsEnabled" value="true" />
        <setting name="callSettersOnNulls" value="true"/>
    </settings>
</configuration>

mybatis 설정 xml을 classpath에 추가한다.

자세한 설정은 아래 참고

https://mybatis.org/mybatis-3/ko/configuration.html

mybatis – 마이바티스 3 | 매퍼 설정

매퍼 설정 마이바티스 XML 설정파일은 다양한 설정과 프로퍼티를 가진다. 문서의 구조는 다음과 같다.: configuration properties 이 설정은 외부에 옮길 수 있다. 자바 프로퍼티 파일 인스턴스에 설정할

mybatis.org

6. 전체 코드 보기

@Slf4j
@Configuration
@RequiredArgsConstructor
public class MyBatisReaderJobConfig {

	/**
	 * CHUNK 크기를 지정한다.
	 */
	public static final int CHUNK_SIZE = 2;
	public static final String ENCODING = "UTF-8";
	public static final String MYBATIS_CHUNK_JOB = "MYBATIS_CHUNK_JOB";

	private final DataSource dataSource;
	private final SqlSessionFactory sqlSessionFactory;

	@Bean
	public MyBatisPagingItemReader<Customer> myBatisItemReader() throws Exception {

		return new MyBatisPagingItemReaderBuilder<Customer>()
			.sqlSessionFactory(sqlSessionFactory)
			.pageSize(CHUNK_SIZE)
			.queryId("com.schooldevops.springbatch.batchsample.jobs.selectCustomers")
			.build();
	}


	@Bean
	public FlatFileItemWriter<Customer> customerCursorFlatFileItemWriter() {
		return new FlatFileItemWriterBuilder<Customer>()
			.name("customerCursorFlatFileItemWriter")
			.resource(new FileSystemResource("./customer_new_v4.csv"))
			.encoding(ENCODING)
			.delimited().delimiter("\t")
			.names("Name", "Age", "Gender")
			.build();
	}


	@Bean
	public Step customerJdbcCursorStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) throws Exception {
		log.info("------------------ Init customerJdbcCursorStep -----------------");

		return new StepBuilder("customerJdbcCursorStep", jobRepository)
			.<Customer, Customer>chunk(CHUNK_SIZE, transactionManager)
			.reader(myBatisItemReader())
			.processor(new CustomerItemProcessor())
			.writer(customerCursorFlatFileItemWriter())
			.build();
	}

	@Bean
	public Job customerJdbcCursorPagingJob(@Qualifier("customerJdbcCursorStep") Step customerJdbcCursorStep, JobRepository jobRepository) {
		log.info("------------------ Init customerJdbcCursorPagingJob -----------------");
		return new JobBuilder(MYBATIS_CHUNK_JOB, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(customerJdbcCursorStep)
			.build();
	}
}

여기서는 MyBatis를 이용하여, 페이징을 이용한 청크단위 처리를 수행했다.
Mybatis는 쿼리를 직접 작성하고, 쿼리 내용직접 최적화 할수 있는 장점이 있다.
pageSize를 이용하면 자동으로 offset과 pagesize를 자동으로 계산하여 페이징 처리를 수행해준다.

7. MyBatisItemWriter

   @Bean
    public MyBatisBatchItemWriter<Customer> mybatisItemWriter() {
        return new MyBatisBatchItemWriterBuilder<Customer>()
                .sqlSessionFactory(sqlSessionFactory)
                .statementId("com.schooldevops.springbatch.batchsample.jobs.insertCustomers")
                .build();
    }

MyBatisBatchItemWriter Spring Batch에서 제공하는 ItemWriter 인터페이스를 구현하는 클래스이다.
데이터를 MyBatis를 통해 데이터베이스에 저장하는 데 사용된다.

구성 요소

SqlSessionTemplate: MyBatis SqlSession 생성 및 관리를 위한 템플릿 객체이다.
SqlSessionFactory: SqlSessionTemplate 생성을 위한 팩토리 객체이다.
StatementId: 실행할 MyBatis SQL 맵퍼의 스테이tement ID이다.
ItemToParameterConverter: 객체를 ParameterMap으로 변경할수 있다.

장점

ORM 연동: MyBatis를 통해 다양한 데이터베이스에 데이터를 저장할 수 있다.
SQL 쿼리 분리: SQL 쿼리를 Java 코드로부터 분리하여 관리 및 유지 보수가 용이하다.
유연성: 다양한 설정을 통해 원하는 방식으로 데이터를 저장할 수 있다.

단점

설정 복잡성: MyBatis 설정 및 SQL 맵퍼 작성이 복잡할 수 있다.
데이터베이스 종속: 특정 데이터베이스에 종속적이다.
오류 가능성: 설정 오류 시 데이터 손상 가능성이 있다.

   <insert id="insertCustomers" parameterType="com.schooldevops.springbatch.batchsample.config.Customer">
        INSERT INTO customer2(name, age, gender) VALUES (#{name}, #{age}, #{gender});
    </insert>

데이터를 추가 하기 위한 insert 쿼리를 작성한다,

    @Bean
    public MyBatisBatchItemWriter<Customer> mybatisItemWriter() {
        return new MyBatisBatchItemWriterBuilder<Customer>()
                .sqlSessionFactory(sqlSessionFactory)
                .statementId("com.schooldevops.springbatch.batchsample.jobs.insertCustomers")
               .itemToParameterConverter(item -> {
                   Map<String, Object> parameter = new HashMap<>();
                   parameter.put("name", item.getName());
                   parameter.put("age", item.getAge());
                   parameter.put("gender", item.getGender());
                   return parameter;
               })
                .build();
    }

Map을 이용하여 위와 같이 작성이 가능하다.

5. JdbcPagingItemReader로 DB내용을 읽고, JdbcBatchItemWriter로 DB에 쓰기

j0free — Tue, 5 Nov 2024 17:38:58 +0900

이전에는 csv 파일을 읽고 쓰는 것에 배웠습니다. 이번에는 DB에서 데이터를 읽고 CSV 파일로 쓰거나 CSV 파일을 읽고 DB에 저장하는 방법에 대해 알아보자.

1. JdbcPagingItemReader

JdbcPagingItemReader는 Spring Batch에서 제공하는 ItemReader로, 데이터베이스로부터 데이터를 페이지 단위로 읽는다.
대규모 데이터 처리 효율성: 메모리 사용량을 최소화하고 커밋 간격을 설정하여 대규모 데이터를 효율적으로 처리할 수 있다.
쿼리 최적화: SQL 쿼리를 직접 작성하여 최적화된 데이터 읽기가 가능하다.
커서 제어: 데이터베이스 커서를 사용하여 데이터 순회를 제어할 수 있다.

2. 쿼리 Provider 생성하기

@Bean
public PagingQueryProvider queryProvider() throws Exception {
        SqlPagingQueryProviderFactoryBean queryProvider = new SqlPagingQueryProviderFactoryBean();
        queryProvider.setDataSource(dataSource);  // DB 에 맞는 PagingQueryProvider 를 선택하기 위함
        queryProvider.setSelectClause("id, name, age, gender");
        queryProvider.setFromClause("from customer");
        queryProvider.setWhereClause("where age >= :age");

        Map<String, Order> sortKeys = new HashMap<>(1);
        sortKeys.put("id", Order.DESCENDING);

        queryProvider.setSortKeys(sortKeys);

        return queryProvider.getObject();
    }

SqlPagingQueryProviderFactoryBean: 쿼리 프로파이더 팩토리
setDataSource: 데이터소스를 설정한다.
setSelectClause: select에서 프로젝션할 필드 이름을 지정한다.
setFromClause: 조회할 테이블
setWhereClause: 조건절
setSortKeys: 소트 키를 지정한다.

3. JdbcPagingItemReader 작성

@Bean
 public JdbcPagingItemReader<Customer> jdbcPagingItemReader() throws Exception {
        Map<String, Object> parameterValue = new HashMap<>();
        parameterValue.put("age", 20);

        return new JdbcPagingItemReaderBuilder<Customer>()
                .name("jdbcPagingItemReader")
                .fetchSize(CHUNK_SIZE)
                .dataSource(dataSource)
                .rowMapper(new BeanPropertyRowMapper<>(Customer.class))
                .queryProvider(queryProvider())
                .parameterValues(parameterValue)
                .build();
    }

※ queryProvider를 이용해서 만든 쿼리에 조건을 넣고 CHUNK_SIZE 만큼 읽는다.

4. 전체 코드

@Slf4j
@Configuration
@RequiredArgsConstructor
public class JdbcPagingReaderJobConfig {

	public static final int CHUNK_SIZE = 2;
	public static final String ENCODING = "UTF-8";
	public static final String JDBC_PAGING_CHUNK_JOB = "JDBC_PAGING_CHUNK_JOB";

	private final DataSource dataSource;

	@Bean
	public JdbcPagingItemReader<Customer> jdbcPagingItemReader() throws Exception {
		Map<String, Object> parameterValue = new HashMap<>();
		parameterValue.put("age", 20);

		return new JdbcPagingItemReaderBuilder<Customer>()
			.name("jdbcPagingItemReader")
			.fetchSize(CHUNK_SIZE)
			.dataSource(dataSource)
			.rowMapper(new BeanPropertyRowMapper<>(Customer.class))
			.queryProvider(queryProvider())
			.parameterValues(parameterValue)
			.build();
	}

	@Bean
	public PagingQueryProvider queryProvider() throws Exception {
		SqlPagingQueryProviderFactoryBean queryProvider = new SqlPagingQueryProviderFactoryBean();
		queryProvider.setDataSource(dataSource);
		queryProvider.setSelectClause("id, name, age, gender");
		queryProvider.setFromClause("from customer2");
		queryProvider.setWhereClause("where age >= :age");

		Map<String, Order> sortKeys = new HashMap<>(1);
		sortKeys.put("id", Order.DESCENDING);

		queryProvider.setSortKeys(sortKeys);

		return queryProvider.getObject();
	}

	@Bean
	public FlatFileItemWriter<Customer> customerFlatFileItemWriter() {
		return new FlatFileItemWriterBuilder<Customer>()
			.name("customerFlatFileItemWriter")
			.resource(new FileSystemResource("./customer_new_v1.csv"))
			.encoding(ENCODING)
			.delimited().delimiter("\t")
			.names("Name", "Age", "Gender")
			.build();
	}

	@Bean
	public Step customerJdbcPagingStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) throws Exception {
		log.info("------------------ Init customerJdbcPagingStep -----------------");

		return new StepBuilder("customerJdbcPagingStep", jobRepository)
			.<Customer, Customer>chunk(CHUNK_SIZE, transactionManager)
			.reader(jdbcPagingItemReader())
			.writer(customerFlatFileItemWriter())
			.build();
	}

	@Bean
	public Job customerJdbcPagingJob(@Qualifier("customerJdbcPagingStep") Step customerJdbcPagingStep, JobRepository jobRepository) {
		log.info("------------------ Init customerJdbcPagingJob -----------------");
		return new JobBuilder(JDBC_PAGING_CHUNK_JOB, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(customerJdbcPagingStep)
			.build();
	}

}

※ DB에서 데이터를 읽고 CSV 파일에 읽은 데이터를 쓰고 저장한다.

6. DB 설정

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf8&clusterInstanceHostPattern=?&zeroDateTimeBehavior=CONVERT_TO_NULL&allowMultiQueries=true
    username: root
    password: root1234

* DB에 데이터를 데이터를 넣어놔야 읽고 CSV 파일로 만들 수 있기 때문에, docker를 이용해서 테이블 및 데이터를 준비 해둔다.

7. JdbcBatchItemWriter

JdbcBatchItemWriter Spring Batch에서 제공하는 ItemWriter 인터페이스를 구현하는 클래스이다.
데이터를 JDBC를 통해 데이터베이스에 저장하는 데 사용된다.
DataSource: 데이터베이스 연결 정보를 지정한다.
SqlStatementCreator: INSERT 쿼리를 생성하는 역할을 한다.
PreparedStatementSetter: INSERT 쿼리의 파라미터 값을 설정하는 역할을 한다.
ItemSqlParameterSourceProvider: Item 객체를 기반으로 PreparedStatementSetter에 전달할 파라미터 값을 생성하는 역할을 한다.

장점

데이터베이스 연동: JDBC를 통해 다양한 데이터베이스에 데이터를 저장할 수 있다.
성능: 대량의 데이터를 빠르게 저장할 수 있다.
유연성: 다양한 설정을 통해 원하는 방식으로 데이터를 저장할 수 있다.

단점

설정 복잡성: JDBC 설정 및 쿼리 작성이 복잡할 수 있다.
데이터베이스 종속: 특정 데이터베이스에 종속적이다.
오류 가능성: 설정 오류 시 데이터 손상 가능성이 있다.

8 . 테이블 생성하기

create table testdb.customer2
(
    id     int auto_increment primary key,
    name   varchar(100) null,
    age    int          null,
    gender varchar(10)  null
);

9. SqlPatameterSourceProvider 작성

public class CustomerItemSqlParameterSourceProvider implements ItemSqlParameterSourceProvider<Customer> {
    @Override
    public SqlParameterSource createSqlParameterSource(Customer item) {
        return new BeanPropertySqlParameterSource(item);
    }
}

10. 전체코드

@Slf4j
@Configuration
@RequiredArgsConstructor
public class JdbcBatchItemJobConfig {

	/**
	 * CHUNK 크기를 지정한다.
	 */
	public static final int CHUNK_SIZE = 100;
	public static final String ENCODING = "UTF-8";
	public static final String JDBC_BATCH_WRITER_CHUNK_JOB = "JDBC_BATCH_WRITER_CHUNK_JOB";

	private final DataSource dataSource;

	@Bean
	public FlatFileItemReader<Customer> jdbcFlatFileItemReader() {

		return new FlatFileItemReaderBuilder<Customer>()
			.name("FlatFileItemReader")
			.resource(new ClassPathResource("./customer.csv"))
			.encoding(ENCODING)
			.delimited().delimiter(",")
			.names("name", "age", "gender")
			.targetType(Customer.class)
			.build();
	}

	@Bean
	public JdbcBatchItemWriter<Customer> jdbcFlatFileItemWriter() {

		return new JdbcBatchItemWriterBuilder<Customer>()
			.dataSource(dataSource)
			.sql("INSERT INTO customer2 (name, age, gender) VALUES (:name, :age, :gender)")
			.itemSqlParameterSourceProvider(new CustomerItemSqlParameterSourceProvider())
			.build();
	}


	@Bean
	public Step jdbcFlatFileStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init flatFileStep -----------------");

		return new StepBuilder("jdbcFlatFileStep", jobRepository)
			.<Customer, Customer>chunk(CHUNK_SIZE, transactionManager)
			.reader(jdbcFlatFileItemReader())
			.writer(jdbcFlatFileItemWriter())
			.build();
	}

	@Bean
	public Job jdbcBatchWriterChunkJob(@Qualifier("jdbcFlatFileStep") Step flatFileStep, JobRepository jobRepository) {
		log.info("------------------ Init flatFileJob -----------------");
		return new JobBuilder(JDBC_BATCH_WRITER_CHUNK_JOB, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(flatFileStep)
			.build();
	}
}

* CSV 파일을 읽고 객체와 매핑 후 DB에 데이터를 저장한다.

4. FlatFileItemReader로 단순 파일 읽고, FlatFileItemWriter로 파일에 쓰기

j0free — Mon, 4 Nov 2024 17:49:11 +0900

CSV 파일을 읽고 내용을 집계하여 CSV 파일로 쓰도록 FlatFileItemReader와 FlatFileItemWriter에 대해 알아보자

1.FlatFileItemReader

FlatFileItemReader는 Spring Batch에서 제공하는 기본적인 ItemReader로, 텍스트 파일로부터 데이터를 읽습니다.
고정 길이, 구분자 기반, 멀티라인 등 다양한 형식의 텍스트 파일을 지원하며, 다음과 같은 장점을 가집니다.
간단하고 효율적인 구현: 설정 및 사용이 간편하며, 대규모 데이터 처리에도 효율적입니다.
다양한 텍스트 파일 형식 지원: 고정 길이, 구분자 기반, 멀티라인 등 다양한 형식의 텍스트 파일을 읽을 수 있습니다.
확장 가능성: 토크나이저, 필터 등을 통해 기능을 확장할 수 있습니다.
사용처: 고정 길이, 구분자 기반, 멀티라인 등 다양한 형식의 텍스트 파일 데이터 처리

FlatFileItemReader 장점

간단하고 효율적인 구현, 다양한 텍스트 파일 형식 지원

FlatFileItemReader 단점

복잡한 데이터 구조 처리에는 적합하지 않음

2.FlatFileItemWriter

FlatFileItemWriter는 Spring Batch에서 제공하는 ItemWriter 인터페이스를 구현하는 클래스
데이터를 텍스트 파일로 출력하는 데 사용

FlatFileItemWriter 장점

간편성: 텍스트 파일로 데이터를 출력하는 간편한 방법을 제공한다.
유연성: 다양한 설정을 통해 원하는 형식으로 출력 파일을 만들 수 있다.
성능: 대량의 데이터를 빠르게 출력할 수 있다.

FlatFileItemWriter 단점

형식 제약: 텍스트 파일 형식만 지원한다.
복잡한 구조: 복잡한 구조의 데이터를 출력할 경우 설정이 복잡해질 수 있다.
오류 가능성: 설정 오류 시 출력 파일이 손상될 수 있다.

3. CSV로 부터 정보를 읽기 위한 객체 정의

@Setter
@Getter
public class Customer {

	private String name;
	private int age;
	private String gender;

	public Customer() {
	}
	
}

※ Customer 객체에 Setter와 기본 생성자가 필요한 이유

1. 객체 생성 및 필드 값 할당을 위한 기본 생성자

• FlatFileItemReader는 리플렉션(reflection)을 사용하여 각 레코드를 읽고 매핑할 객체의 인스턴스를 생성합니다.

• 이때, 기본 생성자가 없으면 객체를 생성할 수 없으므로 FlatFileItemReader는 기본 생성자가 반드시 있어야 합니다. 기본 생성자가 없으면 예외가 발생하게 됩니다.

2. CSV 데이터 값을 객체 필드에 할당하기 위한 Setter 메서드

• FlatFileItemReader는 각 CSV 데이터 필드를 매핑할 객체의 필드에 할당하기 위해 Setter 메서드를 사용합니다.

• 예를 들어, CSV 파일의 name, age, gender 데이터를 Customer 객체에 할당하려면 Customer 클래스에 setName(), setAge(), setGender() 메서드가 필요합니다. 이 방법으로 FlatFileItemReader는 필드 값을 각 필드에 쉽게 할당할 수 있습니다.

• 만약 setter가 없다면 필드에 접근할 방법이 없기 때문에 값이 제대로 할당되지 않습니다.

요약

• 기본 생성자는 객체 인스턴스를 만들기 위해 필수입니다.

• Setter 메서드는 리플렉션을 통해 CSV의 각 필드 값을 객체의 필드에 할당하기 위해 필요합니다.

4.FlatFileItemReader 작성

@Bean
public FlatFileItemReader<Customer> flatFileItemReader() {

		return new FlatFileItemReaderBuilder<Customer>()
			.name("FlatFileItemReader")
			.resource(new ClassPathResource("./customer.csv"))
			.encoding(ENCODING)
			.delimited().delimiter(",")
			.names("name", "age", "gender")
			.targetType(Customer.class)
			.build();
	}

name : FlatFileItemReader 빈의 이름을 지정한다.
resource : 읽어들일 파일의 위치를 지정한다.
encoding : 파일의 인코딩을 지정한다.
delimited().delimiter() : 읽어들일 정보간 구분자를 지정한다.
names : 구분자로 구분된 데이터의 이름을 지정한다.
targerType : 매핑할 객체 타입을 지정한다.

5. FlatFileItemWriter

@Bean
public FlatFileItemWriter<Customer> flatFileItemWriter() {

		return new FlatFileItemWriterBuilder<Customer>()
			.name("flatFileItemWriter")
			.resource(new FileSystemResource("./customer_new.csv"))
			.encoding(ENCODING)
			.delimited().delimiter("\t")
			.names("Name", "Age", "Gender")
			.append(false)
			.lineAggregator(new CustomerLineAggregator())
			.headerCallback(new CustomerHeader())
			.footerCallback(new CustomerFooter(aggregateInfos))
			.build();
	}

name : FlatFileItemWriter 빈의 이름을 지정한다.
resource : 읽어들일 파일의 위치를 지정한다.
encoding : 파일의 인코딩을 지정한다.
delimited().delimiter() : 읽어들일 정보간 구분자를 지정한다.
names : 구분자로 구분된 데이터의 이름을 지정한다.
append : 기존 파일에 추가 할지 true or false로 지정한다.
lineAggergator : 라인 구분자를 지정한다.
headerCallback : 출력 파일의 헤더를 지정할 수 있도록 한다.
footerCallback : 출력 파일의 푸터를 지정할 수 있도록 한다.
targerType : 매핑할 객체 타입을 지정한다.

6. CustomerLineAggregator 작성

public class CustomerLineAggregator implements LineAggregator<Customer> {
	@Override
	public String aggregate(Customer item) {
		return item.getName() + "," + item.getAge();
	}
}

FlatFile에 저장할 아이템들을 스트링으로 변환하는 방법을 지정

7. CustomerHeader 작성

public class CustomerHeader implements FlatFileHeaderCallback {
	@Override
	public void writeHeader(Writer writer) throws IOException {
		writer.write("ID,AGE");
	}
}

FlatFileHeaderCallback은 writeHeader를 구현하고, 출력될 파일의 헤더를 달아주는 역할을 한다.

8. CustomerFooter 작성

@Slf4j
public class CustomerFooter implements FlatFileFooterCallback {
	ConcurrentHashMap<String, Integer> aggregateCustomers;

	public CustomerFooter(ConcurrentHashMap<String, Integer> aggregateCustomers) {
		this.aggregateCustomers = aggregateCustomers;
	}

	@Override
	public void writeFooter(Writer writer) throws IOException {
		writer.write("총 고객 수: " + aggregateCustomers.get("TOTAL_CUSTOMERS"));
		writer.write(System.lineSeparator());
		writer.write("총 나이: " + aggregateCustomers.get("TOTAL_AGES"));
	}
}

FlatFileFooterCallback 은 푸터를 작성할때 사용한다.
결과를 집계하여 총 고객수와 총 나이를 출력하고 있다.
이때 전달된 HashMap을 전달하여, 결과를 출력하고 있음을 확인하자.

9. AggregateCustomerProcessor 작성

csv로 부터 읽은 데이터를 객체에 매핑한 결과를 writer를 쓰기 전에 별도의 처리를 하는 클래스이다.

@Slf4j
public class AggregateCustomerProcessor implements ItemProcessor<Customer, Customer> {

	ConcurrentHashMap<String, Integer> aggregateCustomers;

	public AggregateCustomerProcessor(ConcurrentHashMap<String, Integer> aggregateCustomers) {
		this.aggregateCustomers = aggregateCustomers;
	}

	@Override
	public Customer process(Customer item) throws Exception {
		aggregateCustomers.putIfAbsent("TOTAL_CUSTOMERS", 0);
		aggregateCustomers.putIfAbsent("TOTAL_AGES", 0);

		aggregateCustomers.put("TOTAL_CUSTOMERS", aggregateCustomers.get("TOTAL_CUSTOMERS") + 1);
		aggregateCustomers.put("TOTAL_AGES", aggregateCustomers.get("TOTAL_AGES") + item.getAge());
		return item;
	}
}

ItemProcessor은 process 메소드를 구현하였으며, 각 아이템을 하나씩 읽고 아이템의 내용을 집계

전체소스

@Slf4j
@Configuration
public class FlatFileItemJobConfig {

	/**
	 * CHUNK 크기를 지정한다.
	 */
	public static final int CHUNK_SIZE = 100;
	public static final String ENCODING = "UTF-8";
	public static final String FLAT_FILE_WRITER_CHUNK_JOB = "FLAT_FILE_WRITER_CHUNK_JOB";

	private ConcurrentHashMap<String, Integer> aggregateInfos = new ConcurrentHashMap<>();

	private final ItemProcessor<Customer, Customer> itemProcessor = new AggregateCustomerProcessor(aggregateInfos);

	@Bean
	public FlatFileItemReader<Customer> flatFileItemReader() {

		return new FlatFileItemReaderBuilder<Customer>()
			.name("FlatFileItemReader")
			.resource(new ClassPathResource("./customer.csv"))
			.encoding(ENCODING)
			.delimited().delimiter(",")
			.names("name", "age", "gender")
			.targetType(Customer.class)
			.build();
	}

	@Bean
	public FlatFileItemWriter<Customer> flatFileItemWriter() {

		return new FlatFileItemWriterBuilder<Customer>()
			.name("flatFileItemWriter")
			.resource(new FileSystemResource("./customer_new.csv"))
			.encoding(ENCODING)
			.delimited().delimiter("\t")
			.names("Name", "Age", "Gender")
			.append(false)
			.lineAggregator(new CustomerLineAggregator())
			.headerCallback(new CustomerHeader())
			.footerCallback(new CustomerFooter(aggregateInfos))
			.build();
	}


	@Bean
	public Step flatFileStep(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init flatFileStep -----------------");

		return new StepBuilder("flatFileStep", jobRepository)
			.<Customer, Customer>chunk(CHUNK_SIZE, transactionManager)
			.reader(flatFileItemReader())
			.processor(itemProcessor)
			.writer(flatFileItemWriter())
			.build();
	}

	@Bean
	public Job flatFileJob(@Qualifier("flatFileStep") Step flatFileStep, JobRepository jobRepository) {
		log.info("------------------ Init flatFileJob -----------------");

		return new JobBuilder(FLAT_FILE_WRITER_CHUNK_JOB, jobRepository)
			.incrementer(new RunIdIncrementer())
			.start(flatFileStep)
			.build();
	}
}

※ 이전 3장에서 작성 한 batch가 있다면, step 및 job 구성 시에 @Qulifier를 이용하여 각 Job이 필요한 Bean을 넣도록 수정하자

Spring Batch는 초기 실행 시 Job, Step 인터페이스를 구현한 모든 Bean을 등록하려고 하기 때문에 이름 지정을 통해 필요한

Bean을 주입하는 것이 필요하다.

※ Caused by: java.lang.IllegalArgumentException: Job name must be specified in case of multiple jobs 예외 발생

해당 문제는 Spring Boot 3 버전에서부터 Spring Batch 사용 시 업데이트 된 내용 때문이었다.

기존에는 스프링 부트가 구동될 때 모든 Job 빈들을 읽어 실행하는 구조였다면, 새로운 버전에서부터는 복수 개의 Job이 컨텍스트 내에 정의되어 있다면 부트 구동 시점에 가동시킬 Job을 프로프티에 명시해야한다. (하나만 등록 가능)

만약 컨텍스트 내에 하나의 Job만 존재한다면, 해당 Job은 별도의 명시 없이 부트 구동 시점에 실행된다.

해결방법

# application.yml

spring:
  batch:
    job:
      name: myJob

초기 구동 시 실행 할 Job을 명시해준다.

3.SpringBatch ChunkModel과 TaskletModel

j0free — Mon, 21 Oct 2024 01:36:40 +0900

SpringBatch에서 데이터 처리 단위인 ChuckModel과 TaskletModel의 차이점에 대해 알아보고자 한다.

1. Chunk Model

Chunk Model은 처리할 데이터를 일정단위(청크) 로 처리하는 방식이다
ChunkOrientedTaskLet은 Spring Batch에서 제공하는 TaskLet 인터페이스의 구현체
Chunk size 만큼 ItemReader, ItemProcessor, ItemWrite 처리하며, commit-interval이라는 설정값을 이용하여 조정이 가능
Chunk는 최대 Size만큼의 크기를 가진다. 예를 들어 20개의 소스를 처리해야하고, Chunk Size가 2인 경우 Chunk는 2개씩 처리되기 때문에 총 10번의 반복이 필요하다. 즉 10번의 트랜잭션을 탄다는 소리로 이해를 할 수 있다.
몇번의 트랙잭션을 수행 할 것인지도 Chunk Size를 통해 조정이 가능하다.

Chunk 단위의 트랜잭션 처리

각 Chunk가 읽기(Read), 처리(Process), 쓰기(Write) 작업을 거치고 성공적으로 끝나면, 그 Chunk는 트랜잭션이 커밋한다.
예를 들어, 첫 번째 Chunk가 성공하면 트랜잭션이 커밋되고, 두 번째 Chunk가 실행된다.
만약 두 번째 Chunk가 처리되는 도중에 예외(Exception)가 발생하면, 그 Chunk만 롤백한다.
하지만 첫 번째 Chunk는 이미 성공적으로 커밋되었으므로 롤백되지 않습니다. 이는 각 Chunk가 별도의 트랜잭션으로 처리한다.
Spring Batch는 데이터 처리의 안정성을 높이기 위해 Chunk 단위로 트랜잭션을 분리합니다. 이렇게 하면 대용량 데이터를 처리할 때, 부분적으로 성공한 Chunk는 다시 처리하지 않아도 되므로 성능을 향상시킬 수 있다.
따라서, 이전 Chunk가 성공적으로 커밋되었고, 다음 Chunk에서 실패가 발생해도 이전 Chunk는 롤백되지 않는다. 이는 Chunk 단위로 트랜잭션을 관리하는 Spring Batch의 동작 방식 때문이다.

ChunkOrientedTasklet 은 ItemReader, ItemProcessor, ItemWriter 구현체를 각각 호출
Chunk 단위 만큼 ItemReader, ItemProcessor, ItemWriter 구현체를 반복 실행

2. ItemReader

스프링배치에서는 이미 구현된 다양한 ItemReader구현체를 제공

Chunk 단위 만큼 데이터를 읽고 다음 ItemProcessor와 ItemWriter에게 전달한다.

FlatFileItemReader:
- 플랫파일 (즉 구조화 되지 않은파일을 플랫파일이라고한다.)을 읽어 들인다.
- 대표적인 것이 CSV파일 등이 있다.
- 읽어들인 데이터를 객체로 매핑하기 위해서 delimeter를 기준으로 매핑 룰을 이용하여 객체로 매핑한다.
- 혹은 입력에 대해서 Resource object를 이용하여 커스텀하게 매핑할 수도 있다.
StaxEventItemReader:
- XML파일을 읽어 들인다.
- 이름이 함축하듯이 XML파일을 StAX기반으로 읽어 들인다.
JdbcPagingItemReader / JdbcCursorItemReader:
- JDBC를 사용하여 SQL을 실행하고 데이터베이스의 레코드를 읽는다.
- 데이터베이스에서 많은 양의 데이터를 처리해야 하는 경우에는 메모리에 있는 모든 레코드를 읽는 것을 피하고, 한 번의 처리에 필요한 데이터만 읽고 폐기하는 것이 필요하다.
- JdbcPagingItemReader는 JdbcTemplate을 이용하여 각 페이지에 대한 SELECT SQL을 나누어 처리하는 방식으로 구현된다.
- 반면 JdbcCursorItemReader는 JDBC 커서를 이용하여 하나의 SELECT SQL을 발행하여 구현된다.
MyBatisCursorItemReader / MyBatisPagingItemReader:
- MyBatis를 사용하여 데이터베이스의 레코드를 읽는다.
- MyBatis가 제공하는 Spring 조정 라이브러리는 MyBatis-Spring에서 제공된다.
- Paging과 Cursor의 차이점은 MyBatis를 구현방법이 다를뿐이지 JdbcXXXItemReader과 동일하다
- 또한 ItemReaderJPA구현이나 Hibernate와 연동하여 데이터베이스의 레코드를 읽어오는 JpaPagingItemReader, HibernatePagingItemReader, HibernateCursor를 제공한다.
JmsItemReader / AmqpItemReader:
- 메시지를 JMS혹은 AMQP에서 읽어들인다

3. ItemProcessor

ItemProcessor는 ItemReader를 통해 읽어온 데이터를 처리 및 가공하는 역할을 한다.

PassThroughItemProcessor:
- 아무 작업도 수행하지 않는다.
- 입력된 데이터의 변경이나 처리가 필요하지 않는경우 사용된다.
ValidatingItemProcessor:
- 입력된 데이터를 체크한다.
- 입력 확인 규칙을 구현하려면 Spring Batch 전용 org.springframework.batch.item.validator.Validator를 구현해야한다.
- 그러나 일반적인 org.springframework.validation.Validator 의 어댑터인 SpringValidator와 org.springframework.validation의 규칙을 제공한다.
CompositeItemProcessor:
- 동일한 입력 데이터에 대해 여러 ItemProcessor를 순차적으로 실행한다.
- ValidatingItemProcessor를 사용하여 입력 확인을 수행한 후 비즈니스 로직을 실행하려는 경우 활성화 된다.

4. ItemWriter

ItemWriter는 ItemProcessor가 처리 한 데이터를 파일 및 DB에 저장하는 역할을 한다.

FlatFileItemWriter:
- 처리된 Java객체를 CSV 파일과 같은 플랫 파일로 작성한다.
- 파일 라인에 대한 매핑 규칙은 구분 기호 및 개체에서 사용자 정의로 사용할수도 있다.
StaxEventItemWriter:
- XML파일로 자바 객체를 쓰기할 수 있다.
JdbcBatchItemWriter:
- JDBC를 사용하여 SQL을 수행하고 자바 객체를 데이터베이스에 쓰기한다.
- 내부적으로 JdbcTemplate를 사용하게 된다.
MyBatisBatchItemWriter:
- Mybatis를 사용하여 자바 객체를 데이터베이스로 쓰기한다.
- MyBatis-Spring 는 MyBatis에 의해서 제공되는 라이브러리를 이용한다.
JmsItemWriter / AmqpItemWriter:
- JMS혹은 AMQP로 자바 객체의 메시지를 전송한다.

5. Tasklet Model

Chunk 단위로 데이터를 나눠서 처리하는 것이 아닌 한번에 하나의 레코드만 읽어서 처리 할 경우 Tasklet Model이 적합하다

앞선, 2장에서 GreetingTask를 구현 한 것과 같이 사용자가 직접 인터페이스 구현을 해야한다.

SystemCommandTasklet:
- 시스템 명령어를 비동기적으로 실행하는 Tasklet이다.
- 명령 속성에 수행해야할 명령어를 지정하여 사용할 수 있다.
- 시스템 명령은 호출하는 스레드와 다른 스레드에 의해 실행되므로 프로세스 도중 타임아웃을 설정하고, 시스템 명령의 실행 스레드를 취소할 수 있다.
MethodInvokingTaskletAdapter:
- POJO클래스의 특정 메소드를 실행하기 위한 태스클릿이다.
- targetObject 속성에 대상 클래스의 빈을 지정하고, targetMethod속성에 실행할 메소드 이름을 지정한다.
- POJO 클래스는 일괄 처리 종료 상태를 메소드의 반환 값으로 반환이 가능하지만, 이경우 사실은 ExitStatus를 반환값으로 설정해야한다.
- 다른 타입의 값이 반환될 경우 반환값과 상관없이 "정상 종료(ExitStatus:COMPLETED)" 상태로 간주된다.

2.SpringBatch 코드 설명 및 아키텍처 알아보기

j0free — Sun, 20 Oct 2024 22:27:15 +0900

앞선 과정에서 SpringBatch 프로젝트를 구성 및 실행을 해보았습니다.

이번에는 Job, step에 대해 알아보고 SpringBatch 아키텍처에 대해 학습해보도록 하겠습니다.

1.Spring Batch 아키텍처

Job
- Spring Batch에서 일괄 적용을 위한 일련의 프로세스를 요약하는 단일 실행 단위가 된다.
Step
- Job을 구성하는 처리단위이다.
- 하나의 Job에는 여러 Step이 들어갈 수 있다. 1: N 구조로 되어있다.
- 하나의 Job에 여러 Step을 재사용, 병렬화, 조건분기 등을 수행할 수 있다.
- Step은 tasklet 모델 / chunk 모델의 구현체가 탑재되어 실행된다.
JobLauncher
- Job을 수행하기 위한 인터페이스이다.
- JobLauncher는 사용자에 의해서 직접 수행된다.
- 자바 커맨드를 통해서 CommandLineJobRunner 를 실행하여 단순하게 배치 프로세스가 수행될 수 있다.
ItemReader
- 청크단위 모델에서 사용하며, 소스 데이터를 읽어 들이는 역할을 수행한다.
ItemProcessor
- 읽어들인 청크 데이터를 처리한다.
- 데이터 변환을 수행하거나, 데이터를 정제하는 등의 역할을 담당한다.
- 옵션으로 필요없다면 사용하지 않아도 된다.
ItemWriter
- 청크 데이터를 읽어들였거나, 처리된 데이터를 실제 쓰기작업을 담당한다.
- 데이터베이스로 저장하거나, 수정하는 역할을 할 수 있고, 파일로 처리결과를 출력할 수도 있다.
Tasklet
- 단순하고 유연하게 배치 처리를 수행하는 태스크를 수행한다.
JobRepository
- Job과 Step의 상태를 관리하는 시스템이다.
- 스프링배치에서 사용하는 테이블 스키마를 기반으로 상태정보를 저장하고 관리한다.

2. 스프링배치 흐름

앞세 살펴봤던 아키텍처에서 배치의 흐름이 어떻게 흘러가는지 알아보자.

처리흐름 관점

JobScheduler 가 배치를 트리거링 하면 -> JobLauncher 를 실행
JobLauncher 는 Job을 실행 -> JobExecution 을 수행하고, Execution Context 정보를 이용한다.
Job은 ->Step을 실행한다. 이때 StepExecution을 수행하고, Execution Context 정보가 전달되어 수행된다.
Step은 Tasklet과 Chunk모델을 가지고 있으며 위 그림에서는 Chunk 모델로 수행되게 된다.
- Chunk 모델은 ItemReader를 통해서 소스 데이터를 읽어 들인다.
- ItemProcessor를 통해서 읽어들인 청크단위 데이터를 처리한다. 처리는 데이터를 변환하거나 가공하는 역할을 하게 된다.
- ItemWriter는 처리된 청크 데이터를 쓰기작업한다. 다양한 Writer를 통해 데이터베이스에 저장하거나, 파일로 쓰는 역할을 하게 된다.

Spring Batch에서 Chunk란?

Chunk는 Spring Batch에서 대량 데이터를 처리할 때 효율적인 방법 중 하나로, 데이터를 읽기(Read), 처리(Process), **쓰기(Write)**의 단위로 나누어 실행하는 방식입니다. 즉, 전체 데이터를 한 번에 처리하지 않고, 일정한 크기로 나누어 처리하는 것이 특징입니다.

• Chunk 단위: 한 번에 처리할 데이터의 크기를 정의합니다. 예를 들어, chunkSize=10으로 설정하면 10개의 데이터씩 읽고 처리한 후 저장합니다.

• Chunk 기반 처리 흐름: 데이터를 읽고 → 처리하고 → 일정량이 모이면 → 한 번에 기록(Write)하는 방식입니다.

Tasklet과 Chunk의 차이

• Tasklet: 하나의 큰 작업을 단순하게 정의한 단위입니다. 예를 들어, 파일 읽기, 데이터 처리, DB에 쓰기 등의 작업을 순차적으로 한 번에 처리합니다.

• Chunk: Tasklet과 달리 데이터를 일정한 크기로 나누어 처리할 수 있으며, 대용량 데이터를 처리하는 데 적합합니다. 처리 중 에러가 발생해도, 특정 Chunk만 재처리할 수 있어 유연하고 효율적입니다.

왜 Chunk로 작업을 구성해야 하는가?

1. 효율적인 메모리 관리: 대용량 데이터를 한 번에 처리하면 메모리 부족 문제가 발생할 수 있습니다. Chunk는 데이터를 나누어 처리하기 때문에 메모리 사용량을 줄일 수 있습니다.

2. 재처리 용이: 처리 중간에 오류가 발생하면, 전체 작업을 다시 수행하는 대신 해당 Chunk만 다시 처리할 수 있어 효율적입니다.

3. 성능 최적화: Chunk는 일정 단위로 데이터를 일괄 저장하므로, I/O 작업 횟수를 줄여 성능을 향상시킬 수 있습니다. 예를 들어, 매번 데이터베이스에 쓰는 대신 Chunk 단위로 데이터를 일괄 처리합니다.

4. 대용량 데이터 처리: 대규모 배치 작업에서 전체 데이터를 한 번에 처리하기 어려운 경우, Chunk는 대량 데이터를 나누어 처리할 수 있어 더 안정적입니다.

이러한 이유로, Tasklet보다 Chunk 기반 작업 구성이 대량 데이터 처리나 복잡한 배치 처리에서 더 유리합니다.

결론: Tasklet은 단순한 작업 처리에 적합하지만, 대량 데이터 처리에서는 메모리 사용과 에러 처리의 효율성을 위해 Chunk 기반 처리가 더 권장됩니다.

3.Tasklet 구현체 생성하기

GreetingTasklet.java 파일을 생성하고 다음과 같이 작성한다.

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class GreetingTask implements Tasklet, InitializingBean {
	@Override
	public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
		log.info("------------------ Task Execute -----------------");
		log.info("GreetingTask: {}, {}", contribution, chunkContext);

		return RepeatStatus.FINISHED;
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		log.info("----------------- After Properites Sets() --------------");
	}
}

보는바와 같이 Tasklet과 InitializeBean 인터페이스를 구현한다.
Tasklet은 execute 메소드를 구현해야한다.
InitializeBean은 afterPropertiesSet 메소드를 구현해야한다.
execute:
- execute메소드는 StepContributioin 과 ChunkContext 를 파라미터로 받는다.
- 최종적으로 RepeatStatus 를 반환하며 이 값은 다음과 같다.
  - FINISHED: 태스크릿이 종료되었음을 나타낸다.
  - CONTINUABLE: 계속해서 태스크를 수행하도록한다.
  - continueIf(condition): 조건에 따라 종료할지 지속할지 결정하는 메소드에 따라 종료/지속을 결정한다.
afterPropertiesSet:
- 태스크를 수해할때 프로퍼티를 설정하고 난 뒤에 수행되는 메소드이다.
- 사실상 없어도 된다.

4. Job, Step 을 생성하고 빈에 등록

package com.schooldevops.springbatch.batchsample.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.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

import com.schooldevops.springbatch.batchsample.GreetingTask;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Configuration
@RequiredArgsConstructor
public class BasicTaskJobConfiguration {

	private final PlatformTransactionManager transactionManager;

	@Bean
	public Tasklet greetingTasklet() {
		return new GreetingTask();
	}

	@Bean
	public Step step(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
		log.info("------------------ Init myStep -----------------");

		return new StepBuilder("myStep", jobRepository).tasklet(greetingTasklet(), transactionManager)
													   .build();
	}

	@Bean
	public Job myJob(Step step, JobRepository jobRepository) {
		log.info("------------------ Init myJob -----------------");
		return new JobBuilder("myJob", jobRepository).incrementer(new RunIdIncrementer())
													 .start(step)
													 .build();
	}

}

Tasklet, step, Job을 구현하고 Bean으로 등록한다.
step 구성 시 PlatformTransactionManager와 jopRepository를 파라미터로 받는다.
Job 구성 시 시작 점 구성을 위해 step을 파라미터로 받는다.

5. 실행결과

로그를 보면 Spring Batch에서 myStep의 로그가 myJob의 로그보다 먼저 출력되었다. 그이유는 무엇일까?

1. Bean 초기화 순서

Spring에서 빈은 의존성 주입과 초기화 순서에 따라 설정됩니다. myJob은 myStep을 의존하므로, myStep이 먼저 생성되고 초기화된 후에 myJob이 초기화됩니다.

이 과정에서 @Bean으로 정의된 step() 메서드가 먼저 호출되어 myStep을 초기화하고, 그 후 myJob() 메서드가 호출되어 myJob을 초기화합니다.

2. 코드 분석

• myJob 빈을 생성할 때 step이 필요하므로, Spring은 먼저 step 빈을 초기화하고, 해당 단계에서 로그가 찍힙니다.

• step() 메서드에서 greetingTasklet()과 transactionManager가 호출되면서 myStep이 초기화되고, 로그가 출력됩니다.

• 그 이후 myJob이 생성되며 myJob 로그가 출력됩니다.

결론

myJob은 step을 의존하기 때문에, Spring이 의존 관계에 맞춰 step 빈을 먼저 초기화하면서 해당 로그가 먼저 찍힌다.

1.SpringBatch 빠르게 시작하기

j0free — Sun, 20 Oct 2024 17:49:12 +0900

페이스북에서 SpringBatch 스터디 모집한다는 글을 보았고, 신청해서 참여하게 되었습니다.

스터디 진행 방식은 Devocean 블로그 pringBatch 연재 시리즈를 보고 실습을 통해, SpringBatch의 기초를 학습하고 서로 논의를 하며 공부하는 스터디입니다.

앞으로 스터디가 진행되는 동안 공부한 내용을 정리하고자 합니다.
틀리거나 보충 할 내용이 있다면 댓글 부탁드립니다.

참고 : [SpringBatch 연재 01] SpringBatch 빠르게 시작하기

1. SpringBatch 프로젝트 구성

인텔리제이를 통해 프로젝트 이름 및 JDK 17로 프로젝트 생성 후 build.gradle에 필요한 의존성을 설정합니다.

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.2'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'com.schooldevops.spring-batch'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    runtimeOnly 'com.h2database:h2'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-batch'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.batch:spring-batch-test'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
}

tasks.named('test') {
    useJUnitPlatform()
}

SpringBatch 프로젝트를 구성하기 위한 필수 의존성

implementation 'org.springframework.boot:spring-boot-starter-batch'

h2가 runtime시에 필요하기 때문에 rumtimeOnly로 h2 의존성을 추가

runtimeOnly 'com.h2database:h2'

2. h2 설정

# H2 DataBase용
spring:
  batch:
    jdbc:
      initialize-schema: always
    job:
      enabled: true
  datasource:
    driver-class-name: org.h2.Driver  # Database를 H2로 사용하겠다.
    url: jdbc:h2:~/test  # H2 접속 정보
    username: sa  # H2 접속 시 입력할 username 정보 (원하는 것으로 입력)
    password:  # H2 접속 시 입력할 password 정보 (원하는 것으로 입력)
    hikari:
      maximum-pool-size: 10
  h2:
    console: # H2 DB를 웹에서 관리할 수 있는 기능
      enabled: true           # H2 Console 사용 여부
      path: /h2-console       # H2 Console 접속 주소
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

SpringBatch 실행 시 DB 설정을 해주지 않으면, DataSoruce 설정이 필요하다고 에러가 나오며 실행이 되지 않을 것입니다.

빠른 구성을 위해 h2 embedded 설정해서 DataSource 설정해보도록 하겠습니다.

접속 URL : http://localhost:8080/h2-console

h2 접속화면

h2에 접속하게 되면 위와 같은 화면이 나올 것입니다.

yaml에 설정해 놓은 접속정보를 통해 접속을 해봅시다.

SpringBatch에 필요한 기본 테이블이 생성된 것을 볼 수 있습니다.

spring:
  batch:
    jdbc:
      initialize-schema: always

위와 같이 schema: always로 설정 했기 때문에 서버가 구동 시 기본 테이블을 매번 새로 생성하고 있습니다.

자동 생성 시 spring.batch.jdbc.initialize-schema 설정은 ALWAYS, EMBEDDED, NEVER로 설정이 가능합니다.

ALWAYS : 스크립트를 항상 실행합니다. RDBMS 설정이 되어 있을 경우 내장 DB보다 우선적으로 실행됩니다.
EMBEDDED : 내장 DB일 때만 실행되며 스키마가 자동 생성됩니다. (기본값)
NEVER : 스크립트를 항상 실행하지 않습니다. 운영에서 수동으로 스크립트 생성 후 설정하는 것을 권장합니다. 내장 DB일 경우 스크립트가 생성이 안되기 때문에 오류가 발생합니다.

그래도 접속이 안된다면, @EnableBatchProcessing 어노테이션을 붙였는지 확인 해보도록 합니다.

Spring Boot 3.0에서는 '@EnableBatchProcessing' 사용이 권장되지 않습니다.

이전에는 이 어노테이션이 Spring Batch의 자동 구성을 활성화하는 데 사용되었지만, 이제는 더 이상 필요하지 않아 어플리케이션에서 제거해야 합니다.

'@EnableBatchProcessing'을 추가하면 Spring Batch의 자동 구성(메타데이터 테이블 생성, 작업 시작 시 자동 실행 등)이 비활성화되기 때문입니다.

3. 스프링배치 스키마 구조

스프링배치를 수행하면 자동으로 배치를 위한 스키마가 생성이 된다.
다음은 스키마 구조이다.

Spring Batch의 메타데이터 스키마는 배치 작업의 실행 기록을 추적하고, 재시작 시 상태를 관리하는 데 사용된다. 스키마는 주로 다음과 같은 주요 테이블들로 구성된다.

https://docs.spring.io/spring-batch/reference/schema-appendix.html

Meta-Data Schema :: Spring Batch

The Spring Batch Metadata tables closely match the domain objects that represent them in Java. For example, JobInstance, JobExecution, JobParameters, and StepExecution map to BATCH_JOB_INSTANCE, BATCH_JOB_EXECUTION, BATCH_JOB_EXECUTION_PARAMS, and BATCH_ST

docs.spring.io

인프라 공방 - 1.AWS 수동 키 생성

j0free — Mon, 24 Oct 2022 21:33:04 +0900

AWS에 접속하기 위해서는 pem key를 생성해야 한다.

네트워크 및 보안 -> 키페어 -> 키 페어 생성을 순서대로 클릭한다.

key 이름 및 파일 형식을 선택 -> 키 페어 생성 버튼을 누른다.