JPA 환경 구성 및 회원 기능 구현

By on October 17, 2019

Eclipse, H2 DataBase 설치

JPA 테스트를 하기 위해서 이클립스와 H2 database 를 설치 하자.
- Eclipse 설치(or intellij)
  - 다운로드 경로 : https://www.eclipse.org/downloads/
- H2 DataBase
  - H2 Database 는 자바로 작성되어 별도의 설치 과정이 없고 2M 이하의 매우 가벼운 데이터 베이스이기 때문에 간단한 프로젝트를 개발 할때 매우 유용하다.
  - 다운로드 경로 : https://www.h2database.com/html/download.html
  - 설치 방법
    - H2 DataBase 다운로드 후 압축 해제
    - /h2db/bin/h2.bat(sh) 를 실행
    - https://localhost:8082 로 접속하여 아래와 같은 화면이 나오면 된다.

Maven 프로젝트 생성

이클립스 프로젝트 생성
- file -> new -> project -> Maven Project

JPA 프로젝트 구조

  src/main
  ├──java
  |  ├──Member
  |  └──Main
  ├──resources
  |   └── META-INF
  |       └── persistence.xml
  pom.xml

jpa, hibernate, h2 db 의존성 추가

pom.xml

  <dependencies>
      <!-- JPA, 하이버네이트 -->
      <dependency>
          <groupId>org.hibernate</groupId>
          <artifactId>hibernate-entitymanager</artifactId>
          <version>4.3.10.Final</version>
      </dependency>
      <!-- H2 데이터베이스 -->
      <dependency>
          <groupId>com.h2database</groupId>
          <artifactId>h2</artifactId>
          <version>1.4.199</version>
      </dependency> 
  </dependencies>

회원관리 테이블 생성(Member)

  CREATE TABLE MEMBER (
      ID VARCHAR(255) NOT NULL, --아이디(기본 키)
      NAME VARCHAR(255),             --이름
      AGE INTEGER NOT NULL,       --나이
      ADDRESS VARCHAR(255),      --주소
      PRIMARY KEY (ID)
  )

h2 db console

JPA 설정 정보 persistence.xml 작성

/resources/META-INF/persistence.xml 은 JPA 를 사용 하기 위한 설정 정보를 관리하는 파일이다. 해당 클래스 패스 경로에 작성 하면 자동으로 JPA 가 설정 정보를 읽는다.

  <?xml version="1.0" encoding="UTF-8"?>
  <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" version="2.1">
      <persistence-unit name="jpa-exam1">
          <properties>
    
              <!-- 필수 속성 -->
              <property name="javax.persistence.jdbc.driver" value="org.h2.Driver"/>
              <property name="javax.persistence.jdbc.user" value="sa"/>
              <property name="javax.persistence.jdbc.password" value="1234"/>
              <property name="javax.persistence.jdbc.url" value="jdbc:h2:tcp://localhost/~/test"/>
              <property name="hibernate.dialect" value="org.hibernate.dialect.H2Dialect" />
    
              <!-- 옵션 -->
              <property name="hibernate.show_sql" value="true" />
              <property name="hibernate.format_sql" value="true" />
              <property name="hibernate.use_sql_comments" value="true" />
              <property name="hibernate.id.new_generator_mappings" value="true" />
    
              <!--<property name="hibernate.hbm2ddl.auto" value="create" />-->
          </properties>
      </persistence-unit>
    
  </persistence>

Member 클래스 작성

      package com.jpa.exam.JPA_Eaxm1;
        
      import javax.persistence.Column;
      import javax.persistence.Entity;
      import javax.persistence.Id;
      import javax.persistence.Table;
        
      @Entity
      @Table(name="MEMBER")
      public class Member {
          @Id
          private String id;
          @Column(name = "name")
          private String memberName;
          private int age;
          private String address;
            
          public String getId() {
              return id;
          }
          public void setId(String id) {
              this.id = id;
          }
          public String getMemberName() {
              return memberName;
          }
          public void setMemberName(String memberName) {
              this.memberName = memberName;
          }
          public int getAge() {
              return age;
          }
          public void setAge(int age) {
              this.age = age;
          }
          public String getAddress() {
              return address;
          }
          public void setAddress(String address) {
              this.address = address;
          }
      }

어노테이션(Annotation) 참조

Annotation	설명
@Entity	클래스를 테이블과 맵핑 한다고 JPA에게 알려주는 어노테이션
@Table	엔티티 클래스에 맵핑할 테이블 명을 설정한다
@Id	해당 필드를 테이블의 기본키(pk) 로 매핑 한다
@Column	해당 필드를 해당 컬럼에 매핑 한다

Main 클래스 작성

  package com.jpa.exam.JPA_Eaxm1;
    
  import java.util.List;
    
  import javax.persistence.EntityManager;
  import javax.persistence.EntityManagerFactory;
  import javax.persistence.EntityTransaction;
  import javax.persistence.Persistence;
  import javax.persistence.TypedQuery;
    
  public class Main 
  {
      public static void main( String[] args )
      {
      	//엔티티 매니저 팩토리 생성 
          EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpaExam");
          //엔티티 매니저 생성
          EntityManager em = emf.createEntityManager();
          //엔티티 트렌젝션 생성
          EntityTransaction tx = em.getTransaction();
          try {
          	//트랜잭션 시작
              tx.begin(); 
              //회원 등록
              addMember(em);
              //회원 조회
              Member member = findMember(em,"jpa1");
              System.out.println("find member Name : " + member.getMemberName());
              //회원 테이블 전체 조회
              List<Member> members = findMembers(em);
              System.out.println("find Members Count : " + members.size());
              //회원 삭제
              deleteMember(em, member);
              tx.commit();//트랜잭션 커밋
          } catch (Exception e) {
              e.printStackTrace();
              tx.rollback(); //트랜잭션 롤백
          } finally {
              em.close(); //엔티티 매니저 종료
          }
          emf.close(); //엔티티 매니저 팩토리 종료
      }
    
  	private static void deleteMember(EntityManager em, Member member) {
  		em.remove(member);
  	}
    	
  	private static Member findMember(EntityManager em, String id) {
  		Member member = em.find(Member.class, id);
  		return member;
  	}
    	
  	/*
  	 * JPQL 을 이용한 테이블 조회
  	 */
  	private static List<Member> findMembers(EntityManager em){
  		TypedQuery<Member> query = em.createQuery("select m from member m", Member.class);
  		List<Member> members = query.getResultList();
  		return members;
  	}
    
  	private static void addMember(EntityManager em) {
  		Member member = new Member();
          member.setId("jpa1");
          member.setMemberName("홍길동");
          member.setAge(20);
          member.setAddress("Hello Java JPA");
    
          //등록
          em.persist(member);
  	}
  }

회원 조회, 등록, 수정, 삭제 기능을 구현 완료 하였다. 이제 Main 클래스를 실행 시켜 보자. 정상적으로 수행 되는 것을 볼 수 있으며 아래와 같이 hibernate 에서 수행한 쿼리도 로그로 확인 할 수 있다.

  Hibernate: 
      /* insert com.jpa.exam.JPA_Eaxm1.Member
          */ insert 
          into
              MEMBER
              (address, age, name, id) 
          values
              (?, ?, ?, ?)
  Hibernate: 
      /* update
          com.jpa.exam.JPA_Eaxm1.Member */ update
              MEMBER 
          set
              address=?,
              age=?,
              name=? 
          where
              id=?
  Hibernate: 
      /* SELECT
          M 
      FROM
          Member M */ select
              member0_.id as id1_0_,
              member0_.address as address2_0_,
              member0_.age as age3_0_,
              member0_.name as name4_0_ 
          from
              MEMBER member0_
  find Members Count : 1
  Hibernate: 
      /* delete com.jpa.exam.JPA_Eaxm1.Member */ delete 
          from
              MEMBER 
          where
              id=?

마무리

JPA 를 사용 하기 위한 기본 환경 구성 및 회원을 관리하는 어플리케이션을 만들어 보았다. JDBC 개발에 비해 많은 코드가 줄어 든 것을 볼 수 있다.
다음 시간에서는 JPA의 영속성 관리에 대해 정리 해보도록 하자.