[개념 콕] 스프링 JPA란? <ORM, Hibernate, JPA>

ORM(Object-Relational Mapping)

ORM이란?

ORM 핵심 개념

• 매핑
• 객체와 데이터베이스 테이블 간의 대응 관계를 설정합니다.
• 자바 클래스의 필드는 데이터베이스 테이블의 열에 매핑됩니다.

• 엔티티
• 데이터베이스 테이블에 대응하는 객체입니다.
• 각 엔티티 인스턴스는 데이터베이스 테이블의 한 행을 나타냅니다.

• 속성
• 엔티티 클래스의 필드는 데이터베이스 테이블의 열에 매핑됩니다.
• 클래스의 name 속성은 테이블의 name 열에 매핑됩니다.

• 연관 관계
• 객체 간의 관계를 정의하고 이를 데이터베이스 테이블 간의 외래 키 관계로 매핑합니다.
• 일대일, 일대다, 다대일, 다대다 관계가 있습니다.

ORM의 장점

• 객체 지향 프로그래밍의 일관성 유지
• 데이터베이스 접근 로직을 객체 지향 방식으로 작성할 수 있어 코드의 일관성을 유지할 수 있습니다.

• 생산성 향상
• CRUD 코드를 자동화하여 개발 생산성을 높입니다.
• 복잡한 SQL 쿼리를 직접 작성하지 않아도 되므로 개발 속도가 빨라집니다.

• 유지보수 용이성
• 데이터베이스 스키마가 변경될 경우, 엔티티 클래스를 수정하여 쉽게 대응할 수 있습니다.
• 비즈니스 로직과 데이터베이스 접근 로직의 분리로 유지보수가 용이해집니다.

Hibernate

Hibernate란?

Hibernate 핵심 개념

• 객체-관계 매핑(ORM)
• 자바 클래스와 데이터베이스 테이블 간의 매핑을 설정합니다.
• 데이터베이스의 테이블을 자바 객체로, 테이블의 컬럼을 객체의 필드로 매핑합니다.

• 데이터베이스 독립성
• 데이터베이스에 종속되지 않으며, 다양한 데이터베이스 시스템을 지원합니다.
• 데이터베이스 변경 시 코드 수정이 최소화됩니다.

• 투명한 지속성
• 데이터베이스에 접근하는 코드를 작성하지 않고도 객체의 상태를 데이터베이스에 자동으로 동기화합니다.
• 엔티티 객체의 생명주기를 관리합니다.

• HQL (Hibernate Query Language)
• 객체 지향 쿼리 언어로, SQL과 유사하지만 테이블이 아닌 엔티티 객체를 대상으로 쿼리를 수행합니다.
• 복잡한 조회, 집계 등을 객체 지향적으로 표현할 수 있습니다.

• 캐싱
• 1차 캐시와 2차 캐시를 지원하여 성능을 최적화합니다.
• 자주 조회되는 데이터를 메모리에 저장하여 데이터베이스 접근을 줄입니다.

Hibernate의 장점과 단점

• 생산성
복잡한 SQL 쿼리를 자동으로 생성하여 데이터베이스 접근 코드를 단순화합니다.

• 유지보수성
객체 모델을 기반으로 데이터베이스 스키마를 자동으로 생성 및 업데이트할 수 있어 유지보수가 용이합니다.

• 이식성
다양한 데이터베이스 시스템을 지원하여 데이터베이스 변경 시 코드 수정이 최소화됩니다.

• 학습 곡선
Hibernate의 다양한 기능과 설정을 이해하는 데 시간이 필요할 수 있습니다.

• 성능 오버헤드
자동화된 작업으로 인해 일부 성능 오버헤드가 발생할 수 있습니다. 이는 캐싱 및 튜닝을 통해 최적화할 수 있습니다.

엔티티 클래스 작성

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

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

    // getters and setters
}

• @Entity 어노테이션
• 클래스 레벨에 적용되며, 해당 클래스가 JPA 엔티티임을 나타냅니다.
• @Entity가 붙은 클래스는 데이터베이스 테이블과 매핑되며, Hibernate가 관리합니다.

• @Id 어노테이션
• 엔티티 클래스의 필드 중 기본 키(Primary Key)로 사용될 필드에 적용됩니다.
• 기본 키는 각 엔티티 인스턴스를 고유하게 식별하는 역할을 합니다.
• 예시에서는 id 필드가 기본 키로 설정되어 있습니다.

• @GeneratedValue 어노테이션
• 기본 키 값의 생성 전략을 지정하는 데 사용됩니다.

• 필드와 컬럼 매핑
• 기본적으로 Hibernate는 필드 이름과 동일한 이름의 데이터베이스 컬럼과 매핑합니다.
• 따라서 name 필드는 "name" 컬럼과 매핑되고, email 필드는 "email" 컬럼과 매핑됩니다.

Hibernate 설정 파일 (hibernate.cfg.xml)

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydatabase</property>
        <property name="hibernate.connection.username">myuser</property>
        <property name="hibernate.connection.password">mypassword</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- List of annotated classes -->
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

데이터베이스 연동 코드

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Main {
    public static void main(String[] args) {
        // Hibernate 설정 파일로부터 SessionFactory 생성
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        // Session을 사용하여 데이터베이스 작업 수행
        Session session = sessionFactory.openSession();
        session.beginTransaction();

        User user = new User();
        user.setName("John Doe");
        user.setEmail("john.doe@example.com");

        session.save(user);

        session.getTransaction().commit();
        session.close();
    }
}

JPA(Java Persistence API)

JPA의 주요 구성 요소

• Entity
데이터베이스 테이블에 매핑되는 자바 클래스입니다. 각 엔티티 클래스는 @Entity 어노테이션으로 표시되며, 클래스의 필드는 테이블의 컬럼에 매핑됩니다.

• Entity Manager
엔티티를 생성, 수정, 삭제, 조회할 수 있는 인터페이스입니다. EntityManager는 JPA 컨텍스트에서 엔티티 객체를 관리합니다.

• Persistence Unit
JPA 설정 정보가 포함된 단위입니다. persistence.xml 파일에 정의되며, 데이터베이스 연결 정보와 엔티티 클래스를 설정합니다.

JPA의 주요 메서드

• persist(Object entity) 새로운 엔티티를 데이터베이스에 저장합니다.

• find(Class<T> entityClass, Object primaryKey)
주어진 기본 키로 데이터베이스에서 엔티티를 조회합니다.

• merge(Object entity) 데이터베이스에 이미 존재하는 엔티티를 업데이트합니다.

• remove(Object entity) 엔티티를 데이터베이스에서 삭제합니다.

• createQuery(String qlString) JPQL 쿼리를 실행하기 위해 Query 객체를 생성합니다.

• createNamedQuery(String name)
미리 정의된 네임드 쿼리를 실행하기 위해 Query 객체를 생성합니다.

• getTransaction() 현재 트랜잭션을 반환합니다.

• getReference(Class<T> entityClass, Object primaryKey)
프록시 객체를 사용하여 지연 로딩 방식으로 엔티티를 조회합니다.

• flush() 현재 영속성 컨텍스트의 변경 사항을 데이터베이스에 반영합니다.

• clear() 영속성 컨텍스트를 초기화합니다.

• close(): 엔티티 매니저를 닫습니다.

JPA로 엔티티 생성, 조회, 업데이트, 삭제하기

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

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

    // 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; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

javaCopy code
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

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

        // 엔티티 생성 및 저장
        em.getTransaction().begin();
        User user = new User();
        user.setName("John Doe");
        user.setEmail("john.doe@example.com");
        em.persist(user);
        em.getTransaction().commit();

        // 엔티티 조회
        User foundUser = em.find(User.class, user.getId());
        System.out.println("Found User: " + foundUser.getName());

        // 엔티티 업데이트
        em.getTransaction().begin();
        foundUser.setEmail("john.newemail@example.com");
        em.merge(foundUser);
        em.getTransaction().commit();

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

        // 엔티티 매니저 및 팩토리 종료
        em.close();
        emf.close();
    }
}

1. persist(Object entity): 새로운 User 엔티티를 데이터베이스에 저장합니다.

2. find(Class<T> entityClass, Object primaryKey): 데이터베이스에서 User 엔티티를 기본 키를 통해 조회합니다.

3. merge(Object entity): 기존 User 엔티티를 수정하고 데이터베이스에 반영합니다.

4. remove(Object entity): 데이터베이스에서 User 엔티티를 삭제합니다.

Spring Data JPA

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

public interface UserRepository extends JpaRepository<User, Long> {
}

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> getUserById(Long id) {
        return userRepository.findById(id);
    }

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

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

내일배움캠프는 개발에 필요한 핵심만 배웁니다

취업 준비, 어디서부터 시작해야 할지 모르겠다면?