step 1

상위 데이터 1개를 가져오는 구문

List<User> findTop1ByName(String name);

테스트 코드

System.out.println("findTop1ByName: " + userRepository.findTop1ByName("martin"));

확인

마지막 한 줄을 가져오는 구문(정렬 후에 마지막 한줄을 가져온다.)

// 역순으로 정렬해서 마지막 한줄을 출력하는 예제
List<User> findTopByNameOrderByIdDesc(String name)

테스트 코드

System.out.println("findTopByNameOrderByIdDesc: " + userRepository.findTopByNameOrderByIdDesc("martin"));

확인

다중 정렬을 사용하는 예제

// Id의 역순, Email의 정순으로 정렬하여 출력
List<User> findFirstByNameOrderByIdDescEmailAsc(String name);

테스트 코드

System.out.println("findFirstByNameOrderByIdDescEmailAsc: " + userRepository.findFirstByNameOrderByIdDescEmailAsc("martin"));

확인

사용자가 직접 정렬 기준을 정하는 예제

// 사용자가 정렬기준을 파라미터로 전달하는 예제
List<User> findFirstByName(String name, Sort sort);

테스트 코드

System.out.println("findFirstByName: " + userRepository.findFirstByName("martin", Sort.by(Sort.Order.asc("email"))));

확인

정렬 메소드를 별도로 작성하여 코드를 줄이는 방법

정렬 메소드 작성

private Sort getSort(){
        return Sort.by(
                Sort.Order.desc("id"),
                Sort.Order.asc("email"),
                Sort.Order.desc("createdAt")
        );
    }

테스트 코드

// 정렬을 메소드로 이용하여 사용하는 방법
System.out.println("findFirstByName: " + userRepository.findFirstByName("martin", getSort()));

확인

해당 컬럼이 null이 아닌 값을 찾는 예제

List<User> findByIdIsNotNull();

테스트 코드

System.out.println("findByIdIsNotNull: " + userRepository.findByIdIsNotNull());

원하는 값과 일치하는 데이터 출력 예제(in)

List<User> findByNameIn(List<String> names);

테스트 코드 (배열로 파리미터를 입력한다.)

System.out.println("findByNameIn: " + userRepository.findByNameIn(Lists.newArrayList("martin","dennis")));

사용자 지정문자를 포함한 데이터를 출력하는 예제(like)

    List<User> findByNameIn(List<String> names);
    List<User> findByNameStartingWith(String name);
    List<User> findByNameEndingWith(String name);
    List<User> findByNameContains(String name);
    List<User> findByNameLike(String name);

테스트 코드

// 뒷부분에 자동으로 %를 붙여준다.
System.out.println("findByNameStartingWith: " + userRepository.findByNameStartingWith("mar"));
// 앞부분에 자동으로 %를 붙여준다.
System.out.println("findByNameEndingWith: " + userRepository.findByNameEndingWith("mar"));
// 앞뒤로 자동으로 %를 붙여준다.
System.out.println("findByNameContains: " + userRepository.findByNameContains("mar"));
// 사용자가 원하는 위치에 %를 붙여주어야 한다.
System.out.println("findByNameLike: " + userRepository.findByNameLike("%art%"));

확인

findByNameStartingWith

findByNameEndingWith

findByNameContains

findByNameLike

jpa 메소드를 생성할 때 by 이하의 절에 where 조건에 추가할 변수명을 입력하여 사용한다.

and / or 조건 예제

// and, or 조건문
    List<User> findByEmailAndName(String email, String name);
    List<User> findByEmailOrName(String email, String name);

테스트 코드

System.out.println("findByEmailAndName: " + userRepository.findByEmailAndName("martin@fastcampus.com","martin"));
System.out.println("findByEmailOrName: " + userRepository.findByEmailOrName("martin@fastcampus.com","dennis"));

확인

특정 숫자 이상의 값을 구하는 예제

After, Before를 이용하여 값을 구할 수 있다.

List<User> findByCreatedAtAfter(LocalDateTime yesterday);
List<User> findByIdAfter(Long id);

테스트 코드

// 어제 날짜를 입력
// 어제 날짜 이후로 출력
System.out.println("findByCreatedAtAfter: " + userRepository.findByCreatedAtAfter(LocalDateTime.now().minusDays(1L)));
// ID가 4초과인 데이터 출력        
System.out.println("ffindByIdAfter: " + userRepository.findByIdAfter((4L)));

Before와 After는 = 을 포함하지 않는다.

따라서 호환가능한 다른 키워드를 이용할 수 있다.

List<User> findByCreatedAtGreaterThan(LocalDateTime yesterday);
List<User> findByCreatedAtGreaterThanEqual(LocalDateTime yesterday);

테스트 코드

System.out.println("findByCreatedAtGreaterThan: " + userRepository.findByCreatedAtGreaterThan(LocalDateTime.now().minusDays(1L)));
System.out.println("findByCreatedAtGreaterThanEqual(: " + userRepository.findByCreatedAtGreaterThanEqual(LocalDateTime.now().minusDays(1L)));

equals를 포함한 데이터 출력 확인

특정범위 사이의 데이터를 출력하는 예제 (Between)

양 끝단의 데이터를 함께 출력한다.

List<User> findByCreatedAtBetween(LocalDateTime yesterday, LocalDateTime tomorrow);
List<User> findByIdBetween(Long id1, Long id2);

테스트 코드

// 어제와 오늘 사이의 데이터를 출력
System.out.println("findByCreatedAtBetween(: " + userRepository.findByCreatedAtBetween(LocalDateTime.now().minusDays(1L), LocalDateTime.now().plusDays(1L)));
// Id값이 1과 3 사이의 데이터 출력
System.out.println("findByIdBetween(: " + userRepository.findByIdBetween(1L, 3L));

위와 같은 결과 같을 가져오는 쿼리

List<User> findByIdGreaterThanEqualAndIdLessThanEqual(Long id1, Long id2);

테스트 코드 작성

// 위와 같은 결과 값을 출력하는 테스트 코드
System.out.println("findByIdGreaterThanEqualAndIdLessThanEqual: " + userRepository.findByIdGreaterThanEqualAndIdLessThanEqual(1L, 3L));

결과 확인

기존의 작성한 UserRepository에 메소드를 구현

참고 사이트: https://ykh6242.tistory.com/105

findBy뒤에 Dto 변수를 입력하면 자동으로 해당변수의 해당하는 데이터를 찾아온다.

UserName으로 데이터를 찾는 메소드 구현

아래와 같은 리턴타입으로 변경할 수도 있다.

Test 코드 작성

데이터를 입력하는 부분을 Dto() 함수로 따로 뺐다.

    // 테스트를 진행하기 전에 데이터를 입려하는 부분
    public void Dto(){
        // 기본 데이터 생성 jpa를 이용하여 insert 된다.
        userRepository.save(new User("martin", "martin@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
        userRepository.save(new User("dennis", "dennis@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
        userRepository.save(new User("sophia", "sophia@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
        userRepository.save(new User("james", "james@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
        userRepository.save(new User("martin2", "martin2@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
    }

사용자 이름으로 데이터를 찾는 테스트 코드 작성

    @Test
    void select(){
        // 데이터 입력
        Dto();
        // user name으로 결과 가져오기
        System.out.println(userRepository.findByName("martin"));
    }

이메일로 데이터를 찾는 예제

    User findByEmail(String email);

    User getByEmail(String email);

    User readByEmail(String email);

    User queryByEmail(String email);

    User searchByEmail(String email);

    User streamByEmail(String email);

    User findUserByEmail(String email);

테스트 코드

// 이메일을 이용하여 데이터 검색
        // 아래 내용 모두 동일한 쿼리와 결과값이 나오는걸 확인 할 수 있다.
        System.out.println("findByEmail: " + userRepository.findByEmail("martin@fastcampus.com"));
        System.out.println("getByEmail: " + userRepository.getByEmail("martin@fastcampus.com"));
        System.out.println("readByEmail: " + userRepository.readByEmail("martin@fastcampus.com"));
        System.out.println("queryByEmail: " + userRepository.queryByEmail("martin@fastcampus.com"));
        System.out.println("searchByEmail: " + userRepository.searchByEmail("martin@fastcampus.com"));
        System.out.println("streamByEmail: " + userRepository.streamByEmail("martin@fastcampus.com"));
        System.out.println("findUserByEmail: " + userRepository.findUserByEmail("martin@fastcampus.com"));

원하는 컬럼의 갯수를 지정하여 데이터 내보내기

By를 기준으로 앞부분에 컬럼의 갯수를 입력하고 뒷부분에 Dto변수명을 입력한다.

List<User> findFirst1ByName(String name);
List<User> findTop1ByName(String name);

테스트 코드 작성

System.out.println("findTop1ByName: " + userRepository.findTop1ByName("martin"));
System.out.println("findFirst11ByName: " + userRepository.findFirst1ByName("martin"));

쿼리 확인(where절에 limit 조건이 추가된 것을 확인할 수 있다.)

원하는 데이터를 찾은 후 찾은 데이터를 수정한 후 다시 저장하여 조회하는 예제

 		// update 예제
        User user = userRepository.findById(1L).orElse(null);
        user.setEmail("update@naver.com");
        userRepository.save(user);
        Optional<User> user1 = userRepository.findById(1L);
        System.out.println(user1.toString());

flush(), saveAndFlush(): 쿼리를 조절하는 메소드가 아니라 DB 반영 시점을 조절하는 메소드이다.

//        userRepository.save(new User("new martin", "Newmartin2@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
        userRepository.saveAndFlush(new User("new martin", "Newmartin2@fastcampus.com", LocalDateTime.now(), LocalDateTime.now()));
//        userRepository.flush();
        userRepository.findAll().forEach(System.out::println);

count(): 데이터 갯수를 구하는 메소드

// 데이터 갯수 구하기
        long count = userRepository.count();
        System.out.println(count);

existsById(): 해당 아이디 값이 존재하는지 구하는 메소드

// 데이터 존재 유무 체크
        boolean exists = userRepository.existsById(2L);
        System.out.println(exists);

내부적으로 count를 해줘서 그걸로 존재유무를 판단한다.

원하는 데이터를 삭제하는 메소드

delete(): 실행전에 조회를 한번 실행한 후 삭제 진행 그 후 재 조회 한다.

userRepository.delete(userRepository.findById(1L).orElseThrow(RuntimeException::new));

deleteById(): 실행전에 조회를 한번 실행한 후 삭제 진행 그 후 재 조회 한다.

userRepository.deleteById(2L);
userRepository.findAll().forEach(System.out::println);

확인

deleteAll(): 모든 데이터를 삭제하는 메소드, 반복적으로 delete가 동작한다.

userRepository.deleteAll();

deleteAll() 메소드를 이용해서 원하는 데이터를 골라서 삭제하는 방법

userRepository.deleteAll(userRepository.findAllById(Lists.newArrayList(1L, 3L)));

deleteAllInBatch(): 각각 delete를 하지 않고 or 문법을 이용해서 한번에 delete를 진행한다.

모든 데이터를 삭제하는 방법, 이전에 데이터를 조회하지 않고 삭제를 진행한다.

userRepository.deleteAllInBatch();

원하는 데이터를 삭제하는 방법

userRepository.deleteAllInBatch(userRepository.findAllById(Lists.newArrayList(1L, 4L)));

페이징처리하기 위한 메소드

PageRequest.of(): 0부터 시작되는 사용자가 원하는 페이지의 데이터를 가져오는 메소드

        // 페이징 처리 예제
        Page<User> users = userRepository.findAll(PageRequest.of(0,3));
        System.out.println("현재 페이지: " + users);
        System.out.println("총 데이터 수: " + users.getTotalElements());
        System.out.println("총 페이지 수: "+ users.getTotalPages());
        System.out.println("현재 페이지 데이터 수: " + users.getNumberOfElements());
        System.out.println("정렬 상태: " + users.getSort());
        System.out.println("현재 페이지 데이터 크기: " + users.getSize());
        users.getContent().forEach(System.out::println);

검색을 처리하는 메소드: example

        // 데이터 검색 예제
        ExampleMatcher matcher = ExampleMatcher.matching()
                // 검색을 제외
                .withIgnorePaths("name")
                // like 조건을 이용하여 검색, endsWith 을 이용하여 마지막 문장이 일치하는지 확인
                .withMatcher("email", endsWith());
        Example<User> example = Example.of(new User("ma", "fastcampus.com"),matcher);
        userRepository.findAll(example).forEach(System.out::println);

        // 정확히 일치하는지 확인 and 연산 이용
        Example<User> example2 = Example.of(new User("martin", "martin@fastcampus.com"));
        userRepository.findAll(example2).forEach(System.out::println);

        User user = new User();
        user.setEmail("ma");
        user.setName("da");
        ExampleMatcher matcher1 = ExampleMatcher.matching().withMatcher("email", contains());
        Example<User> example1 = Example.of(user, matcher1);
        userRepository.findAll(example1).forEach(System.out::println);