Spring Data JPA 활용

public interface MemberRepository extends JpaRepository<Member, Long> {
    // JpaRepository가 제공하는 메서드들 (자동 구현)
}

// === 저장 ===
Member member = new Member("kim");
memberRepository.save(member);           // INSERT or UPDATE (merge)
memberRepository.saveAndFlush(member);   // save + 즉시 flush
memberRepository.saveAll(List.of(m1, m2)); // 여러 건 저장

// === 조회 ===
Optional<Member> member = memberRepository.findById(1L);
List<Member> members = memberRepository.findAll();
List<Member> members = memberRepository.findAllById(List.of(1L, 2L, 3L));
boolean exists = memberRepository.existsById(1L);
long count = memberRepository.count();

// === 삭제 ===
memberRepository.delete(member);         // 단건 삭제
memberRepository.deleteById(1L);         // ID로 삭제
memberRepository.deleteAll();            // 전체 삭제 (N개 쿼리)
memberRepository.deleteAllInBatch();     // 전체 삭제 (1개 쿼리)
memberRepository.deleteAllByIdInBatch(List.of(1L, 2L)); // 배치 삭제

// === JPA 특화 ===
memberRepository.flush();                // 영속성 컨텍스트 flush
Member ref = memberRepository.getReferenceById(1L); // 프록시 반환

// ID를 직접 할당하는 경우 Persistable 구현
@Entity
public class Item implements Persistable<String> {
    
    @Id
    private String id;  // 직접 할당
    
    @CreatedDate
    private LocalDateTime createdDate;
    
    @Override
    public String getId() {
        return id;
    }
    
    @Override
    public boolean isNew() {
        // createdDate가 null이면 새로운 엔티티
        return createdDate == null;
    }
}

// 사용
Item item = new Item("ITEM-001");
itemRepository.save(item);  // persist() 호출 (SELECT 없음)

// 실제 주입되는 객체 확인
@Repository
public class MemberService {
    
    @Autowired
    private MemberRepository memberRepository;
    
    public void checkProxy() {
        System.out.println(memberRepository.getClass());
        // 출력: class jdk.proxy3.$Proxy123
        // 또는: class com.sun.proxy.$Proxy123
    }
}

public interface MemberRepository extends JpaRepository<Member, Long> {
    
    // === 기본 조회 ===
    List<Member> findByUsername(String username);
    // SELECT * FROM member WHERE username = ?
    
    Optional<Member> findByEmail(String email);
    // SELECT * FROM member WHERE email = ?
    
    // === 복합 조건 ===
    List<Member> findByUsernameAndAge(String username, int age);
    // SELECT * FROM member WHERE username = ? AND age = ?
    
    List<Member> findByUsernameOrEmail(String username, String email);
    // SELECT * FROM member WHERE username = ? OR email = ?
    
    // === 비교 연산 ===
    List<Member> findByAgeGreaterThan(int age);
    // SELECT * FROM member WHERE age > ?
    
    List<Member> findByAgeGreaterThanEqual(int age);
    // SELECT * FROM member WHERE age >= ?
    
    List<Member> findByAgeLessThan(int age);
    // SELECT * FROM member WHERE age < ?
    
    List<Member> findByAgeBetween(int start, int end);
    // SELECT * FROM member WHERE age BETWEEN ? AND ?
}

public interface MemberRepository extends JpaRepository<Member, Long> {
    
    // === 단건 조회 ===
    Member findByUsername(String username);           // null 가능
    Optional<Member> findByEmail(String email);       // Optional 권장
    
    // === 컬렉션 조회 ===
    List<Member> findByAgeGreaterThan(int age);       // 빈 리스트 반환
    Collection<Member> findByTeamName(String name);
    Set<Member> findByStatus(Status status);
    
    // === 페이징 ===
    Page<Member> findByAge(int age, Pageable pageable);   // 카운트 쿼리 포함
    Slice<Member> findByTeam(Team team, Pageable pageable); // 카운트 없음
    List<Member> findByUsername(String username, Pageable pageable);
    
    // === 스트림 ===
    Stream<Member> findAllByAgeGreaterThan(int age);  // try-with-resources 필수
    
    // === 비동기 ===
    @Async
    Future<Member> findByEmail(String email);
    @Async
    CompletableFuture<Member> findByUsername(String username);
    
    // === 카운트/존재 여부 ===
    long countByAge(int age);
    boolean existsByEmail(String email);
    
    // === 삭제 ===
    long deleteByUsername(String username);           // 삭제된 건수 반환
    List<Member> removeByAge(int age);                // 삭제된 엔티티 반환
}

// 엔티티 구조
@Entity
public class Member {
    @ManyToOne
    private Team team;
    
    @Embedded
    private Address address;
}

@Entity
public class Team {
    private String name;
}

@Embeddable
public class Address {
    private String city;
    private String street;
}

// Repository
public interface MemberRepository extends JpaRepository<Member, Long> {
    
    // 연관 엔티티 프로퍼티 접근 (Team.name)
    List<Member> findByTeamName(String teamName);
    // SELECT m FROM Member m WHERE m.team.name = ?
    
    // Embedded 프로퍼티 접근
    List<Member> findByAddressCity(String city);
    // SELECT m FROM Member m WHERE m.address.city = ?
    
    // 깊은 중첩도 가능
    List<Member> findByTeamLeaderName(String leaderName);
    // SELECT m FROM Member m WHERE m.team.leader.name = ?
}

// ⚠️ 주의: 프로퍼티 이름 충돌
// Member에 teamName 필드가 있으면 team.name이 아닌 teamName으로 해석
// 해결: findByTeam_Name(String name) - 언더스코어로 명시적 구분

public interface MemberRepository extends JpaRepository<Member, Long> {
    
    // === First, Top으로 결과 제한 ===
    Member findFirstByOrderByAgeDesc();              // 가장 나이 많은 1명
    Member findTopByOrderByAgeDesc();                // 동일
    
    List<Member> findFirst3ByOrderByAgeDesc();       // 상위 3명
    List<Member> findTop10ByTeamName(String name);   // 팀별 상위 10명
    
    // === 정렬 ===
    List<Member> findByTeamNameOrderByAgeDesc(String teamName);
    List<Member> findByTeamNameOrderByAgeDescUsernameAsc(String teamName);
    
    // === Sort 파라미터 사용 ===
    List<Member> findByTeamName(String teamName, Sort sort);
}

// Sort 사용 예시
Sort sort = Sort.by(Sort.Direction.DESC, "age");
List<Member> members = memberRepository.findByTeamName("teamA", sort);

// 복합 정렬
Sort sort = Sort.by(
    Sort.Order.desc("age"),
    Sort.Order.asc("username")
);

// TypeSafe Sort (권장)
Sort sort = Sort.by(
    Sort.Order.desc("age").nullsLast(),
    Sort.Order.asc("username").ignoreCase()
);

public interface MemberRepository extends JpaRepository<Member, Long> {
    
    // 이름 기반 파라미터 (권장)
    @Query("select m from Member m where m.username = :username and m.age = :age")
    List<Member> findByUsernameAndAge(
        @Param("username") String username, 
        @Param("age") int age
    );
    
    // 컬렉션 파라미터
    @Query("select m from Member m where m.username in :names")
    List<Member> findByNames(@Param("names") Collection<String> names);
}

// build.gradle (Spring Boot 3.x + Gradle)
dependencies {
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    annotationProcessor 'com.querydsl:querydsl-apt:5.0.0:jakarta'
    annotationProcessor 'jakarta.annotation:jakarta.annotation-api'
    annotationProcessor 'jakarta.persistence:jakarta.persistence-api'
}

// Q클래스 생성 위치 설정
def querydslDir = "$buildDir/generated/querydsl"

sourceSets {
    main.java.srcDirs += [ querydslDir ]
}

tasks.withType(JavaCompile) {
    options.annotationProcessorGeneratedSourcesDirectory = file(querydslDir)
}

@Configuration
public class QueryDslConfig {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Bean
    public JPAQueryFactory jpaQueryFactory() {
        return new JPAQueryFactory(entityManager);
    }
}

@Repository
@RequiredArgsConstructor
public class MemberQueryRepository {
    
    private final JPAQueryFactory queryFactory;
    
    // 기본 조회
    public List<Member> findAll() {
        return queryFactory
            .selectFrom(member)
            .fetch();
    }
    
    // 조건 조회
    public List<Member> findByUsername(String username) {
        return queryFactory
            .selectFrom(member)
            .where(member.username.eq(username))
            .fetch();
    }
    
    // 정렬
    public List<Member> findAllOrderByAge() {
        return queryFactory
            .selectFrom(member)
            .orderBy(member.age.desc())
            .fetch();
    }
    
    // 페이징
    public List<Member> findWithPaging(int offset, int limit) {
        return queryFactory
            .selectFrom(member)
            .offset(offset)
            .limit(limit)
            .fetch();
    }
}

public List<MemberDto> searchMembers(MemberSearchCondition condition) {
    return queryFactory
        .select(new QMemberDto(
            member.id,
            member.username,
            member.age,
            team.name
        ))
        .from(member)
        .leftJoin(member.team, team)
        .where(
            usernameEq(condition.getUsername()),
            teamNameEq(condition.getTeamName()),
            ageGoe(condition.getAgeGoe()),
            ageLoe(condition.getAgeLoe())
        )
        .fetch();
}

// 동적 조건 메서드들
private BooleanExpression usernameEq(String username) {
    return hasText(username) ? member.username.eq(username) : null;
}

private BooleanExpression teamNameEq(String teamName) {
    return hasText(teamName) ? team.name.eq(teamName) : null;
}

private BooleanExpression ageGoe(Integer ageGoe) {
    return ageGoe != null ? member.age.goe(ageGoe) : null;
}

private BooleanExpression ageLoe(Integer ageLoe) {
    return ageLoe != null ? member.age.loe(ageLoe) : null;
}

// 조건 조합
private BooleanExpression ageBetween(Integer ageGoe, Integer ageLoe) {
    return ageGoe(ageGoe).and(ageLoe(ageLoe));
}

// ToOne 관계 Fetch Join
public List<Member> findAllWithTeam() {
    return queryFactory
        .selectFrom(member)
        .join(member.team, team).fetchJoin()
        .fetch();
}

// ToMany 관계 Fetch Join (주의: 페이징 불가)
public List<Team> findAllWithMembers() {
    return queryFactory
        .selectFrom(team)
        .join(team.members, member).fetchJoin()
        .distinct()
        .fetch();
}

// 동적 Fetch Join
public List<Member> findMembers(boolean fetchTeam) {
    JPAQuery<Member> query = queryFactory.selectFrom(member);
    
    if (fetchTeam) {
        query.join(member.team, team).fetchJoin();
    }
    
    return query.fetch();
}

public Page<MemberDto> searchMembersPage(
        MemberSearchCondition condition, 
        Pageable pageable) {
    
    // 데이터 조회
    List<MemberDto> content = queryFactory
        .select(new QMemberDto(
            member.id,
            member.username,
            member.age,
            team.name
        ))
        .from(member)
        .leftJoin(member.team, team)
        .where(
            usernameEq(condition.getUsername()),
            teamNameEq(condition.getTeamName())
        )
        .offset(pageable.getOffset())
        .limit(pageable.getPageSize())
        .fetch();
    
    // Count 쿼리 최적화
    JPAQuery<Long> countQuery = queryFactory
        .select(member.count())
        .from(member)
        .leftJoin(member.team, team)
        .where(
            usernameEq(condition.getUsername()),
            teamNameEq(condition.getTeamName())
        );
    
    // 마지막 페이지면 count 쿼리 생략
    return PageableExecutionUtils.getPage(content, pageable, countQuery::fetchOne);
}