18~23. 스프링 DB 접근 기술

H2 데이터베이스 설치

개발이나 테스트 용도로 가벼운 데이터베이스 

 

https://h2database.com/html/main.html 에서 다운로드 가능

H2 Database Engine

압축을 풀고 h2.bat 실행하면 로그인 화면이 나타남

하지만 웹 애플리케이션과 웹 콘솔이 동시에 접근하게 되면 오류가 나서 충돌의 여지가 있기때문에 JDBC URL을 수정

jdbc:h2:tcp://localhost/~/test

혹시 문제가 발생하면 test.mv.db를 지운 후 서버를 재시작하면 된다.

---

테이블 생성하기

테이블 관리를 위해 프로젝트 루트에 sql/ddl.sql 파일을 생성해서 관리해주면 좋다.(git 저장소에 저장도 용이)

member 테이블이 생성되었고, 좌측에 생성하자마자 바로 테이블이 보인다. 조회를 해보자.

조회가 잘 된다. 아직 데이터는 없지만, 컬럼 이름인 ID와 NAME이 잘 뜨는 걸 볼 수 있다.

(컬럼 이름은 /domain/Member의 멤버와 같다.)

 

데이터 값을 임의로 추가해본다. spring1, spring2를 넣으면 다음처럼 ID 값은 자동으로 증가되는 것을 볼 수 있다.

---

순수 JDBC

환경 설정

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

implementation 'org.springframework.boot:spring-boot-starter-jdbc'
	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

 

아래와 같이 빨간 불이 뜨면 임포트가 안된 것이기 때문에 build.gradle에 가서 코끼리 버튼을 클릭해준다.

코끼리 버튼(Reload All Gradle Projects) 클릭

 

기존 만들었던 인터페이스인 MemberRepository를 구현하는 구현체인 JdbcMemberRepository를 생성 후 내용 작성

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

DB에 연결하려면 DataSource가 필요하기 때문에 선언해주고 데이터베이스 접속 정보를 만들어두고 dataSource.getConnection( ) 메서드를 통해 커넥션을 얻는다. 

이후에 dataSource.getConnection( ) 메서드를 이용해 데이터베이스 커넥션을 가지고 온 후

connection.prepareStatement( ) 메서드로 sql을 작성 후 executeUpdate( ) 메서드로 쿼리를 실행

 

이 방법은 try ~ catch도 잘 잡아주어야 하고 자원 릴리즈도 잘 해주어야 한다.

 

그리고 SpringConfig의 스프링 설정을 변경해준다.

package hello.hellospring;

import hello.hellospring.domain.Member;
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 JdbcMemberRepository(dataSource);
    }
}

DataSource는 데이터베이스 커넥션을 획득할 때 사용하는 객체다.

스프링 부트는 데이터베이스 커넥션 정보를 바탕으로 DataSource를 생성하고 스프링 빈으로 만들어준다. 그래서 DI를 받을 수 있는 것이다.

 

이제 프로젝트를 실행한 후 회원 목록을 보면 이전에 DB에 insert 했던 회원 정보가 같이 출력되는 것을 확인할 수 있다.

구현 클래스 추가 이미지

(MemberService는 MemberService를 의존, MemberService의 구현체는 MemoryMemberRepository, JdbcMemberRepository가 있음)

메모리에 저장하는 MemberRepository에 등록하지 않고 데이터베이스에 저장하는 JdbcMemberRepository를 등록함.

이것을 개방-폐쇄 원칙(OCP, Open-Closed Principle)이라고 한다.

• 확장에는 열려있고, 수정·변경에는 닫혀있다.
• 스프링의 DI를 사용하면 기존 코드를 전혀 손대지 않고, 설정만으로 구현 클래스를 변경할 수 있다.
• 데이터를 DB에 저장하므로 스프링 서버를 다시 실행해도 데이터가 안전하게 저장된다.

---

스프링 통합 테스트

스프링 컨테이너와 DB까지 연결한 통합 테스트

MemberServiceTest를 복사한 후 MemberServiceIntegrationTest로 생성

 

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

package hello.hellospring.service.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
import hello.hellospring.service.MemberService;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
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.assertThrows;

@SpringBootTest
@Transactional
class MemberServiceIntegrationTest {

    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    void 회원가입() {
        // given : 주어진 상황
        Member member = new Member();
        member.setName("spring");

        // 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("이미 존재하는 회원입니다.");

    }

}

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

---

스프링 JdbcTemplate

• 순수 Jdbc와 동일한 환경 설정을 하면 됨
• 스프링 JdbcTemplate과 MyBatis같은 라이브러리는 JDBC API에서 본 반복 코드를 대부분 제거해줌, 하지만 SQL은 직접 작성해야 함
• 실무에서도 많이 사용하고 있는 방식

스프링 JdbcTemplate 회원 리포지토리

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
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;

    public JdbcTemplateMemberRepository(DataSource dataSource) {
        jdbcTemplate = new JdbcTemplate(dataSource);
    }


    @Override
    public Member save(Member member) {
        SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
        jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id"); // 테이블 명, PK 전달
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("name", member.getName());
        Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters)); // 키를 반환받음
        member.setId(key.longValue()); // 반환 받은 키로 set
        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을 사용하도록 스프링 설정 변경

package hello.hellospring;

import hello.hellospring.domain.Member;
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 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 JdbcMemberRepository(dataSource);
        return new JdbcTemplateMemberRepository(dataSource);
    }
}

DB 연동을 포함한 테스트 성공

---

JPA

• JPA는 기존의 반복 코드는 물론, 기본적인 SQL도 JPA가 직접 만들어서 실행해줌
• JPA를 사용하면 SQL과 데이터 중심의 설계에서 객체 중심의 설계로 패러다임을 전환할 수 있음
• JPA를 사용하면 개발 생산성을 크게 높일 수 있음

JPA는 객체와 ORM 기술이다.

ORM: Object 객체와 Relational 테이블을 Mapping 매핑한다.

 

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

//	implementation 'org.springframework.boot:spring-boot-starter-jdbc'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

spring-boot-starter-data-jpa는 내부에 jdbc 관련 라이브러리를 포함하기 때문에 jdbc는 제거해도 된다.

 

application.properties에 다음 내용 추가

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는 테이블을 자동으로 생성하는 기능을 제공하는데 none을 사용하면 해당 기능을 끈다. create를 사용하면 엔티티 정보를 바탕으로 테이블도 직접 생성해준다.

그리고 Reload All Gradle Projects를 한 후 External Library를 확인하면 hibernate가 추가된 것을 확인할 수 있다.

hibernate가 라이브러리에 추가된 모습

 

JPA는 엔티티 매니저로 동작하는데, build.gradle에 spring-boot-starter-data-jpa를 추가하면 스프링 부트가 자동으로 엔티티 매니저를 자동으로 생성해줌. 만들어 진 것을 Injection 받으면 된다.

 

JPA 엔티티 매핑

package hello.hellospring.domain;

import jakarta.persistence.*;

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

}

IDENTITY: DB가 id 값을 자동으로 생성해주는 것

 

JPA 회원 리포지토리

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import jakarta.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) { // pk 기반이 아니기때문에 jpql로 작성
        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();
    }
}

서비스 계층에 트랜잭션 추가한 코드

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

@Transactional
public class MemberService {
    private final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    /**
     * 회원가입
     */
    public Long join(Member member) {
        validateDuplicateMember(member); // 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName()) // null일 가능성이 있다면 Optional로 감싼다.
                .ifPresent(m -> { // findByName의 결과가 Optional<Member>이기때문에 바로 .ifPresent 메서드를 실행할 수 있다.
                    throw new IllegalStateException("이미 존재하는 회원입니다.");
            });
    }

    /**
     * 전체 회원 조회
     */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    /**
     * 단일 회원 조회
     */
    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    }

}

테스트 성공

JPA도 꼭 깊게 공부하자.

---

스프링 데이터 JPA

스프링 데이터 JPA는 JPA를 편리하게 사용하게 도와주는 기술이기때문에 꼭 JPA를 학습한 후에 스프링 데이터 JPA를 학습해야 한다.

 

앞의 JPA 설정을 그대로 사용한다.

 

스프링 데이터 JPA 회원 리포지토리

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

스프링 데이터 JPA 회원 리포지토리를 사용하도록 스프링 설정 변경

package hello.hellospring;

import hello.hellospring.repository.*;
import hello.hellospring.service.MemberService;
import jakarta.persistence.EntityManager;
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);
    }
}

스프링 데이터 JPA가 SpringDataJpaMemberRepository를 보고 스프링 빈을 자동으로 만들어서 객체를 생성해서 스프링 빈에 등록하고, 그걸 Injection을 해서 쓴 것이다.

 

스프링 데이터 JPA 제공 클래스

• JpaRepository 인터페이스의 내부에서 기본적인 CRUD랑 단순 조회들은 다 제공이 된다.
• 스프링 데이터 JPA는 이렇게 인터페이스만으로 간단하게 개발할 수 있는 강력한 기능을 제공한다.
• findByName( ), findByEmail( ) 처럼 메서드 이름만으로 조회 기능 제공
• 페이징 기능 자동 제공

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