JPA + MyBatis 하이브리드 — 한 프로젝트에서 두 기술을 공존시키는 방법

dependencies {
    // JPA
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // MyBatis
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:3.0.3'

    // DB 드라이버
    runtimeOnly 'com.mysql:mysql-connector-j'
}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        format_sql: true
    open-in-view: false  # OSIV 끄는 걸 권장

# MyBatis 설정
mybatis:
  mapper-locations: classpath:mapper/**/*.xml
  configuration:
    map-underscore-to-camel-case: true

@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;    // JPA
    private final OrderStatMapper orderStatMapper;    // MyBatis

    @Transactional
    public void createOrderWithStats(OrderCreateRequest request) {
        // 1. JPA로 주문 저장
        Order order = Order.from(request);
        orderRepository.save(order);

        // 2. MyBatis로 통계 테이블 갱신
        orderStatMapper.incrementDailyStat(order.getCreatedDate());

        // 둘 다 같은 트랜잭션 — 하나라도 실패하면 둘 다 롤백
    }
}

src/main/java/com/example/order/
├── domain/
│   ├── Order.java              # JPA 엔티티
│   └── OrderItem.java
├── repository/
│   └── OrderRepository.java    # Spring Data JPA Repository
├── mapper/
│   └── OrderStatMapper.java    # MyBatis Mapper 인터페이스
├── dto/
│   ├── OrderCreateRequest.java
│   └── DailyStatDto.java       # MyBatis 조회 결과 DTO
└── service/
    └── OrderService.java       # JPA + MyBatis 조합

src/main/resources/
└── mapper/
    └── order/
        └── OrderStatMapper.xml  # MyBatis XML

@Transactional
public void dangerousUpdate() {
    // 1. JPA로 주문 조회 → 영속성 컨텍스트에 캐싱됨
    Order order = orderRepository.findById(1L).orElseThrow();
    // order.status = "PENDING" (1차 캐시)

    // 2. MyBatis로 상태 직접 변경
    orderStatMapper.updateOrderStatus(1L, "COMPLETED");
    // DB는 "COMPLETED"로 바뀜

    // 3. JPA로 다시 조회
    Order sameOrder = orderRepository.findById(1L).orElseThrow();
    // sameOrder.status = "PENDING" ← 1차 캐시에서 가져오므로 옛날 값!
}

@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;
    private final OrderStatMapper orderStatMapper;
    private final EntityManager em;

    @Transactional
    public DailyStatDto getStatAfterUpdate(Long orderId) {
        // JPA로 엔티티 수정
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.complete();  // 상태 변경 (더티 체킹 대상)

        // MyBatis로 통계 조회 전에 flush — JPA 변경분을 DB에 반영
        em.flush();

        // 이제 MyBatis 쿼리가 최신 데이터를 볼 수 있음
        return orderStatMapper.getDailyStat(order.getCreatedDate());
    }
}

@Transactional
public void updateViaMyBatisAndContinueWithJpa(Long orderId) {
    // MyBatis로 대량 업데이트
    orderStatMapper.bulkUpdateExpiredOrders();

    // 1차 캐시 초기화 — 이후 JPA 조회는 DB에서 새로 가져옴
    em.clear();

    // 최신 데이터로 조회
    Order order = orderRepository.findById(orderId).orElseThrow();
    // 이제 DB 최신 상태가 반영됨
}

// 좋은 예: 기술별로 메서드를 분리
@Transactional
public void processOrder(Long orderId) {
    completeOrder(orderId);       // JPA만 사용
    updateStatistics(orderId);     // MyBatis만 사용 (별도 메서드)
}

private void completeOrder(Long orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    order.complete();
    // 트랜잭션 커밋 시 자동 flush
}

private void updateStatistics(Long orderId) {
    orderStatMapper.incrementCompletedCount(orderId);
}

@Mapper
public interface OrderStatMapper {

    // 일별 통계 조회
    DailyStatDto getDailyStat(@Param("date") LocalDate date);

    // 월별 매출 리포트 (복잡한 조인 + 집계)
    List<MonthlyRevenueDto> getMonthlyRevenue(
        @Param("year") int year,
        @Param("month") int month
    );

    // 대량 상태 업데이트
    int bulkUpdateExpiredOrders();

    // 일별 통계 카운트 증가
    void incrementDailyStat(@Param("date") LocalDate date);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.order.mapper.OrderStatMapper">

    <!-- 월별 매출 리포트 — 다중 조인 + 윈도우 함수 -->
    <select id="getMonthlyRevenue" resultType="com.example.order.dto.MonthlyRevenueDto">
        SELECT
            p.category_name,
            COUNT(o.id) AS order_count,
            SUM(o.total_amount) AS total_revenue,
            /* 전월 대비 증감률 */
            ROUND(
                (SUM(o.total_amount) - LAG(SUM(o.total_amount))
                    OVER (ORDER BY p.category_name))
                / NULLIF(LAG(SUM(o.total_amount))
                    OVER (ORDER BY p.category_name), 0) * 100
            , 2) AS growth_rate
        FROM orders o
        JOIN order_items oi ON o.id = oi.order_id
        JOIN products p ON oi.product_id = p.id
        WHERE YEAR(o.created_at) = #{year}
          AND MONTH(o.created_at) = #{month}
          AND o.status = 'COMPLETED'
        GROUP BY p.category_name
        ORDER BY total_revenue DESC
    </select>

    <!-- 만료 주문 일괄 업데이트 -->
    <update id="bulkUpdateExpiredOrders">
        UPDATE orders
        SET status = 'EXPIRED',
            updated_at = NOW()
        WHERE status = 'PENDING'
          AND created_at &lt; DATE_SUB(NOW(), INTERVAL 30 DAY)
    </update>

    <!-- 일별 통계 증가 — UPSERT 패턴 -->
    <insert id="incrementDailyStat">
        INSERT INTO daily_order_stats (stat_date, order_count)
        VALUES (#{date}, 1)
        ON DUPLICATE KEY UPDATE
            order_count = order_count + 1
    </insert>

</mapper>

// 나쁜 예 — MyBatis가 JPA 엔티티를 반환
@Mapper
public interface BadMapper {
    Order findOrderById(Long id);  // JPA 엔티티를 반환 → 비영속 상태
}

// 좋은 예 — 별도 DTO 사용
@Mapper
public interface GoodMapper {
    OrderDetailDto findOrderDetail(Long id);  // 전용 DTO 반환
}

// JPA Repository 테스트
@DataJpaTest
class OrderRepositoryTest {
    @Autowired
    private OrderRepository orderRepository;
    // ...
}

// MyBatis Mapper 테스트
@MybatisTest  // mybatis-spring-boot-starter-test 의존성 필요
class OrderStatMapperTest {
    @Autowired
    private OrderStatMapper orderStatMapper;
    // ...
}

@Configuration
@EnableJpaRepositories(basePackages = "com.example.**.repository")
@MapperScan(basePackages = "com.example.**.mapper")
public class DataAccessConfig {
    // 대부분 빈 클래스로 충분 — 스캔 경로만 명시
}

logging:
  level:
    # JPA SQL 로깅
    org.hibernate.SQL: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE

    # MyBatis SQL 로깅
    com.example.order.mapper: DEBUG