1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// AOP 없이 트랜잭션, 로깅, 보안을 직접 처리하는 코드
public class OrderService {
    public void createOrder(OrderRequest request) {
        // 보안 검사
        if (!SecurityContext.hasPermission("ORDER_CREATE")) {
            throw new UnauthorizedException();
        }

        // 로깅
        log.info("주문 생성 시작: {}", request);
        long startTime = System.currentTimeMillis();

        // 트랜잭션 시작
        Connection conn = dataSource.getConnection();
        conn.setAutoCommit(false);

        try {
            // === 비즈니스 로직 (진짜 하고 싶은 코드) ===
            Order order = new Order(request);
            orderRepository.save(order);
            // === 비즈니스 로직 끝 ===

            conn.commit();
        } catch (Exception e) {
            conn.rollback();
            throw e;
        } finally {
            conn.close();
        }

        // 로깅
        log.info("주문 생성 완료: {}ms", System.currentTimeMillis() - startTime);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// AOP가 적용된 코드
@Service
public class OrderService {

    @Secured("ORDER_CREATE")  // 보안 → AOP
    @Transactional            // 트랜잭션 → AOP
    @Timed                    // 로깅 → AOP
    public void createOrder(OrderRequest request) {
        Order order = new Order(request);
        orderRepository.save(order);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@Aspect
@Component
public class LoggingAspect {

    // Before: 메서드 실행 전
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        log.info("호출: {}", joinPoint.getSignature().getName());
    }

    // AfterReturning: 메서드 정상 완료 후
    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))",
                    returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        log.info("완료: {} → {}", joinPoint.getSignature().getName(), result);
    }

    // AfterThrowing: 예외 발생 시
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))",
                   throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        log.error("예외: {} → {}", joinPoint.getSignature().getName(), ex.getMessage());
    }

    // After: 정상/예외 관계없이 항상 실행 (finally와 유사)
    @After("execution(* com.example.service.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        log.info("종료: {}", joinPoint.getSignature().getName());
    }

    // Around: 메서드 실행 전후를 모두 제어 (가장 강력)
    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            Object result = joinPoint.proceed();  // 실제 메서드 실행
            return result;
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            log.info("{} 실행시간: {}ms",
                joinPoint.getSignature().getName(), elapsed);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// JDK Dynamic Proxy 직접 구현 예시
public interface OrderService {
    void createOrder(OrderRequest request);
}

public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderRequest request) {
        System.out.println("주문 생성: " + request);
    }
}

// InvocationHandler: 프록시의 모든 메서드 호출을 가로챈다
public class TransactionHandler implements InvocationHandler {
    private final Object target;

    public TransactionHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("트랜잭션 시작");
        try {
            Object result = method.invoke(target, args);  // 실제 메서드 호출
            System.out.println("트랜잭션 커밋");
            return result;
        } catch (Exception e) {
            System.out.println("트랜잭션 롤백");
            throw e;
        }
    }
}

// 프록시 생성
OrderService target = new OrderServiceImpl();
OrderService proxy = (OrderService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    new Class[]{OrderService.class},
    new TransactionHandler(target)
);

proxy.createOrder(request);  // 프록시를 통해 호출

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// CGLIB Proxy 동작 원리 (개념적)
public class OrderServiceImpl {
    public void createOrder(OrderRequest request) {
        System.out.println("주문 생성: " + request);
    }
}

// CGLIB이 생성하는 프록시 (개념적으로 이런 서브클래스를 만든다)
public class OrderServiceImpl$$EnhancerBySpringCGLIB extends OrderServiceImpl {
    private MethodInterceptor interceptor;

    @Override
    public void createOrder(OrderRequest request) {
        // Interceptor를 통해 호출
        interceptor.intercept(this, method, args, methodProxy);
    }
}

1
2
3
4
5
6
// 다양한 execution 패턴
@Pointcut("execution(public * *(..))")                        // 모든 public 메서드
@Pointcut("execution(* com.example.service.*Service.*(..))")  // *Service 클래스의 모든 메서드
@Pointcut("execution(* com.example..*.*(..))") // com.example 하위 모든 패키지의 모든 메서드
@Pointcut("execution(String com.example.service.*.*(..))")    // String 반환 메서드만
@Pointcut("execution(* *(Long, ..))")                         // 첫 파라미터가 Long인 메서드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 커스텀 어노테이션 정의
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Timed {}

// 해당 어노테이션이 붙은 메서드에 Aspect 적용
@Around("@annotation(com.example.annotation.Timed)")
public Object measureTime(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    try {
        return joinPoint.proceed();
    } finally {
        log.info("{}: {}ms", joinPoint.getSignature().getName(),
            System.currentTimeMillis() - start);
    }
}

// 사용
@Timed
public void heavyOperation() { ... }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Aspect
@Component
public class SecurityAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    private void serviceLayer() {}

    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    private void transactionalMethod() {}

    // AND: 서비스 레이어이면서 트랜잭셔널한 메서드
    @Before("serviceLayer() && transactionalMethod()")
    public void beforeTransactionalService(JoinPoint jp) { ... }

    // OR: 서비스 레이어이거나 리포지토리 레이어
    @After("serviceLayer() || repositoryLayer()")
    public void afterDataAccess(JoinPoint jp) { ... }

    // NOT: 트랜잭셔널이 아닌 메서드
    @Before("serviceLayer() && !transactionalMethod()")
    public void beforeNonTransactional(JoinPoint jp) { ... }
}

1
2
3
4
5
6
7
8
// TransactionAttribute 예시
@Transactional(
    propagation = Propagation.REQUIRED,
    isolation = Isolation.DEFAULT,
    timeout = 30,
    readOnly = false,
    rollbackFor = Exception.class
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// TransactionAspectSupport.invokeWithinTransaction() 핵심 로직 (간략화)
protected Object invokeWithinTransaction(Method method, Class<?> targetClass,
        InvocationCallback invocation) throws Throwable {

    // 1. 트랜잭션 속성 조회
    TransactionAttribute txAttr = getTransactionAttributeSource()
        .getTransactionAttribute(method, targetClass);

    // 2. TransactionManager 획득
    PlatformTransactionManager tm = determineTransactionManager(txAttr);

    // 3. 트랜잭션 시작
    TransactionStatus status = tm.getTransaction(txAttr);

    Object retVal;
    try {
        // 4. Target 메서드 실행
        retVal = invocation.proceedWithInvocation();
    } catch (Throwable ex) {
        // 5a. 롤백 규칙에 해당하면 롤백
        completeTransactionAfterThrowing(status, txAttr, ex);
        throw ex;
    }

    // 5b. 정상 완료 → 커밋
    commitTransactionAfterReturning(status);
    return retVal;
}

1
2
3
4
5
6
public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition)
        throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// DataSourceUtils.doGetConnection() 내부 로직 (간략화)
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
    // 1. 현재 스레드에 바인딩된 Connection이 있는지 확인
    ConnectionHolder conHolder =
        (ConnectionHolder) TransactionSynchronizationManager
            .getResource(dataSource);

    // 2. 이미 바인딩된 Connection이 있으면 그것을 반환
    if (conHolder != null && conHolder.hasConnection()) {
        conHolder.requested();  // 참조 카운트 증가
        return conHolder.getConnection();
    }

    // 3. 바인딩된 Connection이 없으면 새로 획득
    Connection con = dataSource.getConnection();

    // 4. 트랜잭션 동기화가 활성화되어 있으면 ThreadLocal에 바인딩
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        ConnectionHolder holderToUse = new ConnectionHolder(con);
        TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
    }

    return con;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// TransactionSynchronizationManager 내부 (간략화)
public abstract class TransactionSynchronizationManager {

    // 리소스 바인딩: DataSource → Connection, EntityManagerFactory → EntityManager
    private static final ThreadLocal<Map<Object, Object>> resources =
        new NamedThreadLocal<>("Transactional resources");

    // 동기화 콜백: 트랜잭션 커밋/롤백 시 실행할 콜백들
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
        new NamedThreadLocal<>("Transaction synchronizations");

    // 현재 트랜잭션 이름
    private static final ThreadLocal<String> currentTransactionName =
        new NamedThreadLocal<>("Current transaction name");

    // 현재 트랜잭션 readOnly 여부
    private static final ThreadLocal<Boolean> currentTransactionReadOnly =
        new NamedThreadLocal<>("Current transaction read-only status");

    // 현재 트랜잭션 격리 수준
    private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
        new NamedThreadLocal<>("Current transaction isolation level");

    // 현재 트랜잭션 활성 여부
    private static final ThreadLocal<Boolean> actualTransactionActive =
        new NamedThreadLocal<>("Actual transaction active");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// AbstractPlatformTransactionManager.suspend() 내부 (간략화)
protected final SuspendedResourcesHolder suspend(Object transaction) {
    // 1. 현재 ThreadLocal에서 동기화 콜백들을 꺼냄
    List<TransactionSynchronization> suspendedSynchronizations =
        doSuspendSynchronization();

    // 2. 현재 ThreadLocal에서 Connection을 꺼냄 (unbind)
    Object suspendedResources = doSuspend(transaction);
    // → TransactionSynchronizationManager.unbindResource(dataSource)

    // 3. 꺼낸 것들을 묶어서 보관
    return new SuspendedResourcesHolder(
        suspendedResources, suspendedSynchronizations,
        name, readOnly, isolationLevel, wasActive);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Service
public class OrderService {

    @Transactional
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));

        // 비동기로 알림 발송 — 이 메서드 안에서의 DB 작업은
        // createOrder의 트랜잭션(T1)과 무관한 별도 트랜잭션(T2)에서 실행된다
        notificationService.sendAsync(order.getId());

        // 여기서 예외가 발생해 T1이 롤백되어도,
        // sendAsync 내부의 T2는 이미 커밋되었을 수 있다
        throw new RuntimeException("주문 처리 중 오류");
    }
}

@Service
public class NotificationService {

    @Async
    @Transactional  // 새 스레드에서 새 트랜잭션(T2)으로 실행됨
    public void sendAsync(Long orderId) {
        Notification noti = new Notification(orderId, "주문 확인");
        notificationRepository.save(noti);
        // T2 커밋 — T1의 롤백과 무관하게 알림 레코드가 남는다
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 해결 방법: TransactionalEventListener + @Async
@Service
public class OrderService {

    @Transactional
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        // 이벤트 발행 — 트랜잭션 커밋 후에만 처리됨
        eventPublisher.publishEvent(new OrderCreatedEvent(order.getId()));
    }
}

@Component
public class NotificationEventHandler {

    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 이 시점에서는 T1이 이미 커밋 완료된 상태
        // 새 스레드에서 새 트랜잭션으로 안전하게 실행
        notificationService.send(event.getOrderId());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Service
public class OrderService {
    @Transactional
    public void processOrder(Long orderId) {
        orderRepository.updateStatus(orderId, "PROCESSING");
        auditService.log("ORDER_PROCESSING", orderId);  // REQUIRES_NEW
        // auditService.log가 성공한 후 여기서 예외가 발생하면
        // 주문 상태 변경은 롤백되지만, 감사 로그는 남는다
    }
}

@Service
public class AuditService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String action, Long targetId) {
        auditRepository.save(new AuditLog(action, targetId));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Service
public class OrderService {

    public void processOrder(Long orderId) {
        // this.createOrder()는 프록시를 거치지 않는다!
        this.createOrder(orderId);  // @Transactional 무시!
    }

    @Transactional
    public void createOrder(Long orderId) {
        // 트랜잭션이 적용되지 않음
        orderRepository.save(new Order(orderId));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 방법 1: 별도 빈으로 분리 (권장)
@Service
public class OrderService {
    private final OrderCreator orderCreator;

    public void processOrder(Long orderId) {
        orderCreator.createOrder(orderId);  // 프록시를 거침 ✅
    }
}

@Service
public class OrderCreator {
    @Transactional
    public void createOrder(Long orderId) {
        orderRepository.save(new Order(orderId));
    }
}

// 방법 2: Self-injection
@Service
public class OrderService {
    @Lazy @Autowired
    private OrderService self;

    public void processOrder(Long orderId) {
        self.createOrder(orderId);  // 프록시를 거침 ✅
    }

    @Transactional
    public void createOrder(Long orderId) {
        orderRepository.save(new Order(orderId));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 기본 동작: RuntimeException과 Error만 롤백
@Transactional
public void method() throws IOException {
    repository.save(entity);
    throw new IOException("파일 오류");
    // IOException은 Checked Exception → 롤백하지 않고 커밋된다!
}

// 해결: rollbackFor 명시
@Transactional(rollbackFor = Exception.class)
public void method() throws IOException {
    repository.save(entity);
    throw new IOException("파일 오류");
    // 이제 롤백된다 ✅
}

1
2
3
4
@Transactional(readOnly = true)
public List<Order> findOrders(Long userId) {
    return orderRepository.findByUserId(userId);
}

1
2
3
4
@Transactional
private void internalMethod() {  // 트랜잭션 적용 안 됨! (조용히 무시)
    repository.save(entity);
}

1
2
3
4
5
6
7
8
9
10
@Transactional
public void createOrder(OrderRequest request) {
    Order order = orderRepository.save(new Order(request));

    // 외부 PG사 결제 API 호출 (3~5초 소요)
    paymentGateway.charge(order.getTotalAmount());

    // 이 시간 동안 DB Connection을 점유하고 있다!
    // Connection Pool이 고갈될 위험
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// 해결: 이벤트 기반 분리
@Transactional
public void createOrder(OrderRequest request) {
    Order order = orderRepository.save(new Order(request));
    // 트랜잭션 커밋 후 이벤트 처리
    applicationEventPublisher.publishEvent(new OrderCreatedEvent(order));
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreated(OrderCreatedEvent event) {
    // 트랜잭션 밖에서 결제 API 호출
    paymentGateway.charge(event.getOrder().getTotalAmount());
}

1
2
3
4
5
6
7
@Async
@Transactional
public void asyncMethod() {
    // @Async는 새 스레드에서 실행된다
    // 트랜잭션 컨텍스트는 ThreadLocal 기반이므로 전파되지 않는다
    // 이 메서드는 새 트랜잭션에서 실행된다 (기존 트랜잭션과 무관)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Service
@RequiredArgsConstructor
public class OrderService {

    private final PaymentService paymentService;
    private final OrderRepository orderRepository;

    @Transactional  // 외부 트랜잭션 (REQUIRED)
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));

        try {
            // 내부 트랜잭션 (REQUIRED → T1에 참여)
            paymentService.processPayment(order);
        } catch (PaymentException e) {
            // 결제 실패해도 주문은 "대기" 상태로 저장하려는 의도
            log.warn("결제 실패, 주문을 대기 상태로 저장: {}", e.getMessage());
            order.setStatus(OrderStatus.PENDING);
        }

        // 여기까지 정상 도달했지만...
        // TransactionInterceptor가 커밋을 시도하면
        // → UnexpectedRollbackException 발생!
        // → 주문도 결제도 모두 롤백됨
    }
}

@Service
public class PaymentService {

    @Transactional  // REQUIRED → OrderService의 트랜잭션에 참여
    public void processPayment(Order order) {
        // 결제 처리 중 예외 발생
        if (order.getTotalAmount().compareTo(BigDecimal.ZERO) <= 0) {
            throw new PaymentException("결제 금액이 0 이하입니다");
        }
        // PaymentException은 RuntimeException을 상속
        // → TransactionInterceptor가 rollback-only를 마킹
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// AbstractPlatformTransactionManager.commit() 내부 (간략화)
public final void commit(TransactionStatus status) {
    // rollback-only 플래그 확인
    if (status.isRollbackOnly()) {
        // 커밋 대신 롤백 수행
        rollback(status);
        // 그리고 예외를 던짐
        throw new UnexpectedRollbackException(
            "Transaction silently rolled back because it has been marked as rollback-only");
    }
    // 정상 커밋 진행
    doCommit(status);
}

1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class PaymentService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)  // 독립 트랜잭션
    public void processPayment(Order order) {
        // 이 트랜잭션(T2)은 외부(T1)와 독립적
        // T2가 롤백되어도 T1에는 영향 없음
        if (order.getTotalAmount().compareTo(BigDecimal.ZERO) <= 0) {
            throw new PaymentException("결제 금액이 0 이하입니다");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Service
public class PaymentService {

    @Transactional
    public PaymentResult processPayment(Order order) {
        try {
            // 결제 처리
            return PaymentResult.success();
        } catch (Exception e) {
            // 예외를 던지지 않고 실패 결과를 반환
            // → TransactionInterceptor가 rollback-only를 마킹하지 않음
            return PaymentResult.failure(e.getMessage());
        }
    }
}

// 호출 측
@Transactional
public void createOrder(OrderRequest request) {
    Order order = orderRepository.save(new Order(request));
    PaymentResult result = paymentService.processPayment(order);

    if (result.isFailed()) {
        order.setStatus(OrderStatus.PENDING);
    }
    // 정상 커밋 가능
}

1
2
3
4
5
@Transactional(noRollbackFor = PaymentException.class)
public void processPayment(Order order) {
    // PaymentException이 발생해도 rollback-only 마킹하지 않음
    // 주의: 이 방법은 해당 예외가 정말로 롤백이 필요 없는 경우에만 사용
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 엔티티 정의
@Entity
@Table(name = "members",
    uniqueConstraints = @UniqueConstraint(columnNames = "email"))
public class Member {
    @Id @GeneratedValue
    private Long id;

    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private String name;

    // 생성자, getter 생략
}

// 테스트 — 이 테스트는 통과하지만, 프로덕션에서는 실패한다!
@SpringBootTest
@Transactional  // ← 테스트 종료 시 자동 롤백
class MemberServiceTest {

    @Autowired
    private MemberService memberService;

    @Autowired
    private MemberRepository memberRepository;

    @Test
    void 이메일_중복_저장이_성공하는_것처럼_보인다() {
        // given
        Member member1 = new Member("test@example.com", "홍길동");
        Member member2 = new Member("test@example.com", "김철수");  // 중복 이메일!

        // when
        memberRepository.save(member1);
        memberRepository.save(member2);  // INSERT SQL이 아직 실행되지 않음!

        // then — 이 테스트는 통과한다
        // 왜? 롤백되므로 flush가 일어나지 않아 DB에 INSERT가 안 갔기 때문
        // 프로덕션에서는 커밋 시점에 Unique constraint violation 발생!
        List<Member> members = memberRepository.findAll();
        // 1차 캐시에서 반환되므로 2건이 조회된다
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@SpringBootTest
@Transactional
class MemberServiceTest {

    @Test
    @Commit  // 테스트 종료 시 커밋 (롤백하지 않음)
    void 이메일_중복_저장_테스트() {
        Member member1 = new Member("test@example.com", "홍길동");
        Member member2 = new Member("test@example.com", "김철수");

        memberRepository.save(member1);
        memberRepository.save(member2);

        // @Commit이므로 트랜잭션 커밋 시 flush 발생
        // → Unique constraint violation 감지!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@SpringBootTest
@Transactional
class MemberServiceTest {

    @Autowired
    private EntityManager em;

    @Test
    void flush를_호출하면_제약조건_위반이_감지된다() {
        Member member1 = new Member("test@example.com", "홍길동");
        Member member2 = new Member("test@example.com", "김철수");

        memberRepository.save(member1);
        memberRepository.save(member2);

        // flush() 호출 → INSERT SQL이 즉시 실행됨
        assertThrows(DataIntegrityViolationException.class, () -> {
            em.flush();
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@DataJpaTest  // @Transactional이 포함되어 있음
class MemberRepositoryTest {

    @Autowired
    private TestEntityManager testEntityManager;

    @Test
    void TestEntityManager로_제약조건을_검증한다() {
        Member member1 = new Member("test@example.com", "홍길동");
        testEntityManager.persistAndFlush(member1);  // 즉시 INSERT 실행

        Member member2 = new Member("test@example.com", "김철수");
        // 두 번째 persistAndFlush에서 Unique 위반 발생
        assertThrows(PersistenceException.class, () -> {
            testEntityManager.persistAndFlush(member2);
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@SpringBootTest
// @Transactional 없음 — 프로덕션과 동일한 트랜잭션 동작
class MemberServiceIntegrationTest {

    @Autowired
    private MemberService memberService;

    @Autowired
    private MemberRepository memberRepository;

    @AfterEach
    void tearDown() {
        memberRepository.deleteAllInBatch();  // 테스트 후 데이터 정리
    }

    @Test
    void 실제_트랜잭션_커밋을_검증한다() {
        // 서비스 메서드 호출 → 내부에서 @Transactional로 커밋
        memberService.register("test@example.com", "홍길동");

        // 새 트랜잭션에서 조회 → DB에 실제 반영되었는지 확인
        Member found = memberRepository.findByEmail("test@example.com")
            .orElseThrow();
        assertEquals("홍길동", found.getName());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Service
public class OrderService {
    private final TransactionTemplate transactionTemplate;

    public OrderService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
        this.transactionTemplate.setIsolationLevel(
            TransactionDefinition.ISOLATION_READ_COMMITTED);
        this.transactionTemplate.setTimeout(10);
    }

    public Order createOrder(OrderRequest request) {
        return transactionTemplate.execute(status -> {
            Order order = new Order(request);
            orderRepository.save(order);

            if (someCondition) {
                status.setRollbackOnly();  // 프로그래밍 방식 롤백
            }

            return order;
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 트랜잭션 범위를 메서드 일부에만 적용
public void processWithPartialTransaction(Long orderId) {
    // 트랜잭션 밖: 외부 API 호출 (Connection 미점유)
    PaymentResult paymentResult = paymentGateway.charge(orderId);

    // 트랜잭션 안: DB 업데이트만
    transactionTemplate.executeWithoutResult(status -> {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.updatePaymentStatus(paymentResult);
    });

    // 트랜잭션 밖: 알림 발송
    notificationService.sendOrderConfirmation(orderId);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 파사드: 트랜잭션 경계를 담당
@Service
public class OrderFacade {
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final NotificationService notificationService;

    @Transactional
    public OrderResult processOrder(OrderRequest request) {
        Order order = orderService.create(request);
        Payment payment = paymentService.process(order);
        return new OrderResult(order, payment);
    }
    // 개별 서비스에는 @Transactional을 붙이지 않거나 REQUIRED로 참여
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Service
public class OrderService {
    @Transactional
    public void createOrder(OrderRequest request) {
        Order order = orderRepository.save(new Order(request));
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
        // 이벤트는 등록만 되고, 트랜잭션 커밋 후 처리된다
    }
}

@Component
public class OrderEventHandler {

    // 트랜잭션 커밋 후에만 실행 (롤백되면 실행되지 않음)
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void onOrderCreated(OrderCreatedEvent event) {
        emailService.sendConfirmation(event.getOrder());
    }

    // 롤백 후 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void onOrderFailed(OrderCreatedEvent event) {
        alertService.notifyFailure(event.getOrder());
    }
}