반응형
Spring Data JPA Query Methods 키워드 완벽 가이드
Spring Data JPA의 Query Methods(메서드 이름 쿼리)는 메서드 이름만으로 JPQL 쿼리를 자동 생성해주는 강력한 기능입니다. 이 글에서는 주요 키워드를 카테고리별로 체계적으로 정리하고, 실제 사용 예시와 JPQL/SQL 변환까지 한눈에 확인할 수 있도록 정리했습니다.
📑 목차
- 핵심 규칙 요약
- 기준 엔티티 (User)
- 논리 연산자 & NULL 체크
- 비교 연산자
- 범위 / 날짜
- 문자열 패턴 (LIKE 계열)
- 집합 연산 (IN 계열)
- 정렬 (OrderBy)
- 불린(Boolean) 조건
- 부정 / 기타
- 실전용 UserRepository 예시 코드
- 사용 패턴 빠른 참조표
✅ 핵심 규칙 요약
Query Methods를 사용하기 전에 아래 기본 규칙을 숙지하세요.
- 기본 형태:
findBy+ 필드명 + 키워드 + (필드명 + 키워드)... - 반환 타입:
List<T>,Optional<T>,Page<T>,Slice<T>,Long(count 용) - 정렬:
OrderBy필드명Asc/OrderBy필드명Desc - 페이징:
Pageable파라미터 추가 시 자동 페이징 지원
📦 기준 엔티티 (User)
이 글의 모든 예시는 아래 User 엔티티를 기준으로 작성되었습니다.
@Entity
public class User {
@Id @GeneratedValue
private Long id;
private String name;
private String email;
private Integer age;
private Boolean active;
private LocalDateTime createdDate;
@Enumerated(EnumType.STRING)
private Role role;
@ManyToOne
private Department department;
}
1. 논리 연산자 & NULL 체크
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 논리 | And |
AND 조건 | findByNameAndAge(String name, Integer age) |
WHERE u.name = ?1 AND u.age = ?2 |
WHERE name = ? AND age = ? |
| 논리 | Or |
OR 조건 | findByNameOrEmail(String name, String email) |
WHERE u.name = ?1 OR u.email = ?2 |
WHERE name = ? OR email = ? |
| NULL | IsNull |
IS NULL | findByEmailIsNull() |
WHERE u.email IS NULL |
WHERE email IS NULL |
| NULL | IsNotNull / NotNull |
IS NOT NULL | findByEmailIsNotNull() |
WHERE u.email IS NOT NULL |
WHERE email IS NOT NULL |
2. 비교 연산자
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 비교 | LessThan |
< 보다 작은 | findByAgeLessThan(Integer age) |
WHERE u.age < ?1 |
WHERE age < ? |
| 비교 | LessThanEqual |
<= 이하 | findByAgeLessThanEqual(Integer age) |
WHERE u.age <= ?1 |
WHERE age <= ? |
| 비교 | GreaterThan |
> 보다 큰 | findByAgeGreaterThan(Integer age) |
WHERE u.age > ?1 |
WHERE age > ? |
| 비교 | GreaterThanEqual |
>= 이상 | findByAgeGreaterThanEqual(Integer age) |
WHERE u.age >= ?1 |
WHERE age >= ? |
3. 범위 / 날짜
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 범위 | Between |
두 값 사이 | findByAgeBetween(Integer min, Integer max) |
WHERE u.age BETWEEN ?1 AND ?2 |
WHERE age BETWEEN ? AND ? |
| 날짜 | After |
특정 시점 이후 | findByCreatedDateAfter(LocalDateTime t) |
WHERE u.createdDate > ?1 |
WHERE created_date > ? |
| 날짜 | Before |
특정 시점 이전 | findByCreatedDateBefore(LocalDateTime t) |
WHERE u.createdDate < ?1 |
WHERE created_date < ? |
4. 문자열 패턴 (LIKE 계열)
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 문자열 | Like |
LIKE 그대로 사용 | findByNameLike(String pattern) |
WHERE u.name LIKE ?1 |
WHERE name LIKE ? |
| 문자열 | NotLike |
NOT LIKE | findByNameNotLike(String pattern) |
WHERE u.name NOT LIKE ?1 |
WHERE name NOT LIKE ? |
| 문자열 | StartingWith |
접두어 검색 (값%) | findByNameStartingWith(String prefix) |
WHERE u.name LIKE ?1% |
WHERE name LIKE '김%' |
| 문자열 | EndingWith |
접미어 검색 (%값) | findByNameEndingWith(String suffix) |
WHERE u.name LIKE %?1 |
WHERE name LIKE '%동' |
| 문자열 | Containing |
포함 검색 (%값%) | findByNameContaining(String keyword) |
WHERE u.name LIKE %?1% |
WHERE name LIKE '%길동%' |
| 문자열 | IgnoreCase |
대소문자 무시 | findByNameIgnoreCase(String name) |
WHERE UPPER(u.name) = UPPER(?1) |
WHERE UPPER(name) = UPPER(?) |
💡 IgnoreCase 조합 팁: IgnoreCase는 다른 키워드와 조합해서 사용할 수 있습니다.
예:findByNameContainingIgnoreCase(String keyword)→WHERE UPPER(name) LIKE UPPER('%keyword%')
5. 집합 연산 (IN 계열)
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 집합 | In |
여러 값 중 하나 | findByRoleIn(List<Role> roles) |
WHERE u.role IN ?1 |
WHERE role IN (?, ?, ?) |
| 집합 | NotIn |
여러 값이 아닌 것 | findByRoleNotIn(List<Role> roles) |
WHERE u.role NOT IN ?1 |
WHERE role NOT IN (?, ?, ?) |
6. 정렬 (OrderBy)
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 정렬 | OrderBy |
특정 필드 기준 정렬 | findByAgeOrderByCreatedDateDesc(Integer age) |
WHERE u.age = ?1 ORDER BY u.createdDate DESC |
WHERE age = ? ORDER BY created_date DESC |
| 정렬 | Asc |
오름차순 | OrderByNameAsc |
ORDER BY u.name ASC |
ORDER BY name ASC |
| 정렬 | Desc |
내림차순 | OrderByNameDesc |
ORDER BY u.name DESC |
ORDER BY name DESC |
⚠️ OrderBy 주의사항: OrderBy는 반드시 조건(WHERE 절) 뒤에 붙는 형식으로 사용합니다.
예:findByDepartmentOrderByCreatedDateDesc(Department dept)
7. 불린(Boolean) 조건
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL 변환 | SQL 변환 |
|---|---|---|---|---|---|
| 불린 | True |
= true | findByActiveTrue() |
WHERE u.active = true |
WHERE active = true |
| 불린 | False |
= false | findByActiveFalse() |
WHERE u.active = false |
WHERE active = false |
8. 부정 / 기타
| 카테고리 | 키워드 | 설명 | Java 메서드 예시 | JPQL / SQL 예시 |
|---|---|---|---|---|
| 부정 | Not |
값이 다른 경우 (<>) | findByNameNot(String name) |
WHERE u.name <> ?1 / WHERE name <> ? |
| 고유 | Distinct |
중복 제거 | findDistinctByEmail(String email) |
SELECT DISTINCT u.email FROM User u WHERE ... |
| 순위 | First / Top |
상위 N개만 | findFirstByOrderByCreatedDateDesc()findTop5ByAgeGreaterThan(Integer age) |
ORDER BY ... + LIMIT (DB 페이징 사용) |
🔧 실전용 UserRepository 예시 코드
위 표의 키워드를 실제로 사용하는 UserRepository 전체 예시입니다. 복사해서 Spring Boot 프로젝트에 바로 적용해 보세요.
public interface UserRepository extends JpaRepository<User, Long> {
// ---------- 기본 / 논리 ----------
List<User> findByName(String name);
List<User> findByNameAndAge(String name, Integer age);
List<User> findByNameOrEmail(String name, String email);
// ---------- NULL ----------
List<User> findByEmailIsNull();
List<User> findByEmailIsNotNull();
// ---------- 비교 ----------
List<User> findByAgeLessThan(Integer age);
List<User> findByAgeLessThanEqual(Integer age);
List<User> findByAgeGreaterThan(Integer age);
List<User> findByAgeGreaterThanEqual(Integer age);
// ---------- 범위 / 날짜 ----------
List<User> findByAgeBetween(Integer min, Integer max);
List<User> findByCreatedDateAfter(LocalDateTime t);
List<User> findByCreatedDateBefore(LocalDateTime t);
// ---------- 문자열 패턴 ----------
List<User> findByNameLike(String pattern); // 직접 % 포함
List<User> findByNameNotLike(String pattern);
List<User> findByNameStartingWith(String prefix); // prefix%
List<User> findByNameEndingWith(String suffix); // %suffix
List<User> findByNameContaining(String keyword); // %keyword%
List<User> findByNameContainingIgnoreCase(String keyword); // 대소문자 무시
// ---------- 집합(IN) ----------
List<User> findByRoleIn(Collection<Role> roles);
List<User> findByRoleNotIn(Collection<Role> roles);
// ---------- 정렬 ----------
List<User> findByDepartmentOrderByCreatedDateDesc(Department dept);
List<User> findByAgeOrderByNameAsc(Integer age);
// ---------- 불린 ----------
List<User> findByActiveTrue();
List<User> findByActiveFalse();
// ---------- 부정 / 기타 ----------
List<User> findByNameNot(String name);
List<User> findDistinctByEmail(String email);
Optional<User> findFirstByOrderByCreatedDateDesc();
List<User> findTop5ByAgeGreaterThan(Integer age);
}
⚡ 사용 패턴 빠른 참조표
| 목적 | 사용 키워드 |
|---|---|
| 단순 검색 | findBy필드명, findBy필드명And다른필드 |
| 문자열 검색 | Containing, StartingWith, EndingWith, Like |
| 날짜/숫자 범위 | Between, LessThan, GreaterThanEqual |
| 정렬 | OrderBy필드명Asc / Desc |
| 집합 조건 | In, NotIn |
| 상태값 (Boolean) | True, False |
| 대소문자 무시 | IgnoreCase 조합 |
| NULL 체크 | IsNull, IsNotNull |
| 상위 N개 | First, Top |
| 중복 제거 | Distinct |
이 포스팅 하나만 북마크해두면, Spring Data JPA의 Query Method 키워드를 개발 중 언제든 빠르게 참조할 수 있습니다. 실무에서 자주 쓰이는 패턴 위주로 구성했으니 바로 적용해 보세요!
반응형