[Spring] 인프런 스프링 입문(김영한 님) - 순수JDBC, 통합테스트, 스프링JdbcTemplate, JPA, 스프링 데이터 JPA

이 글은 인프런 김영한 님의 스프링 입문 강의 를 듣고 정리한 글입니다.

(이어서)

스프링 DB 접근 기술

...

순수 JDBC

애플리케이션과 DB를 연결해 저장하는 법을 배워볼 것이다.

쿼리문을 이용해 DB에 데이터를 넣고 빼는 방법

그 중에서도 20년 전 방식인 순수 JDBC API만을 사용한 방법을 먼저 보고, 점차 발전되는 기술들을 배울 것이다.

자바는 기본적으로 DB와 연결하려면 JDBC라는 드라이버가 꼭 있어야 한다.

1

build.gradle

아래 코드를 추가한다.

dependencies {
    // codes ...
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    runtimeOnly 'com.h2database:h2'
}

• implementation 'org.springframework.boot:spring-boot-starter-jdbc' : DB와 연결을 위해, JDBC 드라이버 추가
• runtimeOnly 'com.h2database:h2' : DB와 연결할 때, DB가 제공하는 클라이언트가 필요해서 추가한 코드

application.properties

아래 코드를 추가한다. (src/main/java/resources/application.properties)

spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa

• url : 접근할 DB의 경로. H2데이터베이스에 접속할 때 넣었던 주소와 동일하다.

• driver-class-name : 접근할 DB드라이버의 이름

  • import하지 않으면 빨간색이다. build.gradle에 가서 아래 그림과 같은 버튼을 누르면 해결된다.

    

• spring.datasource.username=sa : 스프링부트2.4부터는 이를 추가하지 않으면 오류가 발생한다(Wrong user name or password). 공백이 전혀 없어야 한다.

2

이제 JDBC로 연결된 리포지토리를 만들어 본다. 기존 MemoryMemberRepository가 아닌 새로운 구현체 JdbcMemberRepository를 만든다.

옛날 기술이므로 이렇게 했었구나~ 정도말 알고 참고만 하자!!

JdbcMemberRepository.java

(src/main/java/프로젝트명/repository에 생성)

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.jdbc.datasource.DataSourceUtils;

import javax.sql.DataSource;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class JdbcMemberRepository implements MemberRepository{

    private final DataSource dataSource;

    public JdbcMemberRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public Member save(Member member) {
        String sql = "insert into member(name) values(?)";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, member.getName());
            pstmt.executeUpdate();
            rs = pstmt.getGeneratedKeys();
            if (rs.next()) {
                member.setId(rs.getLong(1));
            } else {
                throw new SQLException("id 조회 실패");
            }
            return member;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public Optional<Member> findById(Long id) {
        String sql = "select * from member where id = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, id);
            rs = pstmt.executeQuery();
            if(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                return Optional.of(member);
            } else {
                return Optional.empty();
            }
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public List<Member> findAll() {
        String sql = "select * from member";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            rs = pstmt.executeQuery();
            List<Member> members = new ArrayList<>();
            while(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                members.add(member);
            }
            return members;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    @Override
    public Optional<Member> findByName(String name) {
        String sql = "select * from member where name = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, name);
            rs = pstmt.executeQuery();
            if(rs.next()) {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                return Optional.of(member);
            }
            return Optional.empty();
        } catch (Exception e) {
            throw new IllegalStateException(e);
        } finally {
            close(conn, pstmt, rs);
        }
    }
    private Connection getConnection() {
        return DataSourceUtils.getConnection(dataSource);
    }
    private void close(Connection conn, PreparedStatement pstmt, ResultSet rs)
    {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (pstmt != null) {
                pstmt.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn != null) {
                close(conn);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    private void close(Connection conn) throws SQLException {
        DataSourceUtils.releaseConnection(conn, dataSource);
    }
}

• DataSource : DB와 연결하기 위해 필요한 요소. import한다 (javax.sql.DataSource)

  • datasource는 스프링으로부터 주입받아야 한다.

    스프링이 application.properties정보를 바탕으로 DataSource를 만들어 두는데, 이를 주입받아야 한다.

• Connection connection = dataSource.getConnection(sql)

  • DB로부터의 커넥션(소켓)을 얻을 수 있다.

  • 이제 여기에 SQL문을 만들어 DB에 전달하면 되는 것이다.

• pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)

  • Connection에 넣을 SQL문을 준비한다.

  • Statement.RETURN_GENERATED_KEYS : 옵션. DB에서 자동으로 생성된 키를 가져온다.

    DB에서 generated by default as identity로 생성되는 값, 즉 id값을 말함.

• pstmt.setString(1, member.getName());

  • 1, member.getName() : sql문의 첫 번째 와일드카드(?)를 member.getName()으로 셋팅한다.

• pstmt.executeUpdate();

  • DB에 저장하기 위해 DB에 sql쿼리문을 보낸다.

• rs = pstmt.getGeneratedKeys();

  • Statement.RETURN_GENERATED_KEYS로 얻은 키 값을 가져온다.

• try-catch문으로 Exception을 잡아 주어야 한다.

• close(conn, pstmt, rs) : 사용한 자원 (Connection, PreparedStatement, ResultSet)을 릴리즈해줘야 한다.

  • ❗ 네트워크를 통해 이용한 자원들은 사용 후 반드시 리소스를 반환해야 한다.

    그렇지 않으면 자원이 계속 쌓여서 서비스 장애가 날 수 있다.

• pstmt.executeQuery();

  • DB를 조회할 때는 executeQuery()를 사용한다.

스프링으로 DB 커넥션 연결 및 해제하기

private Connection getConnection() {
    return DataSourceUtils.getConnection(dataSource);
}    

• 스프링 프레임워크를 통해 DB 커넥션을 얻을 때는 반드시 이렇게 얻어야 한다. (형식)

  • DataSourceUtils를 통해 getConnection()을 사용해야 한다.

    데이터베이스 트랜잭션이 발생하지 않고 똑같은 커넥션을 유지하도록 도와 준다.

private void close(Connection conn) throws SQLException {
    DataSourceUtils.releaseConnection(conn, dataSource);
}

• 마찬가지로 스프링 프레임워크를 통해 DB 커넥션을 닫을 때도 반드시 이렇게 닫아야 한다.
  • DataSourceUtils를 통해 releaseConnection()을 사용해야 한다.

3

이제 JDBC로 연결되도록 리포지토리를 완성했으므로 사용해 보자.

SpringConfig.java

(src/main/java/프로젝트/service/SpringConfig)

아래와 같이 수정한다.

package hello.hellospring;

import hello.hellospring.repository.JdbcMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class SpringConfig {

    private DataSource dataSource;

    @Autowired
    public SpringConfig(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository() {
        // return new MemoryMemberRepository();
        return new JdbcMemberRepository(dataSource);
    }
}

• DataSource
  • 데이터베이스 커넥션을 획득할 떄 사용하는 객체.
  • 스프링이 데이터베이스 커넥션(application.properties) 정보를 바탕으로, 자체적으로 DataSource를 스프링 빈으로 생성해 준다. 이를 생성자로 주입해 사용한다(DI).
    • @Autowired DataSource dataSource로 해도 되지만, DI로 하는 것이 더 좋은 방법.

❗ 다른 어떤 코드도 변경하지 않고, 인터페이스를 확장해 JdbcMemberRepository.java를 만들고 SpringConfig.java만 수정했다.

4

이제 수정된 DB를 다시 확인해 본다.

• H2를 실행하고, 스프링 앱을 실행한 뒤, localhost:8080으로 접속해 회원 목록을 조회한다.
  • H2 DB에 저장했던 내역이 조회되면 성공이다.
• 이번에는 회원 가입으로 회원을 추가한 뒤 다시 회원 목록을 조회한다.
  • 추가한 회원이 목록으로 조회되면 성공이다.

이제 데이터를 DB에 저장하므로, 스프링 서버를 껐다 켜도 데이터가 안전하게 저장된다.

(핵심) 중요한 부분!

스프링을 왜 쓰는가?? 객체지향이 좋아서.

❗ 기존의 다른 어떤 코드도 변경하지 않고, 인터페이스를 확장해 JdbcMemberRepository.java를 만들고 SpringConfig.java만 수정했다.

즉 객체지향의 다형성을 편하게 활용할 수 있기 때문이다.

인터페이스(MemberRepository)를 두고, 서로 다른 구현체(MemoryMemberRepository 또는 JdbcMemberRepository)들을 쉽고 편하게 바꿔 끼울 수 있다.

또, DI를 사용함으로써 다른 소스코드들의 내용은 전혀 손 댈 필요가 없어졌다.

스프링은 이 과정들이 더 편하도록 지원해 준다.

• MemberService는 MemberRepository를 의존하고 있다.
• MemberRepository는 그 구현체로 MemoryMemberRepository와 JdbcMemberRepository를 가지고 있다.

바뀐 스프링 설정은 위와 같다.

• 기존에 스프링 빈으로 등록한 MemoryMemberRepository를 삭제하고,
• 새로 memberRepository를 스프링 빈으로 등록했다.
• 그 외에 나머지 코드는 손 댈 게 없다.

이를 SOLID원칙 중 '개방-폐쇄 원칙(OCP, Open-Closed Principle)'이라고 한다. (SOLID는 나중에 검색해 보라)

• 확장에는 열려 있고, 수정(변경)에는 닫혀 있다.

• 확장(기능추가)을 하려면 수정을 해야 하는데 어떻게 이게 가능한가?

  • 우리가 한 것처럼, 객체지향의 다형성을 잘 활용하면 기능을 완전히 변경하면서도 기존 코드 전체를 변경하지 않아도 된다.

    (물론 새로운 기능을 조립하는 코드 정도는 수정해야 한다)

  • 스프링의 DI를 사용하면, "기존 코드를 전혀 손대지 않고, 설정만으로 구현 클래스를 변경"할 수 있다. 이것이 객체지향의 매력 중 하나이다.

스프링 통합 테스트

스프링 컨테이너와 DB까지 연결된 ''통합 테스트''를 진행해 보자.

지금까지 했던 테스트코드는 스프링을 사용하지 않고, 순수한 자바 코드만 가지고 만든 것이다.

하지만 이제 스프링이 관여해서 데이터소스 등을 사용하기 때문에, 테스트코드도 스프링을 사용하도록 수정해야 한다.

(원래는 보통 TEST 전용 DB를 쓰거나, 로컬 DB를 연결한 다음 진행한다.)

MemberServiceIntegrationTest.java

라는 새로운 테스트클래스를 만들어 진행한다.

(src/test/java/프로젝트/service/MemberServiceIntegrationTest.java)

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
@Transactional
class MemberServiceIntegrationTest {

    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    void 회원가입() {
        // given - 테스트할 데이터
        Member member = new Member();
        member.setName("spring");
        // when - 검증하려는 로직 : MemberService의 join().
        Long saveId = memberService.join(member);

        // then - 테스트 결과 (검증부)
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    void 중복회원예외() {
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        memberService.join(member1);

        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

    }
}

@SpringBootTest

• 스프링 컨테이너와 테스트를 함께 실행한다. (스프링을 직접 띄워서 테스트한다)

@Transactional

• 테스트케이스에 붙이면, 테스트 실행시 트랜잭션을 먼저 실행하고 테스트가 끝나면 롤백을 해 준다.

  이렇게 하면 DB에 데이터가 남지 않으므로 다음 테스트에 영향을 주지 않는다.

  일반 클래스에 붙이면 실행 시 트랜잭션만 실행한다. (롤백은 하지 않는다)

• 테스트는 기본적으로 반복 실행 가능해야 한다. 그런데 DB에 테스트 데이터가 계속 쌓이면 같은 테스트를 반복했을 때 중복 데이터로 테스트가 정확하지 않게 된다.

• 스프링이 @BeforeEach, @AfterEach 대신 트랜잭션을 사용해 이를 해결해 주었다.

  • 트랜잭션(Transcation) : 롤백? - 공부하기..

• 반대로 @Commit 을 붙인 테스트는 롤백하지 않고 변경내용을 DB에 반영하도록 설정할 수 있다.

@Autowired MemberService memberService;
@Autowired MemberRepository memberRepository;

• 테스트코드이므로 DI는 생략하고 곧바로 연결해 준다.
• MemoryMemberRepository가 아닌, 인터페이스인 MemberRepository로 바꾼다.

단위 테스트

스프링을 띄우지 않고 자바 코드로만 진행하며 가장 작은 단위의 테스트로만 진행하는 것을 ''단위테스트''라고 한다. (이전에 했던 MemberServiceTest.java처럼)

반대로 스프링도 띄우고 DB도 연동해 진행하는 테스트를 ''통합테스트''라고 한다 (지금 한 MemberServiceIntegrationTest.java처럼)

보통은 순수한 단위테스트가 더 좋은 테스트일 확률이 높다.

• 가장 작은 단위로 나누어 테스트를 진행.

• 스프링 컨테이너 없이 테스트.

  (테스트 하는 데에 스프링 컨테이너까지 필요해지는 상황 자체가 좋지 않은 상황일 확률이 높다)

따라서 단위테스트를 더 잘 만드는 연습을 하자.

스프링 JdbcTemplate

• 순수 JDBC와 동일한 환경설정을 갖는다.
• 스프링JdbcTemplate 및 MyBatis같은 라이브러리는 JDBC API에서 본 반복 코드를 대부분 제거해준다.
• 하지만 SQL은 직접 작성해야 한다.
• 실무에서도 많이 사용한다.

스프링JdbcTemplate의 이름은 디자인패턴의 템플릿메소드패턴을 많이 사용한 데서 유래했다.

1

JdbcTemplateMemberRepository.java

라는 새로운 테스트클래스를 만들어 진행한다.

(src/main/java/프로젝트/repository/JdbcTemplateMemberRepository.java)

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public class JdbcTemplateMemberRepository implements MemberRepository{

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public JdbcTemplateMemberRepository(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Override
    public Member save(Member member) {
        SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
        jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");

        Map<String, Object> parameters = new HashMap<>();
        parameters.put("name", member.getName());

        Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));
        member.setId(key.longValue());
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        List<Member> result = jdbcTemplate.query("select * from member where id = ?", memberRowMapper(), id);
        return result.stream().findAny();
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> result = jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name);
        return result.stream().findAny();
    }

    @Override
    public List<Member> findAll() {
        return jdbcTemplate.query("select * from member", memberRowMapper());
    }

    private RowMapper<Member> memberRowMapper() {
        return new RowMapper<Member>() {
            @Override
            public Member mapRow(ResultSet rs, int rowNum) throws SQLException {
                Member member = new Member();
                member.setId(rs.getLong("id"));
                member.setName(rs.getString("name"));
                return member;
            }
        };
    }
}

JdbcTemplate

• import 해서 사용 (org.springframework.jdbc.core.JdbcTemplate)
• 생성자에서 JdbcTemplate 대신 DataSource를 인젝션받는다.
• JdbcTemplate를 생성할 때도 (dataSource)를 인젝션받는다.
• 위의 형태로 사용할 것을 권장한다.

참고 : 생성자가 하나만 있을 때는 @Autowired를 생략할 수 있다. (스프링이 자동으로 넣어 준다) 두 개 이상일 때는 안 된다.

List<Member> result = jdbcTemplate.query(sql, 결과, 파라미터)

• query()는 DB에 sql문을 보내는 메서드이다. 리턴타입은 List이다.
• 파라미터는 sql문의 ?에 대응하는 값을 넣는다.

SimpleJdbcInsert

• JdbcTemplate를 넣어서 만드는 객체.

• 쿼리문을 직접 작성하지 않아도 되게 도와준다.

private RowMapper<Member> memberRowMapper()

• 객체 생성을 도와주는 맵퍼?
• 여기서는 query()의 결과를 Member객체로 변환한 다음 돌려주는 용도로 사용했다.

JdbcTemplate 자체도 엄청나게 많은 기능들이 있기 때문에 검색해 알아보자. (매뉴얼)

2

JdbcTemplateMemberRepository.java 를 완성했기 때문에 SpringConfig.java에서 다시 바꿔 끼워 사용해 보자.

SpringConfig.java

아래 메서드를 수정한다.

// ...
@Bean
public MemberRepository memberRepository() {
    // return new MemoryMemberRepository();
    // return new JdbcMemberRepository(dataSource);
    return new JdbcTemplateMemberRepository(dataSource);
}
// ...

3

MemberServiceIntegrationTest.java로 잘 바꿔 끼워졌는지 테스트 해 본다.

테스트 코드의 중요성

실무에서도 근무시간의 60-70%는 테스트코드 개발을, 30-40%는 Production Code(실제 사용할 코드) 개발을 한다.

실무에서는 작은 버그 하나도 전체 시스템에 치명적이기 때문에 (수십억원의 피해),

테스트코드를 꼼꼼하게 잘 짜는 것이 엄청나게 중요하다.

JPA

JPA : Java Persistence API의 약자.

JPA는 '자바의 표준 인터페이스'이고, 그 구현체로 보통 hibernate를 사용한다.

JPA의 장점 및 사용 이유

• JPA를 사용하면 기본적인 SQL문을 JAP가 직접 만들어 실행해 준다.
  • 스프링 JdbcTemplate을 사용해 반복 코드는 줄었지만, 여전히 SQL문은 개발자가 직접 작성해야 한다. JPA를 사용하면 SQL을 직접 작성하지 않아도 된다.
  • 특히 기본 CRUD 기능의 SQL문을 직접 작성할 필요가 없다.
• JPA 사용을 통해 SQL 및 데이터 중심 설계에서 객체 중심의 설계로 패러다임을 전환할 수 있다.
• JPA를 사용하면 개발 생산성을 크게 높일 수 있다.

현재 JPA와 MyBatis라는 API를 비교할 수 있는데, 아직까지 국내에서는 MyBatis를 더 쓰지만 전 세계적인 추세로는 JPA(68%)를 훨씬 더 많이 쓴다. 국내 도입이 늦어진 것.

스프링 기술도 매우 거대하지만 JPA도 그만큼 거대한 기술이다. 스프링만큼 공부가 필요하다.

스프링과 JPA가 비슷한 시기에 나와서 스프링이 JPA를 지원하는 부분이 많다.

1

build.gradle

을 다음과 같이 수정한다.

...
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.h2database:h2'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
...

*org.springframework.boot:spring-boot-starter-data-jpa가 Jdbc 관련 라이브러리를 포함하기 떄문에 jdbc는 제거해도 된다.

수정 후 gradle을 새로고침 한다.

2

application.properties

다음과 같이 수정한다.

spring.datasource.url=jdbc:h2:tcp://localhost/~/test
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

• spring.jpa.show-sql=true : JPA가 생성하는 sql을 출력한다.
• spring.jpa.hibernate.ddl-auto=none : JPA는 원래 객체를 보고 table(DB)을 자동으로 만들어 주지만, 우리는 H2에 이미 만들어 놓았고 만들어진 것을 사용할 것이므로 해당 기능을 끈다.
  • none대신 create를 사용하면 엔티티 정보를 바탕으로 테이블을 직접 생성해 준다.

3

JPA를 사용하려면 먼저 엔티티 Entity 라는 것을 맵핑해야 한다.

JPA는 ORM : Object Relational Mapping 기술을 사용한다.

• 객체(Object)와 관계형(Relational) 데이터베이스의 테이블을 맵핑(Mapping)하는 기술.

JPA의 맵핑 과정은 어노테이션을 통해 이루어진다.

즉 자바 코드에 선언한 어노테이션들을 보고, 관계형 데이터베이스의 요소와 비교한다.

Member.java

package hello.hellospring.domain;

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

@Entity

public class Member {

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

    private String name;

    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;
    }
}

@Entity

• javax.persistence.Entity 를 import
• @Entity 를 선언하면 해당 클래스 객체는 'JPA가 관리하는 엔티티'라고 표현한다.

그리고 PK (Primary Key)를 맵핑해 주어야 한다. 우리 예제에서는 ID이다.

@Id

• import javax.persistence.Id

• ID값 위에 선언해 준다.

  @GeneratedValue

• SQL에서 선언한 generated by default as identity처럼, DB가 자동으로 생성해주는 값에 선언한다.

  이를 Identity 아이덴티티이라고 한다.

• ID값이 자동 생성 값이므로 @Id와 나란히 선언해 준다.

JpaMemberRepository.java

package hello.hellospring.repository;

import hello.hellospring.domain.Member;

import javax.persistence.EntityManager;
import java.util.List;
import java.util.Optional;

public class JpaMemberRepository implements MemberRepository{

    private final EntityManager em;

    public JpaMemberRepository(EntityManager em) {
        this.em = em;
    }

    @Override
    public Member save(Member member) {
        em.persist(member);
        return member;
    }

    @Override
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
        return result.stream().findAny();
    }

    @Override
    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }
}

• EntityManager

  • JPA는 EntityManager로 동작한다. 반드시 선언해야 하는 요소이다.
  • build.gradle에서 data-jpa를 설정해 두면, 스프링 부트가 자동으로 EntityManager라는 것을 만들어 설정한 DB와의 통신을 편하게 해 준다.
  • 생성자에서 이 만들어진 EntityManager를 주입받는 것이다.

• persist(e)

  • 저장. DB에 해당 요소를 영속적으로 저장함.

• find(조회할 타입, PK)

  • 조회. DB 테이블에서 해당 타입에 PK를 갖는 요소를 찾아 옴.

• createQuery("JPQL쿼리문", 타입)

  • JPQL쿼리문을 생성하는 메서드?
  • findByName(), findAll()처럼 PK를 사용하지 않고 조회할 때 해당 메서드를 사용해 JPQL을 작성해야 한다.

JPQL

일반 쿼리문은 테이블을 대상으로 쿼리문을 보내지만,

JPQL은 객체(정확히는 엔티티)를 대상으로 쿼리문을 보낸다. JPQL로 보낸 쿼리문이 SQL로 번역되어 보내진다.

select m from Member m : Member(m) 자체를 조회하고 있다.

다음 시간에 배울 ''스프링 데이터 JPA''를 사용하면 JPQL도 직접 짜지 않아도 된다.

4

❗ JPA를 사용할 때 주의점

: 데이터 저장 및 변경할 때는 반드시 해당 클래스/메서드에 @Transsactional 어노테이션을 선언해야 한다.

JPA는 모든 데이터 저장/변경이 Transaction 안에서 실행되어야 한다.

MemberService.java

• 클래스 선언부 위에 @Transactional을 추가한다.

5

이제 생성한 JpaMemberRepository.java를 사용하도록 SpringConfig.java를 수정한다.

SpringConfig.java

package hello.hellospring;

import hello.hellospring.repository.JpaMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.persistence.EntityManager;

@Configuration
public class SpringConfig {

    private EntityManager em;

    public SpringConfig(EntityManager em) {
        this.em = em;
    }

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository() {
        // return new MemoryMemberRepository();
        // return new JdbcMemberRepository(dataSource);
        // return new JdbcTemplateMemberRepository(dataSource);
        return new JpaMemberRepository(em);
    }
}

private EntityManager em

• 마찬가지로 선언 후 생성자에서 주입해 준다

• JpaMemberRepository(EntityManager em) 파라미터로 사용한다

6

연결했으니 MemberServiceIntegrationTest.java에서 테스트를 해 본다.

테스트 결과 메시지 로그를 자세히 보면, 스프링 접속 후 아래와 같은 메시지가 있다.

Hibernate: select member0_.id as id1_0_, member0_.name as name2_0_ from member member0_ where member0_.name=?

Hibernate: insert into member (id, name) values (null, ?)

• JPA는 인터페이스이고, 구현체로 Hibernate를 사용한다.
• 즉 결국 DB에 전달되는 것은 SQL문인데, 직접 작성할 필요가 없게 편리성을 더한 것.

+

요즘 JPA는 큰 스타트업 등에서도 사용하고 해외에서는 은행에서도 쓸 만큼 많이 사용된다.

JPA는 스프링만큼 공부할 게 많다. 실무에서 사용할 정도가 되려면 깊이 있게 공부할 필요가 있다.

스프링 데이터 JPA

스프링 부트와 JPA만 사용해도 개발 생산성이 매우 높아지고, 개발해야 하는 코드도 크게 줄어든다.

여기에 스프링 데이터 JPA까지 사용하면 인터페이스만으로 개발을 완료할 수 있다.

특히, 기본 CRUD기능을 스프링 데이터 JPA가 제공한다!

스프링 부트 & JPA 라는 기반 위에, 스프링 데이터 JPA라는 프레임워크를 더하면 개발이 즐거워진다.

단순 반복 코드를 줄여 주어, 개발자는 핵심 비즈니스 로직 개발에만 집중할 수 있다.

실무에서 관계형 데이터베이스를 사용한다면, 스프링 데이터 JPA는 필수이다.

❗

스프링 데이터 JPA는 JPA를 편리하게 쓰도록 도와주는 도구일 뿐이다.

따라서 반드시! JPA를 먼저 연습한 다음에 스프링 데이터 JPA를 학습해야 한다.

JPA를 모르는 상태에서 스프링 데이터 JPA를 쓰는 것은 위험한 행위이다. 실제 운영을 하며 부딪히는 문제들을 해결할 수 없게 된다.

1

환경 설정은 JPA의 설정을 그대로 사용한다.

src/main/java/프로젝트/repository에 "인터페이스"를 만든다.

(지금까지와 달리 '인터페이스'를 만든다는 것에 유의한다)

SpringDataJpaMemberRepository.java

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {
    @Override
    Optional<Member> findByName(String name);
}

public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository

• 인터페이스가 인터페이스를 받을 때는 implements가 아닌 extends를 사용한다!
  • JpaRepository와 MemberRepository라는 인터페이스를 받아 오므로 extends를 사용.
  • ✅인터페이스는 다중상속이 가능하다!!
• JpaRepository<Member, Long>
  • <키, 값>인데, 키는 Member, 값은 Entity의 식별자인 PK(id)의 타입인 Long을 넣는다.

2

❗ 중요 원리

: JpaRepository를 상속받은 인터페이스는, 스프링 데이터 JPA가 그 구현체를 자동으로 만들고 스프링 빈에 등록해 준다. 즉, 내가 SpringDataJpaMemberRepository를 구현하고 스프링 빈에 등록할 필요가 없다. 우리는 그 구현체를 가져다 쓰면 된다. 아래와 같다.

SpringConfig.java

package hello.hellospring;

import hello.hellospring.repository.JpaMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {

    private final MemberRepository memberRepository;

    @Autowired
    public SpringConfig(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository);
    }

//    @Bean
//    public MemberRepository memberRepository() {
//        // return new MemoryMemberRepository();
//        // return new JdbcMemberRepository(dataSource);
//        // return new JdbcTemplateMemberRepository(dataSource);
//        // return new JpaMemberRepository(em);
//    }
}

❓ 생성자에 주입되는 MemberRepository는 무엇인가?

❗ 스프링 데이터 JPA가 자동으로 만들어 둔 인터페이스 SpringDataJpaMemberRepository의 구현체이다.

게다가 MemberRepository를 다중상속받았기 때문에 MemberRepository로 주입될 수 있는 것이다.

3

마찬가지로 MemberServiceIntegrationTest.java로 잘 동작하는지 테스트 해 본다.

스프링 데이터 JPA의 제공 기능

• 인터페이스를 통한 기본적인 CRUD
  • 우리가 생각할 수 있는 대부분의 생성, 조회, 수정, 삭제 메서드들을 제공한다.
• findByName() , findByEmail() 처럼 메서드 이름 만으로 조회 기능 제공
• 페이징 기능 자동 제공

메서드 이름만으로 조회 기능?

각 비즈니스마다 달라지는 내용은 공통점이 없기 때문에, 스프링 데이터 JPA가 메서드로 제공할 수 없다.

이런 부분은 SpringDataJpaMemberRepository 인터페이스처럼 직접 만들어 주어야 한다.

(인터페이스의 메서드 이름만으로 쿼리문 개발을 끝낼 수 있다)

예를 들어 , 아까 만들었던 인터페이스의 아래 부분을 확인하자면,

@Override
    Optional<Member> findByName(String name);

규칙 : findBy***()형식의 메서드는 스프링 데이터 JPA가 아래와 같이 쿼리를 생성해 준다.

• select m from Member m where m.*** = ?

• 우리는 findByName()이므로 select m from Member m where m.name = ?이라는 쿼리가 생성될 것이다.

응용 : findByNameAndId(String name, Long id) 이런 식으로도 가능하다.

+

참고: 실무에서는 JPA와 스프링 데이터 JPA를 기본으로 사용하고, 복잡한 동적 쿼리는 Querydsl이라는
라이브러리를 사용하면 된다. Querydsl을 사용하면 쿼리도 자바 코드로 안전하게 작성할 수 있고, 동적
쿼리도 편리하게 작성할 수 있다. 이 조합으로 해결하기 어려운 쿼리는 JPA가 제공하는 네이티브 쿼리를
사용하거나, 앞서 학습한 스프링 JdbcTemplate를 사용하면 된다.