JPA기초 @Entity & @Id & @GeneratedValue & 영속성 컨텍스트

🔥 JPA란 무엇인가? 그리고 @Entity, @Id, @GeneratedValue의 역할

JPA란?

• JPA(Java Persistence API)는 자바 애플리케이션에서 객체(클래스)와 관계형 데이터베이스 간의 매핑을 정의하고 관리하기 위한 표준 인터페이스입니다.
• 역할:
  • 객체와 테이블 간의 매핑을 자동으로 처리 (ORM: Object-Relational Mapping).
  • SQL 없이도 데이터베이스와 상호작용 가능.
  • 데이터베이스 독립적인 애플리케이션 개발 지원.
• 구현체: Hibernate, EclipseLink, OpenJPA 등이 있으며, JPA는 이 구현체들을 위한 표준입니다.

@Entity

역할: 클래스가 JPA 엔터티임을 선언합니다. 데이터베이스 테이블과 매핑됩니다.

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
}
    

위 코드에서 User 클래스는 데이터베이스의 user 테이블과 매핑됩니다.

@Id

역할: Primary Key로 사용할 필드를 지정합니다. 엔터티의 각 인스턴스를 고유하게 식별하기 위해 사용됩니다.

@Entity
public class User {
    @Id
    private Long id;  // Primary Key
}
    

id 필드는 데이터베이스에서 Primary Key로 작동합니다.

@GeneratedValue

역할: Primary Key의 값을 자동으로 생성합니다. 다양한 생성 전략을 지원합니다.

생성 전략:

• GenerationType.AUTO: JPA 구현체가 적절한 전략을 선택.
• GenerationType.IDENTITY: 데이터베이스의 AUTO_INCREMENT 기능 사용.
• GenerationType.SEQUENCE: 데이터베이스의 Sequence 객체 사용.
• GenerationType.TABLE: 키 값을 저장하는 별도의 테이블 사용.

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

데이터베이스에서 id는 자동으로 증가하는 값으로 설정됩니다.

예제 코드 전체

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

@Entity
public class User {

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

    private String name;

    // Getters and setters
    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;
    }
}
    

JPA가 제공하는 주요 장점

• 생산성 향상: 반복적인 SQL 작성 없이 CRUD 작업 가능.
• 유지보수 용이성: 객체 중심으로 코드를 작성하므로 가독성이 좋음.
• 데이터베이스 독립성: 특정 DBMS에 종속되지 않고, 다양한 데이터베이스에서 동일한 코드로 동작.

동작 원리 요약

1. JPA가 User 엔터티를 user 테이블에 매핑합니다.
2. id는 Primary Key로 설정되며, 데이터베이스에서 자동 생성됩니다.
3. SQL 작성 없이도 데이터 저장, 조회, 삭제가 가능합니다.

---

 

 

🔥 @Id와 @GeneratedValue가 없었을 때 데이터베이스와 매핑

1. @Id가 없었을 때

JPA에서 @Id는 Primary Key를 지정하는 어노테이션입니다. 만약 @Id가 없었다면 다음과 같은 문제가 발생합니다:

• Primary Key 미지정으로 인해 JPA가 매핑 불가능: JPA는 엔터티를 데이터베이스 테이블의 어떤 레코드와 매핑할지 Primary Key를 기준으로 판단합니다. @Id가 없으면 에러가 발생합니다.
• 에러 메시지:

  
  javax.persistence.PersistenceException: No identifier specified for entity: com.example.User
              

• 데이터베이스 테이블에 이미 Primary Key가 설정되어 있어도, JPA는 이를 인식하지 못하고 명시적으로 @Id를 요구합니다.

2. @GeneratedValue가 없었을 때

Primary Key의 자동 생성 기능을 사용할 수 없습니다. Primary Key 값을 개발자가 직접 관리해야 하며, 다음과 같은 문제가 생길 수 있습니다:

• 자동 증가 기능 상실: 데이터베이스에서 Primary Key를 자동으로 증가시키지 못하므로, 엔티티를 저장하기 전에 Primary Key 값을 수동으로 설정해야 합니다.
• Primary Key 누락 시 데이터베이스 에러: Primary Key 값이 없으면 데이터베이스에서 제약 조건 위반 에러가 발생합니다.
• 예시 코드 (Primary Key 값 수동 설정):

  
  @Entity
  public class User {
      @Id
      private Long id;  // Primary Key를 직접 설정해야 함
  
      private String name;
  }
  
  // 데이터 저장 시
  User user = new User();
  user.setName("Alice");
  user.setId(1L);  // Primary Key를 수동으로 설정
  entityManager.persist(user);  // 정상 동작
              

• Primary Key를 수동으로 설정하지 않으면 에러 발생:

  
  org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save()
              

3. 데이터베이스에서 매핑된 결과

Primary Key가 없거나 자동 생성되지 않는 경우, 데이터베이스 테이블에 다음과 같은 문제가 발생할 수 있습니다:

• 중복된 레코드 발생 가능:

| id   | name     |
|------|----------|
| NULL | Alice    |
| NULL | Bob      |
        

• 데이터 무결성 위반: 테이블의 고유성을 보장할 수 없습니다.
• 레코드 구분 불가: 특정 레코드를 업데이트하거나 삭제할 때 어떤 레코드를 대상으로 할지 판단할 수 없습니다.

4. 결론

• @Id: JPA에서 엔터티와 테이블 간의 매핑에서 필수적인 어노테이션으로, Primary Key를 반드시 지정해야 합니다.
• @GeneratedValue: Primary Key 값을 자동으로 생성하여 개발자의 수동 설정 부담을 줄여줍니다.
• 두 어노테이션 없이 JPA를 사용하면 데이터 무결성 문제와 JPA 동작 오류가 발생할 수 있습니다.

---

 

 

@PersistenceContext의 역할

1. @PersistenceContext란?

@PersistenceContext는 JPA(Java Persistence API)에서 EntityManager를 주입하기 위해 사용되는 어노테이션입니다.

EntityManager는 JPA의 핵심 객체로, 데이터베이스와 상호작용하며 엔터티를 관리하는 역할을 합니다.

2. 주요 역할

• EntityManager 주입: @PersistenceContext는 컨테이너에서 관리되는 EntityManager를 해당 필드에 주입합니다.
• Persistence Context 관리: 트랜잭션 범위 내에서 EntityManager를 관리하며, 필요한 경우 자동으로 열리고 닫힙니다.
• Persistence Unit 지정 가능: 여러 Persistence Unit이 있을 경우, unitName 속성을 통해 특정 Persistence Unit을 선택할 수 있습니다.

3. 사용 예제

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {

    @PersistenceContext
    private EntityManager entityManager;

    public User findUserById(Long id) {
        return entityManager.find(User.class, id); // User 엔티티 조회
    }

    public void saveUser(User user) {
        entityManager.persist(user); // User 엔티티 저장
    }
}
    

4. 주요 특징

• 자동 관리: JPA 구현체(Hibernate 등)가 EntityManager의 생명 주기를 관리합니다.
• 트랜잭션 기반 동작: EntityManager는 트랜잭션 범위에서 열리고 닫히며, 트랜잭션이 끝나면 자동으로 정리됩니다.
• 스프링 연동: 스프링 프레임워크는 @PersistenceContext를 통해 EntityManager를 의존성으로 주입합니다.
• Persistence Unit 선택 가능: 여러 Unit이 있을 경우 특정 Unit을 지정할 수 있습니다.

  
  @PersistenceContext(unitName = "myPersistenceUnit")
  private EntityManager entityManager;
              

5. @Autowired와의 차이

스프링에서 @Autowired를 통해 EntityManager를 주입할 수도 있지만, @PersistenceContext는 JPA 표준에 따른 방식입니다. 따라서 표준을 따르고자 할 때는 @PersistenceContext를 사용하는 것이 더 명시적입니다.

6. 설정 및 동작

Spring Boot에서는 JPA 설정이 간소화되어 있으며, application.properties에 데이터베이스 설정을 추가하면 EntityManager가 자동으로 생성됩니다:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=1234
spring.jpa.hibernate.ddl-auto=update
    

7. 결론

• @PersistenceContext는 EntityManager를 주입받아 데이터베이스와 상호작용할 수 있도록 합니다.
• JPA 표준 방식으로 EntityManager를 관리하며, 스프링 프레임워크와 쉽게 연동됩니다.
• 트랜잭션 범위 내에서 EntityManager의 생명 주기를 자동으로 관리합니다.

이 글이 JPA를 사용하는 데 도움이 되었길 바랍니다! 😊

---

 

 

🔥 트랜잭션과 엔티티매니저의 관계

트랜잭션(Transaction)과 엔티티매니저(EntityManager)는 JPA에서 데이터 무결성을 보장하고, 데이터베이스와 엔티티 간의 상호작용을 효율적으로 처리하기 위해 함께 동작합니다.

1. EntityManager란?

EntityManager는 JPA에서 영속성 컨텍스트(Persistence Context)를 관리하는 핵심 객체입니다. 데이터베이스와의 상호작용 및 엔티티의 상태를 관리합니다.

• CRUD 작업 수행: persist, find, merge, remove.
• 엔티티 상태 추적 및 데이터베이스와 동기화.
• 영속성 컨텍스트 관리.

2. Transaction이란?

Transaction은 데이터베이스 작업의 논리적 단위로, 작업의 원자성, 일관성, 격리성, 지속성을 보장합니다 (ACID 속성).

• 작업 단위를 그룹화하여 모두 성공하거나 모두 실패하게 만듭니다.
• EntityManager는 트랜잭션 내에서만 데이터베이스와 상호작용합니다.

3. EntityManager와 Transaction의 관계

EntityManager와 Transaction은 영속성 컨텍스트를 통해 연결됩니다. 주요 관계는 다음과 같습니다:

• EntityManager는 트랜잭션 범위 내에서 동작합니다.
• 트랜잭션 시작 시 영속성 컨텍스트가 활성화되며, 커밋 또는 롤백 시 종료됩니다.
• 트랜잭션 없이 데이터베이스 변경 작업이 수행되지 않습니다.

4. 주요 동작 예제

프로그래밍 방식 트랜잭션 관리

EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();

try {
    tx.begin(); // 트랜잭션 시작
    Member member = new Member();
    member.setName("John Doe");
    em.persist(member); // 엔티티 저장
    tx.commit(); // 트랜잭션 커밋
} catch (Exception e) {
    tx.rollback(); // 트랜잭션 롤백
} finally {
    em.close();
}
    

스프링에서 @Transactional 사용

@Service
public class MemberService {
    @Transactional
    public void createMember(String name) {
        Member member = new Member();
        member.setName(name);
        memberRepository.save(member);
    }
}
    

---

🔥 영속성 컨텍스트란 무엇인가?

영속성 컨텍스트(Persistence Context)는 JPA에서 엔티티를 관리하는 저장소입니다. 애플리케이션과 데이터베이스 사이의 중간 계층으로, 엔티티의 상태를 추적하고 데이터베이스와 동기화합니다.

1. 영속성 컨텍스트의 특징

• 1차 캐시: 동일한 엔티티를 여러 번 조회해도 데이터베이스 쿼리가 발생하지 않습니다.
• 변경 감지(Dirty Checking): 엔티티의 상태 변화를 감지하여 트랜잭션 커밋 시 변경 사항을 데이터베이스에 반영합니다.
• 지연 로딩(Lazy Loading): 필요한 시점에만 데이터베이스에서 데이터를 가져옵니다.
• 동일성 보장: 동일한 영속성 컨텍스트 내에서는 동일한 엔티티 객체를 반환합니다.

2. 엔티티의 상태

엔티티는 JPA에서 다음 네 가지 상태 중 하나를 가질 수 있습니다:

• 비영속(Transient): JPA가 관리하지 않는 상태.
• 영속(Managed): 영속성 컨텍스트에서 관리되는 상태.
• 준영속(Detached): 영속성 컨텍스트에서 분리된 상태.
• 삭제(Removed): 삭제 상태로, 트랜잭션 커밋 시 데이터베이스에서 삭제됨.

3. 주요 기능

1차 캐시

엔티티를 메모리에 저장하여 데이터베이스 접근을 최소화합니다.

Member member1 = em.find(Member.class, 1L); // DB에서 조회
Member member2 = em.find(Member.class, 1L); // 1차 캐시에서 조회 (쿼리 발생 X)
    

변경 감지

엔티티 변경 사항을 자동으로 감지하고 반영합니다.

Member member = em.find(Member.class, 1L);
member.setName("Jane Doe"); // 변경 감지
em.getTransaction().commit(); // UPDATE 쿼리 실행
    

쓰기 지연

변경 사항을 트랜잭션 커밋 시점에 한꺼번에 데이터베이스에 반영합니다.

em.persist(member1);
em.persist(member2);
em.getTransaction().commit(); // INSERT 쿼리 실행
    

4. 결론

• 영속성 컨텍스트는 엔티티를 관리하고 데이터베이스와의 상호작용을 최적화합니다.
• 트랜잭션과 결합하여 데이터 무결성을 보장합니다.

---

 

 

트랜잭션과 영속성 컨텍스트: 같은 ID는 같은 엔티티로 식별

1. 트랜잭션과 영속성 컨텍스트

트랜잭션과 영속성 컨텍스트는 JPA의 핵심 개념으로, 데이터 무결성을 보장하고 엔티티를 효율적으로 관리하기 위해 함께 동작합니다.

1.1 트랜잭션

• 트랜잭션은 데이터베이스 작업의 논리적 단위입니다.
• 트랜잭션이 시작되면 JPA는 해당 트랜잭션 내에서 하나의 영속성 컨텍스트를 생성하고 이를 통해 엔티티를 관리합니다.

1.2 영속성 컨텍스트

• 영속성 컨텍스트는 엔티티를 관리하는 메모리 공간(캐시)으로, 엔티티의 상태를 추적하고 데이터베이스와 동기화를 수행합니다.
• 동일한 트랜잭션 내에서 동일한 영속성 컨텍스트가 사용됩니다.

2. 코드에서 일어나는 주요 작업

@Test
@Transactional
@Rollback(false)
public void testMember() throws Exception {
    // given
    Member member = new Member();
    member.setUsername("memberA");

    // when
    Long saveId = memberRepository.save(member);
    Member findMember = memberRepository.find(saveId);

    // then
    Assertions.assertThat(findMember.getId()).isEqualTo(member.getId());
    Assertions.assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
    Assertions.assertThat(findMember).isEqualTo(member);
}
    

2.1 주요 작업

• @Transactional: 테스트 메서드에서 트랜잭션이 시작되고, JPA는 하나의 영속성 컨텍스트를 생성합니다.
• save: memberRepository.save(member)를 호출하면, 엔티티가 영속성 컨텍스트에 저장됩니다.
• find: memberRepository.find(saveId)를 호출하면 JPA는 먼저 영속성 컨텍스트를 확인합니다.
• Assertions: findMember와 member가 같은 인스턴스임을 검증합니다.

3. 영속성 컨텍스트의 동작

3.1 엔티티 저장 (persist)

memberRepository.save(member) 호출 시:

• member 객체가 영속성 컨텍스트에 저장됩니다.
• 트랜잭션이 커밋될 때 데이터베이스에 저장됩니다.

3.2 엔티티 조회 (find)

memberRepository.find(saveId) 호출 시:

• JPA는 먼저 영속성 컨텍스트를 확인합니다.
• 동일한 ID의 엔티티가 이미 영속성 컨텍스트에 존재하면, 데이터베이스 조회 없이 캐시된 엔티티를 반환합니다.

4. 중요한 개념: "같은 영속성 컨텍스트에서 같은 ID는 같은 엔티티"

• 같은 트랜잭션 내에서 같은 영속성 컨텍스트 사용: 트랜잭션이 유지되며, 같은 영속성 컨텍스트가 사용됩니다.
• 영속성 컨텍스트의 동일성 보장: 동일한 ID 값을 가진 엔티티는 같은 객체로 관리됩니다.
• 캐싱 효과: 동일한 엔티티를 데이터베이스에서 여러 번 조회하지 않습니다.

5. Assertions에 대한 설명

Assertions.assertThat(findMember.getId()).isEqualTo(member.getId());
Assertions.assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
Assertions.assertThat(findMember).isEqualTo(member);
    

위 Assertions는 다음을 검증합니다:

• ID와 Username 비교: findMember와 member의 ID와 Username이 동일합니다.
• 객체 동일성 비교: findMember와 member가 같은 메모리 주소를 참조합니다.

6. 예제의 핵심 요약

• 영속성 컨텍스트는 엔티티를 관리하는 캐시 역할을 합니다.
• 1차 캐시: 동일한 ID의 엔티티는 데이터베이스를 조회하지 않고 캐시에서 반환됩니다.
• 트랜잭션과 결합: 같은 트랜잭션 내에서는 같은 영속성 컨텍스트를 사용합니다.
• ID로 같은 엔티티 식별: 같은 영속성 컨텍스트 내에서 동일한 ID를 가진 엔티티는 같은 객체로 취급됩니다.

7. 비유로 이해하기

• 영속성 컨텍스트는 사무실 캐비닛: 한 번 저장된 문서는 동일한 트랜잭션 동안 캐비닛에서 찾아 사용합니다.
• 같은 문서라면 같은 내용: ID(문서 번호)가 같으면 항상 같은 문서를 반환합니다.

---

 

JPA에서 연관관계의 주인 설정

JPA에서 엔티티 간 연관관계의 주인을 설정하는 것은 관계를 관리하는 측을 명확히 하기 위해 중요합니다. 아래에 그 이유를 설명합니다.

1. 연관관계의 주인의 역할

JPA에서 연관관계의 주인은 외래 키(Foreign Key, FK)를 관리하는 엔티티를 의미합니다. 주인은 실제 데이터베이스에 변경 사항을 반영할 책임이 있습니다.

• 주인은 @JoinColumn을 통해 외래 키를 매핑합니다.
• 주인이 아닌 쪽(비주인)은 단순히 매핑 정보를 제공하는 역할로, 외래 키를 직접 변경하지 않습니다.

예를 들어, Order와 Member가 @OneToMany와 @ManyToOne 관계로 연결되어 있다면:

• 데이터베이스에는 Order 테이블에 외래 키가 존재합니다.
• JPA에서는 Order 엔티티가 연관관계의 주인으로 설정되어야 외래 키를 조작할 수 있습니다.

2. 양방향 연관관계와 외래 키

데이터베이스 테이블에서는 외래 키가 한쪽 테이블에만 존재하지만, JPA 엔티티는 객체지향적 모델링을 따르기 때문에 양쪽 엔티티가 서로를 참조할 수 있습니다.

@Entity
public class Member {
    @OneToMany(mappedBy = "member") // 비주인
    private List<Order> orders;
}

@Entity
public class Order {
    @ManyToOne
    @JoinColumn(name = "member_id") // 주인
    private Member member;
}
    

• Order 엔티티는 외래 키 member_id를 직접 관리하므로 주인이 됩니다.
• Member 엔티티는 mappedBy 속성을 통해 Order의 member 필드에 의해 매핑된다는 것을 나타내며, 비주인으로 설정됩니다.

3. 연관관계 주인을 잘못 설정했을 경우 문제

연관관계 주인을 잘못 설정하면 다음과 같은 문제가 발생할 수 있습니다:

• 변경 사항 미반영: 비주인 쪽 엔티티에 값을 설정해도 데이터베이스에 반영되지 않습니다.

Member member = em.find(Member.class, 1L);
Order order = new Order();
member.getOrders().add(order); // 데이터베이스 반영 안 됨
    

올바른 방법:

Order order = new Order();
order.setMember(member); // 데이터베이스에 반영됨
    

• 예상치 못한 결과: 객체 간 참조 상태와 데이터베이스 상태가 불일치할 수 있습니다.

Member member = em.find(Member.class, 1L);
Order order = new Order();
order.setMember(member); // 주인에 설정
member.getOrders().add(order); // 비주인도 동기화
    

4. 왜 JPA는 연관관계의 주인을 강제할까?

데이터베이스는 외래 키를 한쪽 테이블에만 두기 때문에, 이를 매핑하는 JPA도 마찬가지로 한쪽만 책임을 갖도록 강제합니다.

양방향 관계를 허용하면서도 데이터 일관성을 유지하려면 한쪽에서만 외래 키를 변경하도록 설계해야 혼란을 줄일 수 있습니다.

5. 결론

엔티티 간 연관관계의 주인을 명확히 설정하는 것은 데이터베이스 상태와 객체 상태의 일치를 보장하기 위해 필수적입니다. 주인을 설정하지 않거나 잘못 설정하면 데이터가 반영되지 않거나 일관성이 깨질 수 있습니다. 따라서 JPA에서는 항상 외래 키를 직접 관리할 엔티티를 주인으로 지정해야 합니다.

---

 

📝 참고

엔티티 매니저와 영속성 컨텍스트를 정확하게 이해해보자