[Spring Intro] Section 06. 스프링 DB 접근 기술_순수 JDBC, 스프링 통합 테스트, 스프링 JDBC Template

순수 JDBC

환경 설정

# build.gradle 파일에 jdbc, h2 데이터베이스 관련 라이브러리 추가

// DB와 연동하기 위해 필요한 드라이버
implementation 'org.springframework.boot:spring-boot-starter-jdbc'

// DB와 붙을 때 필요한 데이터베이스가 제공하는 클라이언트
runtimeOnly 'com.h2database:h2'

# 스프링 부트 데이터베이스 연결 설정 추가

resources/application.properties

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

주의! 스프링부트 2.4부터는 spring.datasource.username=sa 를 꼭 추가해주어야 한다. 그렇지 않으면 Wrong user name or password 오류가 발생한다. 참고로 다음과 같이 마지막에 공백이 들어가면 같은 오류가 발생한다. spring.datasource.username=sa 공백 주의, 공백은 모두 제거해야 한다.

JDBC 리포지토리 구현

주의! 이렇게 JDBC API로 직접 코딩하는 것은 20년 전 이야기이다.
따라서 고대 개발자들이 이렇게 고생하고 살았구나 생각하고, 정신건강을 위해 참고만 하고 넘어가자.

회원을 저장하는 '역할'은 MemberRepository가 하지만, '구현'을 메모리에 할 것인지 DB와 연동해서 할 것인지에서 차이가 있다.

# Jdbc 회원 리포지토리
src/main/java/hello.hellospring/repository/JdbcMemberRepository.java

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;

        /*
            getConnection을 통해 커넥션을 가져옴
            prepareStatement에 sql 적어주고 RETURN_GENERATED_KEYS라는 특별 옵션을 줌
            이 옵션은 우리가 DB에 insert 해야만 알 수 있는 id 값을 얻을 때 사용함
            setString에서 parameterIndex에 1을 넣어주면 위 String sql의 물음표(?)와 매칭
            물음표에 member.getName()으로 값을 넣어줌
            executeUpdate 하면 DB에 실제 쿼리가 날아감
            getGeneratedKeys를 통해 방금 생성된 키의 id를 반환해 줌

            만약 rs 다음 값이 있다면 getLong을 통해 값을 꺼내서 세팅해 줌
            없다면 실패 문구 던져 줌

            이후 예외처리 해주기
        */

        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;

        /*
            위와 비슷한 방식
            executeQuery를 통해 result 값을 받아옴
            멤버가 있으면 쭉 만들고 반환
        */

        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;

        /*
            위와 비슷한 방식
            리스트 사용, 멤버가 있다면 루프 돌면서 add를 통해 멤버 담은 후 반환
        */

        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() {
        // DataSourceUtils를 사용하면 DB 트랜잭션에 걸렸을 때 DB 커넥션을 똑같이 유지시켜 줌
        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);
    }
}

# 스프링 설정 변경

src/main/java/hello.hellospring/SpringConfig.java

package hello.hellospring;

import hello.hellospring.repository.JdbcMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
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는 데이터베이스 커넥션을 획득할 때 사용하는 객체다.
스프링 부트는 데이터베이스 커넥션 정보를 바탕으로 DataSource를 생성하고 스프링 빈으로 만들어둔다.
그래서 DI를 받을 수 있다.

결과

(터미널에서 h2.sh가 실행되고 있어야 정상적으로 작동함에 주의)

우리가 DB에 입력했던 spring, spring2가 나타난다.

이번에는 회원 가입 페이지에서 이름이 jpa인 회원을 등록해보자.

등록 성공. DB와 잘 연결된 것을 확인했다.

구현 클래스 추가 이미지

MemberService가 MemberRepository에 의존하고 있다.

MemberRepository는 구현체로 MemoryMemberRepository와 JdbcMemberRepository를 가지고 있음.

스프링 설정 이미지

스프링 빈에서 MemoryMemberRepository를 빼고 JdbcMemberRepository로 등록해주었다.

이렇게 하면 구현체가 바뀌어 JdbcMemberRepository로 돌아가게 된다.

개방-폐쇄 원칙(OCP, Open-Closed Principle) ; 확장에는 열려있고, 수정/변경에는 닫혀있다.

> 위처럼 객체지향에서의 다형성을 잘 활용하면 개방-폐쇄 원칙을 지킬 수 있다.

> 스프링의 DI(Dependencies Injection)을 사용하면 기존 코드를 전혀 손대지 않고, 설정만으로 구현 클래스를 변경할 수 있다.

> 데이터를 DB에 저장하므로 스프링 서버를 다시 실행해도 데이터가 안전하게 저장된다.

스프링을 왜 사용하는가?

객체지향적인 설계가 좋은 이유는 다형성을 활용할 수 있기 때문이다.

(하나의 인터페이스를 두고 구현체를 바꿔 끼우는 것이 가능)

또한, Dependency Injection 덕분에 기존 코드는 하나도 손대지 않고

오직 애플리케이션을 설정하는 코드(assembly)만 변경해주면 된다.

이 기능들을 굉장히 편리하게 되도록 스프링 컨테이너가 지원해주는 것이 스프링의 장점!

스프링 통합 테스트

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

회원 서비스 스프링 통합 테스트

src/test/java/hello.hellospring/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 java.util.Optional;

import static org.assertj.core.api.AssertionsForClassTypes.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("hello");

        //when
        Long saveId = memberService.join(member);

        //then
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

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

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

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

결과

코드를 입력한 뒤 테스트를 실행해보면 오류가 발생한다.

이는 우리가 입력했던 spring이라는 회원이 이미 DB에 존재하는데

테스트에서 spring이라는 이름의 회원을 등록하려고 했기 때문이다.

따라서 delete from member를 통해 DB의 데이터를 모두 지워주면 정상적으로 테스트가 실행된다.

(보통 테스트 전용 DB를 구축하거나 로컬 PC의 DB에서 테스트 함)

하지만 테스트를 한번 더 실행하면 DB 중복 데이터로 인해 오류가 발생할 것이다.

이럴 때 @AfterEach보다는 @Transactional을 사용하면 좀 더 편리하다.

@SpringBootTest : 스프링 컨테이너와 테스트를 함께 실행한다.

@Transactional : 테스트 케이스에 이 애노테이션이 있으면, 테스트 시작 전에 트랜잭션을 시작하고, 테스트 완료 후에 항상 롤백한다. 이렇게 하면 DB에 데이터가 남지 않으므로 다음 테스트에 영향을 주지 않는다.

(서비스에서는 롤백 X, 테스트 케이스에서만 롤백)

@Transactional을 통한 테스트 실행 후 DB에 접속해보면 데이터가 남지 않는 것을 확인할 수 있다.

테스트를 여러 번 실행해도 오류가 발생하지 않는다.

** DB까지 올리는 통합 테스트보다는 단위 테스트가 보통 좋은 테스트이므로 쪼개서 테스트 할 수 있도록 하자!

스프링 JDBC Template

순수 Jdbc와 동일한 환경설정을 하면 된다.

스프링 JdbcTemplate과 MyBatis 같은 라이브러리는 JDBC API에서 본 반복 코드를 대부분 제거해준다.

하지만 SQL은 직접 작성해야 한다.

스프링 JdbcTemplate 리포지토리 구현

# 스프링 JdbcTemplate 회원 리포지토리

src/main/java/hello.hellospring/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 (rs, rowNum) -> {
            Member member = new Member();
            member.setId(rs.getLong("id"));
            member.setName(rs.getString("name"));
            return member;
        };
    }
}

# JdbcTemplate을 사용하도록 스프링 설정 변경

src/main/java/hello.hellospring/SpringConfig.java

package hello.hellospring;

import hello.hellospring.repository.JdbcMemberRepository;
import hello.hellospring.repository.JdbcTemplateMemberRepository;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
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 org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class SpringConfig {

    private DataSource dataSource;

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

    @Bean
    public MemberService memberService() {
        // 스프링 빈에 등록되어 있는 memberRepository를 memberService에 넣어줌
        return new MemberService(memberRepository());
    }

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

결과

JdbcTemplateMemberRepository 실행에 성공했다.

내용 및 이미지 출처 : 김영한의 스프링 입문

저작자표시 비영리 동일조건

'🖋️ study > spring' 카테고리의 다른 글

[Spring Intro] Section 07. AOP_AOP가 필요한 상황, AOP 적용 (0)	2023.02.02
[Spring Intro] Section 06. 스프링 DB 접근 기술_JPA, 스프링 데이터 JPA (0)	2023.01.30
[Spring Intro] Section 06. 스프링 DB 접근 기술_H2 데이터베이스 설치 (0)	2023.01.29
[Spring Intro] Section 05. 회원관리 예제 - 웹 MVC 개발(회원 웹 기능, 홈 화면 추가, 등록, 조회) (0)	2023.01.25
[Spring Intro] Section 04. 스프링 빈과 의존관계_컴포넌트 스캔과 자동 의존관계 설정, 자바 코드로 직접 스프링 빈 등록하기 (0)	2023.01.23