Spring JPA Entity 설정

Entity 생성하기(Domain 생성하기, Table 생성하기)

Entity 생성하기

  엔티티(Entity)란 JPA에서 데이터베이스 테이블과 매핑되는 클래스를 의미하며, 각 엔티티 객체는 데이터베이스에서 독립적으로 관리되는 레코드(행, row)를 나타냅니다. 자바클래스 중 DB Table과 연결할 클래스를 marking하기 위해서 @Entity을 사용한다. 또한, class명과 DB Table명이 다르다면 Class에 @Table(name="")을 통해서 어떤 테이블과 맵핑할 것인지 명시해줘야한다.

• @Entity : JPA에서 해당 클래스가 데이터베이스 테이블과 매핑됨을 나타내는 필수 애너테이션
• @Table(name="테이블명") : 클래스명과 테이블명을 다르게 지정하고 싶은 경우에는 @Table 어노테이션을 사용하여 원하는 테이블명을 명시

Entity의 Column 설정하기

그리고 Table column들의 속성을 annotation을 통해서 셋팅해둔다.  어떤 필드를 PK로 지정하기 위해서 @Id를 쓰고, DB 내에서 autoincrement의 속성을 살리기위해서 @GeneratedValue(Strategy = GenerationType.IDENTITY)을 사용하여준다.

• @Id:  엔티티 클래스를 정의할 때는 기본적으로 기본 키(primary key)로 사용할 필드를 지정합니다 
  • @GeneratedValue(Strategy = ? ) : 기본 키의 자동 생성 전략을 설정합니다.
    
    • GenerationType.AUTO: JPA가 데이터베이스에 맞는 생성 전략을 자동으로 선택합니다.
    • GenerationType.IDENTITY: AUTO_INCREMENT와 같이 데이터베이스가 기본 키 값을 생성하도록 설정합니다.
    • GenerationType.SEQUENCE: 시퀀스를 사용하여 기본 키를 생성합니다. Oracle 등에서 주로 사용됩니다.
    • GenerationType.TABLE: 고유성을 보장하는 테이블을 이용해 기본 키를 생성합니다.

@Entity(name = "memo")
public class Memo {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String text;
}

 

• @Enumerated: Enum 타입의 필드를 데이터베이스에 저장할 때 어떤 형태로 저장할지 지정합니다. 
  • EnumType.ORDINAL: Enum의 순서를 정수 값으로 저장합니다. (0, 1, 2 등)
  • EnumType.STRING: Enum 이름 자체를 문자열로 저장합니다.

 

• @Embeddedid :  to define a composite primary key in an entity
  • @Embeddable is used to define the composite key class.

import jakarta.persistence.Embeddable;
import java.io.Serializable;
import java.util.Objects;

@Embeddable
public class OrderId implements Serializable {
    private Long customerId;
    private Long productId;

    public OrderId() {} // Default constructor required

    public OrderId(Long customerId, Long productId) {
        this.customerId = customerId;
        this.productId = productId;
    }

    // Getters
    public Long getCustomerId() { return customerId; }
    public Long getProductId() { return productId; }

    // equals() and hashCode() are required for composite keys
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        OrderId orderId = (OrderId) o;
        return Objects.equals(customerId, orderId.customerId) &&
                Objects.equals(productId, orderId.productId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(customerId, productId);
    }
}

@Entity
public class Order {

    @EmbeddedId
    private OrderId id; // ✅ Composite Primary Key

• JPA를 통해서 EmbeddedID사용하기

public interface OrderRepository extends JpaRepository<Order, OrderId> {
    // Custom query: Count orders by a specific product
    long countByIdProductId(Long productId);
}

 

 

 

 

 

 

• @Column: 열의 속성을 설정하는 데 사용됩니다.
  
  • unique = true: 해당 열에 유일값을 허용하여 중복을 방지합니다.
  • columnDefinition = "POINT": 특정 SQL 데이터 타입을 명시적으로 지정할 때 사용됩니다. 예를 들어, POINT 타입은 위치 데이터를 저장할 때 사용합니다.
  • nullable = true: NULL 값을 허용합니다.
  • name = "name" DB에서의 column name을 설정해준다.

@Column(unique = true, nullable = false, columnDefinition = "POINT")
private String location;

• @Table(uniqueConstraints = {...}):  단일 컬럼의 유니크 제약 조건은 @Column(unique = true) 로 지정할 수 있지만, 두 개 이상의 컬럼 조합에 대해 유니크 제약 조건을 설정하려면 @Table(uniqueConstraints = {...}) 를 사용해야 합니다.
  
  • @UniqueConstraint(columnNames = {...}): 유니크 제약 조건을 적용할 컬럼을 지정하는 역할을 합니다
  • @UniqueConstraint(columnNames = {"companyId", "date"}) 를 설정했기 때문에, 데이터베이스에서 (companyId, date) 조합이 중복되지 않도록 자동으로 검사합니다.

@Entity
@Table(
    name = "dividend", // 테이블명 지정
    uniqueConstraints = {
        @UniqueConstraint(columnNames = {"companyId", "date"}) // companyId + date 조합을 유니크 키로 설정
    }
)
public class DividendEntity {

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

    private Long companyId;

    private String date;

    private Double dividendAmount;
}

• @Transient : DB에 저장하지 않지만 entity 객체에 저장하고 싶은 내용을 저장

// A list to hold each status without persisting it to the database
@Transient
private List<Enum<?>> statuses;

// You can initialize this list in the constructor or a method
public void initializeStatuses() {
    this.statuses = List.of(participationStatus, depositStatus, ratingStatus);
}

 

• @Convert : customize how entity attributes are stored in the database by specifying a converter class.

@Table(name = "auth_menu")
public class AuthMenu extends BaseEntity {

    @EmbeddedId
    private AuthMenuKey id;

    @Convert(converter = YesNoConverter.class)
    @Column(name = "create_yn", length = 1)
    @Comment("생성 권한")
    private YesNoType createYn;

• @comment : used for database column comments.

 

 

 

Entity생성시 고려사항

• Entity의 값을 변경하는 중요한 로직은  Entity class 외에서 실행하더라도, Entity내에서 메소드를 정의하고 이것을 호출하는 형식으로 진행할 필요가 있음. (Encapsulation, Static Factory)
• Entity의 자동생성ID외의 식별자는 일반적으로 UUID를 통한 유일한 생성자 생성에 많이 사용한다. ;

import java.util.UUID;

@Entity
public class User {
    @Id
    private String id; // UUID를 문자열로 저장

    private String name;

    protected User() {} // JPA 기본 생성자

    // 정적 팩토리 메서드 사용 (UUID 자동 생성)
    public static User create(String name) {
        User user = new User();
        user.id = UUID.randomUUID().toString();
        user.name = name;
        return user;
    }
}

테이블 관계설정 

Collection과 Entity의 연결

• @ElementCollection : 필드로 값 타입(Value Type) 컬렉션을 저장할 때 사용하는 JPA 애너테이션. Entity와 컬렉션의 값들을 맵핑하기 위한 추가 테이블을 생성하여 관계를 관리함.
  
  • 이 추가 테이블의 개별행은 기본 키로는 원본 엔티티의 기본 키(PK)와 컬렉션 값 칼럼을 조합한 복합키(Composite Key)로 구성됩니다.
  •  @CollectionTable : @ElementCollection 필드에 대한 테이블의 이름과 원본 엔티티에서 외래키로 사용할 칼럼을 설정

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

    private String name;

    @ElementCollection
    @CollectionTable(name = "user_roles", joinColumns = @JoinColumn(name = "user_id"))
    @Column(name = "role")
    private List<String> roles;
}

 

user 테이블 (User 엔티티)

id (PK)	name
1	Alice
2	Bob

 

user_roles 테이블 (@ElementCollection으로 생성된 추가 테이블)

user_id (FK, PK)	role (PK)
1	ADMIN
1	USER
2	USER

 

Entity 간의 연결

  JPA는 SQL에서의 외래 키(Foreign Key)로 관계를 만드는 방법과 동일하게, 테이블 간의 관계를 연관된 엔티티 클래스를 다른 엔티티의 필드로 정의하여 설정할 수 있습니다. 연관된 엔티티에 JPA어노테이션(@ManyToOne, @OneToMany, @ManyToMany, @OneToOne)을 사용하여 테이블 간 관계를 정의합니다. 

일대다 관계

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

    @ManyToOne
    @JoinColumn(name = "user_id", nullable = false) // FK 설정
    private UserEntity user; // 부모 테이블(UserEntity) 참조
}

• @ManyToOne : 적용되는 연관엔티티가 원본 엔티티와 다대일 관계(자식-부모관계)임을 설정
  
  • @JoinColumn (name = "저장할 FK의 칼럼명", referencedColumnName = " FK로 사용할 연관 테이블의 칼럼 지정") :연관 엔티티 FK로 연결할 칼럼과 칼럼의 이름을 명시적으로 선언할때 사용, 생략시 연관 테이블의 PK를 FK로 사용
    
    • FK를 선언하고 관리하는 어노테이션으로 해당 어노테이션을 갖은 원본 엔티티는 관계를 소유하는 Owning table임
    • unique : Ensures that each value in the foreign key column is unique. used in one-to-one relationships.
    • nullable :  foreign key column to be non NULL. 테이블간 연관관계가 깨지지않게 방지하기 위해서 사용
    • insertable and updatable 속성 :
      • EmbeddedId 칼럼처럼 forienkey를 관리하는 별도의 칼럼이 있어서 해당 칼럼을 readonly로 만든다.
      • 엄밀하게 말하면 dirtychecking이후 sql을 생성할때 해당 칼럼을 무시한다는 의미
      • 해당 속성이 false로 있는 경우 embedded id를 보유하는 경우이며 pk를 변경해야만 fk를 변경할 수 있는데 pk를 변경하면 새로운 record가 생성되므로 결국에는 부모 entity에서 orphan removal이나 cascade all로 관리해야함.

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

    @OneToMany(mappedBy = "user") // 연관관계의 주인은 OrderEntity
    private List<OrderEntity> orders = new ArrayList<>();
}

 

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderEntity> orders = new ArrayList<>();

• @OnetoMany : 일대다 관계를 설정
  • mappedBy 속성을 사용하여 연관관계의 주인(외래 키를 핸들링하는 테이블, 즉, 자식테이블)을 지정하여 접근 즉, 부모 엔티티에서 자식 리스트를 참조할 때 사용
    • 단 List를 접근할때, N+1 문제 발생할 여지가있음
  • cascade = CascadeType.ALL : When the parent is saved or removed, children are created/removed with it
  • orphanRemoval = true : “If an OrderEntity is removed from the orders list, and it no longer has a parent UserEntity, delete it from the database.”
    • Cascade All이나 orphanremoval이 아니라면 owning entity에서만 두 entity 관계가 조정될 수 있음 

UserEntity user = new UserEntity();
OrderEntity order = new OrderEntity();
order.setUser(user);

user.getOrders().add(order);
userRepository.save(user); // ✅ This will also save `order` automatically

user.getOrders().remove(order); // ✅ This will delete the order from DB when user is saved
userRepository.save(user);

 

 

다대다관계

• @ManyToMany  :  다대다(Many-to-Many) 관계를 나타냄.
  • 비즈니스 로직 : *학생(Student)**과 **수업(Course)**의 관계에서는 한 학생이 여러 수업에 참여할 수 있고, 한 수업에는 여러 학생이 참여할 수 있습니다.  
  •  @JoinTable  : 다대다다 관계에서는 별도의 조인 테이블이 필요하며, @JoinTable을 통해 커스터마이징합니다. 이 설정을 통해 양방향으로 관계를 탐색할 수 있습니다.
    
    • name: 조인 테이블의 이름을 지정합니다. 특별한 설정이 없다면 JPA가 자동으로 이름을 생성합니다.
    • joinColumns: 주도권을 가진 엔티티의 외래 키 컬럼을 설정합니다. 
    • inverseJoinColumns: 반대쪽 엔티티의 외래 키 컬럼을 설정합니다.

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany
    @JoinTable(name = "student_course",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id"))
    private List<Course> courses = new ArrayList<>();
}

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}

 

RDB상 JPA가 생성하는 테이블

 

CREATE TABLE student (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(255) NOT NULL
);

CREATE TABLE course (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        title VARCHAR(255) NOT NULL
);

CREATE TABLE student_course ( -- 중간 테이블 자동 생성
                                      student_id BIGINT NOT NULL,
                              course_id BIGINT NOT NULL,
                              PRIMARY KEY (student_id, course_id),  -- 복합키 설정
FOREIGN KEY (student_id) REFERENCES student(id),
FOREIGN KEY (course_id) REFERENCES course(id)
        );

• @ManyToMany를 사용하면 발생하는 문제점
  •  우선, RDB의 상태를 잘 반영하지 못함. RDB에서는 다대다를 구현하는 것이아니라 1:N + N:1 관계로 풀어냄
  • 연관관계가 복잡해질 경우 확장성이 떨어짐  : 추가적인 정보 저장 불가하기때문. 예를 들어, 수강 신청 날짜(enrollmentDate), 성적(grade) 같은 필드를 넣을 수 없음
  • JPA의 변경 감지(Dirty Checking)와 연관관계 관리 문제 :
    • @ManyToMany는 자동으로 중간 테이블을 관리하지만, 변경 감지가 어렵고 성능 최적화가 어려움. remove(student.getCourses().get(0))을 해도 변경 사항이 DB에 제대로 반영되지 않을 수 있음
      • 이는 @ManyToMany가 중간 테이블을 직접 관리하지 않기 때문에 발생함. 
      • JPA DirtyChecking에 대해서 이해필요
  • 때문에 유저와 권한과 같은 단순한 mapping 관계에만 사용하며 복잡한 관계에서는 oneTomany를 사용함.

 

다대다 관계 @OneToMany + @ManyToOne으로 풀어내기 (선호되는 방식)

 

 

실질적으로 ManyToMany 테이블은 많이 사용되지 않고  중간 테이블을 만들어 일대다(@OneToMany) 관계가 두 개 포함

된 엔티티를 형성하는 방식이 더 선호됩니다. 이 방식이 더 유연하고 관리가 용이하기 때문입니다.

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

    @OneToMany(mappedBy = "student")
    private Set<StudentCourse> studentCourses = new HashSet<>();
}

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

    @OneToMany(mappedBy = "course")
    private Set<StudentCourse> studentCourses = new HashSet<>();
}

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

    @ManyToOne
    @JoinColumn(name = "student_id")
    private Student student;

    @ManyToOne
    @JoinColumn(name = "course_id")
    private Course course;

    // 예: 관계에 대한 추가적인 속성
    private LocalDateTime enrollmentDate;
}

 

RDB상 JPA가 생성하는 테이블

CREATE TABLE student (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(255) NOT NULL
);

CREATE TABLE course (
        id BIGINT AUTO_INCREMENT PRIMARY KEY,
        title VARCHAR(255) NOT NULL
);

CREATE TABLE student_course ( -- 중간 테이블을 명시적으로 정의
                                      id BIGINT AUTO_INCREMENT PRIMARY KEY,
                              student_id BIGINT NOT NULL,
                              course_id BIGINT NOT NULL,
                              enrollment_date TIMESTAMP,  -- ✅ 추가 속성 저장 가능
                                      grade DOUBLE,               -- ✅ 추가 속성 저장 가능
                                      FOREIGN KEY (student_id) REFERENCES student(id),
FOREIGN KEY (course_id) REFERENCES course(id)
        );

 

 

 

 

 

Fetching Strategy of Related Entity

Fetching Strategy in JPA defines how and when related entities (associations) are loaded from the database when querying an entity.

 

EAGER Fetching:

• Loads related entities immediately when the parent entity is fetched.
  • meaning if select a record from a table, it will also fetch the related rows from the other table
  • Occurs even if the related entity is never accessed → Risk of unnecessary data loading (Performance Issue).
  • Default for @ManyToOne and @OneToOne.

LAZY Fetching:

• Loads related entities only when accessed (on-demand).
  • meaning JPA will fetch the related entities on demand (i.e., when you explicitly access the relationship property)
  • Prevents unnecessary data fetching, making queries more efficient.
  • Default for @OneToMany and @ManyToMany.

 

Best Practice는 기본적으로 모두 lazyloading으로 설정하고 필요에따라 커스컴 메소드를 eager fetching으로 변경하는 것.

N+1 Problem Case (ORM Specific Problem)

•  The N+1 problem occurs in JPA when fetching entities that have lazy-loaded relationships, leading to multiple additional queries being executed instead of a single optimized one. 
  •  usually happens when parent entity select child entity sequentially 
    • A collection of parent entities is fetched (List<UserEntity> users)
    • Each parent entity accesses its child entities (user.getOrders()) inside a loop
    • The child entities are lazily loaded (FetchType.LAZY)
• Simple case

List<UserEntity> users = userRepository.findAll(); // 1번 실행 (User 조회)

for (UserEntity user : users) {
        System.out.println(user.getOrders()); // N번 실행 (Order 조회)
        }

SELECT * FROM users;  -- (1 Query for Users)

SELECT * FROM orders WHERE user_id = 1;  -- (N Queries for Orders)
SELECT * FROM orders WHERE user_id = 2;
SELECT * FROM orders WHERE user_id = 3;
SELECT * FROM orders WHERE user_id = 4;
SELECT * FROM orders WHERE user_id = 5;

 

• Getting information of related table (Problem)
  • Analysis : auth table's all row  >> user-auth's findbyauthId ; N+1 Problem

public List<AuthorityDto.AuthListResDto> AuthoritiesListWithUserCount() {

    // auth List 전체호출
    List<Auth> auths = authRepository.findAll();
    
    // Loop 돌면서 userauth count 호출하기
    List<AuthorityDto.AuthListResDto> authListdtos = new ArrayList<>();
    for (Auth auth : auths) {
        userAuthRepository.countByIdAuthId(auth.getId());


        AuthorityDto.AuthListResDto authListResDto = AuthorityDto.AuthListResDto
                .builder()
                .authId(auth.getId())
                .name(auth.getName())
                .userAuthCount(userAuthRepository.countByIdAuthId(auth.getId()))
                .build();

        authListdtos.add(authListResDto);
    }


    return authListdtos;
}

 

• Getting information of related table (Solution1)
  • FetchJoin and use Size()
    • possible memory problem if UserAuthList is Large

public List<AuthorityDto.AuthListResDto> AuthoritiesListWithUserCount() {
    List<Auth> auths = authRepository.findAllWithUserAuths();

    return auths.stream()
            .map(auth -> new AuthorityDto.AuthListResDto(
                    auth.getId(),
                    auth.getName(),
                    auth.getUserAuthList().size() // Counting using size()
            ))
            .collect(Collectors.toList());
}

 

• Getting information of related table (Solution2)

@Repository
@RequiredArgsConstructor
public class AuthRepositoryImpl implements AuthRepositoryCustom {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<AuthorityDto.AuthListResDto> findAllWithUserCount() {
        return queryFactory
                .select(new QAuthorityDto_AuthListResDto(
                        auth.id,
                        auth.name,
                        userAuth.countDistinct()
                ))
                .from(auth)
                .leftJoin(userAuth).on(userAuth.auth.eq(auth))
                .groupBy(auth.id, auth.name)
                .fetch();
    }
}

 

 

 

 

Fetching strategies application at two levels

1. Static Fetching Strategy (Defined at Entity Level)
   
   • Applies to entity relationships (@OneToMany, @ManyToOne, etc.).
   • Configured via FetchType.EAGER or FetchType.LAZY.

@Entity
public class Order {

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

    @ManyToOne(fetch = FetchType.EAGER)  // Default for @ManyToOne
    private Customer customer;
}

 

2. Dynamic Fetching Strategy (Applied Per Query) 

• Overrides default fetch behavior for specific queries.
• Done using JPQL (JOIN FETCH), @EntityGraph, Criteria API, or Native Queries.

B. JPQL로 select문을 사용하여 eagerloading 전용의 Method를 설정할 수 있다.

@Query("SELECT m FROM MemberEntity m JOIN FETCH m.visitedHeritages WHERE m.memberId = :memberId")
Optional<MemberEntity> findByMemberIdWithVisitedHeritages(@Param("memberId") String memberId);

 

C. Entity를 사용한 관계테이블 생성이아니라 별도의 관계형 Repository를 생성하여 해당 Repository로부터 직접 Fetch를 한다.

@Entity
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class VisitedHeritageEntity {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false)
  private String memberId;

  @Column(nullable = false)
  private String heritageId;
}

Modifying Strategies of Related Entity

cascading (cascade) and orphan removal (orphanRemoval) control how child entities behave when the parent entity is modified.

• cascade in JPA
  • cascade attribute allows operations performed on a parent entity to propagate to its child entities.
    • There are multiple types of Cascade Operation
      • Saves child entities when parent is saved.
      • Updates child entities when parent is updated.
      • Deletes child entities when parent is deleted.
      • Refreshes child entities when parent is refreshed.
      • Detaches child entities when parent is detached from the persistence contex
  • 조심히 사용해야하는 편의기능이며 성능과는 무관하다. 단점으로는 아래와 같은 것이 있기에 수정할때 관련 레코드는 순차적으로 직접 수정할것같다.
    • 코드의 가독성이 저하될수 있다
    • 한번에 많은 양의 삭제로 성능문제가 발생할 수 잇다.
    • 실수로 데이터 손실이 발생할 수 있다.

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

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;
}

User user = new User();
Order order1 = new Order(user);
Order order2 = new Order(user);

user.getOrders().add(order1);
user.getOrders().add(order2);

entityManager.persist(user);  // 🚀 Saves both user and orders

 

• orphan removal in jpa
  • If a child entity is removed from the parent's collection, it is automatically deleted from the database.
  • It is different from CascadeType.REMOVE, which deletes children only when the parent is deleted.

@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders;

User user = entityManager.find(User.class, 1L);
user.getOrders().remove(0);  // 🚀 Order is also deleted from the database!