[Spring Boot] JPA

안녕하세요? 주니하랑 입니다.

오늘은 JPA에  대해 공부 해 보도록 할 것이에요.

바로 시작 해 보겠습니다!

 

코드에 관련한 내용은 주니하랑의 Github에서 확인 하실 수 있습니다!

---

 

 

📋 목차

---

01.[Spring Boot] thymeleaf와 Spring Boot
02.[Spring Boot] Spring Web 개발 기초
03.[Spring Boot] 회원 관리 예제 - Backend
04.[Spring Boot] Service 개발 및 Test Case 작성
05.[Spring Boot] Spring Bean과 의존관계
06.[Spring Boot] Java Code로 직접 Spring Bean 등록
07.[Spring Boot] 등록, 목록 보기 구현하기
08.[Spring Boot] 기존 코드 손 안대고, 설정으로 구현 Class 변경
09.[Spring Boot] 통합 Test
10.[Spring Boot] JPA
11.[Spring Boot] Spring Data JPA
12.[Spring Boot] AOP

 

 

---

 

 

 

 

📌 Java Code로 직접 Spring Bean 등록

---

JPA는 기존의 반복 Code는 물론이고, 기본적인 SQL도 JPA가 직접 만들어서 실행을 해 주기 때문에 개발자가 Code에 SQL문을 작성할 일이 적어지는 것이 특징인 것이에요.

JPA를 사용하면 SQL과 Data 중심의 설계에서 객체 중심의 설계로 패러다임을 전환할 수 있는 것이에요. 그렇게 되면 개발 생산성을 크게 높일 수 있다는 장점이 있답니다!

 

JPA를 사용하기 위해서는 의존성을 추가해줘야 하는 것이에요.

 

 

build.gradle

plugins {
	id 'org.springframework.boot' version '2.5.3'
	id 'io.spring.dependency-management' version '1.0.11.RELEASE'
	id 'java'
}

group = 'hello'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.boot:spring-boot-starter-jdbc'
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation group: 'org.mariadb.jdbc', name: 'mariadb-java-client', version: '2.4.1'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

test {
	useJUnitPlatform()
}

dependencis에 implementation으로 starter-data-jpa를 추가 해 준 것이에요.
이 의존성에는 jdbc 관련 Library도 포함 되어 있기 때문에 starter-jdbc는 지워도 상관 없지만, 주니하랑은 그대로 납둔 것이에요.

그 밑에 있는 내용은 mariaDB를 사용하기 위한 의존성을 추가한 것이랍니다!

 

         👉 Spring Boot JPA Config Insert

resources/application.properties

spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.datasource.url=jdbc:mariadb://[dbms_ip&port]/SpringStudy?useSSL=false&useUnicode=true&serverTimezone=Asia/Seoul&allowPublicKeyRetrieval=true
spring.datasource.username=junyharang
spring.datasource.password=패스워드
spring.jackson.property-naming-strategy=SNAKE_CASE
spring.jpa.show_sql = true
spring.jap.hibernate.ddl-auto=none

⚠️ 주의
Spring Boot 2.4부터는 spring.datasource.username='DB ID' 등과 같이 DB 접속 정보를 입력 해야 한다.

 

show-sql : JPA가 생성하는 SQL문 출력

ddl-auto : JPA는 Table을 자동으로 생성하는 기능을 제공하는데, none을 사용하면 해당 기능을 사용하지 않게 된다.
               none이 아닌 create를 사용하면 Entity 정보를 바탕으로 Table도 직접 생성

 

 

    📍 JPA Entity Mapping

Member.java

package hello.hellospring.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
} // Class 끝

 

         👉 JPA Primary Key Mapping 전략

JPA에는 기본 키 매핑 전략이 크게 4가지가 있는 것이에요.

• 직접 할당 : 기본 키를 Application에서 직접 Entity Class의 @Id 필드에 set
                    @Id만 사용
• 자동 생성 : 대리키 사용 방식
                    @Id 와 @GeneratedValue 같이 사용
  
  • IDENTITY : 기본 키 생성을 DB에 위임 (예 : MySQL, PostgreSQL, Server DB2 등 - Auto_Increment 등)
    
    • @GeneratedValue(strategy = GenerationType.IDENTITY)
    • id 값을 null로 Query를 날리면 DB가 알아서 Auto_Increment를 작동
      • Auto_Increment는 DB에 INSERT SQL Query가 실행된 뒤 id 값을 알 수 있다.
      • id 값은 DB에 값이 들어간 뒤에야 알 수 있다.
      • 문제점: id 값이 DB에 들어간 뒤에 알게 된다면?
        • 영속성 컨텍스트에서 해당 객체가 관리되려면 무조건 Primary Key 값이 있어야 한다.
          이 경우 Primary Key 값은 DB에 들어가봐야 알 수 있다.
        • IDENTITY 전략의 경우 영속성 컨텍스트의 1차 Cache안에 있는 @Id 값은 DB에 넣기 전까지 Setting이 불가
          (JPA 입장에서 Map의 Key 값이 없으닌까 해당 객체의 값을 넣을 수 있는 방법 없음)
      • 해결책
        
        • IDENTITY 전략에서만 예외적으로 entityManager.persist()가 호출되는 시점에 바로 DB에 INSERT Query를 날리는 방법
          다른 전략에서는 이미 id 값을 알고 있기에 commit gksms tlwjadp INSERT Query를 날린다.
        • 위 과정을 통해 entityManager.persist()가 호출되자마자 INSERT Query를 통해 DB에서 식별자를 조회하여
          영속성 컨텍스트의 1차 Cache 값을 넣는다. (SELECT 문을 다시 날리지 않아도 되는 장점)
      • 단점: 한꺼번에 모은 뒤 INSERT 하는 것이 불가
        
        • 이 경우 버퍼링을 해서 Write를 하는 것이 큰 장점이 없기 때문에 크게 신경쓰지 않아도 됨.
        • 하나의 Transaction 안에서 여러 INSERT Query가 Network를 탄다고 해서 엄청나게 성능이 좋아지지 않음

    • // H2
      crate table Member (
      	id varchar(255) generated by default as identity,
          ...
      )
      
      // MySQL
      create table Member (
      	id varchar(255) auto_increment,
          ...
      )​

    • IDENTITY 전략은 entityManager.persist() 시점에 즉시 INSERT SQL Query를 실행하고, DB 식별자 조회
      • JPA는 보통 Transation commit 시점에 INSERT SQL Query 실행
        • IDENTITY 전 
  • SEQUENCE : DB SEQUNCE를 사용하여 기본 키 할당 (예 - Oracle sequence 등)
  • TABLE : 키 생성 Table 사용 (예 : Sequnce을 사용하는 Table을 사용하여 Table의 기본키 저장 및 관리

 

    📍 Entity Manager

EntityManger는 Entity를 관리하는 역할을 수행하는 Class인 것이에요.

EntityManger는 내부에 영속성 컨텍스트(Persistence Context)라는 걸 두어 관리 한답니다!

 

         👉 Persistence Context(영속성 컨텍스트)란?

 

영속성이란 기본적으로 컴퓨터 공학에서 이야기하는 영속성인데, 이것은 비 휘발성으로 볼 수 있는 것이에요.

휘발성은 컴퓨터의 전원이 나가면 Data가 모두 날아지만, 비 휘발성은 그렇지 않은 것이지요.

이런 휘발성, 비 휘발성이란 단어는 저장 장치 (Memory 등)에서 사용하는 용어이고, DB에서는 영속성이라는 단어를 사용한답니다!

 

결국 영속성 컨텍스트는 Entity를 영구히 저장하는 환경이라고 보면 되는 것이에요.

 

JPA는 Entity Manager와 영속성 컨텍스트를 통해 Data의 상태 변화를 감지하고, 필요한 Query를 수행하는 것이에요.

 

mybatis처럼 직접 SQL Query를 작성하거나, JPA를 활용한 개발은 눈에 보이는 것 이상의 차이가 있답니다!

 

그 예로 CRUD로 불리는 기본적 4가지 동작 중 UPDATE는 JPA에 존재하지 않은 것이에요.

하지만, JPA는 Update를 잘 동작 시킨답니다.

이것은 영속성 컨텍스트가 Data의 변경을 감지하여 자동으로 Update Query를 날려주기 때문이에요.

 

 

         👉 JPA 회원 Repository

JpaMemberRepository.java

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

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

public class JpaMemberRepository implements MemberRepository{

    private final EntityManager em;

    public JpaMemberRepository(EntityManager em) {
        this.em = em;
    } // JpaMemberRepository() 끝

    @Override
    public Member save(Member member) {
        em.persist(member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> reulst = em.createQuery("select m from Member m where m.name = :name", Member.class).setParameter("name", name).getResultList();
        return reulst.stream().findAny();
    }

    @Override
    public List<Member> findAll() {
//        List<Member> result = em.createQuery("select m from Member m", Member.class).getResultList();
//        return result;

        // 위의 코드를 단순화 한 것
        return em.createQuery("select m from Member m", Member.class).getResultList();
    }
}

 

 

 

         👉 Service Layer Taransational Insert

MemberService.java

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

// 컴포넌트 스캔 방식의 Service
//@Service
@Transactional
public class MemberService {   // Service 쪽은 비즈니스 용어에 맞게 이름 등을 적어야 한다.
        // 아래 내용에서 repository 객체를 생성하고, Service Test에서 또 new를 통해 Repository를 생성해서 테스트하면 서로 다른 객체를 이용하게 된다.
//  private final MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    // 이 문제를 해결하기 위해서 아래와 같이 생성자를 통해 외부에서 접근할 수 있도록 해 준다.
    private final MemberRepository memberRepository;

    // @Service가 있는 Service가 객체가 생성될 때, @Autowired가 붙은 생성자는 스프링이 컨테이너에서 빈으로 관리할 때, 생성자를 호출하는데, 이 때 MemberService를 넣어준다.
//    @Autowired
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    } // 생성자 끝

    // 회원 가입
    public Long join(Member member) {
        // 같은 이름이 있는 중복 회원 가입 방지
//        Optional<Member> result = memberRepository.findByName(member.getName());
//
//        result.ifPresent(memeber -> { // ifPresent는 해당 값이 Null이 아니고, 어떤 값이 있으면 동작 (Option로 감싸면 사용 가능)
//            throw new IllegalStateException("이미 존재하는 회원 입니다.");
//        });

        // 위에 코드 보다 더 좋은 코드
//        memberRepository.findByName(member.getName()).ifPresent(member1 -> {
//            throw new IllegalStateException("이미 존재하는 회원 입니다.")
//        });

        // 위의 코드를 Method화 하는 것이 좋다.
        // 해당 코드를 모두 선택하고, Command + Option + M을 눌러준다.

        validateDuplicationMember(member);      // 중복 회원 검증

        memberRepository.save(member);
        return member.getId();
    } // join() 끝

    private void validateDuplicationMember(Member member) {
        // 위에 코드 보다 더 좋은 코드
        memberRepository.findByName(member.getName()).ifPresent(member1 -> {
            throw new IllegalStateException("이미 존재하는 회원 입니다.");
        });
    } // validateDuplicationMember() 끝

    public List<Member> findMembers() {
        return memberRepository.findAll();
    } // findMembers() 끝

    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    } // findOne() 끝

} // Class 끝

@Transational은 org.springframework.transaction.annotation.Transactional를 Import하면 되는 것이에요.

Spring은 해당 Class의 Method를 실행할 때, Tansation을 시작하고, Method가 종료되면 Transation을 Commit하는 것이에요.

만약 Run Time Error가 난다면? Roll Back을 한답니다!

JPA를 통한 모든 Data 변경은 Transation안에서 실행해야 한다는 점 기억해야 되는 것이에요!

 

 

         👉 JPA를 사용하도록 Spring Config Modifie

SpringConfig.java

package hello.hellospring;

import hello.hellospring.repository.JdbcMemberRepository;
import hello.hellospring.repository.JdbcTemplateMemberRepository;
import hello.hellospring.repository.JpaMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

@Configuration
public class SpringConfig {

    private DataSource source;
    private EntityManager em;

    @Autowired
    public SpringConfig(DataSource source, EntityManager em) {
        this.source = source;
        this.em = em;
    } // 생성자 끝

    // @Bean : Bean을 내가 직접 만들겠다는 의미; 스프링은 이것을 보고, Bean을 등록하라는 명령으로 인식
    @Bean
    // 아래 Method를 호출하여 Bean에 등록
    public MemberService memberService() {
        // MeberService를 생성하면서 memberRepository를 Spring Bean에 등록 된 주입하여 준다.
        return new MemberService(memberRepository());
    } // memberService() 끝

    @Bean
    public MemberRepository memberRepository() {
//        return new MemoryMemberRepository();
//        return new JdbcMemberRepository(source);
//        return new JdbcTemplateMemberRepository(source);
        return new JpaMemberRepository(em);
    } // memberRepository() 끝
} // Class 끝

 

 

 

---

 

주니하랑의 글이 마음에 드셨나요? 구독과 공감! 그리고, 댓글은 주니하랑에게 많은 힘이 됩니다