Spring JPA는 처음인데요.

The conceptual diagram illustrates the relationship between the Spring Framework, ORM (Object-Relational Mapping), and JPA (Java Persistence API). It shows how the Spring Framework utilizes ORM for managing database operations and data persistence, with JPA serving as a specific ORM implementation for managing relational data in Java applications. Additionally, it highlights the role of Spring Data JPA in facilitating the integration with JPA for the data access layer in applications.

ORM(Object-Relational Mapping)

객체-관계 매핑을 의미합니다. 이는 객체 지향 프로그래밍 언어를 사용하여 호환되지 않는 유형의 시스템 간의 데이터를 변환하는 프로그래밍 기법입니다. 즉, ORM을 통해 객체 지향 프로그램에서 사용되는 객체를 관계형 데이터베이스의 테이블에 자동으로 영속화할 수 있습니다.

ORM의 주요 목적

• 프로그램의 객체와 데이터베이스의 테이블 사이의 매핑을 자동화하여, SQL 쿼리 없이도 데이터베이스 데이터를 쉽게 저장하고 검색할 수 있게 해줍니다.
• 데이터베이스와 프로그래밍 언어 사이의 패러다임 불일치를 해결합니다. 객체 지향 언어에서는 클래스와 상속과 같은 개념을 사용하지만, 관계형 데이터베이스는 테이블, 행, 열 등을 사용합니다. ORM은 이러한 두 세계 사이의 간격을 메웁니다.
• 개발자가 객체 지향적인 방식으로 데이터에 접근하고 조작할 수 있게 해줍니다. 이로 인해 개발자는 비즈니스 로직에 더 집중할 수 있고, 데이터베이스 작업에 소요되는 시간과 노력을 줄일 수 있습니다.

ORM의 장점

• 생산성 향상: 반복적인 CRUD(Create, Read, Update, Delete) 작업의 코드를 작성할 필요가 없으므로 개발 시간이 단축됩니다.
• 유지보수성 향상: 데이터베이스 설계 변경이 필요할 때 ORM 모델을 업데이트하기만 하면 되므로 변경이 용이합니다.
• 패러다임의 불일치 해결: 객체 지향 프로그램과 관계형 데이터베이스 사이의 패러다임 불일치를 ORM이 해결해 줍니다.
• 데이터베이스 독립성: ORM을 사용하면 데이터베이스에 종속되지 않는 코드를 작성할 수 있으므로, 다른 종류의 데이터베이스로의 마이그레이션이 비교적 용이해집니다.

ORM의 단점

• 성능 문제: ORM 사용 시 발생할 수 있는 성능 저하 문제는 주의 깊게 고려해야 합니다. ORM은 개발자 대신 SQL을 생성하기 때문에, 때때로 비효율적인 쿼리가 생성될 수 있습니다.
• 복잡한 쿼리: 복잡한 쿼리를 ORM으로 표현하기 어려울 수 있으며, 이 경우 ORM의 이점이 줄어들 수 있습니다.

예시

• Hibernate (Java): Java 언어를 위한 강력한 ORM 프레임워크 중 하나입니다.
• Entity Framework (.NET): .NET 애플리케이션 개발을 위한 Microsoft의 ORM 솔루션입니다.
• Django ORM (Python): Django 웹 프레임워크에 내장된 ORM 시스템입니다.
• Sequelize (Node.js): Node.js 애플리케이션을 위한 Promise 기반의 ORM입니다.

ORM은 데이터베이스 작업을 보다 편리하게 만들어 주지만, 사용 시에는 그 한계와 성능에 대한 고려가 필요합니다.

JPA (Java Persistence API)

JPA는 자바 애플리케이션에서 관계형 데이터베이스를 사용하는 방식을 정의한 API입니다. 자바 표준 명세(Specification)로, 자바 EE(Enterprise Edition) 환경뿐만 아니라 자바 SE(Standard Edition) 환경에서도 사용할 수 있습니다. JPA는 ORM(Object-Relational Mapping) 기법을 사용하여 객체와 데이터베이스 테이블 사이의 매핑을 처리합니다. 이를 통해 개발자는 데이터베이스와 상호작용할 때 복잡한 SQL 쿼리 대신 고수준의 객체 지향 모델을 사용할 수 있게 됩니다.

 

JPA의 핵심 기능은 다음과 같습니다:

• 엔티티(Entity): 데이터베이스 테이블을 자바 클래스로 매핑합니다.
• 엔티티 매니저(Entity Manager): 엔티티의 생명주기를 관리합니다.
• 쿼리 언어(JPQL, JPA Query Language): 데이터베이스 쿼리를 위한 플랫폼 독립적인 쿼리 언어를 제공합니다.

하이버네이트 (Hibernate)

하이버네이트는 JPA의 구현체 중 하나로, 가장 널리 사용되는 오픈 소스 ORM 프레임워크입니다. 하이버네이트는 JPA 명세를 준수함과 동시에 JPA가 제공하지 않는 추가적인 기능을 제공합니다. 하이버네이트를 사용하면 데이터베이스와의 상호작용을 위한 복잡한 코드를 대폭 줄일 수 있으며, 데이터베이스 독립적인 애플리케이션 개발이 가능해집니다.

 

하이버네이트의 주요 특징은 다음과 같습니다:

• 풍부한 매핑 기능: 상속, 컴포지션, 다양한 연관 관계 등 복잡한 객체 모델을 데이터베이스에 매핑할 수 있는 강력한 기능을 제공합니다.
• 캐싱: 세션 및 쿼리 캐시를 지원하여 애플리케이션의 성능을 향상시킵니다.
• 지연 로딩(Lazy Loading): 필요할 때까지 연관된 객체의 로딩을 지연시키는 기능을 제공하여 성능을 최적화합니다.
• 자동 스키마 생성: 매핑된 엔티티 기반으로 데이터베이스 스키마를 자동으로 생성하거나 업데이트할 수 있습니다.

JPA vs 하이버네이트

• JPA는 자바 애플리케이션에서 데이터 영속성을 관리하기 위한 표준 인터페이스를 제공하는 반면, 하이버네이트는 이러한 JPA의 구현체 중 하나입니다.
• JPA를 사용하면 구현체를 하이버네이트에서 다른 구현체로 쉽게 변경할 수 있는 반면, 하이버네이트를 직접 사용하면 하이버네이트에 특화된 기능을 사용할 수 있지만, 다른 구현체로의 전환은 더 어려워질 수 있습니다.
• 하이버네이트는 JPA가 제공하지 않는 추가적인 기능과 성능 최적화 기능을 제공합니다.

개발자가 JPA와 하이버네이트 중 어떤 것을 선택해야 할지는 프로젝트의 요구 사항, 특정 기능에 대한 필요성, 개발 팀의 선호도 등 여러 요소를 고려하여 결정해야 합니다.

엔티티 매니저(Entity Manager)

JPA(Java Persistence API)에서 제공하는 핵심 인터페이스 중 하나로, 엔티티의 생명주기를 관리하고, 데이터베이스 작업을 수행하는 데 사용됩니다. 엔티티 매니저를 통해 애플리케이션은 데이터베이스에 엔티티를 저장, 조회, 업데이트, 삭제 등의 작업을 할 수 있으며, 트랜잭션 관리와 쿼리 실행도 가능합니다.

엔티티 매니저의 주요 기능

• 엔티티의 생명주기 관리: 엔티티 매니저는 엔티티 인스턴스의 상태(새로 생성된 상태, 관리 상태, 분리된 상태, 삭제된 상태)를 관리합니다.
• CRUD 작업 수행: Create, Read, Update, Delete 작업을 위한 API를 제공합니다.
  • persist(Object entity): 엔티티를 영속 상태로 만들어 데이터베이스에 저장합니다.
  • find(Class<T> entityClass, Object primaryKey): 주어진 기본 키에 해당하는 엔티티를 찾아 반환합니다.
  • merge(Object entity): 엔티티의 상태를 데이터베이스에 반영하여 업데이트합니다.
  • remove(Object entity): 엔티티를 데이터베이스에서 삭제합니다.
• 쿼리 실행: JPQL(Java Persistence Query Language)이나 Criteria API를 사용하여 데이터베이스 쿼리를 실행할 수 있습니다.
• 트랜잭션 관리: getTransaction()을 사용하여 트랜잭션을 시작, 커밋, 롤백할 수 있습니다.

엔티티 매니저 사용 예제

EntityManagerFactory emf = Persistence.createEntityManagerFactory("persistenceUnitName");
EntityManager em = emf.createEntityManager();

em.getTransaction().begin(); // 트랜잭션 시작

// 엔티티 저장
User user = new User();
user.setName("John Doe");
em.persist(user);

// 엔티티 조회
User foundUser = em.find(User.class, user.getId());

// 엔티티 업데이트
foundUser.setName("Jane Doe");
em.merge(foundUser);

// 엔티티 삭제
em.remove(foundUser);

em.getTransaction().commit(); // 트랜잭션 커밋

em.close();
emf.close();

엔티티 매니저는 데이터베이스와의 상호작용을 추상화하고, 객체 지향적인 방식으로 데이터를 관리할 수 있게 해줍니다. 이를 통해 개발자는 복잡한 SQL 쿼리나 데이터베이스 작업에 대한 세부 사항을 신경 쓰지 않고, 비즈니스 로직에 더 집중할 수 있습니다.

영속성 컨텍스트(Persistence Context)

JPA(Java Persistence API)에서 엔티티(Entity)들을 저장하고 관리하는 환경 또는 영역을 의미합니다. 영속성 컨텍스트는 엔티티 매니저(Entity Manager)에 의해 관리되며, 애플리케이션과 데이터베이스 사이에서 엔티티의 생명주기를 관리하는 중요한 역할을 수행합니다.

영속성 컨텍스트의 주요 기능과 특징

• 엔티티의 생명주기 관리: 영속성 컨텍스트는 엔티티의 상태(비영속, 영속, 준영속, 삭제)를 관리합니다. 엔티티가 영속성 컨텍스트에 포함되어 있으면 영속 상태가 됩니다.
• 1차 캐시: 영속성 컨텍스트는 조회된 엔티티를 메모리 내에 캐시하여, 같은 트랜잭션 내에서 같은 엔티티에 대한 조회가 발생할 경우 데이터베이스 접근 없이 캐시된 엔티티를 반환합니다.
• 동일성(Identity) 보장: 같은 영속성 컨텍스트 내에서는 동일한 데이터베이스 레코드에 대응하는 엔티티 인스턴스가 단 하나만 존재함을 보장합니다. 이는 애플리케이션에서 데이터 일관성을 유지하는 데 도움이 됩니다.
• 트랜잭션 지원: 영속성 컨텍스트는 트랜잭션 범위 내에서 작동하며, 트랜잭션이 커밋되는 시점에 변경된 엔티티를 데이터베이스에 반영(플러시)합니다.
• 변경 감지(Dirty Checking): 영속 상태의 엔티티에 대한 변경사항을 자동으로 감지하고, 트랜잭션 커밋 시 변경된 내용을 데이터베이스에 자동으로 반영합니다.
• 지연 로딩(Lazy Loading): 연관된 엔티티나 컬렉션을 실제 사용되는 시점까지 로딩을 지연시키는 기능을 지원합니다.

영속성 컨텍스트의 이점

• 성능 최적화: 1차 캐시와 변경 감지 기능을 통해 애플리케이션의 성능을 향상시킬 수 있습니다.
• 데이터 일관성 유지: 동일성 보장으로 인해 애플리케이션 내에서 데이터의 일관성을 유지할 수 있습니다.
• 개발 생산성 향상: 엔티티의 상태 변화를 자동으로 관리하므로, 개발자는 데이터베이스 연산에 드는 수고를 줄이고 비즈니스 로직에 더 집중할 수 있습니다.

영속성 컨텍스트는 JPA를 사용하는 애플리케이션에서 데이터를 다루는 방식을 추상화하고, 객체 지향적인 데이터 접근을 가능하게 하는 핵심적인 개념입니다.

 

JPA(Java Persistence API)에서 엔티티(Entity)의 상태는 엔티티의 생명주기 동안 여러 가지 형태를 가질 수 있습니다. JPA에서 관리하는 엔티티 상태는 주로 다음과 같은 네 가지입니다:

1. 비영속 (New or Transient)

• 엔티티가 새로 생성되었지만 아직 영속성 컨텍스트(Persistence Context)에 저장되지 않은 상태입니다. 이 상태의 엔티티는 JPA가 관리하지 않으며, 따라서 데이터베이스에도 존재하지 않습니다.

2. 영속 (Managed)

• 엔티티가 영속성 컨텍스트에 저장된 상태입니다. 이 상태의 엔티티는 JPA가 관리하며, 트랜잭션이 커밋되는 시점에 변경 사항이 데이터베이스에 반영됩니다. 엔티티 매니저(Entity Manager)를 통해 엔티티를 조회하거나 persist 메서드를 사용해 엔티티를 저장할 때 영속 상태가 됩니다.

3. 준영속 (Detached)

• 엔티티가 이전에 영속 상태였으나 현재 영속성 컨텍스트에서 분리된 상태입니다. 이 상태의 엔티티는 JPA가 더 이상 관리하지 않습니다. detach 메서드를 호출하거나 영속성 컨텍스트가 종료될 때 엔티티가 준영속 상태가 됩니다. 준영속 상태의 엔티티를 다시 영속 상태로 만들려면 merge 메서드를 사용해야 합니다.

4. 삭제 (Removed)

• 엔티티가 영속성 컨텍스트에서 삭제를 위해 표시된 상태입니다. 이 상태의 엔티티는 트랜잭션이 커밋되는 시점에 데이터베이스에서도 삭제됩니다. remove 메서드를 사용하여 엔티티를 삭제 상태로 만들 수 있습니다.

이러한 엔티티의 상태는 엔티티의 생명주기를 관리하고, 데이터베이스와의 상호작용을 효율적으로 처리하는 데 중요한 역할을 합니다. 각 상태에 따라 JPA가 엔티티에 적용하는 작업이 달라지므로, 애플리케이션 개발 시 이러한 상태 변화를 이해하고 적절히 관리하는 것이 중요합니다.

 

JPA에서 엔티티 상태를 관리하는 예시 코드를 통해 비영속, 영속, 준영속, 삭제 상태의 변화를 설명합니다. 이 예제에서는 간단한 User 엔티티를 사용하며, JPA를 구성하기 위한 기본 설정이 이미 완료되었다고 가정합니다.

User 엔티티 정의

먼저, User 엔티티를 정의합니다:

package com.example.demo.model;

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

@Entity
public class User {

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

    private String name;

    // 생성자, 게터, 세터 생략
}

엔티티 상태 변화 예시

다음은 EntityManager를 사용하여 User 엔티티의 상태 변화를 보여주는 예시입니다:

package com.example.demo;

import com.example.demo.model.User;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JpaExample {

    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("example-unit");
        EntityManager em = emf.createEntityManager();

        // 비영속 상태 (New / Transient)
        User newUser = new User();
        newUser.setName("John Doe");

        em.getTransaction().begin();

        // 영속 상태 (Managed)
        em.persist(newUser);

        // 준영속 상태 (Detached)
        em.detach(newUser);

        // 다시 영속 상태로 만듦 (Managed)
        User mergedUser = em.merge(newUser);

        // 삭제 상태 (Removed)
        em.remove(mergedUser);

        em.getTransaction().commit();
        em.close();
        emf.close();
    }
}

설명

1. 비영속 상태 (New / Transient): 새로운 User 인스턴스를 생성했지만, 아직 EntityManager와 관련이 없어 비영속 상태입니다.
2. 영속 상태 (Managed): persist 메소드를 호출하여 User 인스턴스를 영속성 컨텍스트에 저장함으로써, 이 인스턴스는 영속 상태가 됩니다. 이 상태에서는 데이터베이스에 반영되지 않았어도 JPA가 관리합니다.
3. 준영속 상태 (Detached): detach 메소드를 호출하여 영속성 컨텍스트에서 User 인스턴스를 분리합니다. 이 상태에서는 JPA가 더 이상 인스턴스를 관리하지 않습니다.
4. 다시 영속 상태로 만듦: merge 메소드를 사용하여 준영속 상태의 인스턴스를 다시 영속 상태로 전환할 수 있습니다.
5. 삭제 상태 (Removed): remove 메소드를 호출하여 User 인스턴스를 삭제 상태로 만듭니다. 트랜잭션이 커밋될 때 데이터베이스에서도 삭제됩니다.

이 예제는 JPA에서 엔티티의 생명주기를 어떻게 관리하는지를 보여줍니다. 실제 애플리케이션에서는 엔티티의 상태에 따라 다양한 비즈니스 로직을 수행할 수 있습니다.

스프링 데이터 (Spring Data)

스프링 데이터(Spring Data)는 데이터 액세스를 추상화하고, 다양한 데이터 저장 기술(관계형 데이터베이스, NoSQL 데이터베이스, 맵-리듀스 프레임워크 등)에 대한 일관된 접근 방식을 제공하는 스프링 프로젝트의 일부입니다. 스프링 데이터는 데이터 액세스 계층을 더 쉽고 효율적으로 구현할 수 있도록 설계되었으며, 반복적인 CRUD(Create, Read, Update, Delete) 작업과 페이징, 정렬 등의 공통 작업을 위한 API를 제공합니다.

스프링 데이터는 다음과 같은 특징을 가집니다:

• 다양한 데이터 저장 기술 지원: 스프링 데이터 JPA, 스프링 데이터 MongoDB, 스프링 데이터 Redis 등 다양한 모듈을 통해 여러 저장 기술을 지원합니다.
• 리포지토리 추상화: 데이터 접근을 위한 공통 인터페이스를 제공하며, 개발자는 인터페이스만 정의하면 실행 시 구현체가 자동으로 생성됩니다.
• 쿼리 메소드 생성: 메소드 이름만으로 쿼리를 생성할 수 있는 기능을 제공하여, 간단한 쿼리는 별도의 구현 없이 사용할 수 있습니다.
• 페이징과 정렬: 페이징과 정렬을 위한 편리한 처리 방법을 제공합니다.

스프링 데이터 JPA

스프링 데이터 JPA(Spring Data JPA)는 스프링 데이터 프로젝트의 하위 모듈 중 하나로, JPA(Java Persistence API)를 사용하여 관계형 데이터베이스를 쉽게 다룰 수 있도록 도와줍니다. 스프링 데이터 JPA는 JPA를 기반으로 하며, JPA를 좀 더 편리하게 사용할 수 있는 고수준의 추상화와 간편한 API를 제공합니다.

스프링 데이터 JPA의 주요 특징은 다음과 같습니다:

• 리포지토리 인터페이스 자동 구현: 개발자가 리포지토리 인터페이스를 정의하면, 스프링 데이터 JPA가 실행 시 이를 구현한 프록시 객체를 자동으로 생성합니다.
• 쿼리 메소드 자동 생성: 메소드 이름을 분석하여 JPQL 쿼리를 생성합니다. 복잡한 쿼리는 @Query 어노테이션을 사용하여 직접 정의할 수도 있습니다.
• 페이징과 정렬 지원: Pageable과 Sort 인터페이스를 통해 페이징과 정렬 기능을 쉽게 구현할 수 있습니다.

사용 예시

스프링 데이터 JPA를 사용한 간단한 리포지토리 인터페이스 예시입니다:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 사용자 이름으로 검색하는 쿼리 메소드
    List<User> findByName(String name);
}

이 인터페이스는 JpaRepository를 확장하고 있으며, findByName 메소드를 통해 이름에 해당하는 사용자를 검색하는 쿼리 메소드를 정의합니다. 스프링 데이터 JPA는 이 인터페이스를 기반으로 실행 시 적절한 쿼리를 자동으로 생성하고 실행하는 구현체를 제공합니다.

 

스프링 데이터 JPA를 사용하면, 복잡한 데이터 액세스 로직을 간결하게 구현할 수 있으며, 개발 생산성과 애플리케이션의 유지보수성을 크게 향상시킬 수 있습니다.

 

스프링 데이터 JPA는 리포지토리 레이어를 구현할 때 반복적인 CRUD 작업을 줄여주는 다양한 메소드를 제공합니다. 이러한 메소드들은 JpaRepository 인터페이스에 정의되어 있으며, 이 인터페이스를 상속하는 리포지토리 인터페이스에 자동으로 상속됩니다.

주요 제공 메소드

• save(S entity): 주어진 엔티티를 저장하고, 그 엔티티를 반환합니다. 엔티티가 새로운 경우에는 INSERT를, 이미 존재하는 경우에는 UPDATE를 실행합니다.
• findById(ID id): 주어진 ID로 엔티티를 조회합니다. 결과는 Optional<T>로 반환됩니다.
• findAll(): 모든 엔티티를 리스트로 반환합니다.
• findAll(Sort sort): 모든 엔티티를 정렬 기준에 맞춰 리스트로 반환합니다.
• findAllById(Iterable<ID> ids): 주어진 ID 컬렉션에 해당하는 모든 엔티티를 리스트로 반환합니다.
• delete(T entity): 주어진 엔티티를 삭제합니다.
• deleteById(ID id): 주어진 ID의 엔티티를 삭제합니다.
• count(): 리포지토리에 존재하는 엔티티의 총 개수를 반환합니다.
• existsById(ID id): 주어진 ID의 엔티티가 존재하는지 여부를 반환합니다.

예시 코드

아래 예시에서는 간단한 User 엔티티에 대한 UserRepository 인터페이스를 정의하고, 스프링 데이터 JPA가 제공하는 메소드를 사용하는 방법을 보여줍니다.

User 엔티티 정의

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

@Entity
public class User {

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

    private String name;
    private String email;

    // 생성자, 게터, 세터 생략
}

UserRepository 인터페이스 정의

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    // 사용자의 이메일로 검색하는 메소드
    List<User> findByEmail(String email);
}

UserRepository 사용 예

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public Optional<User> getUser(Long id) {
        return userRepository.findById(id);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }

    public long getUserCount() {
        return userRepository.count();
    }
}

이 예시에서 UserRepository는 JpaRepository를 상속받아 스프링 데이터 JPA가 제공하는 기본 CRUD 메소드와 함께 findByEmail이라는 쿼리 메소드를 추가로 정의합니다. UserService에서는 이러한 메소드들을 사용하여 실제 비즈니스 로직을 구현합니다.

자동 키 생성 방식

JPA에서 엔티티의 기본 키(Primary Key)를 자동으로 생성하기 위한 전략은 @GeneratedValue 어노테이션을 사용하여 지정할 수 있습니다. @GeneratedValue 어노테이션은 strategy 속성을 통해 다음과 같은 키 생성 전략을 제공합니다:

1. AUTO (기본값): 퍼시스턴스 프로바이더가 자동으로 가장 적합한 전략을 선택합니다.
2. @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id;
3. IDENTITY: 데이터베이스의 IDENTITY 컬럼을 사용하여 기본 키를 생성합니다. 이 전략은 데이터베이스에 의존적이며, 주로 MySQL이나 PostgreSQL에서 사용됩니다.
4. @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
5. SEQUENCE: 데이터베이스의 시퀀스를 사용하여 기본 키를 생성합니다. @SequenceGenerator 어노테이션과 함께 시퀀스의 이름과 할당 크기 등을 지정할 수 있습니다. 주로 Oracle, PostgreSQL, DB2, H2 데이터베이스에서 사용됩니다.
6. @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "entity_seq_gen") @SequenceGenerator(name = "entity_seq_gen", sequenceName = "entity_seq", allocationSize = 1) private Long id;
7. TABLE: 키 생성 전용 테이블을 사용하여 기본 키를 생성합니다. @TableGenerator 어노테이션과 함께 사용하여, 키 저장용 테이블과 컬럼 이름 등을 지정할 수 있습니다. 이 전략은 모든 데이터베이스에서 사용할 수 있지만, 성능에 영향을 줄 수 있습니다.
8. @Id @GeneratedValue(strategy = GenerationType.TABLE, generator = "entity_table_gen") @TableGenerator(name = "entity_table_gen", table = "entity_keys", pkColumnName = "key_name", valueColumnName = "key_val", allocationSize = 1) private Long id;

@Column 어노테이션 속성

@Column 어노테이션은 엔티티의 필드가 데이터베이스 테이블의 컬럼에 어떻게 매핑될지 지정하는 데 사용됩니다. 주요 속성은 다음과 같습니다:

• name: 데이터베이스 테이블의 컬럼 이름을 지정합니다.
• @Column(name = "user_name") private String username;
• nullable: 컬럼이 null 값을 허용할지 여부를 지정합니다. 기본값은 true입니다.
• @Column(nullable = false) private String email;
• length: 문자열 컬럼의 길이를 지정합니다. String 타입에만 사용됩니다.
• @Column(length = 50) private String firstName;
• unique: 컬럼의 값이 유일해야 하는지 여부를 지정합니다. 기본값은 false입니다.
• @Column(unique = true) private String email;
• updatable: 엔티티가 갱신될 때 컬럼 값이 갱신되어야 하는지 여부를 지정합니다. 기본값은 true입니다.
• @Column(updatable = false) private LocalDateTime createdAt;
• insertable: 엔티티가 저장될 때 컬럼 값이 저장되어야 하는지 여부를 지정합니다. 기본값은 true입니다.
• @Column(insertable = false) private LocalDateTime updatedAt;

@Column 어노테이션을 사용하면 엔티티 필드가 데이터베이스 테이블의 컬럼과 어떻게 매핑될지 세밀하게 제어할 수 있습니다. 이는 데이터베이스 설계와 애플리케이션의 데이터 모델 간의 일관성을 유지하는 데 도움이 됩니다.