ORM과 JPA 기초

public Order findOrderWithItems(Long orderId) {
    Connection conn = null;
    PreparedStatement orderStmt = null;
    PreparedStatement itemStmt = null;
    ResultSet orderRs = null;
    ResultSet itemRs = null;
    
    try {
        conn = dataSource.getConnection();
        
        // 1. 주문 기본 정보 조회
        String orderSql = "SELECT o.*, c.name as customer_name, c.email " +
                         "FROM orders o " +
                         "JOIN customers c ON o.customer_id = c.id " +
                         "WHERE o.id = ?";
        orderStmt = conn.prepareStatement(orderSql);
        orderStmt.setLong(1, orderId);
        orderRs = orderStmt.executeQuery();
        
        Order order = null;
        if (orderRs.next()) {
            order = new Order();
            order.setId(orderRs.getLong("id"));
            order.setStatus(OrderStatus.valueOf(orderRs.getString("status")));
            order.setOrderDate(orderRs.getTimestamp("order_date").toLocalDateTime());
            order.setTotalAmount(orderRs.getBigDecimal("total_amount"));
            
            // Customer 정보 매핑
            Customer customer = new Customer();
            customer.setId(orderRs.getLong("customer_id"));
            customer.setName(orderRs.getString("customer_name"));
            customer.setEmail(orderRs.getString("email"));
            order.setCustomer(customer);
        }
        
        if (order == null) {
            return null;
        }
        
        // 2. 주문 상품 목록 조회 (추가 쿼리!)
        String itemSql = "SELECT oi.*, p.name as product_name " +
                        "FROM order_items oi " +
                        "JOIN products p ON oi.product_id = p.id " +
                        "WHERE oi.order_id = ?";
        itemStmt = conn.prepareStatement(itemSql);
        itemStmt.setLong(1, orderId);
        itemRs = itemStmt.executeQuery();
        
        List<OrderItem> items = new ArrayList<>();
        while (itemRs.next()) {
            OrderItem item = new OrderItem();
            item.setId(itemRs.getLong("id"));
            item.setQuantity(itemRs.getInt("quantity"));
            item.setPrice(itemRs.getBigDecimal("price"));
            
            Product product = new Product();
            product.setId(itemRs.getLong("product_id"));
            product.setName(itemRs.getString("product_name"));
            item.setProduct(product);
            
            items.add(item);
        }
        order.setOrderItems(items);
        
        return order;
        
    } catch (SQLException e) {
        throw new RuntimeException("주문 조회 실패", e);
    } finally {
        // 자원 해제 - 누락 시 커넥션 풀 고갈!
        closeQuietly(itemRs);
        closeQuietly(itemStmt);
        closeQuietly(orderRs);
        closeQuietly(orderStmt);
        closeQuietly(conn);
    }
}

// Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    @Query("SELECT o FROM Order o " +
           "JOIN FETCH o.customer " +
           "JOIN FETCH o.orderItems oi " +
           "JOIN FETCH oi.product " +
           "WHERE o.id = :id")
    Optional<Order> findWithDetailsById(@Param("id") Long id);
}

// Service
@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepository;
    
    @Transactional(readOnly = true)
    public Order findOrderWithItems(Long orderId) {
        return orderRepository.findWithDetailsById(orderId)
            .orElseThrow(() -> new EntityNotFoundException("주문을 찾을 수 없습니다"));
    }
}

dependencies {
    // Spring Data JPA (JPA + Hibernate 포함)
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    
    // 데이터베이스 드라이버
    runtimeOnly 'com.mysql:mysql-connector-j'      // MySQL
    runtimeOnly 'org.postgresql:postgresql'         // PostgreSQL
    runtimeOnly 'com.h2database:h2'                 // H2 (개발/테스트용)
}

// spring-boot-starter-data-jpa가 포함하는 것:
// - spring-data-jpa (Spring Data JPA)
// - hibernate-core (Hibernate)
// - jakarta.persistence-api (JPA 스펙)
// - spring-jdbc, spring-tx (트랜잭션)
// - HikariCP (커넥션 풀)

// 개발자가 작성하는 코드
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByName(String name);
}

// Spring이 런타임에 생성하는 프록시 (개념적 표현)
public class ProductRepositoryProxy implements ProductRepository {
    
    private final EntityManager em;
    private final JpaRepositoryImplementation<Product, Long> target;
    
    // JpaRepository 기본 메서드 위임
    @Override
    public Product save(Product entity) {
        return target.save(entity);
    }
    
    @Override
    public Optional<Product> findById(Long id) {
        return target.findById(id);
    }
    
    // 쿼리 메서드는 메서드 이름을 파싱하여 JPQL 생성
    @Override
    public List<Product> findByName(String name) {
        return em.createQuery(
            "SELECT p FROM Product p WHERE p.name = :name", Product.class)
            .setParameter("name", name)
            .getResultList();
    }
}

// 호출 코드
List<Product> products = productRepository.findByName("노트북");

// 내부 동작 (SimpleJpaRepository + QueryExecutorMethodInterceptor)

1. 프록시의 invoke() 메서드 호출
   ↓
2. 메서드 종류 판별
   - 기본 메서드 (save, findById 등) → SimpleJpaRepository로 위임
   - 쿼리 메서드 (findByName 등) → 쿼리 생성 로직 실행
   ↓
3. 쿼리 메서드인 경우: PartTree 파싱
   "findByName" 분석:
   - find: 조회 (SELECT)
   - By: 조건 시작
   - Name: 필드명 (Product.name)
   ↓
4. JPQL 생성
   "SELECT p FROM Product p WHERE p.name = ?1"
   ↓
5. EntityManager로 쿼리 실행
   em.createQuery(jpql).setParameter(1, "노트북").getResultList()
   ↓
6. 결과 반환

@SpringBootTest
class RepositoryProxyTest {
    
    @Autowired
    private ProductRepository productRepository;
    
    @Test
    void 프록시_객체_확인() {
        // 실제 클래스 출력
        System.out.println("Class: " + productRepository.getClass());
        // 출력: Class: class jdk.proxy3.$Proxy123
        // 또는: Class: class com.sun.proxy.$Proxy123
        
        // 인터페이스 확인
        System.out.println("Interfaces: " + 
            Arrays.toString(productRepository.getClass().getInterfaces()));
        // 출력: [interface com.example.repository.ProductRepository, ...]
        
        // 실제 타겟 확인 (AOP 프록시인 경우)
        if (AopUtils.isAopProxy(productRepository)) {
            Object target = AopProxyUtils.getSingletonTarget(productRepository);
            System.out.println("Target: " + target.getClass());
            // 출력: Target: class org.springframework.data.jpa.repository.support.SimpleJpaRepository
        }
    }
}

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    runtimeOnly 'com.h2database:h2'
    
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:
  
  h2:
    console:
      enabled: true
      path: /h2-console
  
  jpa:
    hibernate:
      ddl-auto: create  # 개발 환경에서만! 운영에서는 validate 또는 none
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        use_sql_comments: true

logging:
  level:
    org.hibernate.SQL: debug
    org.hibernate.orm.jdbc.bind: trace  # 바인딩 파라미터 출력

package com.example.demo.domain;

import jakarta.persistence.*;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.time.LocalDateTime;

@Entity
@Table(name = "products")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 200)
    private String name;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;

    @Column(length = 2000)
    private String description;

    @Column(nullable = false)
    private Integer stockQuantity;

    @Column(updatable = false)
    private LocalDateTime createdAt;

    private LocalDateTime updatedAt;

    // 생성 메서드
    public static Product create(String name, BigDecimal price, 
                                  String description, Integer stockQuantity) {
        Product product = new Product();
        product.name = name;
        product.price = price;
        product.description = description;
        product.stockQuantity = stockQuantity;
        product.createdAt = LocalDateTime.now();
        return product;
    }

    // 비즈니스 메서드
    public void update(String name, BigDecimal price, String description) {
        this.name = name;
        this.price = price;
        this.description = description;
        this.updatedAt = LocalDateTime.now();
    }

    public void addStock(int quantity) {
        this.stockQuantity += quantity;
    }

    public void removeStock(int quantity) {
        int restStock = this.stockQuantity - quantity;
        if (restStock < 0) {
            throw new IllegalStateException("재고가 부족합니다.");
        }
        this.stockQuantity = restStock;
    }
}

package com.example.demo.repository;

import com.example.demo.domain.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.math.BigDecimal;
import java.util.List;

public interface ProductRepository extends JpaRepository<Product, Long> {

    // 메서드 이름으로 쿼리 생성
    List<Product> findByNameContaining(String keyword);
    
    List<Product> findByPriceGreaterThan(BigDecimal price);
    
    List<Product> findByStockQuantityLessThan(Integer quantity);

    // @Query로 JPQL 직접 작성
    @Query("SELECT p FROM Product p WHERE p.price BETWEEN :min AND :max")
    List<Product> findByPriceRange(@Param("min") BigDecimal min, 
                                    @Param("max") BigDecimal max);
}

package com.example.demo.service;

import com.example.demo.domain.Product;
import com.example.demo.repository.ProductRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.List;

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

    private final ProductRepository productRepository;

    // 상품 등록
    @Transactional  // 쓰기 작업은 readOnly = false
    public Long createProduct(String name, BigDecimal price, 
                               String description, Integer stockQuantity) {
        Product product = Product.create(name, price, description, stockQuantity);
        productRepository.save(product);
        return product.getId();
    }

    // 상품 조회
    public Product findProduct(Long id) {
        return productRepository.findById(id)
            .orElseThrow(() -> new IllegalArgumentException("상품을 찾을 수 없습니다. id=" + id));
    }

    // 상품 목록 조회
    public List<Product> findAllProducts() {
        return productRepository.findAll();
    }

    // 상품 수정 - 변경 감지 사용
    @Transactional
    public void updateProduct(Long id, String name, BigDecimal price, String description) {
        Product product = findProduct(id);
        product.update(name, price, description);  // 변경 감지!
        // save() 호출 불필요
    }

    // 상품 삭제
    @Transactional
    public void deleteProduct(Long id) {
        Product product = findProduct(id);
        productRepository.delete(product);
    }

    // 재고 추가
    @Transactional
    public void addStock(Long id, int quantity) {
        Product product = findProduct(id);
        product.addStock(quantity);  // 변경 감지!
    }
}

package com.example.demo.service;

import com.example.demo.domain.Product;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import static org.assertj.core.api.Assertions.*;

@SpringBootTest
@Transactional  // 테스트 후 롤백
class ProductServiceTest {

    @Autowired
    ProductService productService;

    @Test
    void 상품_등록() {
        // given
        String name = "테스트 상품";
        BigDecimal price = new BigDecimal("10000");

        // when
        Long productId = productService.createProduct(name, price, "설명", 100);

        // then
        Product found = productService.findProduct(productId);
        assertThat(found.getName()).isEqualTo(name);
        assertThat(found.getPrice()).isEqualByComparingTo(price);
    }

    @Test
    void 상품_수정_변경감지() {
        // given
        Long productId = productService.createProduct("원래 이름", 
            new BigDecimal("10000"), "설명", 100);

        // when
        productService.updateProduct(productId, "변경된 이름", 
            new BigDecimal("20000"), "변경된 설명");

        // then
        Product found = productService.findProduct(productId);
        assertThat(found.getName()).isEqualTo("변경된 이름");
        assertThat(found.getPrice()).isEqualByComparingTo(new BigDecimal("20000"));
    }

    @Test
    void 재고_부족_예외() {
        // given
        Long productId = productService.createProduct("상품", 
            new BigDecimal("10000"), "설명", 10);

        // when & then
        assertThatThrownBy(() -> {
            Product product = productService.findProduct(productId);
            product.removeStock(11);  // 재고보다 많이 차감
        }).isInstanceOf(IllegalStateException.class)
          .hasMessage("재고가 부족합니다.");
    }
}