Spring @Transactional과 PostgreSQL 트랜잭션 abort

@Transactional
public void processOrder(OrderDTO order) {
    // 1. 핵심 데이터 INSERT (성공)
    orderMapper.insert(order);
 
    // 2. 메일 수신자 조회 (실패 가능)
    try {
        mailMapper.selectRecipients(order.getId());
    } catch (Exception e) {
        log.warn("메일 수신자 조회 실패, 건너뜀: {}", e.getMessage());
    }
 
    // 3. 상태 업데이트
    orderMapper.updateStatus(order.getId(), "COMPLETED");
}

Java 레벨                        DB 서버 레벨
─────────────                    ──────────────
try {
  mailMapper.select(...)  ──────→ SQL 실행 → 에러 → 트랜잭션 abort
} catch (Exception e) {
  log.warn("실패");              // DB는 여전히 abort 상태
}
 
orderMapper.update(...)  ───────→ "current transaction is aborted" 거부
 
// Spring COMMIT 시도    ───────→ PostgreSQL: ROLLBACK 처리

// 메일 서비스 (별도 Bean)
@Service
@RequiredArgsConstructor
public class MailServiceImpl implements MailService {
 
    private final MailMapper mailMapper;
 
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public List<RecipientDTO> getRecipients(Long orderId) {
        return mailMapper.selectRecipients(orderId);
    }
}

// 주문 서비스 (호출부)
@Service
@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {
 
    private final OrderMapper orderMapper;
    private final MailService mailService;  // 별도 Bean 주입
 
    @Transactional
    @Override
    public void processOrder(OrderDTO order) {
        orderMapper.insert(order);
 
        try {
            mailService.getRecipients(order.getId());  // 별도 트랜잭션
        } catch (Exception e) {
            log.warn("메일 수신자 조회 실패, 주문 처리는 계속: {}", e.getMessage());
        }
 
        orderMapper.updateStatus(order.getId(), "COMPLETED");
    }
}

@Transactional(propagation = Propagation.NESTED)
public List<RecipientDTO> getRecipients(Long orderId) {
    return mailMapper.selectRecipients(orderId);
}

트랜잭션 흐름:
BEGIN
INSERT orders ✅
SAVEPOINT sp1
  SELECT recipients ❌
ROLLBACK TO SAVEPOINT sp1    ← 여기까지만 롤백
UPDATE status ✅             ← 정상 실행 가능
COMMIT ✅

@Transactional
public void processOrder(OrderDTO order) {
    orderMapper.insert(order);
    orderMapper.updateStatus(order.getId(), "COMPLETED");
}

// 호출부에서 분리
public void handleOrder(OrderDTO order) {
    orderService.processOrder(order);  // 트랜잭션 커밋 완료
 
    try {
        mailService.dispatch(order.toParam());  // 트랜잭션 밖에서 실행
    } catch (Exception e) {
        log.warn("메일 발송 실패: {}", e.getMessage());
    }
}

// 이벤트 발행
@Transactional
public void processOrder(OrderDTO order) {
    orderMapper.insert(order);
    orderMapper.updateStatus(order.getId(), "COMPLETED");
    applicationEventPublisher.publishEvent(new OrderCompletedEvent(order));
}
 
// 커밋 후 이벤트 처리
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void onOrderCompleted(OrderCompletedEvent event) {
    mailService.dispatch(event.getOrder().toParam());
}

@Transactional
public void createUser(UserDTO user) {
    userMapper.insert(user);        // UNIQUE 제약 위반 → abort
    auditMapper.insertLog(user);    // 실행 불가
}

@Service
public class OuterService {
    @Autowired private InnerService innerService;
 
    @Transactional
    public void outerMethod() {
        try {
            innerService.innerMethod();  // RuntimeException → rollback-only 마킹
        } catch (Exception e) {
            log.warn("잡았으니 계속...");
        }
        // COMMIT 시도 → UnexpectedRollbackException 발생
    }
}
 
@Service
public class InnerService {
    @Transactional  // 기본 REQUIRED → 같은 트랜잭션 참여
    public void innerMethod() {
        throw new RuntimeException("실패!");
    }
}

// RuntimeException → 자동 롤백
@Transactional
public void process() {
    throw new CustomBusinessException("비즈니스 규칙 위반");
}
 
// 특정 예외에 대해 롤백하지 않으려면
@Transactional(noRollbackFor = CustomBusinessException.class)
public void process() {
    throw new CustomBusinessException("비즈니스 규칙 위반");
}