읽기 전용 트랜잭션 — readOnly=true가 실제로 하는 일과 성능 효과

@Transactional(readOnly = true)
        │
        ▼
┌─────────────────────────────┐
│  Spring Transaction Manager │  → connection.setReadOnly(true)
└──────────┬──────────────────┘
           ▼
┌─────────────────────────────┐
│  Hibernate (JPA 구현체)     │  → FlushMode.MANUAL 전환
│                             │  → 스냅샷 생성 스킵
└──────────┬──────────────────┘
           ▼
┌─────────────────────────────┐
│  JDBC Driver                │  → DB에 읽기 전용 힌트 전달
└──────────┬──────────────────┘
           ▼
┌─────────────────────────────┐
│  Database (MySQL InnoDB 등) │  → 읽기 전용 최적화 적용
└─────────────────────────────┘

// 일반 트랜잭션 — 엔티티 1000건 조회 시
// → 1000개의 스냅샷 객체 생성 (메모리 2배)
// → flush 시 1000번의 필드 비교 (CPU)

// readOnly=true 트랜잭션 — 엔티티 1000건 조회 시
// → 스냅샷 생성 안 함 (메모리 절약)
// → flush 자체가 없음 (CPU 절약)

-- MySQL에서 실제로 실행되는 흐름
SET TRANSACTION READ ONLY;
START TRANSACTION;
SELECT * FROM orders WHERE user_id = 1;
COMMIT;

@Service
@Transactional(readOnly = true) // 기본: 읽기 전용
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;

    // readOnly = true 자동 적용
    public OrderDto getOrder(Long id) {
        return orderRepository.findById(id)
            .map(OrderDto::from)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }

    // readOnly = true 자동 적용
    public List<OrderDto> getOrders(Long userId) {
        return orderRepository.findByUserId(userId).stream()
            .map(OrderDto::from)
            .toList();
    }

    // readOnly = true 자동 적용
    public Page<OrderDto> searchOrders(OrderSearchCondition condition, Pageable pageable) {
        return orderRepository.search(condition, pageable)
            .map(OrderDto::from);
    }

    @Transactional // 쓰기 메서드만 오버라이드
    public OrderDto createOrder(OrderCreateRequest request) {
        Order order = Order.create(request);
        orderRepository.save(order);
        return OrderDto.from(order);
    }

    @Transactional // 쓰기 메서드만 오버라이드
    public void cancelOrder(Long id) {
        Order order = orderRepository.findById(id).orElseThrow();
        order.cancel();
    }
}

// 주의: 클래스 레벨의 rollbackFor가 리셋됨
@Transactional(readOnly = true, rollbackFor = Exception.class) // 클래스 레벨
public class OrderService {

    @Transactional // rollbackFor가 기본값(빈 배열)으로 리셋!
    public void createOrder(...) { }

    @Transactional(rollbackFor = Exception.class) // 이렇게 명시해야 안전
    public void updateOrder(...) { }
}

@Transactional(readOnly = true)
public void dangerousMethod(Long id) {
    Member member = memberRepository.findById(id).orElseThrow();
    member.setName("변경됨");
    // 컴파일 에러? → 없음
    // 런타임 에러? → 없음 (대부분의 경우)
    // DB 반영? → 안 됨 (flush가 MANUAL이라서)
}

요청 시작 ──────── 서비스 호출 ──────── 뷰 렌더링 ──────── 응답
     │              │                    │
     │   @Transactional(readOnly=true)   │
     │         시작 ──── 종료             │
     │                                   │
     └── 영속성 컨텍스트 유지 ────────────┘ (OSIV=true)

# application.yml
spring:
  jpa:
    open-in-view: false  # 운영 환경에서는 끄는 것을 권장

// Before: readOnly 미적용
@Transactional
public List<OrderDto> getOrders(Long userId) {
    return orderRepository.findByUserId(userId).stream()
        .map(OrderDto::from)
        .toList();
}

// After: readOnly 적용
@Transactional(readOnly = true)
public List<OrderDto> getOrders(Long userId) {
    return orderRepository.findByUserId(userId).stream()
        .map(OrderDto::from)
        .toList();
}

public class RoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        // 현재 트랜잭션이 readOnly면 레플리카로 라우팅
        return TransactionSynchronizationManager.isCurrentTransactionReadOnly()
            ? "replica"
            : "primary";
    }
}