아이템 처리자

예시)
1개의 Job

• Step1
  • 태스클릿 or 아이템처리자
• Step2
  • 태스클릿 or 아이템처리자
• Step3
  • 태스클릿 or 아이템처리자
• Step4
  • 태스클릿 or 아이템처리자

아이템처리자

• readdr (읽기)

• processor (변환)

• writer (쓰기)

  ---

chunks 방식 예시

@Configuration
@RequiredArgsConstructor
@Slf4j
public class RebateOrderItemJobConfig {
    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

    private final OrderItemRepository orderItemRepository; // 읽을 대상
    private final RebatedOrderItemRepository rebatedOrderItemRepository; // 쓸 대상

    @Bean
    public Job rebateOrderItemJob(Step rebateOrderItemJobStep1) {
        return jobBuilderFactory.get("rebateOrderItemJob")
                .start(rebateOrderItemJobStep1)
                .incrementer(new RunIdIncrementer())
                .build();
    }

    @JobScope
    @Bean
    public Step rebateOrderItemJobStep1(
            ItemReader orderItemReader,
            ItemProcessor orderItemProcessor,
            ItemWriter orderItemWriter) {

        return stepBuilderFactory.get("rebateOrderItemJobStep1")
                .<OrderItem, RebatedOrderItem>chunk(1)
                .reader(orderItemReader)
                .processor(orderItemProcessor)
                .writer(orderItemWriter)
                .build();
    }

    @StepScope
    @Bean
    public RepositoryItemReader<OrderItem> orderItemReader() {

        return new RepositoryItemReaderBuilder<OrderItem>()
                .name("orderItemReader")
                .repository(orderItemRepository)
                .methodName("findAll")
			    .pageSize(1)
                .arguments(Arrays.asList())
                .sorts(Collections.singletonMap("id", Sort.Direction.ASC))
                .build();
    }

    @StepScope
    @Bean
    public ItemProcessor<OrderItem, RebatedOrderItem> orderItemProcessor() {
        return orderItem -> new RebatedOrderItem(orderItem);
    }

    @StepScope
    @Bean
    public ItemWriter<RebatedOrderItem> orderItemWriter() {
        return items -> items.forEach(item -> rebatedOrderItemRepository.save(item));
    }
}

---

JPA 기본사용법

참고사이트

범위 정산

6보다 작은 id를 조회하고싶다 -> LessThan을 사용한다

public interface OrderItemRepository extends JpaRepository<OrderItem, Long> {

    Page<OrderItem> findAllByIdLessThan(long id, Pageable pageable);
}

public class makeRebateOrderItemJobConfig {
    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

public class makeRebateOrderItemJobConfig {
    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;

public RepositoryItemReader<OrderItem> orderItemReader() {
        return new RepositoryItemReaderBuilder<OrderItem>()
                .name("orderItemReader")
                .repository(orderItemRepository)
                .methodName("findAllByIdLessThan")
                .pageSize(100)
                .arguments(Arrays.asList(6L))
                .sorts(Collections.singletonMap("id", Sort.Direction.ASC))
                .build();
    }

between 범위 정산

x ~ y 사이의 데이터를 조회하고싶다 -> Between

public interface OrderItemRepository extends JpaRepository<OrderItem, Long> {

    Page<OrderItem> findAllByIdLessThan(long id, Pageable pageable);

    Page<OrderItem> findAllByIdBetween(long fromId, long toId, Pageable pageable);
}

 public RepositoryItemReader<OrderItem> orderItemReader(
            @Value("#{jobParameters['fromId']}") long fromId,
            @Value("#{jobParameters['toId']}") long toId
    ) {
        return new RepositoryItemReaderBuilder<OrderItem>()
                .name("orderItemReader")
                .repository(orderItemRepository)
                .methodName("findAllByIdBetween")
                .pageSize(100)
                .arguments(Arrays.asList(fromId, toId))
                .sorts(Collections.singletonMap("id", Sort.Direction.ASC))
                .build();
    }

---

jpa 외래키 제약 제거

왜?

• 여러 데이터가 분산되어 있는 경우 외래 키 관리가 복잡해질 수 있다
• 정산 중 다른 테이블과 엮여있는 외래키를삭제할 수 없다
• 부모테이블을 다른 DB로 옮기는 경우, 자식 테이블은 어떻게 할 것인가?

Foreign Key (외래키)

• 외래키 제약을 제거하기 위해서는 아래의 1줄만 추가하면 된다

@JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))

public class RebateOrderItem extends BaseEntity {

    @OneToOne(fetch = FetchType.LAZY)
    @ToString.Exclude
    @JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
    private OrderItem orderItem;

    @ManyToOne(fetch = FetchType.LAZY)
    @ToString.Exclude
    @JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
    private Order order;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
    private ProductOption productOption;

    private int quantity;

    //가격
    private int price; // 권장 판매가
    private int salePrice; // 실제 판매가
    private int wholesalePrice; // 도매가
    private int pgFee; // 결제대행사 수수료
    private int payPrice; // 결제금액
    private int refundPrice; // 환불금액
    private int refundQuantity; // 환불 한 갯수
    private boolean isPaid;  // 결제 여부

참고 자료