😀
fistkim TECH BLOG
  • Intro
  • 강의
    • Reactive Programming in Modern Java using Project Reactor
      • Reactor execution model 1
      • Reactor execution model 2
      • Reactor execution model 3 - parallelism
      • Reactor execution model 4 - overview
      • Transform
      • Combine
      • Side Effect Methods
      • Exception/Error handling
      • retry, retryWhen, repeat
      • BackPressure
      • Cold & Hot Streams
    • NEXTSTEP 클린코드 with java 9기
      • 정리노트
    • NEXTSTEP DDD 세레나데 2기
      • CH01 도메인 주도 설계 이해
      • CH02 크게 소리 내어 모델링 하기
      • CH03 도메인 주도 설계 기본 요소
      • CH04 도메인 주도 설계 아키텍처
      • CH05 도메인 이벤트
    • NEXTSTEP 인프라 공방 1기
      • 망 분리하기
      • 통신 확인하기
      • 도커 컨테이너 이해하기
      • [미션 1] 서비스 구성하기 실습
      • [미션 2] 서비스 배포하기 실습
      • 서버 진단하기
      • 어플리케이션 진단하기
      • [미션 3] 서비스 운영하기
      • 웹 성능 진단하기
      • 부하 테스트
      • k6
      • [미션 4] 성능 테스트
      • 리버스 프록시 개선하기
      • 캐싱 활용하기
      • [미션 5] 화면 응답 개선하기
      • Redis Annotation 및 설정
      • 인덱스 이해하기 & DB 튜닝
      • [미션 6-1] 조회 성능 개선하기
      • [미션 6-2] DB 이중화 적용
    • NEXTSTEP 만들면서 배우는 Spring 3기
      • CH01 올바른 방향 바라보기
      • CH02 HTTP 이해 - 웹 서버 구현
        • HTTP 파싱
        • HTTP 웹 서버 구현
      • CH03 MVC - @MVC 프레임워크 구현
        • Servlet 다시 짚기
        • Cookie, Session 다시 짚기
        • MVC 프레임워크 구현
      • CH04 나만의 라이브러리 구현
      • CH05 DI - DI 프레임워크 구현
      • CH06 Aspect OP
    • 스프링 시큐리티
      • 스프링 시큐리티 아키텍처
      • WebAsyncManagerIntegrationFilter
      • SecurityContextPersistenceFilter
      • HeaderWriterFilter
      • CsrfFilter
      • (+) 스프링 시큐리티 + JWT
      • (+) 마치며
    • 더 자바, 코드를 조작하는 다양한 방법
      • CH01 JVM 이해하기
      • (+) 클래스 로더 이해하기
      • CH02 바이트 코드 분석 및 조작
      • (+) jacoco
      • CH03 리플렉션
      • CH04 다이나믹 프록시
      • CH05 애노테이션 프로세서
    • 더 자바, 애플리케이션을 테스트하는 다양한 방법
      • CH01 JUnit 5
      • CH02 Mockito
      • (+) Spy vs Mock
      • CH03 도커와 테스트
      • CH04 성능 테스트
      • (+) VisualVM
      • (+) 테스트 자동화
      • CH05 운영 이슈 테스트
      • CH06 아키텍처 테스트
    • 모든 개발자를 위한 HTTP 웹 기본 지식
      • CH01 인터넷 네트워크
      • CH02 HTTP 기본
      • CH03 HTTP 메서드 속성
      • CH04 HTTP 메서드 활용
      • CH05 HTTP 상태코드
      • CH06 HTTP 헤더1 - 일반 헤더
      • CH07 HTTP 헤더2 - 캐시와 조건부 요청
      • (+) HTTPS 원리
    • 스프링 프레임워크 핵심 기술
      • CH01 IOC 컨테이너
      • CH02 AOP
      • (+) 스프링 의존성 관리
      • (+) 생성자 주입 장점
    • 코딩으로 학습하는 GoF의 디자인 패턴
      • 객체 생성
        • 싱글톤 패턴
        • 팩토리 메소드 패턴
        • 추상 팩토리 패턴
        • 빌더 패턴
        • 프로토타입 패턴
      • 구조
        • 어댑터 패턴
        • 브릿지 패턴
        • 컴포짓 패턴
      • 행동
        • (작성중)
    • 실전 Querydsl
      • CH01 프로젝트 환경구성
      • CH02 예제 도메인 모델
      • CH03 기본문법
      • CH04 중급 문법
      • CH05 실무활용 (스프링 데이터 JPA와 Querydsl)
      • CH06 스프링데이터JPA 가 제공하는 Querydsl 기능
      • (+) 별칭(alias)
      • (+) Slice 쿼리
    • 스프링 데이터 JPA
      • CH01 핵심개념이해 1
      • CH02 핵심개념이해 2
      • CH03 핵심개념이해 3
      • CH04 Spring Data Common
      • CH05 Spring Data JPA
    • 실전! 스프링 부트와 JPA 활용2 - API 개발과 성능 최적화
      • CH01 지연 로딩과 조회 성능 최적화
      • CH02 컬렉션 조회 최적화
      • CH03 전체 정리
    • 초보를 위한 쿠버네티스 안내서
      • CH01 쿠버네티스 시작하기
      • CH02 쿠버네티스 알아보기
      • CH03 쿠버네티스 실습 준비
      • CH04 쿠버네티스 기본 실습
    • Flutter Provider Essential
      • CH01 Introduction
      • CH02 Provider Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Bloc Essential
      • CH01 Introduction
      • CH02 Bloc Overview
      • CH03 TODO App
      • CH04 Weather App
      • CH05 Firebase Authentication App
    • Flutter Advanced Course - Clean Architecture With MVVM
      • CH01 Introduction
      • CH02 Clean Architecture 4 Layer
      • CH03 MVVM
      • CH04 Data Layer
      • (+) Data Layer - response to model
      • (+) Data Layer - Network
      • CH05 Domain Layer
      • CH06 Presentation Layer
      • CH07 Application Layer
      • (+) Application Layer - l10n
      • (+) Application Layer - DI
      • (+) Application Layer - environment
    • 자바 알고리즘 입문
      • CH01 문자열
      • CH02 Array(1, 2 차원 배열)
      • CH03 Two pointers, Sliding window[효율성: O(n^2)-->O(n)]
      • CH04 HashMap, TreeSet (해쉬, 정렬지원 Set)
      • CH05 Stack, Queue(자료구조)
      • CH06 Sorting and Searching(정렬, 이분검색과 결정알고리즘)
      • CH07 Recursive, Tree, Graph(DFS, BFS 기초)
      • CH08 DFS, BFS 활용
      • CH09 Greedy Algorithm
      • CH10 dynamic programming(동적계획법)
  • 도서
    • 만들면서 배우는 클린 아키텍처
      • 학습목표
      • CH01 계층형 아키텍처의 문제는 무엇일까?
      • CH02 의존성 역전하기
      • CH03 코드 구성하기
      • CH04 유스케이스 구현하기
      • CH05 웹 어댑터 구현하기
      • CH06 영속성 어댑터 구현하기
      • CH07 아키텍처 요소 테스트하기
      • CH08 경계 간 매핑하기
      • CH09 어플리케이션 조립하기
      • CH10 아키텍처 경계 강제하기
      • CH11 의식적으로 지름길 사용하기
      • CH12 아키텍처 스타일 결정하기
    • 클린 아키텍처
      • 들어가며
      • 1부 소개
        • 1장 설계와 아키텍처란?
        • 2장 두 가지 가치에 대한 이야기
      • 2부 벽돌부터 시작하기: 프로그래밍 패러다임
        • 3장 패러다임 개요
        • 4장 구조적 프로그래밍
        • 5장 객체 지향 프로그래밍
        • 6장 함수형 프로그래밍
      • 3부 설계 원칙
        • 7장 SRP: 단일 책임 원칙
        • 8장 OCP: 개방-폐쇄 원칙
        • 9장 LSP: 리스코프 치환 원칙
        • 10장 ISP: 인터페이스 분리 원칙
        • 11장 DIP: 의존성 역전 원칙
      • 4부 컴포넌트 원칙
        • 12장 컴포넌트
        • 13장 컴포넌트 응집도
        • 14장 컴포넌트 결합
      • 5부
        • 15장 아키텍처란?
    • 스프링 입문을 위한 자바 객체 지향의 원리와 이해
      • CH01 사람을 사랑한 기술
      • CH02 자바와 절차적/구조적 프로그래밍
      • CH03 자바와 객체 지향
      • (+) 자바 코드 실행에 따른 메모리 적재과정
      • CH04 자바가 확장한 객체 지향
      • CH05 객체 지향 설계 5 원칙 - SOLID
      • CH06 스프링이 사랑한 디자인 패턴
      • CH07 스프링 삼각형과 설정 정보
      • (부록) 람다(lambda)
    • 객체지향의 사실과 오해
      • CH01 협력하는 객체들의 공동체
      • CH02 이상한 나라의 객체
      • CH03 타입과 추상화
      • CH04 역할, 책임, 협력
      • CH05 책임과 메시지
      • CH06 객체 지도
      • CH07 함께 모으기
      • (+) 인터페이스 개념 바로잡기
    • 도메인 주도 개발 시작하기
      • CH01 도메인 모델 시작하기
      • CH02 아키텍처 개요
      • CH03 애그리거트
      • CH04 리포지터리와 모델 구현
      • CH05 스프링 데이터 JPA를 이용한 조회 기능
      • CH06 응용 서비스와 표현 영역
      • CH07 도메인 서비스
      • CH08 애그리거트 트랜잭션 관리
      • CH09 도메인 모델과 바운디드 컨텍스트
      • CH10 이벤트
      • CH11 CQRS
    • 자바 ORM 표준 JPA 프로그래밍
      • CH01 JPA 소개
      • CH02 JPA 시작
      • CH03 영속성 관리
      • CH04 엔티티 매핑
      • CH05 연관관계 매핑 기초
      • CH06 다양한 연관관계 매핑
      • CH07 고급 매핑
      • CH08 프록시와 연관관계 관리
      • CH09 값 타입
      • CH10 객체지향 쿼리 언어
      • CH11 웹 애플리케이션 제작
      • CH12 스프링 데이터 JPA
      • CH13 웹 애플리케이션과 영속성 관리
      • CH14 컬렉션과 부가 기능
      • CH15 고급 주제와 성능 최적화
      • CH16 트랜잭션과 락, 2차 캐시
    • 소프트웨어 세상을 여는 컴퓨터과학
      • CH01 컴퓨터 과학 소개
      • CH02 데이터 표현과 디지털 논리
    • 이펙티브 자바
      • 1 장 들어가기
      • 2장 객체 생성과 파괴
        • [01] 생성자 대신 정적 팩터리 메서드를 고려하라
        • [02] 생성자에 매개변수가 많다면 빌더를 고려하라
        • [03] private 생성자나 열거 타입으로 싱글턴임을 보증하라
        • [04] 인스턴스화를 막으려거든 private 생성자를 사용하라
        • [05] 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라
        • [06] 불필요한 객체 생성을 피하라
        • [07] 다 쓴 객체 참조를 해제하라
        • [08] finalizer 와 cleaner 사용을 피하라
        • [09] try-finally 보다는 try-with-resources 를 사용하라
      • 3장 모든 객체의 공통 메서드
        • [10] equals는 일반 규약을 지켜 재정의하라
        • [11] equals 를 재정의하려거든 hashCode도 재정의하라
        • [12] toString 을 항상 재정의하라
        • [13] clone 재정의는 주의해서 진행하라
        • [14] Comparable 을 구현할지 고려하라
      • 4장 클래스와 인터페이스
        • [15] 클래스와 멤버의 접근 권한을 최소화하라
  • 토픽
    • 서버 모니터링
      • CPU 사용량
      • 메모리 사용량
      • 스레드 풀
    • Spring Boot Monitoring
      • Spring actuator
      • Spring eureka
      • Prometheus
      • grafana
      • Spring actuator + Prometheus + grafana
    • JAVA 데일리 토픽
      • 메모리 누수(memory leak)
      • 객체 참조의 유형
      • 커스텀 스레드 풀
      • Mark And Compact
      • serialVersionUID 이해하기
      • 함수형 인터페이스
      • 메소드 참조
      • equals()와 hashCode()가 무엇이고 역할이 무엇인지
      • StringBuffer vs StringBuilder
      • String vs StringBuilder, StringBuffer
      • String interning
    • JAVA GC
    • 프로그래머스 문제 풀기
      • 해시
      • 스택/큐
      • 힙(Heap)
      • 정렬
      • 완전탐색
      • DFS/BFS
    • 데이터베이스 구성 및 작동 흐름
    • 데이터베이스 JOIN 원리
    • 객체지향생활체조 원칙
    • 상태(state), 상속(inheritance), 합성(composition) 의 상관관계
    • java enum은 메모리에 언제, 어떻게 할당되는가
    • Checked Exception vs UnChecked Exception
    • Reactive Streams 원리탐구 - 간단한 예제 직접 작성해보기
    • Flutter Basic
    • Flutter StatefulWidget 생명주기
    • Flutter 가 위젯을 그리는 원리
    • Flutter 클린 아키텍처
      • application layer
        • 패키지 구조 및 레이어 설명
        • environment
        • dependency injection
        • go_router
        • foreground & background
        • 다국어처리 (l10n, i18n)
        • Global 처리(시스템 점검, fore->back 등)
        • connection_manager
        • permission_manager
        • push_notification_manager
        • firebase 연동
      • data layer
        • 패키지 구조 및 레이어 설명
        • network
        • repository
      • domain layer
        • 패키지 구조 및 레이어 설명
      • presentation layer
        • 패키지 구조 및 레이어 설명
        • resources
    • 기술 관련 포스팅 읽기
  • 기타
    • 작업일지
      • 2023. 10
      • 2023. 09
      • 2023. 08
      • 2023. 07
      • 2023. 06
      • 2023. 05
      • 2023. 04
      • 2023. 03
      • 2023. 02
      • 2023. 01
      • 2022. 12
    • Business Model
      • 아이디어 불패의 법칙
      • 린 모바일 앱 개발
      • 린 스타트업
      • 제로투원
      • MIT 스타트업 바이블
      • 린치핀
    • 백로그 종합
Powered by GitBook
On this page
  • SQL 을 직접 다룰 때 발생하는 문제점
  • 패러다임의 불일치란 무엇이며 JPA가 이를 어떻게 해결해주나
  • 패러다임의 불일치(상속, 연관, 비교)
  • JPA란 무엇인가
  • Spring Data JPA
  • JPA
  • hibernate
  1. 도서
  2. 자바 ORM 표준 JPA 프로그래밍

CH01 JPA 소개

SQL 을 직접 다룰 때 발생하는 문제점

SQL 을 직접 다룰 때 발생하는 문제점은 곧 ORM 을 쓰지 않고 개발하는 경우 겪어야할 불편함이라는 말과 같은 의미이다.

우리는 객체 지향 프로그래밍을 한다. 이 말인즉 특정 시점에 객체가 데이터베이스의 데이터로 영속화 되어야 하고, 반대로 데이터베이스에서 꺼내온 데이터가 객체로 매핑 되어야한다는 뜻이다. 이 과정을 ORM 을 쓰지 않고 SQL 을 직접 사용하여 처리할 경우 SQL 에 의존적인 개발을 하게 된다.

SQL 에 의존적인 개발이란 일일이 필요한 SQL 을 직접 다 작성해야하고, 필요한 데이터들을 작성한 SQL 에 매핑도 다 해줘야하며 조회시에도 데이터를 객체로 변환하는 과정을 다 신경써줘야한다는 것이다. 또한 DAO로 계층을 나눠놓았다고 해도 정확한 파악을 위해서는 결국엔 SQL 을 직접 확인해봐야하는 문제도 있다. 비슷한 맥락에서 특정 엔티티에서 관계를 갖고 있는 다른 엔티티를 조회할 경우 SQL 에서 이 객체까지 같이 조회하지 않았다면 null exception 이 날 수 있다.

책에서는 이와 같은 문제들을 아래와 같이 문제를 항목화했다.

  • 진정한 의미의 계층 분할이 어렵다.

  • 엔티티를 신뢰할 수 없다.

  • SQL 에 의존적인 개발을 피하기 어렵다.

패러다임의 불일치란 무엇이며 JPA가 이를 어떻게 해결해주나

패러다임의 불일치(상속, 연관, 비교)

객체 지향 패러다임과 데이터베이스의 데이터 구조는 차이가 존재한다. 이것이 패러다임의 불일치다. 패러다임 불일치를 항목으로 나누면 아래 세 항목으로 나눌 수 있다.

  • 상속

  • 연관

  • 비교

상속 패러다임 불일치

왼쪽은 객체 패러다임이고 오른쪽은 데이터베이스 패러다임의 모습이다. 데이터베이스에서는 상속이라는 개념을 수용하고 있지 않다. 따라서 저렇게 테이블을 각각 만들어서 데이터를 보관해야한다.

만약 이를 JPA 를 사용하지 않고 처리할 경우에 Album 하나를 insert 한다면 Item, Album 두 테이블에 대한 insert 문들을 모두 만들어 줘야한다. 조회 역시 대상이 되는 두 테이블에 대한 join 문을 각각 만들어 줘야한다. 이러한 처리들이 모두 패러다임 불일치를 해결하기 위한 비용이다.

JPA 가 상속 패러다임 불일치를 해결해주는 방법

JPA 는 간단히 상속하고 있는 대상 객체를 저장만 해주면 된다.

위에서 예시로 든 Album 을 저장하는 경우를 보면 SQL 을 직접 사용했을 때 두 객체에 대한 Insert 문을 작성해줘야했던 것과 달리 JPA 를 사용하면 Album 이라는 객체에 대한 저장만 해주면 두 테이블에 알아서 Insert 문이 실행된다.

jpa.persist(album);

조회 역시 SQL 을 직접 사용하면 두 테이블에 대한 join 문을 만들어서 실행한뒤 결과를 객체에 매핑 해줬어야 했는데, JPA 를 사용할 경우 조회 로직 코드 한 줄이면 해결 된다.

Album album = jpa.find(Album.class, albumId);

연관 패러다임 불일치

객체 지향 패러다임에서는 연관관계란 단지 객체 내에서 참조값을 가지고 있는 것이 전부이다. member 라는 객체가 필드로 team 이라는 필드에 참조값을 지니고 있는 것이다. 그래서 객체 지향 패러다임에서는 연관된 객체를 조회하고 싶다면 반드시 그 객체에 대한 참조값을 해당 객체에서 가지고 있어야 한다.

반면에 데이터베이스에서는 외래키 값을 이용해서 어느 테이블이든 join 을 통해 조회가 가능하다. member 에서 team_id 를 가지고 있으면 member join team, team join member 어떤 식으로든 조회가 가능하다. 객체에서는 team 이 member(1:N) 들을 조회하는 필드를 갖고있지 않으면 조회 자체가 불가능하다.

JPA를 사용하지 않으면 member 에서 team_id 에 해당하는 필드값을 갖게 하고 이를 이용해서 join 문으로 조회를 해와야하는데 member 에서 바로 team 을 조회하지 못하고, member 의 모델링 역시 SQL 에 의존적인 형태로 객체 지향의 특징과 멀어지게 된다.

쉽게 말해서 ORM 이 없었다면 객체 모델링에 외래키 값이 노골적으로 들어가는 식으로 데이터베이스에 종속된 모델링이 나오게 되는데 ORM 덕분에 객체 지향 방식대로 객체 모델링에 객체 참조를 하도록 해도 외래키로 컬럼이 관리가 되고, 조회시에도 객체 참조를 하지만 데이터베이스 상에상에서 join이 실행 되는 것이다.

JPA 가 연관 패러다임 불일치를 해결해주는 방법

객체 지향 패러다임에 따라 그대로 모델링을 해주고 객체 자체를 저장해주면 JPA 가 알아서 외래키를 변환해서 insert 문을 실행해준다. 예를 들어 member 에 team_id 를 위한 필드 값을 만들고 여기에 team의 id 값을 세팅한 뒤 insert 문을 날릴 필요 없이 member 에 team 객체 자체를 참조하는 필드값을 만들고 member를 저장하면 JPA가 알아서 team의 외래키 값으로 변환하여 저장해주는 것이다.

조회도 마찬가지로 지연 로딩을 통해서 객체 그래프 탐색이 발생하면 적절한 join 문을 JPA에서 알아서 만들어서 실행시켜서 조회된 team 객체를 엔티티에 매핑해준다.

비교 패러다임 불일치

String memberId = "100";
Member member1 = memberDAO.getMember(memberId);
Member member2 = memberDAO.getMember(memberId);

100이라는 동일한 pk 로 조회해온 row 를 각각 member1, member2 에 할당할 경우 두 엔티티는 사실상 동일한 객체이지만 member1 과 member2 는 객체 지향 패러다임에서는 member1 != member2 가 된다. 왜냐하면 다른 주소값을 지니게 되기 때문이다.

JPA 가 비교 패러다임 불일치를 해결해주는 방법

String memberId = "100";
Member member1 = jpa.find(Member.class, memberId);
Member member2 = jpa.find(Member.class, memberId);

JPA 에서는 같은 트랜잭션에서 동일한 row 에 대해서 동일성 비교에 성공하도록 보장해준다. 위의 로직이 같은 트랜잭션에서 실행될 경우 member1과 member2의 주소값은 같다.

JPA란 무엇인가

Java Persistence API 는 자바 진영의 ORM 기술 표준이다. JPA 를 애플리케이션 계층 구조에서 보면 아래와 같다. 뒤에 다루겠지만 JPA 는 단지 자바 진영에서 정한 ORM 기술 표준, 명세일 뿐이고 이를 실제 구현한 구현 프레임워크 중 하나가 하이버네이트이다. 하이버네이트는 JPA 에서 선택한 표준 프레임워크이다.

위에서 살펴본 바와 같이 JPA 가 객체 지향 패러다임과 데이터베이스 패러다임 간의 불일치를 해결해주는 덕분에 JPA 를 사용하면 객체 지향 패러다임에 입각한 개발에 더 집중할 수 있다.

아래는 백기선님 강의에서 정리한 내용인데, 같은 내용이어서 옮겨둔다. 각 계층에 대해서 짚어본다.

Spring Data JPA

스프링 공식문서에도 잘 나와있다시피 Spring Data JPA 는 JPA based data access layer 를 support 하는 목적으로 만들어진 라이브러리이다.

Spring Data JPA, part of the larger Spring Data family, makes it easy to easily implement JPA based repositories. This module deals with enhanced support for JPA based data access layers. It makes

JPA

Java Persistence API 는 자바 진영의 ORM 기술 표준이다. 자바 진영에서 정한 ORM 기술 표준, 명세이다.

hibernate

ORM 프레임워크이다. 달리 표현하자면 JPA 의 구현체라고 할 수 있다. JPA 에서는 hibernate 를 내부적으로 가지고 있고 이를 활용하고 있다. (참고로 그래서 JPA를 거치지 않고 hibernate를 직접 활용하는 것도 가능하다.)

hibernate 공식 홈페이지에도 hibernate를 JPA 의 구현체라고 밝히고 있다.

Previous자바 ORM 표준 JPA 프로그래밍NextCH02 JPA 시작

Last updated 1 year ago