1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Entity
public class Member {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    private Team team;
}

@Entity
public class Team {
    @Id @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();
}

1
2
3
4
5
6
7
8
9
10
@Transactional(readOnly = true)
public void printMemberTeams() {
    List<Member> members = memberRepository.findAll();
    // 쿼리 1: SELECT m.id, m.name, m.age, m.team_id FROM member m

    for (Member member : members) {
        System.out.println(member.getName() + " → " + member.getTeam().getName());
        // 각 회원의 team.getName()에서 프록시 초기화 → 추가 쿼리 발생!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// LAZY인데 N+1이 안 발생하는 경우:
// → 연관 엔티티에 접근하지 않을 때뿐이다
List<Member> members = memberRepository.findAll();
for (Member member : members) {
    System.out.println(member.getName());  // team에 접근 안 함 → 추가 쿼리 없음
}

// LAZY인데 N+1이 발생하는 경우:
// → 연관 엔티티에 접근하면 즉시
List<Member> members = memberRepository.findAll();
for (Member member : members) {
    System.out.println(member.getTeam().getName());  // team 접근 → N+1!
}

1
2
3
4
5
6
@Entity
public class Member {
    @ManyToOne(fetch = FetchType.EAGER)  // EAGER로 변경
    @JoinColumn(name = "team_id")
    private Team team;
}

1
2
3
List<Member> members = memberRepository.findAll();
// Spring Data JPA의 findAll()은 내부적으로 JPQL을 실행한다:
// "SELECT m FROM Member m"

1
2
3
4
5
6
7
8
// em.find()는 EAGER를 반영한 JOIN SQL을 생성한다
Member member = em.find(Member.class, 1L);
// → SELECT m.*, t.* FROM member m LEFT JOIN team t ON m.team_id = t.id WHERE m.id = 1

// JPQL/Spring Data JPA는 EAGER를 반영하지 않는다
List<Member> members = memberRepository.findAll();
// → SELECT m.* FROM member m
// → 이후 개별 쿼리로 team 로딩 (N+1)

1
2
3
4
5
6
7
8
9
10
@Transactional(readOnly = true)
public void printTeamMembers() {
    List<Team> teams = teamRepository.findAll();
    // 쿼리 1: SELECT t.id, t.name FROM team t

    for (Team team : teams) {
        System.out.println(team.getName() + ": " + team.getMembers().size());
        // 각 팀의 members 컬렉션 접근 → 추가 쿼리!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY)
    private Member member;

    @ManyToOne(fetch = FetchType.LAZY)
    private Delivery delivery;

    @OneToMany(mappedBy = "order")
    private List<OrderItem> orderItems = new ArrayList<>();
}

1
2
3
4
5
6
7
List<Order> orders = orderRepository.findAll();  // 주문 100건
for (Order order : orders) {
    order.getMember().getName();       // +100 쿼리 (최악의 경우)
    order.getDelivery().getAddress();  // +100 쿼리
    order.getOrderItems().size();      // +100 쿼리
}
// 최악: 1 + 100 + 100 + 100 = 301개 쿼리!

1
2
3
4
5
public interface MemberRepository extends JpaRepository<Member, Long> {

    @Query("SELECT m FROM Member m JOIN FETCH m.team")
    List<Member> findAllWithTeam();
}

1
2
3
4
5
// 다중 @ManyToOne을 한 번에 Fetch Join
@Query("SELECT o FROM Order o " +
       "JOIN FETCH o.member " +
       "JOIN FETCH o.delivery")
List<Order> findAllWithMemberAndDelivery();

1
2
@Query("SELECT t FROM Team t JOIN FETCH t.members")
List<Team> findAllWithMembers();

1
2
@Query("SELECT DISTINCT t FROM Team t JOIN FETCH t.members")
List<Team> findAllWithMembers();

1
2
3
4
// 불가능! 두 개의 컬렉션을 동시에 Fetch Join할 수 없다
@Query("SELECT t FROM Team t JOIN FETCH t.members JOIN FETCH t.projects")
List<Team> findAllWithMembersAndProjects();
// → MultipleBagFetchException 발생!

1
2
3
4
5
6
7
@Entity
public class Team {
    // Set으로 변경하면 MultipleBagFetchException은 피할 수 있다
    // 하지만 카테시안 곱은 여전히 발생하므로 권장하지 않는다
    @OneToMany(mappedBy = "team")
    private Set<Member> members = new HashSet<>();
}

1
2
3
// 위험! 컬렉션 Fetch Join + 페이징
@Query("SELECT t FROM Team t JOIN FETCH t.members")
Page<Team> findAllWithMembers(Pageable pageable);

1
2
3
4
// @ManyToOne Fetch Join + 페이징은 안전하다!
@Query("SELECT m FROM Member m JOIN FETCH m.team")
Page<Member> findAllWithTeam(Pageable pageable);
// → @ManyToOne은 조인해도 행 수가 늘지 않으므로 LIMIT이 정확히 동작한다

1
2
3
// JPA 스펙상 허용되지 않는다
@Query("SELECT t FROM Team t JOIN FETCH t.members m WHERE m.age > 20")
List<Team> findTeamsWithAdultMembers();

1
2
3
4
5
6
7
8
9
10
11
12
// Querydsl에서 동적 Fetch Join
public List<Member> searchMembers(MemberSearchCondition condition) {
    JPAQuery<Member> query = queryFactory
        .selectFrom(member)
        .join(member.team, team).fetchJoin();  // 항상 Fetch Join

    if (condition.getTeamName() != null) {
        query.where(team.name.eq(condition.getTeamName()));
    }

    return query.fetch();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface MemberRepository extends JpaRepository<Member, Long> {

    // JPQL과 함께 사용
    @EntityGraph(attributePaths = {"team"})
    @Query("SELECT m FROM Member m")
    List<Member> findAllWithTeam();

    // 메서드 이름 기반 쿼리에도 적용 가능
    @EntityGraph(attributePaths = {"team"})
    List<Member> findByName(String name);

    // 여러 연관관계를 지정
    @EntityGraph(attributePaths = {"team", "orders"})
    List<Member> findByAgeGreaterThan(int age);
}

1
2
3
// @Query 없이 메서드 이름만으로 N+1 해결
@EntityGraph(attributePaths = {"team"})
List<Member> findByAgeGreaterThan(int age);

1
2
3
4
5
6
7
// Fetch Join: JPQL 작성 필요
@Query("SELECT m FROM Member m JOIN FETCH m.team WHERE m.age > :age")
List<Member> findByAgeFetchJoin(@Param("age") int age);

// EntityGraph: 어노테이션만 추가
@EntityGraph(attributePaths = {"team"})
List<Member> findByAgeGreaterThan(int age);

1
2
3
4
5
6
// Fetch Join은 INNER JOIN → team이 null인 회원은 제외됨
@Query("SELECT m FROM Member m JOIN FETCH m.team")

// EntityGraph는 LEFT OUTER JOIN → team이 null인 회원도 포함됨
@EntityGraph(attributePaths = {"team"})
@Query("SELECT m FROM Member m")

1
2
@EntityGraph(attributePaths = {"team"})
// "team"이 오타나 리팩토링으로 변경되어도 컴파일 에러가 안 난다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Entity
@NamedEntityGraph(
    name = "Member.withTeam",
    attributeNodes = @NamedAttributeNode("team")
)
@NamedEntityGraph(
    name = "Member.withTeamAndOrders",
    attributeNodes = {
        @NamedAttributeNode("team"),
        @NamedAttributeNode(value = "orders", subgraph = "orders-subgraph")
    },
    subgraphs = @NamedSubgraph(
        name = "orders-subgraph",
        attributeNodes = @NamedAttributeNode("orderItems")
    )
)
public class Member {
    @ManyToOne(fetch = FetchType.LAZY)
    private Team team;

    @OneToMany(mappedBy = "member")
    private List<Order> orders = new ArrayList<>();
}

1
2
3
4
5
6
7
public interface MemberRepository extends JpaRepository<Member, Long> {
    @EntityGraph("Member.withTeam")
    List<Member> findByName(String name);

    @EntityGraph("Member.withTeamAndOrders")
    Optional<Member> findDetailById(Long id);
}

1
2
3
4
5
6
@Entity
public class Team {
    @BatchSize(size = 100)
    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();
}

1
2
3
4
5
6
7
@Entity
@BatchSize(size = 100)
public class Team {
    @Id @GeneratedValue
    private Long id;
    private String name;
}

1
2
3
4
5
6
7
8
9
10
@Transactional(readOnly = true)
public void printTeamMembers() {
    List<Team> teams = teamRepository.findAll();
    // 쿼리 1: SELECT t.id, t.name FROM team t
    // → 팀 250개 조회됨

    for (Team team : teams) {
        System.out.println(team.getName() + ": " + team.getMembers().size());
    }
}

1
2
3
4
// 안전: BatchSize + 페이징
Page<Team> teams = teamRepository.findAll(PageRequest.of(0, 10));
// 쿼리 1: SELECT * FROM team LIMIT 10 OFFSET 0  (DB 레벨 페이징!)
// 쿼리 2: SELECT * FROM member WHERE team_id IN (1, 2, ..., 10)

1
2
3
4
5
6
7
8
@Entity
public class Team {
    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();

    @OneToMany(mappedBy = "team")
    private List<Project> projects = new ArrayList<>();
}

1
2
3
4
team1.getMembers().size();  // team1의 members를 초기화하려고 했는데
// BatchSize 때문에 team2, team3, ..., team100의 members도 함께 로딩됨

// team2~100의 members를 실제로 사용하지 않으면 불필요한 데이터 로딩

1
2
3
4
5
6
@Entity
public class Team {
    @Fetch(FetchMode.SUBSELECT)
    @OneToMany(mappedBy = "team")
    private List<Member> members = new ArrayList<>();
}

1
2
3
4
5
6
7
8
9
List<Team> teams = teamRepository.findAll();
// 쿼리 1: SELECT t.id, t.name FROM team t

for (Team team : teams) {
    System.out.println(team.getMembers().size());
}
// 쿼리 2: SELECT m.* FROM member m
//         WHERE m.team_id IN (SELECT t.id FROM team t)
// → 원본 쿼리가 서브쿼리로 들어간다!

1
2
3
// 원본 쿼리가 WHERE 조건, JOIN, ORDER BY를 포함하면
@Query("SELECT t FROM Team t WHERE t.region = :region ORDER BY t.name")
List<Team> findByRegion(@Param("region") String region);

1
2
3
4
5
public record MemberTeamDto(
    Long memberId,
    String memberName,
    String teamName
) {}

1
2
3
4
5
6
public interface MemberRepository extends JpaRepository<Member, Long> {

    @Query("SELECT new com.example.dto.MemberTeamDto(m.id, m.name, t.name) " +
           "FROM Member m JOIN m.team t")
    List<MemberTeamDto> findMemberTeamDtos();
}

1
2
3
@Query("SELECT new com.example.dto.MemberTeamDto(m.id, m.name, t.name) " +
       "FROM Member m JOIN m.team t")
List<MemberTeamDto> findMemberTeamDtos();

1
2
3
4
5
public interface MemberTeamProjection {
    Long getMemberId();
    String getMemberName();
    String getTeamName();
}

1
2
3
@Query("SELECT m.id as memberId, m.name as memberName, t.name as teamName " +
       "FROM Member m JOIN m.team t")
List<MemberTeamProjection> findMemberTeamProjections();

1
public record MemberTeamDto(Long memberId, String memberName, String teamName) {}

1
2
3
4
// 생성자의 파라미터 이름과 SELECT 별칭이 일치해야 한다
@Query("SELECT m.id as memberId, m.name as memberName, t.name as teamName " +
       "FROM Member m JOIN m.team t")
List<MemberTeamDto> findMemberTeamDtos();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public List<MemberTeamDto> searchMembers(MemberSearchCondition condition) {
    return queryFactory
        .select(Projections.constructor(MemberTeamDto.class,
            member.id,
            member.name,
            team.name
        ))
        .from(member)
        .join(member.team, team)
        .where(
            teamNameEq(condition.getTeamName()),
            ageBetween(condition.getAgeLoe(), condition.getAgeGoe())
        )
        .fetch();
}

1
2
3
4
5
6
@Query("SELECT new com.example.dto.OrderItemFlatDto(" +
       "o.id, m.name, oi.productName, oi.price) " +
       "FROM Order o " +
       "JOIN o.member m " +
       "JOIN o.orderItems oi")
List<OrderItemFlatDto> findOrderItemFlat();

1
2
3
4
5
6
7
8
9
10
11
// 1단계: 루트 DTO 조회
@Query("SELECT new com.example.dto.OrderDto(o.id, m.name, o.totalAmount) " +
       "FROM Order o JOIN o.member m " +
       "WHERE o.status = :status")
List<OrderDto> findOrderDtos(@Param("status") OrderStatus status);

// 2단계: orderIds를 모아서 IN 쿼리로 상세 데이터 조회
@Query("SELECT new com.example.dto.OrderItemDto(oi.order.id, oi.productName, oi.price) " +
       "FROM OrderItem oi " +
       "WHERE oi.order.id IN :orderIds")
List<OrderItemDto> findOrderItemDtos(@Param("orderIds") List<Long> orderIds);

1
2
3
4
5
6
7
8
9
10
11
12
// 서비스에서 조합
public List<OrderDto> findOrders(OrderStatus status) {
    List<OrderDto> orders = orderRepository.findOrderDtos(status);
    List<Long> orderIds = orders.stream().map(OrderDto::orderId).toList();
    List<OrderItemDto> items = orderRepository.findOrderItemDtos(orderIds);

    Map<Long, List<OrderItemDto>> itemMap = items.stream()
        .collect(Collectors.groupingBy(OrderItemDto::orderId));

    orders.forEach(o -> o.setOrderItems(itemMap.getOrDefault(o.orderId(), List.of())));
    return orders;
}

1
2
3
4
5
6
7
8
// 주문 목록 화면용 DTO
public record OrderListDto(Long orderId, String memberName, BigDecimal totalAmount) {}

// 주문 상세 화면용 DTO
public record OrderDetailDto(Long orderId, String memberName, String address, ...) {}

// 관리자 대시보드용 DTO
public record OrderAdminDto(Long orderId, String memberName, OrderStatus status, ...) {}

1
2
3
4
5
6
// 주문 목록 API — 가장 자주 호출되는 쿼리
@Query("SELECT o FROM Order o " +
       "JOIN FETCH o.member " +
       "JOIN FETCH o.delivery " +
       "WHERE o.status = :status")
List<Order> findOrdersWithMemberAndDelivery(@Param("status") OrderStatus status);

1
2
3
4
5
6
// 대시보드 API — 통계/집계 데이터
@Query("SELECT new com.example.dto.DashboardDto(" +
       "t.name, COUNT(m), AVG(m.age)) " +
       "FROM Team t LEFT JOIN t.members m " +
       "GROUP BY t.name")
List<DashboardDto> findDashboardData();

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
// 1단계: 아무 최적화 없이 (N+1 발생)
@Transactional(readOnly = true)
public List<OrderResponse> getOrders() {
    List<Order> orders = orderRepository.findAll();  // 1 쿼리
    return orders.stream().map(order -> new OrderResponse(
        order.getId(),
        order.getMember().getName(),      // +N 쿼리
        order.getDelivery().getAddress(), // +N 쿼리
        order.getOrderItems().stream()    // +N 쿼리
            .map(OrderItemResponse::from)
            .toList()
    )).toList();
    // 최악: 1 + 3N 쿼리
}

// 2단계: BatchSize 글로벌 설정 (설정만 추가)
// → 1 + 3 × ⌈N/100⌉ 쿼리 (N=100이면 4개)

// 3단계: ToOne은 Fetch Join으로 최적화
@Query("SELECT o FROM Order o " +
       "JOIN FETCH o.member " +
       "JOIN FETCH o.delivery")
List<Order> findAllWithMemberAndDelivery();

// 서비스: orderItems는 BatchSize로 처리
@Transactional(readOnly = true)
public List<OrderResponse> getOrders() {
    List<Order> orders = orderRepository.findAllWithMemberAndDelivery();
    // 쿼리 1: orders + member + delivery (Fetch Join)
    return orders.stream().map(order -> new OrderResponse(
        order.getId(),
        order.getMember().getName(),      // 이미 로딩됨
        order.getDelivery().getAddress(), // 이미 로딩됨
        order.getOrderItems().stream()    // BatchSize로 IN 쿼리 1개
            .map(OrderItemResponse::from)
            .toList()
    )).toList();
    // 총 2개 쿼리! (Fetch Join 1개 + BatchSize IN 1개)
}

// 4단계 (극한 최적화): DTO 직접 조회
// → 1~2개 쿼리, 필요한 컬럼만 전송, 영속성 컨텍스트 부담 없음

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test
void 주문_조회_시_N_plus_1이_발생하지_않아야_한다() {
    // given
    createTestOrders(50);

    // when
    em.flush();
    em.clear();

    long startCount = getQueryCount();
    List<Order> orders = orderRepository.findAllWithMemberAndDelivery();
    for (Order order : orders) {
        order.getMember().getName();
        order.getDelivery().getAddress();
        order.getOrderItems().size();
    }
    long endCount = getQueryCount();

    // then
    long totalQueries = endCount - startCount;
    assertThat(totalQueries)
        .as("Fetch Join + BatchSize로 쿼리 수가 5개 이하여야 한다")
        .isLessThanOrEqualTo(5);
}