[2025 1학기 스프링부트 스터디] 고윤정 #6주차

 
 
섹션 7 - 스프링 DB 접근 기술
 
안녕하세요.. 6주차 스터디 시작합니다..
 
 
 
 

H2 데이터베이스 설치

 
https://www.h2database.com

H2 Database Engine (redirect)

 
위 링크에서 h2 데이터베이스를 설치해줍니다
 
저는 우분투로 실습해가지구
터미널에서 chmod +x h2.sh 로 권한을 부여해줬습니다!
 

실행 완

 
 
최초 한 번은 첫 화면 그대로 연결해주고
~/test.mv.db 파일이 생성 된 것을 확인한 다음
이후로는 jdbc:h2:tcp://localhost/~/test 로 접속합니다
 
 
 
 
 
 
 
 

순수 JDBC

 

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

 
build.gradle 파일에 jdbc, h2 데이터베이스 관련 라이브러리를 추가해줍니다
 
자바가 데이터베이스와 직접 통신할 수 없기 때문에 jdbc 드라이버가 꼭 있어야 하고
데이터베이스가 제공하는 클라이언트가 필요하기 때문에 h2 데이터베이스를 넣는 것이라고 합니다
 
 

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

 
스프링부트 데이터베이스 연결 설정도 추가해줍니당
옛날에는 개발자가 일일이 어렵게 설정을 했다고 하는데
요즘에는 스프링부트가 다 해줘서 경로만 넣으면 된다고 하셨어요
 
 
 
 
이제 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);
}
}

 
이 엄청나게 긴 코드를 작성해줍니다
 
이 코드에서 간단히 몇개 공부하고 가보겠습니당
 
 
 
 
 
 
 
 
★ DataSource

private final DataSource dataSource;

 
DB 커넥션을 얻기 위한 스프링이 제공하는 연결 객체로, 커넥션 풀을 사용해 효율적으로 DB 연결을 관리함
 
 
★ Connectrion 객체

Connection conn = getConnection();

 
실제 DB와 연결된 객체로 이걸 통해 쿼리를 날려 결과를 받아옴
 
 
★ PreparedStatement

PreparedStatement pstmt = conn.prepareStatement(sql);

 
SQL문을 미리 컴파일해두고, ? 자리에 값을 바인딩해서 실행할 수 있게 해주는 객체로 SQL 인젝션 방지에도 효과적임
 
 
★ ResultSet

ResultSet rs = pstmt.executeQuery();
rs.next();
rs.getLong("id");

 
쿼리 결과를 담는 객체로
rs.next(); 는 한 줄씩 이동하고
rs.getLong("id") 으로 컬럼 값 꺼냄
 
 
 
 
 
 
 
 
 
 
 

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

 
이제 스프링 설정을 변경하는 코드도 작성해줍니다
 
 
 
 
 
 
 
 
 

 
★ 개방-폐쇄 원칙(OCP, Open-Closed Principle)
확장에는 열려있고, 수정, 변경에는 닫혀있다
-> 기존코드를 수정하지 않고도 새로운 기능을 추가할 수 있음 !!
 
 
 
 
 
 
 
 
 
 
 

스프링 통합 테스트

 

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
스프링부트 애플리케이션 전체를 테스트 컨텍스트로 로드해서 통합 테스트 환경을 만들어주는 역할로,
실제 애플리케이션처럼 전체 스프링 컨테이너를 띄우고
@Autowired를 통한 의존성 주입이 가능하고
JPA, 웹 레이어, 서비스 레이어 등을 통합적으로 테스트할 때 사용함
 
★ @Transactional
메서드나 클래스에 붙이면 트랜잭션이 시작되고, 메서드 실행이 끝나면 자동 롤백됨
데이터를 변경하는 테스트에 자주 사용하고 테스트 후 DB 상태를 원래대로 유지하기 위해 사용함
 
 
 
 
선생님께서 단위 테스트에 대해 언급하셨는데,
단위 단위로 쪼개서 스프링 컨테이너 없이 테스트를 잘 할 수 있도록
열심히 훈련해야 된다고 하십니당 ...
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

스프링 JdbcTemplate

 
 
JdbcTemplateMemberRepository 파일을 만들고

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

 
이렇게 코드를 작성해줍니다
 
순수 Jdbc와 동일한 환경설정을 하면 되고,
스프링 JdbcTemplate과 MyBatis 같은 라이브러리는 JDBC API에서 본 반복 코드를 대부분 제거해주지만
SQL은 직접 작성해야 한다고 합니다
 
영상을 따라서 실습을 해보는데
오류가 나지 않도록 테스트코드를 잘 짜는게 정말 정말 정말 중요하다는 것을 강조해주셨습니다
파이팅..
 
 
 
 
 
 
 
 
 
 
 
 
 
 

JPA

 
 
- JPA는 기존의 반복 코드는 물론이고, 기본적인 SQL도 JPA가 직접 만들어서 실행해준다.
- JPA를 사용하면, SQL과 데이터 중심의 설계에서 객체 중심의 설계로 패러다임을 전환을 할 수 있다.
- JPA를 사용하면 개발 생산성을 크게 높일 수 있다.
 
라고 나와있는데
조금 더 쉽게 이해해보겠습니다
 
 

JPA(Java Persistence API)?

자바 객체를 데이터베이스에 저장하고 불러오는 방법을 표준화한 기술
 
기존방식, 즉 JDBC는 SQL을 직접 작성하고 반복 코드가 많고 실수하기가 쉽다고 합니다
그런데 JPA를 사용하면 SQL 작성을 하지 않아도 되고, 자바 객체처럼 다루며, 알아서 DB와 연결, 조회, 저장됩니다!!
 

• Entity : 테이블과 매핑되는 자바 클래스 -> @Entity 사용
• EntityManager : 객체를 DB에 저장/조회/삭제하는 중간 관리자

 
 
 
 
 
 
이제 코드를 작성해봅시당
 

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') {
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
}

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

resources/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

 
-> 스프링부트에 JPA 설정 추가
 
 

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

 
-> JPA 엔티티 매핑
 
 

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

 
-> JPA 회원 리포지토리
 
 

import org.springframework.transaction.annotation.Transactional
@Transactional
public class MemberService {}

 
-> 서비스 계층에 트랜잭션 추가
 
- org.springframework.transaction.annotation.Transactional 를 사용하자.
- 스프링은 해당 클래스의 메서드를 실행할 때 트랜잭션을 시작하고, 메서드가 정상 종료되면 트랜잭션을 커
밋한다. 만약 런타임 예외가 발생하면 롤백한다.
- JPA를 통한 모든 데이터 변경은 트랜잭션 안에서 실행해야 한다.
 
 
 
 

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?

JPA를 더 편하게 쓰기 위해 스프링이 만들어준 도구로
JPA + 스프링부트의 자동화 기능이라고 보면 된다!
 
JPA로도 SQL없이 객체로 DB를 다룰 수 있는데,
스프링 데이터 JPA는 그마저도 생략하고 인터페이스만 만들면 끝이라고 합니다 wow
 
 
 
 
 
 

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

 

 

 
스프링 데이터 JPA 제공 기능

 

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

내용이 정말 많고 너무 어려웠어요....
잘 모르겠지만 최대한 이해해보려고 노력했습니당...
복습만이 살 길

고생하셨습니다 !!!!!!!