Spring Data JPA 심화

// ❌ N+1 — 1번 + N번 추가 쿼리
@Transactional(readOnly = true)
public List<UserDto> getAll() {
    List<User> users = userRepository.findAll();  // 1 query
    return users.stream()
        .map(u -> new UserDto(u.getId(), u.getName(), u.getOrders().size()))
        // 각 user마다 orders 조회 — N queries
        .toList();
}


// ✅ Fetch Join — 1번 쿼리
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();


// ✅ EntityGraph — 어노테이션 기반
@EntityGraph(attributePaths = {"orders"})
List<User> findAll();

@RestController
@RequiredArgsConstructor
public class PostController {
    private final PostRepository repo;

    @GetMapping("/posts")
    public Page<PostDto> getPosts(
        @PageableDefault(size = 20, sort = "createdAt", direction = Sort.Direction.DESC)
        Pageable pageable
    ) {
        return repo.findAll(pageable)
            .map(PostDto::from);
    }
}

// 호출:
// GET /posts?page=0&size=20&sort=createdAt,desc

// build.gradle: implementation 'com.querydsl:querydsl-jpa:5.0.0'

@Repository
@RequiredArgsConstructor
public class PostQueryRepository {
    private final JPAQueryFactory queryFactory;

    public List<Post> search(PostSearchDto search) {
        QPost post = QPost.post;

        return queryFactory
            .selectFrom(post)
            .where(
                titleContains(search.title()),
                authorIdEq(search.authorId()),
                createdAtBetween(search.from(), search.to())
            )
            .orderBy(post.createdAt.desc())
            .limit(search.limit())
            .fetch();
    }

    // null 안전 동적 조건
    private BooleanExpression titleContains(String title) {
        return title != null ? QPost.post.title.contains(title) : null;
    }

    private BooleanExpression authorIdEq(Long id) {
        return id != null ? QPost.post.author.id.eq(id) : null;
    }

    private BooleanExpression createdAtBetween(LocalDate from, LocalDate to) {
        if (from == null && to == null) return null;
        if (from == null) return QPost.post.createdAt.before(to.atStartOfDay());
        if (to == null) return QPost.post.createdAt.after(from.atStartOfDay());
        return QPost.post.createdAt.between(from.atStartOfDay(), to.atStartOfDay());
    }
}

public interface PostSummary {
    Long getId();
    String getTitle();
    String getAuthorName();
    int getCommentCount();
}


@Repository
public interface PostRepository extends JpaRepository<Post, Long> {

    // 인터페이스 기반 — 자동 매핑
    @Query("SELECT p.id as id, p.title as title, p.author.name as authorName, " +
           "       SIZE(p.comments) as commentCount " +
           "FROM Post p")
    List<PostSummary> findAllSummaries();


    // Class 기반 — DTO에 생성자 필요
    @Query("SELECT new com.example.PostSummaryDto(p.id, p.title) FROM Post p")
    List<PostSummaryDto> findAllAsDto();
}

@Repository
public interface UserRepository extends JpaRepository<User, Long>,
                                          JpaSpecificationExecutor<User> {
}


public class UserSpecs {
    public static Specification<User> nameContains(String name) {
        return (root, query, cb) ->
            name == null ? null : cb.like(root.get("name"), "%" + name + "%");
    }

    public static Specification<User> hasRole(Role role) {
        return (root, query, cb) ->
            role == null ? null : cb.equal(root.get("role"), role);
    }

    public static Specification<User> activeOnly() {
        return (root, query, cb) -> cb.equal(root.get("active"), true);
    }
}


// 사용 — 조건 조합
List<User> users = userRepository.findAll(
    Specification.where(UserSpecs.activeOnly())
        .and(UserSpecs.nameContains("alice"))
        .and(UserSpecs.hasRole(Role.USER))
);