[Java] Hibernate란?

 

이번 시간에는 Hiberante에 대하여 알아보려고 한다.

Java 기반의 개발에서 많이 사용되는 ORM (Object-Relational Mapping) 프레임워크이다.

Java 언어로 개발된 애플리케이션에서 데이터베이스와의 상호작용을 쉽게 처리할 수 있도록 도와주는 도구 중 하나이며, 

Hibernate는 객체 지향 프로그래밍과 관계형 데이터베이스 간의 매핑을 담당하여 개발자가 객체 모델을 사용하여

데이터베이스와 상호작용할 수 있게 해준다.

---

 

Hibernate 란?

• Java 클래스를 데이터베이스 테이블에 매핑하는 편리하고 강력한 방법을 제공하는 널리 사용되는 Java용 ORM(객체 관계형 매핑) 프레임워크
• 주석을 사용하면 엔티티 간의 관계를 쉽게 정의, 데이터베이스에 유지하는 방법을 지정하며 엔티티 클래스의 상속 계층 구조를 관리
• 내부적으로 JDBC API를 사용

Hibernate의 장점

1. 간단한 객체 모델
   •  Hibernate는 객체 지향 프로그래밍 언어인 Java의 객체 모델과 관계형 데이터베이스 간의 매핑을 간단화하며, 개발자가 복잡한 SQL 쿼리를 작성하지 않아도 된다.
2. 높은 생산성
   •  데이터베이스와의 상호작용이 간단해지므로 개발자는 빠르게 개발할 수 있고, 반복적인 작업을 최소화할 수 있다.
3. 데이터베이스 독립성
   •  Hibernate는 데이터베이스 벤더에 독립적이므로, 데이터베이스를 변경해도 코드 변경이 필요하지 않을 수 있다.
4. 캐싱 지원
   •  Hibernate는 객체와 데이터베이스 간의 성능을 향상시키기 위한 다양한 캐싱 전략을 제공한다.
5. 트랜잭션 관리
   •  Hibernate는 트랜잭션을 관리하는 데 도움을 주며, ACID 속성을 지원하여 데이터 일관성을 유지한다.

Hibernate의 단점

1. 학습 곡선
   • Hibernate를 제대로 활용하기 위해서는 ORM 개념과 Hibernate의 설정 등을 학습해야 하므로 초기 학습 곡선이 존재한다.
2. 성능 이슈
   • 잘못된 사용 또는 부적절한 설정으로 인해 성능 이슈가 발생할 수 있다. 특히 큰 규모의 데이터베이스와의 작업에서 주의가 필요하다.
3. 복잡성
   • Hibernate를 사용하면서 발생하는 많은 설정과 기능은 프로젝트에 따라 복잡성을 증가시킬 수 있다.
4. DBA의 제약
   • 일부 DBAs는 Hibernate와 같은 ORM 도구를 선호하지 않을 수 있으며, 특히 성능 최적화 및 쿼리 튜닝 측면에서 제약을 가질 수 있다.
5. 최신 기술과의 통합 지연

 

Hibernate 사용 

환경 설정 파일

• gradle 또는 maven 프로젝트는 기본적으로 src/main 디렉터리에서 java와 resources 패키지로 나뉘는데 resources에 대부분의 환경 설정 파일 및 정적 파일들이 포함
• Hibernate의 환경 설정도 resources에서 작성

<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.1">
    <persistence-unit name="blog">
        <!-- 엔티티 클래스 -->
        <class>entity.User</class>
        <class>entity.UserLog</class>
        <properties>
        <!-- 필수 속성 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://175.210.112.200:3006/blog_test?autoReconnect=true"/>
            <property name="javax.persistence.jdbc.user" value="bizplus"/>
            <property name="javax.persistence.jdbc.password" value="bizplus"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>

            <!-- 옵션 속성 -->
            <!-- 콘솔에 하이버네이트가 실행하는 SQL문 출력 -->
            <property name="hibernate.show_sql" value="true"/>
            <!-- SQL 출력 시 보기 쉽게 정렬 -->
            <property name="hibernate.format_sql" value="true"/>
            <!-- 애플리케이션 실행 시점에 데이터베이스 테이블 자동 생성 -->
            <property name="hibernate.hbm2ddl.auto" value="create"/>
        </properties>
    </persistence-unit>
</persistence>

 

매핑

• Hibernate 매핑은 자바 코드로 작성한 객체와 관계형 데이터베이스의 각종 테이블 간의 관계 및 테이블 스키마 등을 매
• 각 테이블을 Hibernate를 사용하여 자바 코드로 작성한 클래스를 엔티티(Entity)
• 클래스를 엔티티로 만들기 위해서는 클래스에 javax.persistence.Entity 어노테이션을 선언하면 된다
•  엔티티를 작성할 때 주의해야 할 점은 반드시 기본 생성자를 만들어줘야 한다

@Entity
@Table(name = "posts")
@Getter
@Setter
@ToString
@NamedQueries({
        @NamedQuery(name = "Post.findAll", query = "SELECT p FROM Post p INNER JOIN User u ON p.user.id = u.id WHERE p.deletedAt is null ORDER BY p.createdAt DESC "),
        @NamedQuery(name = "Post.findById", query = "SELECT p.id, p.title, p.body FROM Post p WHERE p.id = :id")
})
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = true)
    private Integer id;

    private String title;

    private String body;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "created_at")
    private Date createdAt;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "updated_at")
    private Date updatedAt;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "deleted_at")
    private Date deletedAt;

    @OneToMany(mappedBy = "post", cascade = CascadeType.PERSIST)
    private List<Comment> commentList = new ArrayList<>();

    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.PERSIST)
    @JoinTable(
            name = "post_tag",
            joinColumns = {@JoinColumn(name = "post_id", referencedColumnName = "id")},
            inverseJoinColumns = {@JoinColumn(name = "tag_id", referencedColumnName = "id")}
    )
    private List<Tag> tags = new ArrayList<>();

    @OneToMany(mappedBy = "post", cascade = CascadeType.PERSIST)
    private List<Like> likeList = new ArrayList<>();

}

 

Session Factory

• EntityManagerFactory 
  • Hibernate의 세션을 생성하고 관리하는데 사용되는 인터페이스입니다. 이 클래스의 인스턴스는 애플리케이션 레벨에서 단 하나만 존재

package com.blog.util;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class HibernateUtil {

    private static EntityManagerFactory entityManagerFactory;

    static {
        try{
            entityManagerFactory = Persistence.createEntityManagerFactory("blog");
        }catch (Exception e){
            System.out.println("Hibernate Util Error");
            e.printStackTrace();
        }
    }

    public static EntityManagerFactory getEntityManagerFactory(){
        return entityManagerFactory;
    }

    public static void closeEntityManagerFactory(){
        try {
            entityManagerFactory.close();
        }catch (Exception e) {
            System.out.println("Close EntityManagerFactory Error");
            e.printStackTrace();
        }
    }
}

 

DAO 

package com.blog.data.dao;

import com.blog.util.HibernateUtil;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class JpaDAO<E> {

    protected EntityManagerFactory entityManagerFactory = HibernateUtil.getEntityManagerFactory();

    //등록(C)
    public E create(E entity) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();
        try {
            entityTransaction.begin();
            entityManager.persist(entity);
            entityTransaction.commit();
            return entity;
        } catch (Exception e) {
            e.printStackTrace();
            entityTransaction.rollback();
            return null;
        } finally {
            entityManager.close();
        }
    }

    //수정(U)
    public E update(E entity) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();
        try {
            entityTransaction.begin();
            entityManager.merge(entity);
            entityTransaction.commit();
            return entity;
        } catch (Exception e) {
            e.printStackTrace();
            entityTransaction.rollback();
            return null;
        } finally {
            entityManager.close();
        }
    }

    //조회(F)
    public E find(Class<E> type, Object id) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        E entity = entityManager.find(type, id);

        if (entity == null) {
            return null;
        } else {
            return entity;
        }
    }


    //삭제(D)
    public boolean delete(Class<E> type, Object id) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();

        try {
            Object references = entityManager.getReference(type, id);
            entityTransaction.begin();
            entityManager.remove(references);
            entityTransaction.commit();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            entityTransaction.rollback();
            return false;
        } finally {
            entityManager.close();
        }
    }

    //리스트
    public List<E> findWithNamedQuery(String queryName) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();

        Query query = entityManager.createNamedQuery(queryName);
        List<E> result = query.getResultList();

        entityManager.close();

        return result;
    }


    public List<E> findWithNamedQuery(String queryName, Map<String, Object> parameters) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Query query = entityManager.createNamedQuery(queryName);

        Set<Map.Entry<String, Object>> setParameters = parameters.entrySet();

        for (Map.Entry<String, Object> entry : setParameters) {
            query.setParameter(entry.getKey(), entry.getValue());
        }
        return query.getResultList();
    }

    public List<E> findWithNamedQuery(String queryName, String paramName, Object paramValue) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Query query = entityManager.createNamedQuery(queryName);

        query.setParameter(paramName, paramValue);

        List<E> result = query.getResultList();
        entityManager.close();

        return result;
    }

    public long countWithNamedQuery(String queryName) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Query query = entityManager.createNamedQuery(queryName);

        long result = (long) query.getSingleResult();
        entityManager.close();

        return result;
    }

    public long countWithNamedQuery(String queryName, String paramName, Object paramValue) {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Query query = entityManager.createNamedQuery(queryName);
        query.setParameter(paramName, paramValue);

        long result = (long) query.getSingleResult();
        entityManager.close();

        return result;
    }

}

• 위 코드에서 entityMangaerFactory의 공통적으로 사용 할  수 있는 기본적인 CRUD 메소드를 관리 하였다.
• https://github.com/94-c/toy_servlet-blog-project

GitHub - 94-c/toy_servlet-blog-project: # Hibernate 및 Servlet 를 활용한 Blog 프로젝트