[스프링 입문] 6. 스프링 DB 접근 기술

📌 H2 데이터베이스 설치

H2 : 개발이나 테스트 용도로 용량도 작고 가볍고 편리한 DB, 웹 화면 제공

• https://www.h2database.com 에서 설치
  • AllPlatforms 설치
• cmd 창
  • cd h2
  • cd bin
  • chmod 755 h2.sh (mac은 실행 권한을 줘야함)
  • ./h2.sh
• 화면 창이 뜸
• 안 뜰 경우 : : 해당 포트 이전의 주소를 지우고 localhost로 변경

 

❗ 최초에만 database 파일 생성

 

✔ JDBC URL : jdbc:h2:~/test (내 home에 있는 test 파일 경로)

• 사용자명, 비밀번호는 그대로 두고 연결 버튼 클릭
• home에 test.mv.db 파일이 생성되었는지 확인
• cmd에서 dir로 확인

➕ 이후부터는 파일로 접근하게 되면 웹 콘솔과 애플리케이션이 같이 접근이 안돼서 충돌이 있을 수 있음

 

➡ JDBC URL : jdbc:h2:tcp://localhost/~/test로 접속

(파일을 통해 직접 접근하는 것이 아니라 socket을 통해 접근 -> 여러 곳에서 접근 가능)

➡ 연결

 

 

📌 테이블 생성

1. 데이터베이스와 연결

 H2 데이터베이스를 연 후 JDBC URL에 jdbc:h2:tcp://localhost/~/test 작성 후 연결

2. 테이블 생성

1) sql 작성

drop table if exists member CASCADE;
create table member
(
 id bigint generated by default as identity,
 name varchar(255),
 primary key (id)
);

 

✔ Member.java와 비교

• id : java에서는 long type, database에서는 bigint type
• generated by default as identity : 값을 세팅하지 않고 insert하면, DB가 자동으로 값을 채워줌

2) DB에 넣기

insert into member(name) values('spring')

 

3) 조회

select * from member;

 

sql문을 모두 지운 상태로 MEMBER table을 클릭하면 자동으로 조회하는 코드가 작성됨

 

❗ SQL

• IntelliJ에 sql 디랙토리를 만들고, ddl.sql 파일을 생성하면 깃 등에서 관리하기 편함
• cmd 끄면 DB 연결 거부 -> DB 연결부터 다시 해야 함

 

반응형

📌 순수 JDBC (참고만)

DB에 연동해서 insert query, select query를 날려 데이터를 db에 넣고 빼는 것

아주 오래된 기술

1. 환경설정

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

implementation 'org.springframework.boot:spring-boot-starter-jdbc'
runtimeOnly 'com.h2database:h2'

 

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

🔶 main/resources/templates/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 꼭 추가
• 추가 안하면 오류 발생

 

2. JDBC 리포지토리 구현

🔶 main/.../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;

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

 

3. 스프링 설정 변경

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;

@Configuration
public class SpringConfig {
    private final DataSource dataSource;
    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는 데이터베이스 커넥션을 획득할 때 사용하는 객체
• Spring boot는 데이터베이스 커넥션 정보를 바탕으로 DataSource를 생성하고 스프링빈으로 반들어둠 -> DI 받을 수 있음

 

 

• 개방-폐쇄 원칙(OCP, Open-Close Principle)
  • 확장에는 열려있고 수정, 변경에는 닫혀있음

• 스프링의 DI(Dependences Injection)을 사용
  • 기존의 코드를 전혀 손대지 않고 application을 설정하는 코드(어셈블리)만 수정하여 구현클래스를 변경 가능

 

스프링 통합 테스트

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.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

@SpringBootTest
@Transactional
class MemberServiceIntegrationTest {
    @Autowired MemberService memberService;
    @Autowired MemberRepository memberRepository;

    @Test
    public void 회원가입() throws Exception {
        //Given
        Member member = new Member();
        member.setName("hello");

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

        //Then
        Member findMember = memberRepository.findById(saveId).get();
        assertEquals(member.getName(), findMember.getName());
    }
    @Test
    public void 중복_회원_예외() throws Exception {

        //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에 데이터가 남지 않으므로 다음 테스트에 영향을 주지 않음
• 서비스 등 다른 곳에 붙었다면 롤백하지 않고 정상적으로 돈다

✔ 단위 테스트 : 순수 자바 코드로 작성한 테스트
✔ 통합 테스트 : 스프링과 DB 연동까지 하는 테스트

•  단위 테스트가 더 좋은 테스트일 때가 많음

 

스프링 JdbcTemplate

• 순수 Jdbc와 동일한 환경설정을 하면 됨
• 스프링 JdbcTemplate과 MyBatis 같은 라이브러리는 JDBC API에서 본 반복코드를 대부분 제거해줌 (SQL은 직접 작성해야함)
• 실무에서 자주 사용
• 생성자가 하나일 경우 @Autowired 생략 가능

 

 

스프링 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");
        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 List<Member> findAll() {
        return jdbcTemplate.query("select * from member", memberRowMapper());
    }

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

    private RowMapper<Member> memberRowMapper() {
        return (rs, rowNum) -> {
            Member member = new Member();
            member.setId(rs.getLong("id"));
            member.setName(rs.getString("name"));
            return member;
        }; 
    }
}

JPA

• JDBC에서 JDBCTemplate으로 바꾸면 반복코드가 제거됨
• 하지만 SQL은 개발자가 직접 작성해야 함
• 기존의 반복 코드는 물론, 기본적인 SQL query를 자동으로 처리해줌
• SQL과 데이터 중심의 설계에서 객체 중심의 설계로 패러다임을 전활할 수 있음
  • 개발 생산성을 크게 높일 수 있음

 

라이브러리 추가

1. build.gradle

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

implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'

• spring-boot-starter-data-jpa : 내부에 jdbc 관련 라이브러리를 포함
• jdbc 라이브러리 코드는 제거해도 됨

2. application.properties

🔶 main/.../resource/applicaation.properties

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

 

✔ show-sql

• JPA가 생성하는 sql을 출력

✔ ddl-auto

• JPA는 객체를 보고 테이블을 자동으로 생성함
• 하지만 이미 테이블이 만들어져있으므로 none으로 설정해서 기능 끔
• create를 사용하면 엔티티 정보를 바탕으로 테이블도 직접 생성해줌

 

JPA entity mapping

• JPA : 자바 표준 인터페이스, 구현은 여러 업체들이 함
  • JPA 인터페이스, hibernate 구현체를 주로 사용
  • 객체와 ORM(Object Relational database table Mapping)

 

Member.java

package hello.hellospring.domain;

import javax.persistence.*;

@Entity
public class Member {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "username")
    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

•  JPA가 관리하는 Entity가 되는 것

✔ @Id @GeneratedValue(strategy = GenerationType.IDENTITY)

• pk인 id를 mapping
•  id는 DB에서 자동으로 값 생성됨
•  IDENTITY 전략

✔ @Column(name="username")

 

Repository 생성

 

🔶  main/.../repository/JpaMemberRepository.java

• JPA는 EntityManager로 모든 것이 동작함
  • build.gradle에서 spring-boot-starter-data-jpa 라이브러리를 가져오면서 spring boot가 자동으로 EntityManager를 생성해줌 (현재 DB와 연결도 해줌)
  • 만들어준 것을 injection 받으면 됨
• save 함수에 em.persist(member);작성 후 member를 반환해줌 (저장)
  • findById 함수에 em.find(Member.class, id); 작성 후(조회)
  • Optional.ofNullable(member)반환
• findByName 함수에 em.createQuery("select m from Member m where m.name=:name", Member.class).setParameter("name", name).getResultList(); 작성 후
  • result.stream().findAny() 반환
• findAll 함수에는 JPQL이라는 객체 지향 쿼리 언어 사용
  • em.createQuery("select m from Member m", Member.class).getResultList(); 작성 후

 

❗ JPQL(객체지향쿼리)

• table 대상으로 query를 날리지 않고 객체를 대상으로 query를 날림 -> SQL로 번역됨
• ex) findAll 함수의 "selectm from Member m"에서 객체 m 자체를 select

 

❗ 스프링 데이터 JPA

• JPA를 스프링에 감싸서 제공하는 기술

 

❗ @Transactional 작성

• JPA는 데이터를 저장하거나 변경할 때 트랜잭션이 반드시 존재해야 함
  • JPA를 통한 모든 데이터 변경은 트랜잭션 안에서 실행해야 함
  • MemberService.java 클래스 위에 @Transactional 작성
  • 회원가입 할 때 필요한 기능이므로 join 함수 위에 해줘도 됨

 

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;
    }
    public Member save(Member member) {
        em.persist(member);
        return member;
    }
    public Optional<Member> findById(Long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }
    public List<Member> findAll() {
        return em.createQuery("select m from Member m", Member.class)
                  .getResultList();
    }
    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();
    } 
}

 

Config

🔶 main/.../service/SpringConfig.java

 

✔ EntityManager

✔ memberRepository

SpringConfig.java

package hello.hellospring;
import hello.hellospring.repository.*;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.persistence.EntityManager;
import javax.sql.DataSource;

@Configuration
public class SpringConfig {

    private final DataSource dataSource;
    private final EntityManager em;
    public SpringConfig(DataSource dataSource, EntityManager em) {
        this.dataSource = dataSource;
        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);
    }
}

 

스프링데이터 JPA

• 스프링 부트와 JPA 기반 위에 스프링데이터 JPA라는 프레임워크를 사용하면, 리포지토리에 구현클래스 없이 인터페이스 만으로 개발할 수 있음
• 반복 개발해온 기본 CRUD도 제공
• 실무에서 관계형 데이터베이스를 사용한다면 스프링 데이터 JPA는 필수

 

SpringDataJpaMemberRepository

🔶 main/.../repository/SpringDataJpaMemberRepository

 

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

 

• JpaRepository<Member, Long>, MemberRepository를 extends
  • interface끼리 받을 때는 extends사용
  • 스프링 데이터 JPA가 SpringDataJpaMemberRepository를 스프링빈으로 자동 등록
  • 구현체를 자동으로 만들고 스프링빈에 등록함

 

SpringConfig

package hello.hellospring;
import hello.hellospring.repository.*;
import hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {

    private final MemberRepository memberRepository;

    public SpringConfig(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }
    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository);
    }
}

 

스프링 데이터 JPA 제공 기능

✔ 인터페이스를 통한 기본적인 CRUD 제공
✔ findByName(), findByEmail()처럼 메서드 이름만으로 조회 기능 제공
✔ 페이징 기능 자동 제공

 

 

 

 

이 글은 <김영한_스프링 입문>을 수강하고 참고하여 작성한 글입니다

 

 

 

 

---

PREV

[스프링 입문] 5. 회원 관리 예제 - 웹MVC 개발

NEXT

[스프링 입문] 7. AOP