📚 [JPA] #1. JPA 소개

✔ 과거에는 객체를 데이터베이스에 저장하려면 복잡한 JDBC API와 SQL을 하나하나 적어야 했다.
✔ JdbcTemplate이나 MyBatis 같은 것을 사용하면서 개발 코드가 많이 줄었지만 SQL은 하나하나 작성해야 했다.
✔ JPA를 사용하면 SQL 조차도 작성할 필요가 없다. JPA가 적절한 SQL을 생성하고 데이터베이스에 실행해서 객체를 저장하거나 불러오게 된다.

📕 SQL 중심적인 개발의 문제점

1. 무한 반복, 지루한 코드
◾ CRUD 쿼리 무한 반복해야된다. 객체에 필드가 추가되면 쿼리들에 하나씩 일일이 다 추가해줘야 한다.
◾ 관계형 DB(Oracle, MySQL)에서는 SQL만 사용할 수 있으므로 SQL 의존적인 개발을 할 수 밖에 없다.

2. 패러다임의 불일치 (객체 vs 관계형 데이터베이스)
◾ 관계형 DB는 데이터를 정교화해서 저장하는게 목적이고, 객체는 필드나 메서드 같은게 묶여서 캡슐화해서 쓰는게 목적이다.
◾ 관계형 DB의 목적과 객체지향 프로그래밍의 목적이 일치하지 않는다. 그러나, 객체를 저장할 수 있는 가장 현실적인 방안은 관계형 DB이다.
◾ 관계형 DB가 인식할 수 있는 것은 SQL뿐이기 때문에 결국 Object를 SQL로 짜야한다. 결론적으로 객체와 관계형 데이터베이스 사이의 패러다임 불일치 문제를 해결하는데 너무 많은 시간과 코드를 소비한다는 게 문제다.

📖 객체와 관계형 데이터베이스의 차이

1. 상속

✔ 객체에는 상속 관계가 있지만, 관계형 DB에는 상속 관계가 없다. 슈퍼타입 서브타입 관계를 사용하면 객체 상속과 유사한 형태로 테이블을 설계할 수 있다.

Album을 DB에 저장할 경우
◽ 객체를 분해하여 ITEM 테이블 삽입 SQL과 ALBUM 테이블 삽입 SQL, 총 2개를 작성해야 한다.

Album을 DB에서 조회할 경우
◽ 각 테이블을 조회하는 Join SQL을 작성하고 각각의 객체를 생성, 나온 값을 일일이 객체에 넣고 그런 복잡한 과정을 거쳐야 한다. 그래서 DB에 저장할 객체에는 상속 관계를 쓰지 않는다.

Album을 자바 컬렉션에 저장할 경우

list.add(album);

Album을 자바 컬렉션에서 조회할 경우

Album album = list.get(albumId);

//부모 타입으로 조회 후 다형성 활용
Item item = list.get(albumId);

2. 연관관계

✔ 객체는 참조를 사용해서 연관된 객체를 조회하고, 테이블은 PK, FK를 사용해서 join을 통해 연관된 테이블을 조회한다.

◽ 객체는 참조를 사용 : member.getTeam()
◽ 테이블은 외래키를 사용 : JOIN ON M.TEAM_ID = T.TEAM_ID

🎈 객체를 테이블에 맞추어 모델링

class Member {
	String id; //MEMBER_ID 컬럼 사용
	Long teamId; //TEAM_ID FK 컬럼 사용
    String username; //USERNAME 컬럼 사용
}

class Team {
	Long id; //TEAM_ID PK 사용
	String name; //NAME 컬럼 사용
}

◽ 관계형 데이터베이스는 Join이라는 기능이 있기 때문에 외래키의 값을 그대로 보관해도 된다.
◽ 하지만 객체는 연관된 객체의 참조를 보관해야 한다.

🎈 객체다운 모델링

class Member {
	String id; //MEMBER_ID 컬럼 사용
	Team team; //참조로 연관관계를 맺는다
    String username; //USERNAME 컬럼 사용
    
    Team getTeam() {
        return team;
    }
}

class Team {
	Long id; //TEAM_ID PK 사용
	String name; //NAME 컬럼 사용
}

◽ 외래 키의 값을 그대로 보관하는 것이 아니라 연관된 Team의 참조를 보관한다.

🎈 객체 모델링 조회

SELECT M.*, T.* FROM MEMBER M
JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID
  
public Member find(String memberId) {
	//SQL 실행 ...
    Member member = new Member();
    //데이터베이스에서 조회한 회원 관련 정보 입력
    Team team = new Team();
    //데이터베이스에서 조회한 팀 관련 정보 입력
    
    //회원과 팀 관계 설정
    member.setTeam(team);
    return member;
}

◽ 그런데 이렇게 객체다운 모델링을 사용하면 객체를 테이블에 저장하거나 조회하기가 쉽지 않다는 단점이 있다.
◽ 이러한 과정들은 모두 패러다임 불일치를 해결하려고 소모하는 비용이다. 만약 자바 컬렉션에 회원 객체를 저장한다면 이런 비용이 전혀들지 않는다.

🎈 객체 그래프 탐색
◽ 객체는 자유롭게 객체 그래프를 탐색할 수 있어야 한다. 하지만 처음 실행하는 SQL에 따라 탐색 범위가 결정되기 때문에 SQL 중심적인 개발에서는 그것이 불가능하다.

🎈 엔티티 신뢰 문제

class MemberService {
	public void process() {
        Member member = memberDAO.find(memberId);
        member.getTeam(); //???
        member.getOrder().getDelivery(); //???
    }
}

◽ getTeam()와 getOrder().getDelicery()가 null인지 아닌지를 이 코드만 보고는 확인할 수 없다.
◽ SQL에서 탐색된 객체 이외에는 사용할 수 없으므로 엔티티를 신뢰할 수 없다.
◽ 계층 아키텍쳐에서는 이전 계층에서 넘어온 내용을 신뢰할 수 있어야 하는데 SQL 중심적인 개발에서는 그것이 불가능하므로 객체가 SQL에 의존한다.

memberDAO.getMember(); //Member만 조회 

memberDAO.getMemberWithTeam(); //Member와 Team 조회
 
//Member,Order,Delivery
memberDAO.getMemberWithOrderWithDelivery();

◽ 그렇다고 모든 객체를 미리 로딩할 수는 없으므로 상황에 따라 동일한 회원 조회 메서드를 여러벌 생성해야 한다.
◽ 즉, 진정한 의미의 계층 분할이 어렵다. 또한, 객체답게 모델링 할수록 매핑 작업만 늘어난다.

❓ 객체를 자바 컬렉션에 저장하듯이 DB에 저장할 수는 없을까? 이 문제를 해결한 것이 바로 JPA(Java Persistence API)이다.

3. 데이터 타입

4. 데이터 식별 방법

📙 JPA 소개

📖 JPA란?

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

📖 ORM이란?

◽ Object-relational mapping(객체 관계 매핑)
◽ 객체는 객체대로 설계하고, 관계형 데이터베이스는 관계형 데이터베이스대로 설계하고, ORM 프레임워크가 중간에서 매핑을 해준다.
◽ 대중적인 언어에는 대부분 ORM 기술이 존재

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

◽ 개발자가 직접 JDBC API를 사용하는게 아닌 JPA를 사용하면 JPA가 JDBC API를 호출하는 방식이다.

JPA 동작 - 저장

◽ JPA에게 MemberDAO에서 Member 객체를 저장하고 싶다하면 JPA가 Entity를 분석 후 Insert SQL 생성한다. 그리고 JDBC API를 사용하여 DB에 SQL을 보낸다.
◽ 쿼리를 개발자가 만드는게 아니고 JPA가 만들어준다.
◽ 패러다임의 불일치를 해결해준다.

JPA 동작 - 조회

◽ JPA에게 MemberId 10번을 찾아달라고 하면 JPA가 Member 객체를 보고 적절한 조회 쿼리를 만들고 JDBC API를 통해 DB로부터 결과를 받아온다. 그래서 ResultSet 매핑을 수행 후 Entity Object를 반환한다.
◽ 패러다임의 불일치를 해결해준다.

JPA는 표준 명세

◽ JPA는 인터페이스의 모음
◽ JPA 2.1 표준 명세를 구현한 3가지 구현체 : 하이버네이트, EclipseLink, DataNucleus

📖 JPA를 왜 사용해야 하는가?

1. SQL 중심적인 개발에서 객체 중심으로 개발

2. 생산성 - JPA와 CRUD

✔ 한 줄만 작성하면 되기에 좋은 생산성을 가질 수 있다. JPA의 영속성 컨텍스트로 인해 컬렉션에서 단순하게 조회 후 setName만 호출하여 update 할 수 있다.

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

3. 유지보수 - 기존: 필드 변경시 모든 SQL 수정

✔ 기존에는 필드 변경시 모든 SQL 문을 수정해야 했지만, JPA에서는 필드만 추가하면 SQL은 JPA가 처리한다.

4. JPA와 패러다임의 불일치 해결

✔ JPA와 상속 : 특정 객체를 저장할 경우 상속 관계를 JPA가 분석하여 필요한 쿼리를 JPA가 생성한다.
✔ JPA와 연관관계, JPA와 객체 그래프 탐색 : 지연 로딩을 사용하여 신뢰할 수 있는 엔티티, 계층을 제공한다.
✔ JPA와 비교하기 : 동일한 트랜잭션에서 조회한 엔티티는 같음을 보장한다.

5. JPA의 성능 최적화 기능

🎈 1차 캐시와 동일성(identity) 보장
◽ 같은 트랜잭션 안에서는 같은 엔티티를 반환 -> 약간의 조회 성능 향상
◽ DB Isolation Level이 Read Commit이어도 애플리케이션에서 Repeatable Read 보장

🎈 트랜잭션을 지원하는 쓰기 지연(transactional write-behind)
◽ 트랜잭션을 커밋할 때까지 INSERT SQL을 모음
◽ JDBC BATCH SQL 기능을 사용해서 한번에 SQL 전송
◽ UPDATE, DELETE로 인한 로우(ROW)락 시간 최소화
◽ 트랜잭션 커밋 시 UPDATE, DELETE SQL 실행하고, 바로 커밋

🎈 지연 로딩(Lazy Loading)과 즉시 로딩(Eager Loading)

◽ 지연 로딩: 객체가 실제 사용될 때 로딩
-> 실제 Team 객체의 필드를 접근할 때 Team 테이블로부터의 조회 쿼리를 날려서 데이터를 얻어옴
◽ 즉시 로딩: JOIN SQL로 한번에 연관된 객체까지 미리 조회
-> 한 번에 join을 활용하여 연관된 모든 데이터를 얻어옴

📚 참고자료

자바 ORM 표준 JPA 프로그래밍 - 기본편