[스프링부트] 스프링 데이터 JPA

JPA ( Java Persistent API )

JPA는 마이바티스보다 가벼운 애로 레파지토리를 쉽게 구현할 수 있도록 도와준다.

레가시와 부트 둘 다 사용 가능하고 JPA는 자동으로  SQL 을 만들어준다. 

 

새로운 스키마 생성

workbench 를 사용하면 sql을 작성하지않고도 만들수 있다.

왼쪽 위부분에 드럼통 모양을 클릭한 뒤 위와같이 스키마를 생성해주고 Apply로 적용시켜준다.

테이블이 없는 상태로 만들어놓고 설정 작업을 한다.

 

JPA 설정 하기 application.properties소스코드

application.properties에 다음의 코드들을 추가적으로 작성한다.

# JPA configurations
# Create table config
# Create : Create after Drop // update : Create and Update
spring.jpa.hibernate.ddl-auto=update

ddl을 자동으로 작성해주는 설정 코드 ( ddl - 테이블의 생성 수정 삭제 등 )

# checked database original function
spring.jpa.generate-ddl=false

우리가 쓰는 DB가 지원하는 특수기능들을 사용할 것인가를 설정하는것 false

# checked show SQL log
spring.jpa.show-sql=true

SQL 로그를 볼 것인가

# usage DBMS
spring.jpa.database=mysql

내가 사용할 DB설정

# select log level
logging.level.org.hibernate=info

로그 레벨 설정

 

VO클래스 생성

JPA를 사용하게 되면 VO자체가 테이블, DB의 엔티티가 된다.

패키지와 클래스명 확인

 

Board.java 소스코드

package com.springboot.boot01.domain;
 
import java.sql.Timestamp;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
 
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;
 
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
 
@Setter
@Getter
@ToString
@Entity
@Table(name="boot_board")
public class Board {
 
    //테이블이 만들어졌다고 가정하고 필드들을 나열한다.
    /*
     * # @GeneratedValue : 숫자형 주요키에 부여할 속성
     * 1. AUTO : JPA 자체에서 시퀀스 기능을 부여
     * 2. SEQUENCE : ORACLE의 시퀀스 기능을 부여
     * 3. IDENTITY : MYSQL의 AUTO_INCREMENT 기능을 부여
     */
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer boardNo;
    private String title;
    private String writer;
    private String content;
    @CreationTimestamp    //INSERT시에 현재시간을 읽어서 저장
    private Timestamp regDate;
    @UpdateTimestamp    //UPDATE시에 현재시간을 읽어서 저장
    private Timestamp updateDate;
    
}

 

Test

테스트를 위해 클래스를 만들어준다. (위치 주의)

단위별로 볼 수 있다.

 

BoardRepositoryTest.java 소스코드

package com.springboot.boot01.test.board;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class BoardRepositoryTest {
    
    
    @Test
    //테이블 생성 테스트
    public void test() {
        //테이블 생성
    }
    
 
}

실행하면 콘솔창에서 Hibernate: ~~ 실행이 된걸 확인할 수 있다.

DB에 테이블이 생성된 것을 확인 할 수 있다.

 

CRUD 테스트 (인터페이스 생성)

마이바티스의 경우에는 mapper를 만들어서 사용했었다.

부트에서도 마찬가지로 인터페이스를 생성한다. 

 

BoardRepository.java 소스코드

package com.springboot.boot01.repository;
 
import java.util.List;
 
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
 
import com.springboot.boot01.domain.Board;
 
//CRUD
//CrudRepository<엔티티클래스, 프라이머리키의 타입>
public interface BoardRepository extends CrudRepository<Board, Integer> {
 
    /*
        # Spring Data JPA는 메서드의 이름만으로 원하는 SELECT문을 실행시킬 수 있습니다.
        # 쿼리 메서드는 이름규칙에 맞게 지어줘야 정확하게 작동합니다.
        ex) find + 엔티티클래스명 + By + 컬럼명
    
        -- 참조문서
        # https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods.query-creation
     */
    
    //제목으로 게시물 검색 처리
    List<Board> findBoardByTitle(String title);
    
    //작성자로 게시물 검색 처리 - 쓰는게 확실하긴 한데 엔티티 클래스명 생략 가능! 
    List<Board> findByWriter(String writer);
 
    
    
    
    
    
    /*
        # 검색처리 시에 LIKE 구문 처리
        1. 단순  LIKE: findBy~~Like
        2. 키워드 + %: findBy~~StartingWith
        3. % + 키워드: findBy~~EndingWith
        4. % + 키워드 + %: findBy~~Containing
     */
    
    //글 내용으로 검색  LIKE %keyword% 처리
    List<Board> findByContentContaining(String keyword);
    
    
    
    
    
    
    
    
    /*
     * # WHERE 절에서 AND, OR 조건 처리
     * - 쿼리메소드 네이밍시에 And, Or 문자열을 추가한다.
     * - 파라미터도 지정한 속성 수만큼 맞춰줘야 한다.
     */
    
    //제목 + 내용으로 검색
    List<Board> findByTitleContainingOrContentContaining(String title, String content);
 
    
    
    
    
    
    
    
    
    /*
        # 부등호 조건 처리
        1. > : GreaterThan
        2. < : LessThan
     */
   
   //ex: title Like %?% AND board_no > ?
   List<Board> findByTitleContainingAndBoardNoGreaterThan(String title, Integer boardNo);
    
    
   
   
   
   
   
   
   
    
    /*
     * # ORDER BY 절 사용
     * - OrderBy + 속성명 + Asc, Desc 를 사용한다.
     */
    
    //title LIKE %?% ORDER BY board_no DESC
    List<Board> findByTitleContainingOrderByBoardNoDesc(String title);
    
    
    
    
    
    
    
    
    
    
    /*
     * # 페이징 처리
     * - 위와 같은 쿼리 메서드를 사용할 때 모든 쿼리 메서드의 마지막 파라미터로 페이지 처리 구문인
     *      LIMIT 절을 지원하는 Pageable 인터페이스와 정렬처리를 지원하는  Sort 인터페이스를
     *   JPA에서 지원하고 있다.
     */
    
    //WHERE board_no > ? ORDER BY board_no DESC LIMIT ?, ?
    List<Board> findByBoardNoGreaterThanOrderByBoardNoDesc(Integer boardNo, Pageable paging);
    
    //Pageable 객체로 정렬 처리하기
    //List<Board> findByBoardNoGreaterThan(Integer boardNo, Pageable paging);
    
    
    
    
    
    
    
    
    
    
    
    
    /*
        # 페이징 처리의 편의성을 개선한 Page<T> 리턴타입
        - 페이징 처리 결과데이터를 List<T>타입으로 얻는 것보다 Page<T>타입으로 얻을 경우
                 전체 게시물 수나, 이전, 다음페이지 활성화 여부 등 더 많은 정보를 얻어낼 수 있습니다.
    */
    Page<Board> findByBoardNoGreaterThan(Integer boardNo, Pageable paging);
    
    
    
    
    
    
    
    
    
    
    
    /////////////////////////////////////////////////////////////////////////////
    
    
    //필요한 컬럼만 조회해야할 경우(위에것들은 무조건 select * from 임) : @Query 사용
    @Query("select b.title, b.content from Board b " //엔티티 명을 적어주어야하고 그 별칭도 적어준다.
            + "where b.title like %?1% and b.boardNo > 0 order by b.boardNo desc") 
    List<Object[]> findByTitle2(String title);
    
    @Query("select b.title, b.content from Board b " //엔티티 명을 적어주어야하고 그 별칭도 적어준다.
            + "where b.title like %?1% and b.boardNo > 0 order by b.boardNo desc") 
    Page<Object[]> findByTitle3(String title, Pageable paging);
    
    
    
}
 

 

BoardRepositoryTest.java 전체 소스코드

package com.springboot.boot01.test.board;
 
import java.util.Arrays;
import java.util.List;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;
 
import com.springboot.boot01.domain.Board;
import com.springboot.boot01.repository.BoardRepository;
 
 
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class BoardRepositoryTest {
    
    @Autowired
    private BoardRepository repo;
    
    @Test
    //테이블 생성 테스트
    public void test() {
        //테이블 생성
    }
    
    @Test
    //게시물 삽입 테스트
    public void testInsert() {
        Board article = new Board();
        article.setTitle("테스트1중!");
        article.setContent("테스트1 중이랍니다~~!!!");
        article.setWriter("김테스트1");
        
        //insert구문은 save()메서드를 사용!
        repo.save(article);
        System.out.println("게시글 등록 성공!");
    }
    
    @Test
    //하나의 게시물 조회 테스트
    public void testSelectOne() {
        //하나의 게시물을 조회할 때는  findById().get()를 사용!
        Board article = repo.findById(2).get();
        System.out.println(article);
    }
    
    @Test
    //모든 게시물 조회 테스트
    public void testSelectAll() {
        
        for(Board article : repo.findAll()) {
            System.out.println(article);
        }    
    }
    
    @Test
    //게시물 수정 테스트
    public void testUpdate() {
        //먼저 수정할 게시물을 조회한다.
        Board article = repo.findById(1).get();
        
        //수정 데이터를 입력
        article.setTitle("제목수정");
        article.setWriter("작성자변경!");
        
        //수정 반영 : save()메서드
        repo.save(article);
        System.out.println("수정 완료!");
    }
    
    @Test
    //게시물 삭제 테스트
    public void testDelete() {
        repo.deleteById(2);
        System.out.println("삭제 완료!");
    }
    
    //게시물 200개 집어넣기
    @Test
    public void testInser200() {
        for(int i=1; i<=200; i++) {
            Board article = new Board();
            article.setTitle("제목테스트" + i);
            article.setContent("내용 테스트" + i + "중 입니다...");
            article.setWriter("작성자"+i);
            
            repo.save(article);
        }
    }
 
    
    @Test
    //제목으로 검색 테스트
    public void testByTitle() {
//        List<Board> list = repo.findBoardByTitle("제목테스트3");
//        for(Board board : list) {
//            System.out.println(board);
//        }
        
        //java8부터 사용가능한 문법
        //제목으로 검색 테스드
        repo.findBoardByTitle("제목테스드7")
            .forEach(board -> System.out.println(board));
        //작성자로 검색 테스트
        repo.findByWriter("작성자7")
            .forEach(b -> System.out.println(b));
    }
    
    
    //WHERE LIKE 절 테스트
    @Test
    public void testByContaining() {
//    repo.findByContentContaining("3")
//        .forEach(b -> System.out.println(b));
//
//    repo.findByTitleContainingOrContentContaining("33", "99")
//        .forEach(b -> System.out.println(b));
//
//    repo.findByTitleContainingAndBoardNoGreaterThan("3", 100)
//        .forEach(b -> System.out.println(b));
 
    repo.findByTitleContainingOrderByBoardNoDesc("44")
    .forEach(b -> System.out.println(b));
        
        
    }
    
    
    //페이징 테스트
    @Test
    public void testByPaging() {
        
        //페이지 정보 객체 생성
        //of메서드의 첫번째 파라미터 값 : 페이지 번호 - 1, 두번째 파라미터 값: 한 페이지에 보여줄 게시물 수
//        Pageable paging = PageRequest.of(0, 10);
//        
//        repo.findByBoardNoGreaterThanOrderByBoardNoDesc(0, paging)
//            .forEach(b -> System.out.println(b));
        
        //메서드 명이 너무 기니까 정렬은 Pageable 객체로 정렬 처리하기
//        Pageable paging = PageRequest.of(0, 10, Sort.Direction.DESC, "boardNo");
//        repo.findByBoardNoGreaterThan(0, paging)
//            .forEach(b -> System.out.println(b));
        
        
        //Page<T>리턴 타입을 사용한 페이징 처리
        Pageable paging = PageRequest.of(0, 10, Sort.Direction.DESC, "boardNo");
        Page<Board> result = repo.findByBoardNoGreaterThan(0, paging);
        
        System.out.println("Page size : " + result.getSize());
        System.out.println("Total size : " + result.getTotalPages());
        System.out.println("Total count : " + result.getTotalElements());
        System.out.println("Prex : " + result.hasPrevious());
        System.out.println("Next : " + result.hasNext());
        
        List<Board> articles = result.getContent();
        articles.forEach(b -> System.out.println(b));
        
    }
    
    
    @Test
    public void testByTitle2() {
//        repo.findByTitle2("33")
//            .forEach(arr -> System.out.println(Arrays.toString(arr)));
        
        Pageable paging = PageRequest.of(0, 10);
        Page<Object[]> result = repo.findByTitle3("66", paging);
        
        result.getContent().forEach(arr -> System.out.println(Arrays.toString(arr)));
    }
    
}