이 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로 확인 |
확인 문제
- Pointcut과 Advice의 차이는 무엇인가요?
- 스프링 AOP가 프록시로 동작하면 어떤 호출에 적용되지 않나요?
답: 1) Pointcut은 어디에 끼울지 고르는 식이고, Advice는 끼워 넣는 코드와 시점입니다. 2) 프록시를 거치지 않는 호출, 예를 들어 같은 객체 안의 this 호출입니다.
직접 해 보기
- 자신의 프로젝트에서 같은 코드가 3곳 이상 복사된 부분을 찾아 횡단 관심사인지 판단해 보세요.
- 서비스 Bean을 주입받아
getClass()를 출력해 보고 클래스 이름이 어떻게 보이는지 확인하세요. - “프록시가 끼어든다”에서 설명한 호출 순서를 그림으로 그리고, 대상 메서드에서 예외가 날 때 흐름이 어디로 가는지 표시해 보세요.
@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하고 삼킴 |
호출자가 실패를 모름 | 예외를 그대로 전달 |
확인 문제
- 좋은 Aspect는 호출자의 결과와 예외를 바꾸나요?
System.nanoTime()을 쓰는 이유는 무엇인가요?
답: 1) 바꾸지 않고 기록만 덧붙입니다. 2) 벽시계가 아니라 경과 시간 측정용으로 쓰이기 때문입니다.
직접 해 보기
finally를try끝으로 옮기면 어떤 테스트가 실패할지 예측하고 확인하세요.joinPoint.proceed()호출을 지우면greet의 반환값이 어떻게 되는지 확인하세요.- 기록에 메서드 인자 값을 넣고 싶을 때 개인정보 측면에서 주의할 점을 적어 보세요.
애노테이션 없이 패키지로 고르는 포인트컷
앞의 “@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 호출 |
확인 문제
execution(public * com...service..*(..))에서..는 무엇을 뜻하나요?@Before는 대상의 결과를 바꿀 수 있나요?
답: 1) 하위 패키지를 포함한다(인자 자리에서는 인자 개수에 상관없다)는 뜻입니다. 2) 바꿀 수 없습니다. 대상 실행 전에 한 번 실행될 뿐입니다.
직접 해 보기
- 포인트컷을
execution(* *..GreetingService.*(..))로 바꾸고 결과가 같은지 확인하세요. public을 지우면 어떤 메서드가 대상이 되는지 확인하세요(스프링 AOP의 프록시가 가로챌 수 있는 범위는 이 예제에서 확인하지 않았습니다).- 패키지 방식으로 컨트롤러의 모든 요청을 세는 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 분리 |
확인 문제
this.greet(name)은 왜 프록시를 거치지 않나요?- 가장 간단한 해결 방법은 무엇인가요?
답: 1) this는 프록시가 아니라 진짜 객체이기 때문입니다. 2) 안쪽 메서드를 다른 Bean으로 분리해 주입받아 호출하는 것입니다.
직접 해 보기
@Transactional(REQUIRES_NEW)를 같은 클래스의 메서드에 붙이고this로 호출해 새 트랜잭션이 시작되지 않는 것을 확인해 보세요. (Chapter 17 “트랜잭션 경계: 읽기 전용과 REQUIRES_NEW” 절의REQUIRES_NEW와 연결됩니다.)selfCall이CallerService처럼 다른 Bean을 거치도록 고쳐 테스트를 통과시켜 보세요.- 자신의 프로젝트에서 같은 클래스 안
@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)에 저장 |
확인 문제
- 시작 요청이
200이 아니라202를 돌려주는 이유는 무엇인가요? - 진행 상황은 어떻게 확인하나요?
답: 1) 처리가 끝난 것이 아니라 요청이 접수되었다는 뜻이기 때문입니다. 2) GET .../{jobId}로 상태(processed, failed, status)를 조회합니다.
직접 해 보기
bulk.batch-async설정을 빼고(기본 비동기)BatchTests를 실행하면 어떤 테스트가 불안정해질지 예측하세요.- 상태 조회를 반복하는 클라이언트(폴링) 주기를 얼마로 정할지 고민해 보세요. 이 예제는 결과 푸시(웹소켓 등)를 다루지 않았습니다.
- 상태 값에
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) 이번 묶음의 마지막 id입니다. 2) 빈 결과로 끝났음을 확인하는 단순한 종료 조건을 쓰기 위해서입니다.
직접 해 보기
ORDER BY id를 빼면 어떤 문제가 생길지 설명해 보세요.- 청크 크기를 5, 6으로 바꿔 조회 횟수가 어떻게 달라지는지 세어 보세요.
- 정렬 키가 중복될 수 있는 컬럼(예: 가입 연도)이면 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) 이미 커밋되어 남습니다.
직접 해 보기
MERGE를 단순INSERT로 바꾸면 재실행 테스트가 어떻게 실패하는지 확인하세요.- 청크 크기를 1로 두고 중간에 예외를 던져 앞 청크가 남는지 확인하세요.
- 실패한 값을
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이 남음 |
이후 시작이 계속 거절 | 정리 로직 필요(이 예제에는 없음) |
확인 문제
synchronized가 보장하는 범위는 어디까지인가요?- 상태를 DB에 두는 이점은 무엇인가요?
답: 1) 같은 JVM 안에서의 동시 시작입니다. 2) 서버를 재시작해도 상태가 남고, 목록으로 조회할 수 있습니다.
직접 해 보기
synchronized를 지우고 동시에 두 번start()를 부르는 테스트를 써서 둘 다 통과하는 경우가 있는지 보세요(결과는 실행마다 다를 수 있습니다).batch_job의RUNNING행을 직접 지우면 다음 시작이 허용되는지 확인하세요.- 서버가 여러 대일 때 중복 실행을 막으려면 어떤 장치가 필요할지 설계해 보세요.
청크 실패와 결과 상태
수천 명을 처리하다 일부 묶음이 실패했을 때 전체를 처음부터 다시 돌리거나 모두 포기할 수는 없습니다. 이 배치는 실패한 묶음만 실패로 세고 나머지는 이어 갑니다. 이 절에서는 그 동작과 상태 값을 테스트로 확인합니다.
실행 반복의 실패 처리
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) 알 수 없습니다. 묶음 단위로만 셉니다.
직접 해 보기
- 실패시킬 회원을 5번으로 바꾸면
processed와failed가 어떻게 달라질지 예측하세요. - 실패 후 장애 원인을 고친 뒤 배치를 다시 실행하면 최종 스냅샷이 몇 행이 되는지 확인하세요.
- 묶음 안에서 실패한 회원만 가려내려면 구조를 어떻게 바꿔야 할지 적어 보세요.
한계와 다음 단계
이 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 잠금이나 분산 잠금으로 중복 실행을 막아야 합니다.
- 정말 오래 걸리는 작업은 작업 큐로 분리합니다.
직접 해 보기
- 위 표의 항목 하나를 골라 어떻게 보완할지 설계해 보세요.
- 서버를
RUNNING상태에서 강제 종료한 뒤 어떤 일이 생길지 예측하고, 안전하게 복구하는 절차를 적어 보세요. - 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 코드와 테스트 실행 결과에서 확인했습니다. 개념은 아래 문서를 참고했습니다.
직접 해보기
./gradlew :examples:ch35-aop:bootRun으로 서버를 켜고curl "http://localhost:8080/api/greet?name=Boot"를 호출한 뒤curl http://localhost:8080/api/executions로 실행 기록이 한 건 남는지 확인해 보세요.GreetingService에는 기록 코드가 한 줄도 없다는 점도 함께 봅니다.MeasuredAspect에서 기록을finally가 아니라try끝으로 옮기고./gradlew :examples:ch35-aop:test --tests '*AspectTests*'를 실행해failureIsRecordedAndRethrown이 어떻게 되는지 확인해 보세요. 되돌린 뒤에는proceed()의 결과를 반환하지 않으면greet의 반환값이 어떻게 되는지도 봅니다.selfCall안의greet(name)호출에@Measured기록이 남지 않는 이유를this와 프록시로 설명하고,CallerService처럼 다른 Bean을 거치도록 고친 뒤AspectTests를 다시 실행해 보세요../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인지 확인합니다.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 단위 테스트와, 웹·영속 계층만 띄우는 슬라이스 테스트를 다룹니다.