전체 메뉴

테마

Chapter 18

AOP와 온디맨드 배치

Spring Boot 4.1.1에서 @Around AOP로 실행 시간을 기록하고 프록시의 self-invocation 함정을 확인한 뒤, 202 응답·keyset 페이징·청크 트랜잭션·멱등 저장을 갖춘 온디맨드 배치를 만듭니다.

난이도
중급 심화
예상 학습
140분
Spring Boot 기준
Spring Boot 4.1.1
JDK 기준
JDK 21
최종 검토

전체 24개 Chapter 중 Chapter 18입니다. 예제 코드는 공개 저장소 spring-boot-curriculum에서 확인할 수 있습니다.

Learning goals

오늘 배울 내용

  • Aspect·Advice·Pointcut·JoinPoint의 역할 설명하기
  • @Around에서 결과와 예외를 보존하며 실행 시간 기록하기
  • 프록시 방식의 self-invocation 한계를 테스트로 확인하기
  • 202와 jobId 조회로 요청을 오래 잡지 않는 배치 시작 API 만들기
  • keyset 페이징·청크 트랜잭션·멱등 저장·중복 실행 방지 구현하기
  1. 횡단 관심사 식별
  2. Around Advice
  3. 프록시 경계
  4. 비동기 시작
  5. Keyset 청크 처리
  6. 실패 상태 기록
이 Chapter의 진행 흐름

이 Chapter는 두 가지를 다룹니다. 앞부분은 AOP로, 실행 시간 기록처럼 여러 곳에 반복되는 관심사를 업무 코드 밖으로 빼는 방법과 그 프록시 방식이 만드는 함정을 봅니다. 뒷부분은 Chapter 17의 오케스트레이션을 재사용하는 온디맨드 배치입니다. 스케줄러가 아니라 누군가 호출하면 시작하고, 회원 전체를 일정 크기로 나누어 읽어 처리하며, 결과를 스냅샷 표에 덮어씁니다.

이 Chapter에서 만드는 것

만드는 것 설명
@Measured + MeasuredAspect 메서드 실행 시간과 성공 여부를 기록하는 @Around 어드바이스
CallCounter 애노테이션 없이 패키지로 대상을 고르는 포인트컷
프록시 함정 테스트 같은 객체 안 호출(self-invocation)은 AOP가 동작하지 않음을 확인
POST /api/batch/member-summaries 배치를 시작하고 작업 번호(jobId)를 돌려줌(202)
GET /api/batch/member-summaries/{jobId} 진행 상태 조회
SummaryBatchRunner keyset 페이징으로 읽고, 청크마다 트랜잭션, 멱등 저장, 중복 실행 거절

테스트는 AOP(ch35) 10건, 배치(ch36) 7건입니다. 이 중 이 Chapter가 직접 다루는 것은 AOP 9건과 배치 7건입니다.

직접 실행해 확인한 결과

확인 결과
ch35 test 10건 통과(AspectTests 8, AopControllerTests 1, 컨텍스트 1)
ch36 test 44건 통과(배치 관련: BatchTests 5, AsyncBatchTests 1, BatchChunkFailureTests 1)
ch35 실행: /api/greet?name=Boot 후 /api/executions Hello, Boot!, 기록 1건(GreetingService.greet, success:true)
ch36 실행: 배치 시작 → 조회 202 {"jobId":1}, 조회 DONE, processed:5, failed:0
ch36 실행: 없는 jobId 404 배치 작업을 찾을 수 없습니다: jobId=9999

사전 지식

  • Chapter 09의 트랜잭션과 프록시, Chapter 17의 오케스트레이션.
  • 코드는 examples/ch35-aop(AOP)와 examples/ch36-bulk-orchestration(배치)입니다.

확인 환경

Docker 컨테이너(JDK 21.0.11), Spring Boot 4.1.1, H2 인메모리입니다. ch35 10건, ch36 44건이 cleanTest test에서 모두 통과했습니다. 운영 DB(Oracle 등)와 여러 서버 환경은 확인하지 않았습니다.

예제 코드

대상 링크
AOP ch35-aop/
배치 ch36-bulk-orchestration/
AOP 테스트 AspectTests.java
Aspect MeasuredAspect.java
대상 서비스 GreetingService.java
CallCounter CallCounter.java
다른 Bean 경유 CallerService.java
컨트롤러 BatchController.java
설정 BatchConfig.java
배치 테스트 BatchTests.java
비동기 테스트 AsyncBatchTests.java
배치 실행기 SummaryBatchRunner.java
모듈 API 테스트 ModuleApiTests.java
저장소 BatchJobRepository.java
예외 BatchAlreadyRunningException.java
청크 실패 테스트 BatchChunkFailureTests.java
Chapter 설명(저장소 문서) README.md

공통 관심사와 AOP

서비스 메서드 수십 개에 “시작 시각 기록, 실행, 끝난 시각 기록” 코드를 복사해 붙이면, 업무 코드는 기록 코드에 묻히고 기록 방식을 바꿀 때 수십 곳을 고쳐야 합니다. 이런 여러 곳에 걸쳐 반복되는 관심사(로깅, 시간 측정, 권한 확인, 트랜잭션)를 횡단 관심사라 하고, 업무 코드에서 떼어 한곳에 두는 기법이 AOP(Aspect-Oriented Programming)입니다. 이미 쓰고 있는 @Transactional도 AOP로 동작합니다(Chapter 09).

용어

용어 뜻 이 Chapter의 예
Aspect 횡단 관심사를 모은 클래스 MeasuredAspect, CallCounter
Advice 끼워 넣는 코드와 시점(@Around, @Before 등) measure(...), count(...)
Pointcut 어디에 끼워 넣을지 고르는 식 @annotation(...Measured), execution(...)
JoinPoint 끼워 넣을 수 있는 지점(스프링에서는 메서드 실행) 대상 메서드 호출

프록시가 끼어든다

스프링은 Aspect가 적용될 Bean을 프록시 객체로 감쌉니다. 호출하는 쪽은 진짜 객체 대신 프록시를 받고, 프록시가 어드바이스를 실행한 뒤 진짜 객체를 부릅니다.

이 구조 때문에 프록시를 거치지 않는 호출에는 AOP가 적용되지 않습니다. 이 함정은 아래 “프록시의 함정: 같은 객체 안 호출” 절에서 테스트로 확인합니다.

프록시인지 확인

AspectTests.serviceBeanIsAProxy는 주입받은 Bean이 프록시인지 AopUtils.isAopProxy(greetings)로 확인하고 통과했습니다. Aspect가 적용되는 Bean이 실제 클래스가 아니라 프록시라는 사실을 눈으로 확인하는 가장 쉬운 방법입니다.

의존성 확인

AOP 코드(org.aspectj.lang...)를 쓰므로 AspectJ 어노테이션 라이브러리가 필요합니다. 이 예제의 빌드 설정에서 어떤 스타터로 가져오는지는 이 절에서 정리하지 않았습니다. examples/ch35-aop/build.gradle을 확인하세요.

따라 하기

./gradlew :examples:ch35-aop:test --tests '*AspectTests*'
./gradlew :examples:ch35-aop:bootRun
curl "http://localhost:8080/api/greet?name=Boot"
curl http://localhost:8080/api/executions
Hello, Boot!
[{"method":"GreetingService.greet","elapsedMillis":0,"success":true}]

greet를 한 번 불렀을 뿐인데 실행 기록이 한 건 남았습니다. 서비스 코드에는 기록 코드가 없고, Aspect가 프록시를 통해 끼어든 결과입니다.

자주 하는 실수

실수 증상 해결
Aspect 클래스에 @Component를 빠뜨림 어드바이스가 실행되지 않음 @Aspect + @Component
AspectJ 의존성 누락 org.aspectj.lang 컴파일 오류 AOP 의존성 확인
프록시 여부를 눈으로 추정 적용 여부를 모름 AopUtils.isAopProxy로 확인

확인 문제

  1. Pointcut과 Advice의 차이는 무엇인가요?
  2. 스프링 AOP가 프록시로 동작하면 어떤 호출에 적용되지 않나요?

답: 1) Pointcut은 어디에 끼울지 고르는 식이고, Advice는 끼워 넣는 코드와 시점입니다. 2) 프록시를 거치지 않는 호출, 예를 들어 같은 객체 안의 this 호출입니다.

직접 해 보기

  1. 자신의 프로젝트에서 같은 코드가 3곳 이상 복사된 부분을 찾아 횡단 관심사인지 판단해 보세요.
  2. 서비스 Bean을 주입받아 getClass()를 출력해 보고 클래스 이름이 어떻게 보이는지 확인하세요.
  3. “프록시가 끼어든다”에서 설명한 호출 순서를 그림으로 그리고, 대상 메서드에서 예외가 날 때 흐름이 어디로 가는지 표시해 보세요.

@Around로 실행 시간 기록하기

@Around는 대상 메서드의 앞과 뒤, 그리고 예외까지 감싸는 가장 강력한 어드바이스입니다. 이 절에서는 @Measured가 붙은 메서드의 실행 시간과 성공 여부를 기록하는 Aspect를 만듭니다. 핵심은 기록은 덧붙이되 결과와 예외는 그대로 전달하는 것입니다.

표식 애노테이션

/** 이 애노테이션이 붙은 메서드의 실행 시간과 성공 여부를 기록한다. */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Measured { }

대상 메서드에는 한 줄만 붙입니다.

@Service
public class GreetingService {
    @Measured
    public String greet(String name) { return "Hello, " + name + "!"; }

    @Measured
    public String slow(long millis) throws InterruptedException { Thread.sleep(millis); return "done"; }

    @Measured
    public String fail() { throw new IllegalStateException("의도한 실패"); }
}

Aspect

@Aspect
@Component
public class MeasuredAspect {

    private final ExecutionLog log;

    public MeasuredAspect(ExecutionLog log) { this.log = log; }

    @Around("@annotation(com.jqdom.curriculum.ch35.aspect.Measured)")
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String name = signature.getDeclaringType().getSimpleName() + "." + signature.getName();
        long start = System.nanoTime();
        boolean success = false;
        try {
            Object result = joinPoint.proceed();
            success = true;
            return result;
        } finally {
            long elapsed = (System.nanoTime() - start) / 1_000_000;
            log.add(new ExecutionRecord(name, elapsed, success));
        }
    }
}

코드 읽기

  • @Around("@annotation(...Measured)"): @Measured가 붙은 메서드가 포인트컷입니다.
  • joinPoint.proceed(): 진짜 메서드를 실행합니다. 이 호출을 하지 않으면 대상이 실행되지 않습니다.
  • 결과를 return result로 그대로 돌려주므로 호출자는 Aspect의 존재를 모릅니다.
  • finally에서 기록하기 때문에 성공과 예외 모두 남습니다. 예외는 catch하지 않아 그대로 위로 전달됩니다.
  • System.nanoTime()은 시계가 아니라 경과 시간 측정용입니다. 밀리초로 바꿔 기록합니다.
  • 기록 대상 ExecutionLog는 메모리 목록입니다. 운영에서는 로그나 지표로 보내지만 여기서는 테스트하기 쉽게 목록으로 두었습니다.

테스트가 확인한 것

테스트 확인
measuredMethodIsRecordedAndResultIsUnchanged greet("Boot")의 반환값 Hello, Boot!가 그대로, 기록은 1건(GreetingService.greet, 성공)
elapsedTimeIncludesTheMethodBody slow(60) 호출 뒤 기록의 경과 시간이 60ms 이상
failureIsRecordedAndRethrown fail()은 IllegalStateException이 그대로 던져지고, 기록은 success=false
methodWithoutAnnotationIsNotMeasured @Measured가 없는 plain()은 기록 없음
callThroughAnotherBeanPassesTheProxy 다른 Bean(CallerService)을 거쳐 불러도 1건 기록

MockMvc 테스트(AopControllerTests)는 GET /api/greet?name=Boot 호출 뒤 GET /api/executions가 1건(GreetingService.greet, success=true)을 돌려주는 것까지 확인했습니다.

자주 하는 실수

실수 증상 해결
proceed()를 호출하지 않음 대상 메서드가 실행되지 않음 proceed() 호출
결과를 반환하지 않음 호출자가 null을 받음 proceed() 결과를 그대로 반환
기록을 finally가 아니라 정상 경로에만 둠 실패가 기록되지 않음 finally에서 기록
예외를 catch하고 삼킴 호출자가 실패를 모름 예외를 그대로 전달

확인 문제

  1. 좋은 Aspect는 호출자의 결과와 예외를 바꾸나요?
  2. System.nanoTime()을 쓰는 이유는 무엇인가요?

답: 1) 바꾸지 않고 기록만 덧붙입니다. 2) 벽시계가 아니라 경과 시간 측정용으로 쓰이기 때문입니다.

직접 해 보기

  1. finally를 try 끝으로 옮기면 어떤 테스트가 실패할지 예측하고 확인하세요.
  2. joinPoint.proceed() 호출을 지우면 greet의 반환값이 어떻게 되는지 확인하세요.
  3. 기록에 메서드 인자 값을 넣고 싶을 때 개인정보 측면에서 주의할 점을 적어 보세요.

애노테이션 없이 패키지로 고르는 포인트컷

앞의 “@Around로 실행 시간 기록하기” 절은 대상 메서드에 @Measured를 직접 붙였습니다. 이번에는 대상 코드를 건드리지 않고 패키지 규칙으로 대상을 고릅니다. CallCounter는 service 패키지 아래 클래스의 public 메서드가 호출된 횟수를 셉니다.

코드

@Aspect
@Component
public class CallCounter {

    private final Map<String, AtomicInteger> counts = new ConcurrentHashMap<>();

    @Before("execution(public * com.jqdom.curriculum.ch35.service..*(..))")
    public void count(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getDeclaringType().getSimpleName()
                + "." + joinPoint.getSignature().getName();
        counts.computeIfAbsent(name, key -> new AtomicInteger()).incrementAndGet();
    }
    // countOf(method), clear() 생략
}

코드 읽기

execution(public * com.jqdom.curriculum.ch35.service..*(..))를 조각으로 읽습니다.

조각 뜻
public 접근 제한자가 public
* (반환 타입 자리) 어떤 반환 타입이든
com.jqdom.curriculum.ch35.service.. 이 패키지와 그 하위 패키지
* (이름 자리) 어떤 클래스·메서드든
(..) 인자가 몇 개든
  • @Before는 대상 실행 전에 한 번 실행되고 결과나 예외에 관여하지 않습니다. 세기만 하므로 가장 가벼운 어드바이스를 골랐습니다.
  • ConcurrentHashMap과 AtomicInteger: 여러 요청이 동시에 불러도 안전하게 세기 위해서입니다.
  • 대상 서비스는 이 Aspect의 존재를 모릅니다.

테스트가 확인한 것

packagePointcutCountsCallsWithoutAnnotations는 plain() 2번과 selfCall("A") 1번을 부른 뒤 GreetingService.plain 2, GreetingService.selfCall 1을 확인했습니다. 마지막 줄 GreetingService.greet 0은 이어지는 “프록시의 함정: 같은 객체 안 호출” 절의 주제입니다.

두 방식 비교

방식 장점 단점
표식 애노테이션 (@Measured) 대상이 코드에 드러남, 범위가 명확 대상마다 붙여야 함
패키지 규칙 (execution) 대상 코드 수정 없음 의도치 않게 범위가 넓어질 수 있음, 새 클래스가 자동 포함됨

로깅처럼 넓게 적용하는 것은 패키지 방식이, 선택적으로 적용하는 것은 애노테이션 방식이 어울립니다.

자주 하는 실수

실수 증상 해결
패키지 이름 오타 어드바이스가 아무 데도 적용되지 않음 포인트컷 식과 실제 패키지 비교
범위가 의도보다 넓음 예상 밖 클래스까지 적용 범위를 좁히거나 테스트로 고정
private 메서드를 대상으로 기대 적용되지 않음 프록시가 가로채는 public 호출

확인 문제

  1. execution(public * com...service..*(..))에서 ..는 무엇을 뜻하나요?
  2. @Before는 대상의 결과를 바꿀 수 있나요?

답: 1) 하위 패키지를 포함한다(인자 자리에서는 인자 개수에 상관없다)는 뜻입니다. 2) 바꿀 수 없습니다. 대상 실행 전에 한 번 실행될 뿐입니다.

직접 해 보기

  1. 포인트컷을 execution(* *..GreetingService.*(..))로 바꾸고 결과가 같은지 확인하세요.
  2. public을 지우면 어떤 메서드가 대상이 되는지 확인하세요(스프링 AOP의 프록시가 가로챌 수 있는 범위는 이 예제에서 확인하지 않았습니다).
  3. 패키지 방식으로 컨트롤러의 모든 요청을 세는 Aspect를 설계해 보세요.

프록시의 함정: 같은 객체 안 호출

Aspect는 프록시를 거친 호출에만 동작합니다. 그래서 같은 객체 안에서 this로 부르는 메서드에는 어드바이스도, @Transactional도 적용되지 않습니다. Chapter 09에서 트랜잭션이 안 걸리는 증상으로 만났던 바로 그 원인을 이번에는 AOP 테스트로 확인합니다.

재현 코드

@Service
public class GreetingService {

    @Measured
    public String greet(String name) { ... }

    /** 같은 객체 안에서 this로 부르는 메서드. 프록시를 거치지 않아 @Measured가 동작하지 않는다. */
    public String selfCall(String name) {
        return greet(name);   // this.greet(name)
    }
}

selfCall 안의 greet(name)은 사실 this.greet(name)입니다. this는 프록시가 아니라 진짜 객체이므로 프록시의 어드바이스가 끼어들 틈이 없습니다.

테스트 결과

호출 기록(@Measured)
caller.callGreet("A") (다른 Bean을 거쳐 greet 호출) 1건 기록됨
greetings.selfCall("A") (안에서 this.greet) 0건 (기록 없음)

패키지 포인트컷(CallCounter)도 마찬가지입니다. selfCall("A") 1번이 센 값은 GreetingService.selfCall 1이고, 그 안의 greet은 GreetingService.greet 0으로 세어지지 않았습니다. 바깥 호출 selfCall은 프록시를 지났으므로 셌지만, 안쪽 호출은 지나지 않았기 때문입니다.

해결 방향

방법 설명
다른 Bean으로 분리 안쪽 메서드를 별도 Bean으로 옮기고 주입해 호출. 이 예제의 CallerService가 이 방식이며 기록이 남음을 확인했습니다
구조 재설계 같은 클래스 안에서 서로 부르지 않는 구조로 바꿈
자기 자신 주입이나 AspectJ 위빙 이 절에서 시도하거나 확인하지 않았습니다

가장 간단하고 설명하기 쉬운 해결은 Bean을 나누는 것입니다. 이 방식은 계층 분리의 원칙과도 맞습니다.

따라 하기

./gradlew :examples:ch35-aop:test --tests '*AspectTests*'

AspectTests 8건에는 다른 Bean을 거친 호출(기록 1건)과 selfCall(기록 0건)이 모두 포함되어 있고, 재검증에서 모두 통과했습니다.

자주 하는 실수

실수 증상 해결
같은 클래스 안에서 @Transactional 메서드 호출 트랜잭션이 시작되지 않음 다른 Bean으로 분리
같은 클래스 안에서 @Measured 메서드 호출 기록 0건 다른 Bean으로 분리
해결을 위해 구조를 바꾸지 않고 this 대신 자기 자신을 주입 이 절에서 확인하지 않음 우선 Bean 분리

확인 문제

  1. this.greet(name)은 왜 프록시를 거치지 않나요?
  2. 가장 간단한 해결 방법은 무엇인가요?

답: 1) this는 프록시가 아니라 진짜 객체이기 때문입니다. 2) 안쪽 메서드를 다른 Bean으로 분리해 주입받아 호출하는 것입니다.

직접 해 보기

  1. @Transactional(REQUIRES_NEW)를 같은 클래스의 메서드에 붙이고 this로 호출해 새 트랜잭션이 시작되지 않는 것을 확인해 보세요. (Chapter 17 “트랜잭션 경계: 읽기 전용과 REQUIRES_NEW” 절의 REQUIRES_NEW와 연결됩니다.)
  2. selfCall이 CallerService처럼 다른 Bean을 거치도록 고쳐 테스트를 통과시켜 보세요.
  3. 자신의 프로젝트에서 같은 클래스 안 @Transactional 호출이 있는지 찾아보세요.

온디맨드 배치 설계: 202와 jobId

전체 회원의 요약을 미리 계산해 표에 저장해 두는 일은 오래 걸립니다. 요청 하나가 그 시간을 기다리게 하면 타임아웃이 나고 서버 스레드가 묶입니다. 그래서 요청은 작업을 시작만 시키고 작업 번호를 돌려주며, 결과는 번호로 따로 조회합니다. 이 배치는 스케줄러(cron)가 아니라 호출되면 시작하는 온디맨드 방식입니다.

API

@RestController
@RequestMapping("/api/batch/member-summaries")
class BatchController {

    /** 실행을 시작하고 작업 번호를 돌려준다(202). 진행 상황은 GET으로 확인한다. */
    @PostMapping
    ResponseEntity<Map<String, Long>> start() {
        return ResponseEntity.accepted().body(Map.of("jobId", runner.start()));
    }

    @GetMapping("/{jobId}")
    BatchJob status(@PathVariable long jobId) { return runner.status(jobId); }
}
요청 응답
POST /api/batch/member-summaries 202 + {"jobId": 번호}
GET /api/batch/member-summaries/{jobId} 200 + 작업 상태
없는 번호 404 (BatchJobNotFoundException)

작업 상태

/** 배치 작업 상태. status는 RUNNING, DONE, DONE_WITH_FAILURES, FAILED 중 하나. */
public record BatchJob(long id, String status, int processed, int failed, String message) { }
status 뜻
RUNNING 실행 중
DONE 모두 성공
DONE_WITH_FAILURES 끝났지만 실패한 묶음이 있음
FAILED 예기치 못한 오류로 중단

processed와 failed는 묶음이 끝날 때마다 갱신되므로, 조회로 진행 상황을 볼 수 있습니다.

실행을 요청 스레드에서 분리

@Configuration
class BatchConfig {
    @Bean(destroyMethod = "shutdown")
    ExecutorService batchExecutor(@Value("${bulk.batch-async:true}") boolean async) {
        return async ? Executors.newSingleThreadExecutor() : new CallerRunsExecutorService();
    }
}
  • 기본은 단일 스레드 실행기입니다. 요청 스레드는 executor.execute(() -> run(jobId))로 일을 맡기고 바로 돌아옵니다.
  • bulk.batch-async=false이면 CallerRunsExecutorService가 호출한 스레드에서 바로 실행합니다. 테스트가 결과를 기다리지 않고 확인하기 위한 장치입니다. 비동기 코드를 테스트하려고 sleep을 넣으면 느리고 불안정합니다.
  • 비동기가 정말 동작하는지는 AsyncBatchTests가 따로 확인합니다. 시작 직후 상태를 보고, 최대 10초 동안 50ms 간격으로 조회해 DONE이 되기를 기다립니다. 결과는 DONE, 처리 5건, 실패 0건이었습니다.

API 테스트 결과

BatchTests.apiStartsAndReportsTheJob은 POST가 202와 jobId를 돌려주고, 이어서 GET이 status=DONE, processed=5를 돌려주는 것을 확인했습니다. unknownJobIs404는 없는 번호 999를 404로 확인했습니다. (이 테스트는 비동기를 끈 설정입니다.)

따라 하기

./gradlew :examples:ch36-bulk-orchestration:bootRun
curl -i -X POST http://localhost:8080/api/batch/member-summaries
curl http://localhost:8080/api/batch/member-summaries/1
curl -i http://localhost:8080/api/batch/member-summaries/9999
HTTP/1.1 202   {"jobId":1}
{"id":1,"status":"DONE","processed":5,"failed":0,"message":null}
HTTP/1.1 404   {"message":"배치 작업을 찾을 수 없습니다: jobId=9999"}

데이터가 5건뿐이라 시작 후 곧바로 DONE이 됩니다. 처리량이 큰 환경에서는 RUNNING 상태가 관찰됩니다.

자주 하는 실수

실수 증상 해결
오래 걸리는 일을 요청 안에서 끝까지 실행 요청이 타임아웃 202 + jobId, 별도 스레드
비동기 배치를 테스트에서 그대로 사용 결과가 불안정 bulk.batch-async=false로 같은 스레드 실행
비동기 동작 자체를 검증하지 않음 실제로는 비동기가 아닐 수 있음 AsyncBatchTests처럼 별도 확인
상태를 메모리에만 보관 서버 재시작 시 사라짐 상태 표(batch_job)에 저장

확인 문제

  1. 시작 요청이 200이 아니라 202를 돌려주는 이유는 무엇인가요?
  2. 진행 상황은 어떻게 확인하나요?

답: 1) 처리가 끝난 것이 아니라 요청이 접수되었다는 뜻이기 때문입니다. 2) GET .../{jobId}로 상태(processed, failed, status)를 조회합니다.

직접 해 보기

  1. bulk.batch-async 설정을 빼고(기본 비동기) BatchTests를 실행하면 어떤 테스트가 불안정해질지 예측하세요.
  2. 상태 조회를 반복하는 클라이언트(폴링) 주기를 얼마로 정할지 고민해 보세요. 이 예제는 결과 푸시(웹소켓 등)를 다루지 않았습니다.
  3. 상태 값에 CANCELLED를 추가한다면 어디를 고쳐야 할지 적어 보세요.

keyset 페이징으로 전체 회원 읽기

배치는 회원 전체를 읽어야 하지만 한 번에 메모리에 올릴 수는 없습니다. 일정 개수씩 이어 읽습니다. 이어 읽는 방법은 둘입니다.

방식 SQL 모양 특징
OFFSET ... OFFSET n LIMIT size 구현이 쉽지만, 읽는 도중 행이 추가·삭제되면 건너뛰거나 중복되기 쉽고 뒤로 갈수록 건너뛸 행이 많아짐
keyset WHERE id > :lastId ORDER BY id ... size 마지막으로 읽은 키부터 이어 읽어 위치가 흔들리지 않음

이 배치는 keyset 방식을 씁니다. OFFSET이 뒤쪽에서 느려지는 정도는 이 예제에서 측정하지 않았습니다.

모듈 api

/** 배치가 전체를 한 번에 읽지 않도록 id 순서로 이어 읽는다. */
List<Long> memberIdsAfter(long lastId, int limit);

구현 SQL은 WHERE id > #{lastId} ORDER BY id FETCH FIRST #{limit} ROWS ONLY입니다. FETCH FIRST n ROWS ONLY는 표준 SQL 문법으로 H2에서 동작했고, 다른 DB에서의 동작은 확인하지 않았습니다.

읽기 반복

long lastId = 0;
while (true) {
    List<Long> ids = members.memberIdsAfter(lastId, chunkSize);
    if (ids.isEmpty()) {
        break;
    }
    lastId = ids.get(ids.size() - 1);
    // 이 묶음을 처리
}

코드 읽기

  • 처음에는 lastId = 0입니다. id가 양수라는 입구 검증의 전제와 맞습니다.
  • 결과가 비어 있으면 끝입니다. 마지막 묶음이 chunkSize보다 작아도 한 번 더 조회해 빈 결과를 확인한 뒤 끝납니다.
  • 다음 시작점은 이번 묶음의 마지막 id입니다. 정렬이 ORDER BY id라서 가능합니다.
  • 읽은 id 묶음은 Orchestrator에 CallContext로 그대로 넘깁니다. 요청 경로와 같은 코드를 재사용합니다.

테스트

ModuleApiTests.idsAreReadInKeysetPages가 읽는 법을 따로 검증하고, BatchTests는 청크 크기 2로 5명을 [1,2] [3,4] [5] 세 번에 나누어 처리해 processed=5, 스냅샷 5행이 된 것을 확인했습니다. 크기를 2로 줄이는 방법은 Chapter 17 “IN 목록을 나누는 Chunks와 MyBatis foreach” 절의 청크 테스트와 같습니다.

자주 하는 실수

실수 증상 해결
ORDER BY를 빼먹음 마지막 id가 최대값이 아니어서 건너뜀·중복 키 기준 정렬
유일하지 않은 컬럼을 키로 사용 같은 값 사이에서 행이 빠짐 유일한 키(id)
종료 조건 없이 반복 무한 루프 빈 결과면 종료
OFFSET으로 전체 읽기 읽는 도중 행이 바뀌면 건너뜀·중복 keyset

확인 문제

  1. 다음 시작점은 무엇인가요?
  2. 마지막 묶음이 청크보다 작아도 한 번 더 조회하는 이유는 무엇인가요?

답: 1) 이번 묶음의 마지막 id입니다. 2) 빈 결과로 끝났음을 확인하는 단순한 종료 조건을 쓰기 위해서입니다.

직접 해 보기

  1. ORDER BY id를 빼면 어떤 문제가 생길지 설명해 보세요.
  2. 청크 크기를 5, 6으로 바꿔 조회 횟수가 어떻게 달라지는지 세어 보세요.
  3. 정렬 키가 중복될 수 있는 컬럼(예: 가입 연도)이면 keyset이 왜 깨지는지 생각해 보세요.

청크 트랜잭션과 멱등 저장

배치 전체를 하나의 트랜잭션으로 묶으면 마지막에 실패했을 때 앞의 모든 작업이 사라지고, 트랜잭션이 오래 열려 있어 부담이 큽니다. 그래서 청크마다 트랜잭션을 따로 쓰고, 다시 실행해도 결과가 늘어나지 않도록 같은 회원은 덮어씁니다.

청크 하나의 처리

/** chunk 하나를 한 트랜잭션으로 처리한다. 저장 중 예외가 나면 이 chunk의 저장만 취소된다. */
private int processChunk(long jobId, List<Long> ids) {
    SummaryResult result = orchestrator.summarize(new CallContext(ids));
    tx.executeWithoutResult(status -> {
        for (MemberSummary summary : result.summaries()) {
            jobs.upsertSnapshot(summary.id(), summary.grade(),
                    summary.points() == null ? 0 : summary.points(),
                    summary.orderCount() == null ? 0 : summary.orderCount(), jobId);
        }
    });
    return result.summaries().size();
}

코드 읽기

  • 요약 계산(orchestrator.summarize)은 읽기 전용 트랜잭션 안에서 일어나고, 저장은 별도의 TransactionTemplate 트랜잭션에서 합니다. 선언형 @Transactional 대신 TransactionTemplate을 쓴 것은 한 메서드 안에서 트랜잭션 범위를 코드로 좁히기 위해서이고, 같은 클래스 안 호출 문제(앞의 “프록시의 함정: 같은 객체 안 호출” 절)도 피합니다.
  • 한 묶음의 저장 중 예외가 나면 그 묶음의 저장만 롤백되고 앞 묶음은 이미 커밋된 상태로 남습니다.
  • 실패해 null로 남은 값(points, orderCount)은 스냅샷에서 0으로 저장합니다. 여기서 Chapter 17의 “실패 정책 네 가지와 응답 모양” 절에서 구분한 조회 실패(null)와 기록 없음(0)이 합쳐져 버립니다. 스냅샷 컬럼이 NOT NULL이라는 단순화이며 이 한계는 아래 “한계와 다음 단계” 절에 적었습니다.

덮어쓰기

/** 같은 회원은 덮어쓴다. 다시 실행해도 결과가 늘어나지 않는다(멱등). H2의 MERGE ... KEY 문법이다. */
void upsertSnapshot(long memberId, String grade, long points, long orderCount, long jobId) {
    jdbc.sql("MERGE INTO member_summary_snapshot (member_id, grade, points, order_count, job_id) "
                    + "KEY (member_id) VALUES (:m, :g, :p, :c, :j)")
            ...
}
  • member_summary_snapshot은 member_id가 기본키입니다. MERGE ... KEY (member_id)는 있으면 갱신하고 없으면 삽입합니다.
  • MERGE ... KEY는 H2 문법입니다. Oracle은 MERGE INTO ... USING ... ON ... WHEN MATCHED/NOT MATCHED, PostgreSQL은 INSERT ... ON CONFLICT 같은 식으로 문법이 다르며, 다른 DB로 옮길 때는 이 한 메서드만 바꾸면 되도록 Repository에 모아 두었습니다. 다른 DB에서 실행해 보지는 않았습니다.

재실행 테스트

runningAgainOverwritesInsteadOfDuplicating은 배치를 두 번 연속 실행합니다. 두 번째 실행 뒤에도 스냅샷은 5행이고, 5행 모두 job_id가 두 번째 작업 번호입니다. 즉 새 행이 늘지 않고 같은 행이 덮어써졌습니다.

첫 실행의 값은 processesEveryMemberInChunks가 확인했습니다. 처리 5건, 실패 0건, 스냅샷 5행이고 1번 회원은 등급 SENIOR, 포인트 600, 주문 3입니다. 이 값은 Chapter 17의 API 응답과 같으므로, 요청 경로와 배치 경로가 같은 계산을 쓴다는 증거가 됩니다.

자주 하는 실수

실수 증상 해결
전체 배치를 하나의 트랜잭션으로 묶음 끝에서 실패하면 전부 사라짐 청크마다 트랜잭션
저장을 단순 INSERT로 함 재실행 시 중복 또는 기본키 오류 MERGE(덮어쓰기)
다른 DB에 MERGE ... KEY 사용 문법 오류 DB별 문법으로 교체
null을 그대로 저장하려 함 스키마·의미 충돌 이 예제는 0으로 단순화

확인 문제

  1. 멱등이란 무엇이고 이 배치에서 어떻게 달성하나요?
  2. 한 청크의 저장이 실패하면 앞 청크는 어떻게 되나요?

답: 1) 여러 번 실행해도 결과가 같은 성질이며, 같은 회원을 덮어써서 행이 늘어나지 않게 합니다. 2) 이미 커밋되어 남습니다.

직접 해 보기

  1. MERGE를 단순 INSERT로 바꾸면 재실행 테스트가 어떻게 실패하는지 확인하세요.
  2. 청크 크기를 1로 두고 중간에 예외를 던져 앞 청크가 남는지 확인하세요.
  3. 실패한 값을 null 그대로 저장하려면 스키마를 어떻게 바꿔야 할지 적어 보세요.

중복 실행 방지와 실행 스레드

관리자가 “실행” 버튼을 두 번 누르거나 두 사람이 동시에 누르면 같은 배치가 겹쳐 돌 수 있습니다. 같은 회원 행을 두 작업이 번갈아 덮어쓰면 결과의 job_id가 섞이고 부하만 늘어납니다. 이 절에서는 겹쳐 실행되는 것을 막는 가장 단순한 방법과 그 한계를 봅니다.

시작 코드

/** 작업을 만들고 실행을 맡긴 뒤 작업 번호를 바로 돌려준다. 이미 실행 중이면 거절한다. */
public synchronized long start() {
    jobs.findRunningJobId().ifPresent(id -> {
        throw new BatchAlreadyRunningException(id);
    });
    long jobId = jobs.create();
    executor.execute(() -> run(jobId));
    return jobId;
}

코드 읽기

  • synchronized: 같은 JVM 안에서 start()가 동시에 하나만 들어오게 합니다. 이것이 없으면 두 요청이 모두 “실행 중인 작업 없음”을 읽고 둘 다 작업을 만드는 경합이 생깁니다.
  • findRunningJobId: batch_job에 status = 'RUNNING'인 행이 있는지 봅니다. 상태가 DB에 있으므로 서버 재시작 뒤에도 남습니다.
  • 있으면 BatchAlreadyRunningException("이미 실행 중인 배치가 있습니다: jobId=...")입니다. 웹 계층의 변환 상태 코드는 이 절에서 확인하지 않았습니다.
  • 작업을 만들고(RUNNING으로 저장) 나서 실행을 위임합니다. 위임한 작업이 DONE 등으로 끝날 때 상태가 바뀝니다.

테스트

secondStartWhileRunningIsRejected는 batch_job에 RUNNING 행을 직접 넣어 둔 상태에서 start()를 호출합니다. 결과는 BatchAlreadyRunningException이 던져지고 스냅샷은 0행이었습니다. 즉 거절된 호출은 아무 일도 하지 않았습니다.

실행 스레드

실행기는 앞의 “온디맨드 배치 설계: 202와 jobId” 절에서 설정한 단일 스레드 실행기입니다. 겹쳐 시작은 막혔고, 만약 시작됐더라도 단일 스레드라서 순서대로만 실행됩니다. 두 장치가 이중으로 겹침을 막습니다.

이 방법이 안전한 범위

상황 안전한가
서버 한 대, 요청이 동시에 옴 안전 (synchronized + 상태 표)
서버 두 대 이상 안전하지 않음. synchronized는 JVM 안에서만 유효. DB 잠금이나 유니크 제약이 필요하며 구현하지 않았음
실행 중에 서버가 죽음 상태가 RUNNING으로 남아 이후 시작이 계속 거절됨. 정리 로직이 없음(“한계와 다음 단계” 절)

한계가 분명한 만큼 이 예제는 “서버 한 대” 가정을 README에도 적어 두었습니다.

따라 하기

./gradlew :examples:ch36-bulk-orchestration:test --tests '*BatchTests*'

재검증에서 5건이 통과했고 secondStartWhileRunningIsRejected가 포함되어 있습니다.

자주 하는 실수

실수 증상 해결
synchronized 없이 상태만 확인 두 요청이 동시에 통과 시작을 직렬화
서버 두 대에서 synchronized에 의존 중복 실행 가능 DB 잠금·유니크 제약
실행 중 서버가 죽어 RUNNING이 남음 이후 시작이 계속 거절 정리 로직 필요(이 예제에는 없음)

확인 문제

  1. synchronized가 보장하는 범위는 어디까지인가요?
  2. 상태를 DB에 두는 이점은 무엇인가요?

답: 1) 같은 JVM 안에서의 동시 시작입니다. 2) 서버를 재시작해도 상태가 남고, 목록으로 조회할 수 있습니다.

직접 해 보기

  1. synchronized를 지우고 동시에 두 번 start()를 부르는 테스트를 써서 둘 다 통과하는 경우가 있는지 보세요(결과는 실행마다 다를 수 있습니다).
  2. batch_job의 RUNNING 행을 직접 지우면 다음 시작이 허용되는지 확인하세요.
  3. 서버가 여러 대일 때 중복 실행을 막으려면 어떤 장치가 필요할지 설계해 보세요.

청크 실패와 결과 상태

수천 명을 처리하다 일부 묶음이 실패했을 때 전체를 처음부터 다시 돌리거나 모두 포기할 수는 없습니다. 이 배치는 실패한 묶음만 실패로 세고 나머지는 이어 갑니다. 이 절에서는 그 동작과 상태 값을 테스트로 확인합니다.

실행 반복의 실패 처리

try {
    processed += processChunk(jobId, ids);
} catch (CallFailedException e) {
    failed += ids.size();
    message = e.getMessage();
    log.warn("chunk 실패 jobId={} firstId={} message={}", jobId, ids.get(0), e.getMessage());
}
jobs.updateProgress(jobId, processed, failed);

그리고 반복이 끝나면 다음처럼 마무리합니다.

jobs.finish(jobId, failed == 0 ? "DONE" : "DONE_WITH_FAILURES", message);

반복 전체를 감싼 바깥 catch (RuntimeException e)는 예상하지 못한 오류에서 FAILED로 마감합니다.

상황 최종 status
모든 묶음 성공 DONE
일부 묶음 실패(CallFailedException), 나머지 성공 DONE_WITH_FAILURES
그 밖의 예외 FAILED (그때까지의 진행 상황은 저장)

코드 읽기

  • 잡는 것은 CallFailedException입니다. Chapter 17에서 STOP 정책이 던지는 예외이므로, 필수 모듈이 실패한 묶음이 이 경로를 탑니다.
  • 실패한 묶음의 회원 수 전체를 failed에 더합니다. 묶음 안에서 누가 실패했는지는 세분하지 않습니다.
  • 마지막 실패의 메시지를 message에 남깁니다. 실패가 여러 번이면 마지막 것만 남는 단순한 구조입니다.
  • 로그에는 작업 번호, 묶음의 첫 id, 메시지를 WARN으로 남겨 어느 구간이 실패했는지 추적할 수 있게 합니다.

테스트

BatchChunkFailureTests는 FailingRewardForMemberThree로 3번 회원이 들어 있는 묶음의 reward 호출을 실패시킵니다. 청크 크기는 2라서 묶음은 [1,2] [3,4] [5]이고, 실패하는 묶음은 [3,4]입니다.

확인 항목 값
status DONE_WITH_FAILURES
processed 3
failed 2
message 필수 호출이 실패했습니다: reward
스냅샷의 member_id [1, 2, 5]

앞 묶음(1, 2)과 뒤 묶음(5)의 결과는 남았고, 실패한 묶음(3, 4)은 저장되지 않았습니다. 이 테스트에서는 reward가 실패하면 묶음이 실패하는 규칙(필수 호출)을 주입한 것이며, Chapter 17의 기본 규칙(reward는 CONTINUE)과는 다른 설정입니다. 이 설정 방법은 테스트 코드(support 패키지)에서 확인하세요.

재실행으로 복구

실패한 구간은 배치를 다시 시작하면 처리됩니다. 이미 성공한 행은 “청크 트랜잭션과 멱등 저장” 절의 덮어쓰기로 저장되므로 중복되지 않습니다. 즉 멱등성이 재시도를 안전하게 만듭니다. 실패한 구간만 골라 다시 하는 기능은 만들지 않았습니다.

따라 하기

./gradlew :examples:ch36-bulk-orchestration:test --tests '*BatchChunkFailureTests*'

재검증에서 1건이 통과했고, 기대값(processed 3, failed 2, 스냅샷 [1, 2, 5])은 위 표와 같습니다.

자주 하는 실수

실수 증상 해결
모든 예외를 잡고 계속 진행 원인 불명의 실패가 숨음 약속된 예외만 세고, 나머지는 FAILED
실패 로그에 구간 정보 없음 어느 구간이 실패했는지 모름 jobId, 첫 id, 메시지 기록
실패 후 처음부터 수동으로 정리 중복·누락 멱등 저장 후 재실행

확인 문제

  1. 일부 묶음이 실패해도 끝까지 가는 이유는 무엇인가요?
  2. 이 예제에서 실패를 회원 단위로 알 수 있나요?

답: 1) 전체를 포기하지 않고 성공한 구간의 결과를 살리기 위해서입니다. 2) 알 수 없습니다. 묶음 단위로만 셉니다.

직접 해 보기

  1. 실패시킬 회원을 5번으로 바꾸면 processed와 failed가 어떻게 달라질지 예측하세요.
  2. 실패 후 장애 원인을 고친 뒤 배치를 다시 실행하면 최종 스냅샷이 몇 행이 되는지 확인하세요.
  3. 묶음 안에서 실패한 회원만 가려내려면 구조를 어떻게 바꿔야 할지 적어 보세요.

한계와 다음 단계

이 Chapter의 마지막 절입니다. 만든 것을 정리하고, 구현하지 않았거나 확인하지 않은 것을 한곳에 적습니다. 학습용 예제를 실무에 가져갈 때 가장 먼저 점검할 목록입니다.

만든 것

  • AOP: @Around 시간 측정, 패키지 포인트컷 횟수 세기, 프록시 함정 재현(ch35, 10건 통과).
  • 배치: 온디맨드 시작(202와 jobId), keyset 읽기, 청크 트랜잭션, 덮어쓰기 저장, 중복 실행 거절, 청크 실패 처리(ch36 배치 7건 통과).

한계와 확인하지 않은 것

항목 상태
서버 여러 대 중복 실행 방지가 synchronized라 한 대에서만 유효
실행 중 서버 종료 RUNNING이 남아 이후 시작이 거절됨. 정리 로직 없음
실패 회원 개별 추적 묶음 단위로만 셈
null 보존 스냅샷에 0으로 저장 (조회 실패와 기록 없음이 합쳐짐)
MERGE ... KEY H2 문법. 다른 DB는 확인하지 않음
스케줄 실행(cron) 다루지 않음. 호출될 때만 실행
취소, 일시정지, 진행률 푸시 구현하지 않음
Spring Batch 사용하지 않음
성능 대량 데이터에서 측정하지 않음
AOP 적용 범위 인터페이스 없는 클래스, private/final 메서드의 프록시 한계는 확인하지 않음

다음 단계로 무엇을 보면 좋은가

  • 재시작과 이력 관리가 필요해지면 Spring Batch 같은 배치 프레임워크를 검토합니다(이 과정에서는 다루지 않았습니다).
  • 여러 서버라면 DB 잠금이나 분산 잠금으로 중복 실행을 막아야 합니다.
  • 정말 오래 걸리는 작업은 작업 큐로 분리합니다.

직접 해 보기

  1. 위 표의 항목 하나를 골라 어떻게 보완할지 설계해 보세요.
  2. 서버를 RUNNING 상태에서 강제 종료한 뒤 어떤 일이 생길지 예측하고, 안전하게 복구하는 절차를 적어 보세요.
  3. AOP로 배치의 청크 처리 시간을 @Measured와 비슷하게 기록하려면 어디에 붙여야 하는지 생각해 보세요. (“프록시의 함정: 같은 객체 안 호출” 절에서 본 함정에 걸리지 않는 위치를 고르세요.)

용어와 참고 자료

Chapter 18의 용어를 모았습니다. 트랜잭션과 프록시는 Chapter 09 용어 정리, 오케스트레이션은 Chapter 17 용어 정리를 참고하세요.

용어

용어 설명 나온 곳
횡단 관심사 로깅, 시간 측정처럼 여러 곳에 걸쳐 반복되는 관심사입니다. 공통 관심사와 AOP
AOP 횡단 관심사를 업무 코드에서 분리해 한곳에 모으는 기법입니다. 공통 관심사와 AOP
Aspect 횡단 관심사를 모은 클래스입니다. 공통 관심사와 AOP
Advice 끼워 넣는 코드와 시점입니다(@Around, @Before). 공통 관심사와 AOP
Pointcut Advice를 적용할 지점을 고르는 식입니다. 애노테이션 없이 패키지로 고르는 포인트컷
JoinPoint Advice가 끼어들 수 있는 지점입니다. 공통 관심사와 AOP
proceed() @Around에서 대상 메서드를 실제로 실행하는 호출입니다. @Around로 실행 시간 기록하기
프록시 진짜 객체를 감싸 호출을 가로채는 대리 객체입니다. 공통 관심사와 AOP
self-invocation 같은 객체 안에서 this로 부르는 호출입니다. 프록시를 우회합니다. 프록시의 함정: 같은 객체 안 호출
온디맨드 배치 일정이 아니라 호출될 때 시작하는 배치입니다. 온디맨드 배치 설계: 202와 jobId
202 Accepted 요청을 받았고 처리는 아직 끝나지 않았다는 HTTP 상태입니다. 온디맨드 배치 설계: 202와 jobId
폴링 클라이언트가 주기적으로 상태를 조회하는 방식입니다. 온디맨드 배치 설계: 202와 jobId
keyset 페이징 마지막으로 읽은 키보다 큰 값부터 이어 읽는 방식입니다. keyset 페이징으로 전체 회원 읽기
청크 배치가 한 번에 읽고 처리하는 묶음입니다. keyset 페이징으로 전체 회원 읽기
TransactionTemplate 코드로 트랜잭션 범위를 정하는 스프링 도구입니다. 청크 트랜잭션과 멱등 저장
멱등 같은 작업을 여러 번 해도 결과가 같은 성질입니다. 청크 트랜잭션과 멱등 저장
upsert 있으면 갱신하고 없으면 삽입하는 저장입니다. 청크 트랜잭션과 멱등 저장

참고 자료

구현과 값은 저장소의 examples/ch35-aop, examples/ch36-bulk-orchestration 코드와 테스트 실행 결과에서 확인했습니다. 개념은 아래 문서를 참고했습니다.

직접 해보기

  1. ./gradlew :examples:ch35-aop:bootRun으로 서버를 켜고 curl "http://localhost:8080/api/greet?name=Boot"를 호출한 뒤 curl http://localhost:8080/api/executions로 실행 기록이 한 건 남는지 확인해 보세요. GreetingService에는 기록 코드가 한 줄도 없다는 점도 함께 봅니다.
  2. MeasuredAspect에서 기록을 finally가 아니라 try 끝으로 옮기고 ./gradlew :examples:ch35-aop:test --tests '*AspectTests*'를 실행해 failureIsRecordedAndRethrown이 어떻게 되는지 확인해 보세요. 되돌린 뒤에는 proceed()의 결과를 반환하지 않으면 greet의 반환값이 어떻게 되는지도 봅니다.
  3. selfCall 안의 greet(name) 호출에 @Measured 기록이 남지 않는 이유를 this와 프록시로 설명하고, CallerService처럼 다른 Bean을 거치도록 고친 뒤 AspectTests를 다시 실행해 보세요.
  4. ./gradlew :examples:ch36-bulk-orchestration:bootRun으로 서버를 켜고 curl -i -X POST http://localhost:8080/api/batch/member-summaries로 배치를 시작해 202와 jobId를 확인하세요. 이어서 curl http://localhost:8080/api/batch/member-summaries/1로 status, processed, failed를 읽고, curl -i http://localhost:8080/api/batch/member-summaries/9999가 404인지 확인합니다.
  5. upsertSnapshot의 MERGE를 단순 INSERT로 바꾸고 ./gradlew :examples:ch36-bulk-orchestration:test --tests '*BatchTests*'에서 runningAgainOverwritesInsteadOfDuplicating이 어떻게 실패하는지 읽어 보세요. 되돌린 뒤 BatchChunkFailureTests에서 실패시킬 회원을 3번에서 5번으로 바꾸면 processed, failed, 스냅샷의 member_id가 어떻게 달라질지 예측하고 --tests '*BatchChunkFailureTests*'로 확인합니다.

이번 장의 정리

  • AOP는 로깅, 시간 측정 같은 횡단 관심사를 Aspect 한곳에 모읍니다. 스프링은 대상 Bean을 프록시로 감싸 Advice를 실행하며, 프록시인지는 AopUtils.isAopProxy로 확인합니다.
  • @Around는 proceed()의 결과를 그대로 반환하고 finally에서 기록해, 호출자의 결과와 예외를 바꾸지 않으면서 성공과 실패를 모두 남깁니다.
  • 대상은 @Measured 같은 표식 애노테이션이나 execution(...) 패키지 포인트컷으로 고릅니다. 애노테이션은 범위가 분명하고, 패키지 방식은 대상 코드를 고치지 않지만 범위가 의도보다 넓어질 수 있습니다.
  • 같은 객체 안의 this 호출은 프록시를 거치지 않아 @Measured도 @Transactional도 적용되지 않습니다. 가장 간단한 해결은 안쪽 메서드를 다른 Bean으로 나누는 것입니다.
  • 배치 시작 API는 202와 jobId를 돌려주고 단일 스레드 실행기에서 작업을 돌리며, 진행 상황은 GET .../{jobId}로 조회합니다. 테스트는 bulk.batch-async=false로 같은 스레드에서 실행하고, 비동기 동작은 AsyncBatchTests가 따로 확인합니다.
  • 회원 전체는 id > lastId와 ORDER BY id의 keyset 페이징으로 청크씩 읽고, 청크마다 TransactionTemplate 트랜잭션에서 MERGE로 덮어써 다시 실행해도 행이 늘지 않습니다.
  • synchronized와 batch_job의 RUNNING 상태로 겹친 시작을 거절하고, CallFailedException이 난 청크만 실패로 세어 DONE_WITH_FAILURES로 마감합니다. 예상하지 못한 예외는 FAILED입니다.
  • 중복 실행 방지는 서버 한 대에서만 유효하고, 실행 중 서버가 죽으면 RUNNING이 남으며, MERGE ... KEY는 H2 문법이라는 한계가 남아 있습니다.

다음 Chapter 19 단위·슬라이스 테스트에서는 스프링 없이 서비스 규칙을 검사하는 Mockito 단위 테스트와, 웹·영속 계층만 띄우는 슬라이스 테스트를 다룹니다.

FAQ

자주 묻는 질문

@Around에서 반드시 지켜야 할 것은 무엇인가요?

대상 메서드의 결과를 그대로 반환하고 예외도 삼키지 않고 다시 던져야 합니다. 기록 로직 때문에 업무 결과가 바뀌면 안 됩니다.

같은 객체 안에서 메서드를 호출하면 AOP가 왜 동작하지 않나요?

호출이 스프링 프록시를 거치지 않고 this를 통해 바로 실행되기 때문입니다. 프록시를 통과하는 외부 호출과 self-invocation을 테스트로 비교합니다.

배치 시작 API가 202를 반환하는 이유는 무엇인가요?

작업을 요청했지만 아직 완료되지 않았기 때문입니다. jobId를 반환하고 별도 조회 API에서 진행 상태를 확인합니다.

Keyset 페이징은 무엇을 기준으로 다음 묶음을 읽나요?

마지막으로 처리한 id보다 큰 행을 다음 묶음으로 읽습니다. OFFSET이 커질수록 생기는 비용을 피하면서 순차 처리합니다.

작성·편집 ToolPado

콘텐츠 유형 Spring Boot 학습 가이드

기술 기준 Spring Boot 4.1.1 · JDK 21

마지막 검토