JPA / MyBatis 혼용시 주의사항 (in 배치 애플리케이션)

@Bean
public Step problematicStep() {
    return stepBuilder("step")
        .<BatchTarget, BatchTarget>chunk(100, transactionManager)
        .reader(jpaReader())           // JPA로 읽음 → 영속성 컨텍스트에 캐시
        .processor(processor())
        .writer(myBatisWriter())       // MyBatis로 UPDATE → DB만 변경
        .listener(new StepExecutionListener() {
            @Override
            public ExitStatus afterStep(StepExecution stepExecution) {
                // 문제: 영속성 컨텍스트에는 변경 전 데이터가 남아있음
                BatchTarget target = batchTargetRepository.findById(1L).get();
                log.info("status: {}", target.getStatus());  // 변경 전 값!
                return ExitStatus.COMPLETED;
            }
        })
        .build();
}

@Bean
public ItemProcessor<SourceRecord, BatchResult> processor() {
    return record -> {
        // JPA로 대상 조회 → 영속성 컨텍스트에 캐시됨
        BatchTarget target = batchTargetRepository.findById(record.getTargetId()).get();

        return BatchResult.builder()
            .target(target)
            .amount(record.getAmount())
            .build();
    };
}

@Bean
public MyBatisBatchItemWriter<BatchResult> writer() {
    // MyBatis로 INSERT (target_id 포함)
    // 만약 이 INSERT가 BatchTarget 테이블도 UPDATE 한다면?
    // → 영속성 컨텍스트의 BatchTarget은 stale 상태
}

@Bean
public ItemProcessor<SourceRecord, BatchResult> processor() {
    return record -> {
        // 1차 캐시에서 반환 → DB 변경사항 반영 안 됨!
        BatchTarget target = batchTargetRepository.findById(record.getTargetId()).get();

        // target.getProcessedCount()가 MyBatis에서 증가했는데 반영 안 됨
        return BatchResult.builder()
            .target(target)
            .amount(record.getAmount())
            .build();
    };
}

@Bean
public CompositeItemWriter<BatchResult> compositeWriter() {
    CompositeItemWriter<BatchResult> writer = new CompositeItemWriter<>();

    writer.setDelegates(List.of(
        myBatisResultWriter(),    // 1. MyBatis로 result INSERT
        jpaTargetWriter()         // 2. JPA로 target UPDATE
    ));

    return writer;
}

@Bean
public ItemWriter<BatchResult> jpaTargetWriter() {
    return items -> {
        for (BatchResult result : items) {
            // 문제: MyBatis가 INSERT한 result를 JPA가 모름
            // result.getTarget()이 영속 상태면 연관관계 불일치 가능
            BatchTarget target = result.getTarget();
            target.setLastProcessedAt(result.getProcessedAt());
            batchTargetRepository.save(target);
        }
    };
}

@Bean
public Step stepWithRetry() {
    return stepBuilder("step")
        .<Input, Output>chunk(100, transactionManager)
        .reader(reader())
        .processor(processor())
        .writer(myBatisWriter())
        .faultTolerant()
        .retryLimit(3)
        .retry(DeadlockLoserDataAccessException.class)
        .listener(new RetryListener() {
            @Override
            public <T, E extends Throwable> void onError(
                RetryContext context,
                RetryCallback<T, E> callback,
                Throwable throwable
            ) {
                // Retry 시 JPA로 상태 확인하려 하면
                // 이전 MyBatis 작업 결과가 rollback 되었는지 JPA는 모름
                Entity entity = jpaRepository.findById(id).get();  // stale 가능
            }
        })
        .build();
}

@Bean
public Step pagingStep() {
    return stepBuilder("step")
        .<Order, OrderSettlement>chunk(100, transactionManager)
        .reader(jpaPagingReader())    // page 1 읽음 → 영속성 컨텍스트에 100개
        .processor(processor())
        .writer(myBatisBatchWriter()) // MyBatis로 상태 UPDATE
        // 다음 청크에서 page 2 읽을 때
        // → 새 쿼리지만, 같은 데이터가 있다면?
        // → 1차 캐시에서 반환될 수 있음 (stale)
        .build();
}

@Bean
public Step safeStep() {
    return stepBuilder("step")
        .<Input, Output>chunk(100, transactionManager)
        .reader(reader())
        .writer(myBatisWriter())
        .listener(new ChunkListener() {
            @Override
            public void afterChunk(ChunkContext context) {
                entityManager.clear();  // 청크 완료 후 1차 캐시 클리어
            }
        })
        .build();
}

@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query("UPDATE batch_target SET status = :status WHERE id = :id", nativeQuery = true)
void updateStatus(@Param("id") Long id, @Param("status") String status);

// Option A: MyBatis로 통일
@Bean
public Step allMyBatisStep() {
    return stepBuilder("step")
        .<Map<String, Object>, BatchResult>chunk(100, transactionManager)
        .reader(myBatisPagingReader())
        .processor(processor())
        .writer(myBatisBatchWriter())
        .build();
}

// Option B: JPA로 통일
@Bean
public Step allJpaStep() {
    return stepBuilder("step")
        .<BatchTarget, BatchResult>chunk(100, transactionManager)
        .reader(jpaPagingReader())
        .processor(processor())
        .writer(jpaItemWriter())
        .build();
}

// 잘못된 예: 서로 다른 TransactionManager
@Bean
public PlatformTransactionManager jpaTransactionManager() { ... }

@Bean
public PlatformTransactionManager myBatisTransactionManager() { ... }
// → 청크 트랜잭션에는 하나만 참여 → 커밋 시점 불일치 발생

// 올바른 예: 단일 TransactionManager
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
    return new JpaTransactionManager(emf);
}
// MyBatis도 같은 DataSource 사용 시 동일 트랜잭션 참여