🔧 백엔드 개발자를 위한 JPA 핵심 정리

웹 서비스를 만들다 보면 사용자의 데이터를 저장하거나 불러오는 일이 정말 많습니다.

회원가입 시 입력한 정보, 게시판의 글과 댓글, 주문 내역 등 수많은 데이터가 오가죠.

 

그렇다면 이런 데이터는 어디에, 어떻게 저장되고 관리될까요?

 

Spring Boot로 API를 만들었다면 , 이제 다음 단계는 바로 데이터베이스와의 연동입니다.

단순히 save()만 한다고 끝나는 것이 아니라, JPA의 동작 원리, Entity와 Repository 설계, 연관관계 매핑, 트랜잭션 관리, 그리고 성능 최적화 전략까지 함께 이해해야 안정적이고 효율적인 백엔드 시스템을 만들 수 있습니다.

 

이번 글에서는 실무에서 자주 마주치는 데이터 처리의 핵심 개념들을 중심으로, JPA와 함께 백엔드 개발자가 반드시 알아야 할 내용들을 정리해 보겠습니다.

---

🔌 데이터베이스 연결의 기본기: JDBC와 ConnectionPool

JDBC란?

JDBC(Java Database Connectivity)는 자바에서 데이터베이스에 접근하기 위한 표준 API입니다.

DB에 연결하고, SQL을 실행하며, 결과를 처리하는 역할을 하죠.

 

하지만 순수 JDBC 방식은 실무에서 여러 한계를 드러냅니다. 요청이 들어올 때마다 매번 DB 연결을 새로 생성해야 하기 때문에 성능에 부담이 크고, try-catch-finally 구조가 반복돼 코드가 지저분해지기 쉽습니다. 게다가 자바 코드 안에 SQL이 섞이다 보니 유지보수도 어렵습니다.

 

이러한 이유로 우리는 커넥션 풀과 같은 기술을 함께 사용하며, 나아가 JPA 같은 ORM 도구로 더 효율적인 데이터 처리를 하게 됩니다.

 

Connection Pool 이란?

커넥션 풀은 미리 여러 개의 DB 연결을 생성해 두고, 요청이 들어올 때마다 하나씩 빌려주는 구조입니다.

Spring Boot에서는 기본적으로 HikariCP를 사용해 효율적인 연결을 제공합니다.

# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/app
    username: root
    password: pass
    driver-class-name: com.mysql.cj.jdbc.Driver
    
    # HikariCP 설정
    hikari:
      maximum-pool-size: 20        # 최대 연결 수
      minimum-idle: 5              # 최소 유지 연결 수
      connection-timeout: 3000     # 연결 대기 시간 (ms)
      idle-timeout: 600000         # 유휴 연결 제거 시간 (ms)
      max-lifetime: 1800000        # 연결 최대 수명 (ms)
      leak-detection-threshold: 60000  # 연결 누수 감지 시간

💡 실무 팁: ConnectionPool 크기는 CPU 코어 수의 2-3배 정도로 설정하는 것이 일반적입니다.

---

🔍 ORM과 JPA 생태계 이해하기

ORM이란?

ORM(Object-Relational Mapping)은 객체와 데이터베이스의 테이블을 매핑해 주는 기술입니다.

우리는 자바 객체를 다루지만, ORM이 이를 SQL로 변환하여 DB에 반영해 줍니다.

ORM이 도입되면 다음과 같은 장점이 있습니다:

• SQL 없이 객체 중심 개발 가능
• DB 독립적인 코드 작성
• 트랜잭션과 캐시를 통한 성능 최적화

JPA, Hibernate, Spring Data JPA 관계

기술	역할	설명
JPA	Java ORM 표준 스펙	인터페이스/어노테이션 정의
Hibernate	JPA 구현체	실제 ORM 기능 제공
Spring Data JPA	Spring의 JPA 추상화	Repository 패턴으로 편의 기능 제공

- JPA는 표준 인터페이스,

- Hibernate는 실제 동작을 수행하는 구현체,

- Spring Data JPA는 Repository 기반 추상화를 제공합니다.

---

🧩 Entity와 Repository 설계

Entity란?

Entity는 DB 테이블에 매핑되는 클래스입니다.

각 Entity는 고유한 ID와 컬럼을 가지고, JPA 어노테이션으로 정의합니다

@Entity
public class User {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private String email;
    
    // Getter, Setter, Constructor
}

 

Repository란?

Repository는 Entity에 대한 CRUD 작업을 추상화한 인터페이스입니다.

Spring Data JPA에서는 JpaRepository를 상속받아 사용합니다.

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

💡 복잡한 SQL 없이도 데이터 조작이 가능하고, 커스텀 쿼리도 메서드로 정의할 수 있어요.

 

---

🔗 연관관계 매핑 (1:1, 1:N, N:M)

JPA에서는 엔티티 간 관계도 객체처럼 표현할 수 있습니다.

• 1:1 관계 → @OneToOne
• 1:N / N:1 관계 → @OneToMany, @ManyToOne
• N:M 관계 → @ManyToMany (대신 중간 엔티티 권장)

 

예: 사용자와 게시글 (1:N)

@Entity
public class User {
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Post> posts = new ArrayList<>();
}

@Entity
public class Post {
    @ManyToOne(fetch = FetchType.LAZY)
    private User user;
}

 

지연로딩(LAZY) vs 즉시로딩(EAGER)은 성능에 큰 영향을 주므로 신중히 선택해야 합니다.

 

💡 실무 팁:
- 대부분의 연관관계는 LAZY로 설정하세요
- N:M 관계는 중간 테이블을 별도 엔티티로 풀어 관리하는 것이 좋습니다.

---

⚡ 트랜잭션과 영속성 컨텍스트

영속성 컨텍스트란?

영속성 컨텍스트는 JPA에서 엔티티를 1차 캐시에 저장하여 관리하는 공간입니다.

여기서 동일 객체를 재사용하고, 변경 감지를 통해 효율적인 UPDATE가 가능합니다.

트랜잭션 관리

Spring에서는 @Transactional 어노테이션으로 트랜잭션을 관리합니다.

@Service
@Transactional
public class UserService {
    public void register(User user) {
        userRepository.save(user);
        // 트랜잭션 커밋 시점에 DB 반영됨
    }
}

 

 

영속성 컨텍스트의 핵심 역할

• 1차 캐시: 동일한 객체 재사용 (조회 성능 향상)
• Dirty Checking: 변경 감지 후 자동 업데이트
• 지연 쓰기: 트랜잭션 커밋 시 일괄 반영

---

🚀 N+1 문제와 성능 최적화 전략

N+1 문제란?

N+1 문제는 JPA에서 가장 흔하게 발생하는 성능 이슈입니다.

연관된 엔티티를 조회할 때 추가 쿼리가 N번 실행되는 문제예요.

 

게시글 1번 조회 + 작성자 N번 조회 = 총 N+1번 쿼리 실행되는 문제입니다.

 

해결 방법

1. JPQL + Fetch Join

@Query("SELECT p FROM Post p JOIN FETCH p.user")
List<Post> findAllWithUser();

 

2. @EntityGraph

@EntityGraph(attributePaths = {"user"})
List<Post> findAll();

 

3. Batch Size 설정

spring:
  jpa:
    properties:
      hibernate:
        default_batch_fetch_size: 100

💡 데이터가 많을수록 페이징 + fetch join을 적절히 조합하는 전략이 중요합니다.

---

🛠️ 실무에서 자주 사용하는 JPA 패턴들

JPA는 단순한 CRUD를 넘어 실무에서 유용하게 활용할 수 있는 다양한 패턴들을 제공합니다.

아래는 그중 자주 사용되는 핵심 패턴들입니다.

 

1. Soft Delete (논리적 삭제)

DB에서 데이터를 물리적으로 삭제하지 않고, deleted라는 필드를 이용해 논리적으로 삭제된 것처럼 처리하는 방식입니다.

실무에서 데이터 복구나 이력 관리를 위해 자주 사용됩니다.

@Entity
@SQLDelete(sql = "UPDATE users SET deleted = true WHERE id = ?")
@Where(clause = "deleted = false")
public class User extends BaseEntity {

    @Column(name = "deleted")
    private boolean deleted = false;

    public void delete() {
        this.deleted = true;
    }
}

💡 @SQLDelete는 삭제 쿼리를 커스터마이징하고, @Where는 조회 시 조건을 자동으로 추가해 줍니다.

 

2. 버전 관리 (Optimistic Lock)

낙관적 락은 동시에 여러 트랜잭션이 같은 데이터를 수정하려 할 때 충돌을 방지하기 위한 전략입니다.

@Version 필드를 사용하면 자동으로 버전이 증가하며 충돌 여부를 체크할 수 있습니다.

@Entity
public class Product {

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

    private String name;
    private BigDecimal price;

    @Version
    private Long version; // JPA가 자동으로 증가시킴

    public void updatePrice(BigDecimal newPrice) {
        this.price = newPrice;
    }
}

💡 같은 데이터를 동시에 수정하려는 시도가 감지되면 OptimisticLockException이 발생합니다.

 

3. 감사(Audit) 정보 자동 관리

작성자, 수정자, 생성일, 수정일과 같은 정보를 자동으로 관리하고 싶을 때 JPA Auditing 기능을 활용할 수 있습니다.

이를 위해 설정 클래스와 @CreatedDate, @LastModifiedDate 등을 사용합니다.

@Configuration
@EnableJpaAuditing
public class JpaAuditingConfig {

    @Bean
    public AuditorAware<String> auditorAware() {
        return () -> {
            Authentication authentication = SecurityContextHolder
                .getContext().getAuthentication();

            if (authentication == null || !authentication.isAuthenticated()) {
                return Optional.of("system");
            }

            return Optional.of(authentication.getName());
        };
    }
}

 

그리고 BaseEntity 같은 추상 클래스에 공통 필드를 선언해 두고 상속받아 사용하면 관리가 편리해집니다.

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Getter
public abstract class BaseEntity {

    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    @CreatedBy
    @Column(updatable = false)
    private String createdBy;

    @LastModifiedBy
    private String updatedBy;
}

💡 엔티티에 @CreatedBy, @LastModifiedBy를 설정하면 사용자 정보를 자동 주입받을 수 있습니다.

---

🧡 마무리하며

이번 글에서는 백엔드 개발에서 핵심인 데이터베이스 연동부터 JPA 활용, 성능 최적화까지 실무에서 꼭 필요한 내용들을 정리해 봤습니다.

 

📌 핵심 요약

• 데이터베이스 연결: JDBC와 ConnectionPool의 중요성, HikariCP 설정
• ORM과 JPA: 객체-관계 매핑의 장점과 JPA 생태계 이해
• Entity 설계: BaseEntity, Repository 패턴, 커스텀 쿼리 활용
• 연관관계 매핑: 1:1, 1:N, N:M 관계의 올바른 매핑 방법
• 트랜잭션 관리: 영속성 컨텍스트와 다양한 트랜잭션 전략
• 성능 최적화: N+1 문제 해결과 쿼리 최적화 기법

특히 실무에서는 N+1 문제 해결과 적절한 페이징 전략이 서비스 성능에 큰 영향을 미칩니다.

Fetch Join, @EntityGraph, Batch Size 등을 상황에 맞게 적절히 활용하는 것이 중요해요.

 

다음 글에서는 Spring Boot 기반 간단한 API 실습을 다뤄보겠습니다. 

궁금한 점이나 더 자세히 알고 싶은 JPA 활용법이 있다면 댓글로 남겨주세요! 🚀