[스프링 DB 2편] #5. 데이터 접근 기술 - JPA

[YONGHYNG]

JPA

Java Persistence API 자바 진영의 ORM 기술 표준

• 객체 지향적인 데이터 처리 : 데이터베이스 테이블 객체로 다룸, 객체 지향 설계의 장점을 데이터 계층에서도 유지
• 표준 기술 : JPA는 Java EE 표준, ORM 구현체와 호환 됨

ORM

• Object-relational mapping(객체 관계 매핑)
• 객체는 객체대로 설계, 관계형 데이터베이스는 관계형 데이터베이스대로 설계
• ORM 프레임워크가 중간에서 매핑

JPA는 애플리케이션과 JDBC 사이에서 동작

JPA 동작 - 저장

JPA 동작 - 조회

JPA와 CRUD

• 저장 : jpa.persist(member)
• 조회 : Member member = jpa.find(memberId)
• 수정 : member.setName("변경할 이름")
• 삭제 : jpa.remove(member)

JPA 설정

build.gradle

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'org.springframework.boot:spring-boot-starter-web'

    //JdbcTemplate 추가
    //implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    //MyBatis 추가
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.0'
    //JPA, 스프링 데이터 JPA 추가
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    //H2 데이터베이스 추가
    runtimeOnly 'com.h2database:h2'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    //테스트에서 lombok 사용
    testCompileOnly 'org.projectlombok:lombok'
    testAnnotationProcessor 'org.projectlombok:lombok'

}

application.propeerties

//스프링 부트 3.0 이상 
#JPA log
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.orm.jdbc.bind=TRACE

Item - ORM 매핑

package hello.itemservice.domain;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity //JPA가 사용하는 객체, 엔티티라고 부름
public class Item{

    /**
     * @Id : 테이블의 PK와 해당 필드를 매핑
     * @GeneratedValue(strategy = GenerationType.IDENTITY) : PK 생성 값을 데이터베이스에서 생성하는 IDENTITY 방식 사용(MySQL auto increment)
     * */
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * @Column : 객체의 필드를 테이블의 컬럼과 매핑, @Column 생략시 필드 이름을 테이블 컬럼 이름으로 사용
     * length = 10 == varchar 10
     * */
    @Column(name = "item_name", length = 10)
    private String itemName;
    private Integer price;
    private Integer quantity;

    public Item(){}

    public Item(String itemName, Integer price, Integer quantity){
        this.itemName = itemName;
        this.price = price;
        this.quantity = quantity;
    }
}

JpaItemRepositoryV1

package hello.itemservice.repository.jpa;

import hello.itemservice.domain.Item;
import hello.itemservice.repository.ItemRepository;
import hello.itemservice.repository.ItemSearchCond;
import hello.itemservice.repository.ItemUpdateDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.transaction.Transactional;
import java.util.List;
import java.util.Optional;

@Slf4j
@Repository
/**
 * @Transactional
 * 1. JPA 모든 데이터 변경(등록, 수정, 삭제)는 트랜잭션 안에서 이루어짐
 * 2. 조회는 트랜잭션 없이도 가능, 변경의 경우 일반적으로 서비스 계층에서 트랜잭션 시작하기 때문에 문제 없음
 * 3. JPA에서 데이터 변경시 트랜잭션 필수
 * */
@Transactional
public class JpaItemRepositoryV1 implements ItemRepository {

    /**
     * private final EntityManager em : 스프링을 통해 엔티티 매니저 주입 받음
     * JPA의 모든 동작은 엔티티 매니저를 통해 이루어짐, 엔티티 매니저는 내부 데이터 소스 가지고 DB에 접근 가능
     * */
    private final EntityManager em;

    public JpaItemRepositoryV1(EntityManager em){
        this.em = em;
    }
    /**
     *  JPA가 만들어서 실행한 SQL
     *  insert into item(id, item_name, price, quantity) values (null, ?, ?, ?)
     *  insert into item(id, item_name, price, quantity) values (default, ?, ?, ?)
     *  insert into item(item_name, price, quantity) values (?, ?, ?)
     *  PK 생성 전략을 IDENTITY 로 사용, Item 객체의 id 필드에 데이터베이스가 생성한 PK 값 들어감  
     * */
    @Override
    public Item save(Item item){ //저장
        em.persist(item);
        return item;
    }
    /**
     * update() 수정
     *  JPA가 실행할 SQL : update item set item_name=? , price=?, quantity=?. where id=?
     *  em.update() 같은 메서드 호출이 없어도 실행되는 이유
     *  JPA는 트랜잭션이 커밋되는 시점에, 변경된 엔티티 객체가 있는지 확인, 변경된게 있으면 UPDATE SQL 실행
     * */
    @Override
    public void update(Long itemId, ItemUpdateDto updateParam){ //수정, 변경
        Item findItem = em.find(Item.class, itemId);
        findItem.setItemName(updateParam.getItemName());
        findItem.setPrice(updateParam.getPrice());
        findItem.setQuantity(updateParam.getQuantity());
    }

    @Override
    public Optional<Item> findById(Long id){ //조건 검색
        Item item = em.find(Item.class, id);
        return Optional.ofNullable(item);
    }
     /**
     * JPQL : JPA는 JPQL 이라는 객체지향 쿼리 언어 제공, 여러 데이터를 복잡한 조건으로 조회할 때 사용
     * 실행된 JPQL
     *  select i from Item i where i.itemName like concat('%',:itemName,'%') and i.price <= :maxPrice
     *  JPQL을 통해 실행된 SQL
        select
           item0_.id as id1_0_,
           item0_.item_name as item_nam2_0_,
           item0_.price as price3_0_,
           item0_.quantity as quantity4_0_
        from item item0_
            where (item0_.item_name like ('%'||?||'%'))
         and item0_.price<=?
     * */
    @Override
    public List<Item> findAll(ItemSearchCond cond) { //모두 검색
        String jpql = "select i from Item i";

        Integer maxPrice = cond.getMaxPrice();
        String itemName = cond.getItemName();

        if (StringUtils.hasText(itemName) || maxPrice != null) {
            jpql += " where";
        }

        boolean andFlag = false;
        if (StringUtils.hasText(itemName)) {
            jpql += " i.itemName like concat('%',:itemName,'%')";
            andFlag = true;
        }
        if (maxPrice != null) {
            if (andFlag) {
                jpql += " and";
            }
            jpql += " i.price <= :maxPrice";
        }
        log.info("jpql={}", jpql);

        TypedQuery<Item> query = em.createQuery(jpql, Item.class);
        if (StringUtils.hasText(itemName)) {
            query.setParameter("itemName", itemName);
        }
        if (maxPrice != null) {
            query.setParameter("maxPrice", maxPrice);
        }
        return query.getResultList();
    }
}

JpaConfig

package hello.itemservice.config;

import hello.itemservice.repository.ItemRepository;
import hello.itemservice.repository.jpa.JpaItemRepositoryV1;
import hello.itemservice.service.ItemService;
import hello.itemservice.service.ItemServiceV1;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.persistence.EntityManager;
 
@Configuration //Spring 설정 클래스 정의된 메서드는 @Bean을 통해 스프링 빈으로 등록
public class JpaConfig{

    private final EntityManager em; //JPA에서 데이터베이스와 상호작용을 위한 객체

    public JpaConfig(EntityManager em){
        this.em = em;
    }

    @Bean //스프링 빈으로 등록
    public ItemService itemService(){
        return new ItemServiceV1(itemRepository());
    }

    @Bean
    public ItemRepository itemRepository(){
        return new JpaItemRepositoryV1(em);
    }
}

JPA 예외 변환

@repository 기능

• @repository가 붙은 클래스는 컴포넌트 스캔 대상
• @repository가 붙은 클래스는 예외 변환 AOP 적용 대상
• 스프링과 JPA를 함께 사용하는 경우 스프링은 JPA 예외 변환기 (PersistenceExceptionTranslator) 등록
• 예외 변환 AOP 프록시는 JPA 관련 예외가 발생하면 JPA 예외 변환기를 통해 발생한 예외를 스프링 데이터 접근 예외로 변환

결과

리포지토리에 @repository 애노테이션만 있으면 스프링이 예외 변환 처리하는 AOP 만들어줌

예외 변환 전

예외 변환 후