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

[YuDeokRin]

5️⃣ JPA 적용1 - 개발

@Data
@Entity // JPA객체로 만들어주는 annotation
//@Table(name = "item") // 객체명이랑 같으면 생략 가능
public class Item {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) //GenerationType.IDENTITY -> DB에서 값을 넣어주는 전략
    private Long id;

    @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;
    }
}

@Column 을 생략할 경우 필드의 이름을 테이블 컬럼 이름으로 사용한다.
참고로 지금처럼 스프링 부트와 통합해서 사용하면 필드 이름을 테이블 컬럼 명으로 변경할 때 객체 필드의 카멜 케이스를 테이블 컬럼의 언 더스코어로 자동으로 변환해준다.

itemName item_name ,따라서 위 예제의 @Column(name = "item_name") 를생략해도 된다.

• JpaItemRepositoryV1

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.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import java.util.List;
import java.util.Optional;

@Slf4j
@Repository
@Transactional // Jpa의 모든 데이터 변경은 트랜잭션 안에서 일어난다.
public class JpaItemRepository implements ItemRepository {

    private final EntityManager em; // JPA에 저장하고 조회하고, 스프링에서 자동으로 만들어줌

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

    @Override
    public Item save(Item item) {
        em.persist(item);
        return item;
    }

    @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);
    }

    @Override
    public List<Item> findAll(ItemSearchCond cond) {
        String jpql = "SELECT i FROM Item i";

        List<Item> result = em.createQuery(jpql, Item.class)
                .getResultList();
        return result;
    }
}

• private final EntityManager em
  • 생성자를 보면 스프링을 통해 엔티티 매니저(EntityManager)라는 것을 주입 받은 것을 확인
  • JPA의 모든 동작은 엔티티 매니저를 통해서 이루어진다. 엔티티 매니저는 내부에 데이터소스를 가지고 있고 데이터 베이스에 접근할 수 있다.
• @transactional
  • JPA의 모든 데이터 변경(등록, 수정, 삭제)은 트랜잭션 안에서 이루어져야 한다. 조회는 트랜잭션이 없어도 가능
  • 변경의 경우 일반적으로 서비스 계층에서 트랜잭션을 시작하기 때문에 문제가 없다.
  • 일반적으로는 비즈니스 로직을 시작하는 서비스 계층에 트랜잭션을 걸어주는 것이 맞다.

참고 : JPA를 설정하려면 EntityManagerFactory , JPA 트랜잭션 매니저(JpaTransactionManager), 데이터 소스 등등 다양한 설정을 해야 한다.

• JpaItemRepositoryV1
  • 동적으로 처리할 때

 @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";
            }J
            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

@Configuration
public class JpaConfig {

    private final EntityManager em;

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

    @Bean
    ItemService itemService() {
        return new ItemServiceV1(itemRepository());
    }

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

}

• ItemServiceApplication - 변경

//@Import(MyBatisConfig.class)
@Import(JpaConfig.class)
@SpringBootApplication(scanBasePackages = "hello.itemservice.web")
public class ItemServiceApplication {}

• 테스트 실행으로 확인 후 → 애플리케이션 실행보고 해보기

6️⃣ JPA 적용2 - 리포지토리 분석

➡️save() - 저장

• em.persist(item)
  • JPA에서 객체를 테이블에 저장할 때는 엔티티 매니저가 제공하는 persist()메서드를 사용하면 됨.

@Override
public Item save(Item item) {
     em.persist(item);
     return item;
}

• JPA가 만들고 실행한 SQL
  • JPA가 만든 SQL을 보면 id값이 빠져있다 → PK 키 생성 전략을 IDENTITY로 사용했기 때문이다.

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 매핑 참고

@Entity
public class Item {
     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
}

➡️update() - 수정

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());
}

• JPA가 만들어서 실행한 SQL

update item set item_name=?, price=?, quantity=? where id=?

• em.update() 같은 메서드를 전혀 호출하지 않음. 어떻게 Update SQL이 실행되는 것일까?
  • JPA는 트랜잭션이 커밋되는 시점에, 변경된 엔티티 객체가 있는지 확인한다. 특정 엔티티 객체가 변경된 경우에는 UPDATE SQL을 실행한다.
• 트랜잭션 커밋 시점에 JPA가 변경된 엔티티 객체를 찾아서 UPDATE SQL을 수행한다고 이해하면 된다.
• 테스트의 경우 마지막에 트랜잭션이 롤백되기 때문에 JPA는 UPDATE SQL을 실행하지 않는다. 테스트에서 UPDATE SQL을 확인하려면 @Commit 을 붙이면 확인할 수 있다.

➡️ findById() - 단건 조회

public Optional<Item> findById(Long id) {
     Item item = em.find(Item.class, id);
     return Optional.ofNullable(item);
}

• JPA에서 엔티티 객체를 PK를 기준으로 조회할 때는 find()를 사용하고 조회 타입과, PK값을 주면 된다.

• JPA가 다음과 같이 조회 SQL을 만들고 실행하고 결과를 객체로 바로 변환해준다.

• JPA가 만들어서 실행한 SQL

select
   item0_.id as id1_0_0_,
   item0_.item_name as item_nam2_0_0_,
   item0_.price as price3_0_0_,
   item0_.quantity as quantity4_0_0_
 from item item0_
 where item0_.id=?

➡️ findAll - 목록 조회

public List<Item> findAll(ItemSearchCond cond) {
		String jpql = "select i from Item i";
		//동적 쿼리 생략
		TypedQuery<Item> query = em.createQuery(jpql, Item.class); 
		return query.getResultList();
}

• JPQL

  • JPA는 JPQL(Java Persistence Query Language) 객체지향 쿼리 언어를 제공한다.
  • 주로 여러 데이터를 복잡한 조건으로 조회할 때 사용한다.
  • 엔티티 객체를 대상으로 하기 때문에 from 다음에 Item 엔티티 객체 이름이 들어간다. 엔티티 객체와 속성의 대소문자는 구분해야 한다.

• 실행된 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<=?

• 파라미터
  • JPQL에서 파라미터는 다음과 같이 입력
    • where price <= :maxPrice
  • 파라미터 바인딩
    • query.setParameter("maxPrice", maxPrice)

7️⃣ JPA 적용3 - 예외 변환

• JPA의 경우 예외가 발생하면 JPA 예외가 발생하게 된다.

@Repository
@Transactional
public class JpaItemRepositoryV1 implements ItemRepository {

		private final EntityManager em; // 순수한 JPA기술이고, 스프링과 관계 X, 엔티티 매니저는 예외가 발생하면 JPA 관련 예외를 발생시킨다.
	
		
		@Override
    public Item save(Item item) {
        em.persist(item);
        return item;
    }
		
}

✅@repository

• @repository 가 붙은 클래스는 컴포넌트 스캔의 대상이 된다.

• @repository 가 붙은 클래스는 예외 변환 AOP의 적용 대상이 된다.

  • 스프링과 JPA를 함께 사용하는 경우 스프링은 JPA 예외 변환기(PersistenceExceptionTranslator)를 등록한다.
  • 예외 변환 AOP 프록시는 JPA 관련 예외가 발생하면 JPA 예외 변환기를 통해 발생한 예외를 스프링 데이터 접근 예외로 변환한다.

• 예외 변환 후

• 결과적으로 리포지토리에 @Repository 애노테이션만 있으면 스프링이 예외 변환을 처리하는 AOP를 만들어준다.