설정 몇 줄 뒤에서 일어나는 일을 확인합니다
지금까지 만든 API는 서버를 끄면 데이터가 사라지는 메모리 저장소 위에 있었습니다. 이 Chapter에서 처음으로 데이터베이스를 붙입니다. 그런데 application.yml에 URL과 계정 몇 줄을 적었을 뿐인데 DataSource라는 객체가 만들어지고, 커넥션 풀이 켜지고, 테이블이 만들어져 있습니다. 코드는 한 줄도 쓰지 않았습니다. 이 Chapter는 그 자동으로 일어나는 일을 하나씩 확인합니다.
이 Chapter에서 완성할 것
| 만드는 것 | 설명 |
|---|---|
application.yml 데이터소스 설정 |
H2 인메모리 URL과 HikariCP 풀 설정 |
schema.sql, data.sql |
시작할 때 자동 실행되는 테이블 생성과 초기 데이터 |
UserRepository |
JdbcClient로 SQL을 직접 실행하는 저장소 |
GET /db/info |
자동 구성된 DataSource와 풀의 설정을 그대로 보여 주는 확인용 API |
| 테스트 11건 | 풀 설정, 연결, 스크립트 로딩, 파라미터 바인딩 |
설정 파일이 DataSource를 만들고, 시작할 때 SQL 스크립트가 테이블과 초기 데이터를 만들고, JdbcClient로 조회하는 흐름입니다. Chapter 05의 메모리 저장소 자리에 데이터베이스가 들어옵니다.
예제 모듈과 확인 환경
예제는 공개 저장소의 examples/ch08-datasource-h2입니다. 모듈 번호가 Chapter 번호와 한 칸 어긋나 있지만 실행 명령마다 모듈 경로를 적었으므로 그대로 따라가면 됩니다. JDK 21과 Spring Boot 4.1.1을 기준으로 하며, 저장소 루트에서 Gradle Wrapper를 사용합니다.
실행 결과는 컨테이너에서 JAR로 직접 실행해 얻은 값이고, 오류 문구는 복사본에서 같은 실수를 일부러 만들어 얻었습니다. H2와 Spring Boot 4.1.1 기준이며 Windows 실행은 검증하지 못했습니다.
메모리 저장소의 한계와 JDBC, DataSource
메모리에 담아 둔 사용자 목록은 서버를 재시작하면 사라집니다. 서비스를 계속 운영하려면 데이터를 서버 밖의 데이터베이스에 보관해야 합니다. 이 절에서는 자바가 데이터베이스와 대화하는 표준(JDBC)과, 연결을 빌려주는 DataSource, 그리고 연결을 재사용하는 커넥션 풀의 개념을 정리합니다.
메모리 저장소의 한계
Chapter 05의 저장소는 ConcurrentHashMap이었습니다.
| 한계 | 설명 |
|---|---|
| 재시작하면 사라짐 | 데이터가 JVM 메모리에만 있습니다. |
| 서버가 둘이면 어긋남 | 서버마다 자기 메모리를 가져 서로 다른 데이터를 봅니다. |
| 검색이 느림 | 조건 조회를 직접 반복문으로 구현해야 합니다. |
| 일관성 보장이 약함 | 여러 데이터를 함께 바꾸는 트랜잭션이 없습니다. |
데이터베이스는 이 한계를 해결합니다. 데이터를 디스크에 보관하고, 여러 서버가 같은 데이터를 보며, SQL로 조건 검색을 하고, 트랜잭션을 지원합니다.
JDBC: 자바가 DB와 대화하는 표준
JDBC(Java Database Connectivity)는 자바에서 데이터베이스에 접속하고 SQL을 실행하는 표준 API입니다. 데이터베이스마다 드라이버(JDBC 구현체)가 따로 있고, 코드는 JDBC 표준만 알면 드라이버를 바꿔 다른 DB에 접속할 수 있습니다.
JDBC의 연결 주소를 JDBC URL이라고 합니다. jdbc:h2:mem:curriculum처럼 jdbc: 다음에 DB 종류와 위치를 적습니다. 이 Chapter는 H2를 쓰고, 이후 Chapter에서 다른 DB를 만납니다.
연결은 비싸다: 커넥션 풀
요청이 들어올 때마다 DB에 새로 연결하면 느립니다. 연결을 맺는 데는 네트워크 왕복과 인증이 들기 때문입니다. 그래서 연결을 미리 몇 개 만들어 두고 빌려주고 돌려받는 방식을 씁니다. 이것이 커넥션 풀입니다.
DataSource는 이 연결을 빌려주는 표준 인터페이스(javax.sql.DataSource)입니다. 코드는 dataSource.getConnection()으로 연결을 얻고, 풀이 뒤에서 재사용을 관리합니다. Spring Boot는 HikariCP를 기본 풀로 씁니다.
| 개념 | 역할 |
|---|---|
| JDBC | DB 접속·SQL 실행의 표준 API |
| 드라이버 | DB별 JDBC 구현체 |
DataSource |
연결을 얻는 표준 창구 |
| 커넥션 풀 | 연결을 재사용하는 관리자 (HikariCP) |
스프링이 해 주는 일
원래 JDBC는 연결을 얻고, 문장을 만들고, 결과를 읽고, 자원을 닫는 코드가 길었습니다. Spring은 DataSource 설정을 자동 구성하고, 반복 코드를 줄여 주는 도구(JdbcClient)를 제공합니다. “설정 몇 줄이 DataSource가 되는 과정” 절부터 그 결과를 확인합니다.
데이터가 오가는 전체 경로
데이터는 Spring 앱의 UserRepository에서 DataSource(HikariCP 풀), JDBC 드라이버(H2)를 차례로 거쳐 데이터베이스에 닿습니다. 코드는 DataSource만 알고, 풀과 드라이버는 뒤에서 일합니다. 이 구조 덕분에 DB를 바꿔도 위쪽 코드가 거의 바뀌지 않습니다. 이 과정은 H2에서 시작해 Chapter 11에서 Oracle로 같은 코드를 옮겨 봅니다.
순수 JDBC로 쓰면 이렇게 길다
JdbcClient가 줄여 주는 코드가 어느 정도인지 비교해 봅니다. 아래는 개념을 보이기 위한 일반 JDBC 코드이고, 예제 저장소에는 없습니다.
try (Connection con = dataSource.getConnection();
PreparedStatement ps = con.prepareStatement("SELECT id, name FROM users WHERE id = ?")) {
ps.setLong(1, id);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) {
return Optional.of(new User(rs.getLong("id"), rs.getString("name")));
}
return Optional.empty();
}
}
연결 얻기, 문장 만들기, 파라미터 지정, 결과 순회, 자원 닫기가 모두 직접 쓰는 코드입니다. 이 반복을 줄이는 도구가 아래 “JdbcClient로 조회하기” 절의 JdbcClient이고, 더 나아가 SQL을 분리해 관리하는 도구가 Chapter 08의 MyBatis입니다.
확인 문제
DataSource와 커넥션 풀의 관계를 한 문장으로 설명해 보세요.- 서버가 두 대인데 메모리 저장소를 쓰면 어떤 일이 생기나요?
- JDBC URL
jdbc:h2:mem:curriculum에서mem은 무엇을 뜻하나요?
답: 1) DataSource는 연결을 얻는 표준 창구이고, 커넥션 풀은 그 뒤에서 연결을 재사용하는 구현입니다. 2) 서버마다 다른 메모리를 가지므로 같은 요청도 서버에 따라 다른 데이터를 보게 됩니다. 3) 데이터를 JVM 메모리에 두는 인메모리 데이터베이스라는 뜻입니다.
직접 해 보기
- Chapter 05의 서버를 켜고 사용자를 만든 뒤 재시작해서 데이터가 사라지는 것을 확인하세요.
- 위 표를 보고 “요청마다 DB에 새로 연결”하는 방식과 풀을 쓰는 방식의 차이를 두 문장으로 적어 보세요.
- 자신이 쓰는 DB(PostgreSQL, MariaDB 등)의 JDBC URL 형식을 공식 문서에서 찾아
jdbc:h2:mem:과 비교해 보세요.
설정 몇 줄이 DataSource가 되는 과정
application.yml에 데이터베이스 정보를 적으면 Spring Boot가 DataSource와 커넥션 풀을 만들어 줍니다. 이 절에서는 어떤 설정이 어떤 객체가 되는지, 그리고 정말 만들어졌는지 /db/info로 확인합니다.
의존성 두 줄
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-webmvc'
// DataSource, HikariCP 커넥션 풀, JdbcClient 자동 구성을 가져온다.
implementation 'org.springframework.boot:spring-boot-starter-jdbc'
// 인메모리 데이터베이스. 런타임에만 필요하다.
runtimeOnly 'com.h2database:h2'
}
spring-boot-starter-jdbc:DataSource, HikariCP,JdbcClient의 자동 구성을 가져옵니다.com.h2database:h2: H2 데이터베이스와 JDBC 드라이버입니다. 코드가 H2 클래스를 직접 쓰지 않으므로 실행할 때만 필요한runtimeOnly입니다. Chapter 01의 build.gradle 읽기에서 본 의존성 구분입니다.
설정
spring:
datasource:
url: jdbc:h2:mem:curriculum-${random.uuid}
username: sa
password: ""
hikari:
pool-name: curriculum-pool
maximum-pool-size: 5
minimum-idle: 2
주요 코드 설명
url: JDBC URL입니다.jdbc:h2:mem:은 JVM 메모리 안에 만들어지는 H2이고, 프로세스가 끝나면 데이터도 사라집니다. 이름 뒤${random.uuid}를 붙인 이유는 아래 “자주 만나는 오류와 해결 방법” 절의 오류 5에서 설명합니다.username,password: H2의 기본 계정(sa, 빈 비밀번호)입니다. 운영 DB의 비밀번호를 파일에 쓰는 것은 금지이며, Chapter 02에서 배운 환경 변수로 주입합니다.hikari.pool-name,maximum-pool-size,minimum-idle: 풀 이름, 최대 연결 수, 놀고 있어도 유지할 최소 연결 수입니다.spring.datasource.hikari.*가 풀 설정 자리입니다.
정말 만들어졌는지 확인하기
자동 구성은 코드로 보이지 않으므로 꺼내 봐야 확인할 수 있습니다. DataSourceInfoController가 DataSource를 생성자로 받아(생성자 주입) 정보를 돌려줍니다.
@GetMapping("/db/info")
public Map<String, Object> info() throws SQLException {
Map<String, Object> info = new LinkedHashMap<>();
info.put("dataSourceType", dataSource.getClass().getSimpleName());
if (dataSource instanceof HikariDataSource hikari) {
info.put("poolName", hikari.getPoolName());
info.put("maximumPoolSize", hikari.getMaximumPoolSize());
info.put("minimumIdle", hikari.getMinimumIdle());
}
try (Connection connection = dataSource.getConnection()) {
info.put("product", connection.getMetaData().getDatabaseProductName());
info.put("url", connection.getMetaData().getURL());
}
return info;
}
dataSource.getClass().getSimpleName(): 실제로 주입된 객체의 클래스 이름입니다.instanceof HikariDataSource hikari: Java의 패턴 매칭입니다. 풀 구현체이면 풀 설정을 꺼냅니다.try (Connection ...): 연결을 빌려 메타데이터를 읽고 반드시 닫습니다. 왜 닫아야 하는지는 바로 다음 “연결을 닫아도 진짜로 닫히지 않습니다” 절의 주제입니다.
실행 결과
GET /db/info
-> 200 {"dataSourceType":"HikariDataSource","poolName":"curriculum-pool","maximumPoolSize":5,"minimumIdle":2,"product":"H2","url":"jdbc:h2:mem:curriculum-4c17e00a-ec6c-4592-8eb6-381c5da72b58"}
설정에 적은 풀 이름과 크기가 그대로 반영된 HikariDataSource가 만들어져 있습니다. 설정 값(5, 2, curriculum-pool)이 객체의 상태가 된 것을 직접 본 것입니다. /db/info는 학습용이며 실제 서비스에서는 이런 정보를 외부에 노출하지 않습니다.
자동 구성의 흐름
application.yml의 spring.datasource.* 설정과 클래스패스의 HikariCP를 자동 구성이 함께 읽어 HikariDataSource Bean을 만들고, 그 위에 JdbcClient Bean을 만듭니다. Chapter 01에서 말한 “클래스패스의 라이브러리를 보고 설정을 구성한다”가 그대로 적용된 사례입니다. 스타터를 넣으면 풀과 DataSource가 생기고, 우리는 설정만 적습니다.
따라 하기
./gradlew :examples:ch08-datasource-h2:bootRun을 실행합니다.curl http://localhost:8080/db/info를 호출합니다.dataSourceType이HikariDataSource,poolName이curriculum-pool,maximumPoolSize가5이면 성공입니다.application.yml의maximum-pool-size를3으로 바꾸고 다시 실행해 응답이3으로 바뀌는지 확인합니다. 설정이 객체의 상태가 되는 과정을 직접 보는 실험입니다.
설정 항목 한눈에 보기
| 설정 | 의미 | 이 예제의 값 |
|---|---|---|
spring.datasource.url |
어느 DB에 어떻게 연결할지 | jdbc:h2:mem:curriculum-${random.uuid} |
spring.datasource.username, password |
DB 계정 | sa, 빈 문자열 |
spring.datasource.hikari.pool-name |
로그와 모니터링에서 보이는 풀 이름 | curriculum-pool |
spring.datasource.hikari.maximum-pool-size |
동시에 빌려줄 수 있는 최대 연결 | 5 |
spring.datasource.hikari.minimum-idle |
놀고 있어도 유지할 최소 연결 | 2 |
자주 하는 실수
| 실수 | 증상 | 해결 |
|---|---|---|
스타터 대신 h2만 추가 |
DataSource가 자동 구성되지 않을 수 있음 |
spring-boot-starter-jdbc도 추가 |
JDBC URL 오타(jdbc:h3:...) |
claims to not accept jdbcUrl |
URL의 jdbc:종류: 부분 확인 |
운영 비밀번호를 application.yml에 적음 |
저장소에 비밀 값이 남음 | 환경 변수로 주입 |
확인 문제
runtimeOnly로 H2를 선언하는 이유는 무엇인가요?/db/info를 운영 서버에 그대로 두면 왜 위험한가요?
답: 1) 코드가 H2 클래스를 직접 쓰지 않고 실행할 때 드라이버만 필요하기 때문입니다. 2) 풀 설정과 DB 메타데이터 같은 내부 정보를 외부에 노출하기 때문입니다.
직접 해 보기
maximum-pool-size를 10으로 바꾸고/db/info가 10으로 나오는지 확인하세요.pool-name을 바꾸고 서버 로그에서 풀 이름이 로그에 나타나는지 찾아보세요.- 설정에서
hikari블록 전체를 지우면/db/info의 풀 이름과 크기가 어떻게 되는지 관찰하세요. 이 Chapter에서는 기본값을 확인하지 않았으므로 직접 본 값을 적어 보세요.
연결을 닫아도 진짜로 닫히지 않습니다
JDBC 코드에는 connection.close()가 반드시 들어갑니다. 그런데 커넥션 풀을 쓰면 close()가 연결을 끊지 않고 풀에 돌려줍니다. 이 차이를 테스트로 확인하고, 연결을 닫지 않으면 어떤 문제가 생기는지 봅니다.
풀의 연결은 프록시다
풀이 내주는 Connection은 진짜 연결을 감싼 프록시 객체입니다. 프록시의 close()는 물리적 연결을 끊지 않고 “다 썼다”고 풀에 알리는 동작입니다. 풀은 그 연결을 다음 요청에 다시 빌려줍니다.
테스트로 확인하기
@Test
void closingConnectionReturnsItToPoolInsteadOfClosingPhysically() throws SQLException {
Connection first = dataSource.getConnection();
first.close();
Connection second = dataSource.getConnection();
try {
// 풀이 돌려주는 것은 매번 새 프록시 객체지만, 닫은 뒤에도 새 연결을 얻을 수 있다.
assertNotSame(first, second);
assertTrue(second.isValid(1));
assertTrue(first.isClosed());
} finally {
second.close();
}
}
주요 코드 설명
first.close(): 연결을 풀에 돌려줍니다. 물리적 DB 연결은 살아 있습니다.second = dataSource.getConnection(): 다시 빌립니다. 풀은 새 프록시 객체를 내줍니다.assertNotSame(first, second): 프록시 객체는 매번 새로 만들어집니다. 같은 객체가 아닙니다.assertTrue(second.isValid(1)): 새로 빌린 연결이 정상 동작합니다.1은 검사 제한 시간(초)입니다.assertTrue(first.isClosed()): 반납한first는 닫힌 상태로 남습니다. 반납한 연결을 다시 쓰려 하면 안 됩니다.finally { second.close(); }: 테스트에서도 빌린 연결은 반드시 돌려줍니다.
닫지 않으면
maximum-pool-size가 5인 풀에서 연결을 빌리고 닫지 않는 코드가 5번 실행되면, 풀에는 빌려줄 연결이 없습니다. 다음 요청은 연결을 얻으려고 대기합니다. 대기 시간이 길어지면 시간 초과 오류가 나고, 서버 전체가 응답하지 못하는 것처럼 보입니다. 이것을 커넥션 누수라고 부릅니다. 이 Chapter는 누수 탐지는 다루지 않았습니다.
반드시 try-with-resources
연결을 직접 다루는 코드에서는 항상 try-with-resources를 씁니다.
try (Connection connection = dataSource.getConnection()) {
// connection 사용
} // 예외가 나도 여기서 close()가 호출된다
예외가 발생해도 블록을 벗어나면 close()가 호출되어 반납이 보장됩니다. 다행히 JdbcClient나 MyBatis를 쓰면 연결을 빌리고 반납하는 일을 프레임워크가 대신 하므로 직접 다룰 일이 줄어듭니다. 하지만 원리를 알아야 풀 고갈 같은 문제가 났을 때 원인을 짚을 수 있습니다.
풀이 고갈되면 실제로 어떻게 되나
풀 크기가 5인 이 Chapter의 설정에서, 연결을 빌리기만 하고 닫지 않는 상황을 만들어 봤습니다. 아래는 이 절의 설명을 확인하려고 임시로 쓴 테스트이고 예제 저장소에는 없습니다. 기다리는 시간을 줄이려고 connection-timeout을 1초로 낮췄습니다.
@SpringBootTest(properties = "spring.datasource.hikari.connection-timeout=1000")
class PoolExhaustionTests {
@Autowired DataSource dataSource;
@Test
void exhaust() throws Exception {
List<Connection> held = new ArrayList<>();
try {
for (int i = 1; i <= 6; i++) {
try {
held.add(dataSource.getConnection());
System.out.println("BORROWED " + i);
} catch (SQLTransientConnectionException e) {
System.out.println("FAILED AT " + i + ": " + e.getMessage());
}
}
} finally {
for (Connection c : held) c.close();
}
}
}
실제 실행 결과입니다.
BORROWED 1
BORROWED 2
BORROWED 3
BORROWED 4
BORROWED 5
FAILED AT 6: curriculum-pool - Connection is not available, request timed out after 1000ms (total=5, active=5, idle=0, waiting=0)
읽는 법: 다섯 개까지는 빌려지고, 여섯 번째는 풀에 빌려줄 연결이 없어 기다리다가(active=5, idle=0) 시간이 지나 실패합니다. 기본 대기 시간은 더 길어서, 실제 서버에서는 요청들이 줄줄이 기다리다 한꺼번에 실패하는 모습이 됩니다. 이 문제는 “연결을 닫지 않은 코드 한 곳”에서 시작될 수 있고, 증상은 엉뚱한 요청의 지연으로 나타나 원인 찾기가 어렵습니다.
자주 하는 실수
| 실수 | 증상 | 해결 |
|---|---|---|
Connection을 close() 없이 사용 |
시간이 지나며 Connection is not available, request timed out |
try-with-resources |
예외 경로에서 close() 누락 |
오류가 나는 요청만 반복되면 풀 고갈 | try-with-resources 사용(또는 finally에서 close()) |
| 풀 크기를 무작정 키움 | DB가 감당하지 못하는 연결 수 | 닫는 코드를 먼저 점검, 크기는 부하에 맞춰 조정 |
| 반납한 연결을 다시 사용 | 이미 닫힌 연결이라 오류 | 반납 후에는 새로 getConnection() |
확인 문제
- 풀의
close()가 물리적 연결을 끊지 않는 이유는 무엇인가요? JdbcClient를 쓸 때close()를 직접 호출하지 않아도 되는 이유는 무엇인가요?
답: 1) 연결 생성 비용을 줄이려고 다음 요청에 재사용하기 위해서입니다. 2) 연결을 빌리고 반납하는 일을 프레임워크가 대신하기 때문입니다.
직접 해 보기
- 테스트에서
finally의second.close()를 지우고 이 테스트를 여러 번 반복 실행해도 문제가 없는지 관찰하세요. 풀 크기가 5라서 몇 번까지 버티는지 직접 세어 보는 실험이며, 확인 후 되돌립니다. maximum-pool-size를 1로 줄이고 연결을 빌려 닫지 않은 상태에서 다시 빌리면 어떻게 되는지 관찰하세요(대기 후 시간 초과). 이 Chapter에서는 실행해 보지 않은 동작이므로 직접 본 로그를 적어 보세요./db/info컨트롤러가try-with-resources를 쓰는 이유를 한 문장으로 설명해 보세요.
schema.sql과 data.sql로 초기화하기
데이터베이스를 붙였으니 테이블이 필요합니다. 임베디드 데이터베이스는 시작할 때 schema.sql과 data.sql을 자동으로 실행합니다. 이 절에서는 두 파일의 역할과 자동 실행 규칙, 그리고 외부 DB에서의 차이를 봅니다.
두 파일
src/main/resources에 둡니다.
-- schema.sql
CREATE TABLE users (
id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
name VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL UNIQUE,
age INT NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
);
-- data.sql
INSERT INTO users (name, email, age) VALUES ('kim', 'kim@example.com', 28);
INSERT INTO users (name, email, age) VALUES ('lee', 'lee@example.com', 35);
INSERT INTO users (name, email, age) VALUES ('park', 'park@example.com', 42);
주요 코드 설명
GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY: id를 DB가 자동 증가로 만들어 줍니다. Chapter 05에서AtomicLong이 하던 일을 DB가 맡습니다. INSERT에서 id를 쓰지 않은 이유입니다.NOT NULL,UNIQUE: 데이터베이스 수준의 제약입니다. Chapter 06에서 말한 입력 검증과 별개로, DB가 마지막 방어선이 됩니다. 이메일 중복은 DB도 거절합니다.created_at ... DEFAULT CURRENT_TIMESTAMP: 값을 안 넣으면 현재 시각이 들어갑니다. 조회 SQL에서는 이 컬럼을 가져오지 않았습니다.
자동 실행 규칙
| 파일 | 역할 | 실행 시점 |
|---|---|---|
schema.sql |
테이블 등 구조 생성 | 앱 시작 시 |
data.sql |
초기 데이터 입력 | schema.sql 다음 |
spring.sql.init.mode
spring:
sql:
init:
mode: always
| 값 | 의미 |
|---|---|
always |
항상 실행 |
embedded |
임베디드 DB(H2 등)일 때만 실행 (기본) |
never |
실행하지 않음 |
임베디드 데이터베이스는 기본값이 실행이지만 always를 명시해 의도를 드러냈습니다. 외부 데이터베이스에서는 기본값이 never라서 이 스크립트가 실행되지 않습니다. 외부 DB의 구조 관리는 마이그레이션 도구로 하는 것이 일반적이며, 이 과정에서 필요할 때 다룹니다.
이 방식의 쓰임과 한계
학습과 테스트에서 이 방식은 편리합니다. 앱을 켜면 항상 같은 테이블과 같은 초기 데이터가 준비되기 때문입니다. 하지만 운영 데이터베이스에는 맞지 않습니다. 재시작마다 INSERT가 반복되고, 구조 변경 이력이 남지 않습니다. 이 한계는 의식하되 이 Chapter에서는 해결하지 않습니다.
따라 하기
./gradlew :examples:ch08-datasource-h2:bootRun후curl http://localhost:8080/users로 초기 데이터 3건(kim,lee,park)을 확인합니다.data.sql에 한 줄을 추가(INSERT INTO users (name, email, age) VALUES ('choi', 'choi@example.com', 30);)하고 다시 실행해 4건이 나오는지 확인합니다.- 같은 이메일을 두 번 INSERT하도록
data.sql을 고쳐 보면UNIQUE제약 때문에 기동이 실패합니다. 어느 줄에서 실패하는지 메시지로 확인하고 되돌립니다.
자주 하는 실수
| 실수 | 증상 | 해결 |
|---|---|---|
schema.sql을 src/main/java에 둠 |
스크립트가 실행되지 않음 | src/main/resources에 둠 |
spring.sql.init.mode=never |
Table "USERS" not found (this database is empty) |
always 또는 임베디드 기본값 사용 |
| 외부 DB에서 스크립트가 실행되기를 기대 | 기본값이 never라 실행되지 않음 |
마이그레이션 도구 사용 또는 모드를 명시 |
컬럼 순서를 믿고 INSERT를 컬럼 이름 없이 작성 |
구조 변경 시 깨짐 | INSERT INTO users (name, email, age)처럼 컬럼 명시 |
확인 문제
data.sql이schema.sql보다 먼저 실행되면 어떻게 되나요?- 운영 DB에 이 방식을 쓰면 안 되는 이유는 무엇인가요?
답: 1) 테이블이 아직 없어 INSERT가 실패합니다. 그래서 실행 순서는 schema.sql 다음 data.sql입니다. 2) 재시작마다 INSERT가 반복되고 구조 변경 이력이 남지 않기 때문입니다.
직접 해 보기
data.sql에 사용자를 한 명 추가하고GET /users로 4명이 나오는지 확인하세요.schema.sql의emailUNIQUE 제약을 두고data.sql에 같은 이메일을 한 번 더 넣어 보세요. 서버가 어떻게 뜨는지(또는 못 뜨는지) 로그를 읽어 보고 되돌립니다.spring.sql.init.mode를never로 바꾸면 어떤 오류가 나는지 예측하세요. 실제 메시지는 아래 “자주 만나는 오류와 해결 방법” 절의 오류 1에 있습니다.
JdbcClient로 조회하기
테이블이 준비되었으니 SQL을 실행합니다. 순수 JDBC는 연결을 얻고, 문장을 만들고, 결과를 읽고, 자원을 닫는 코드가 깁니다. JdbcClient는 이를 간결하게 줄이면서 이름 있는 파라미터와 record 결과 매핑을 제공합니다. 파라미터 바인딩이 SQL 주입을 막는 원리도 실험으로 확인합니다.
저장소 코드
@Repository
public class UserRepository {
private final JdbcClient jdbc;
public UserRepository(JdbcClient jdbc) {
this.jdbc = jdbc;
}
public List<User> findAll() {
return jdbc.sql("SELECT id, name, email, age FROM users ORDER BY id")
.query(User.class)
.list();
}
public Optional<User> findById(long id) {
return jdbc.sql("SELECT id, name, email, age FROM users WHERE id = :id")
.param("id", id)
.query(User.class)
.optional();
}
public int count() {
return jdbc.sql("SELECT COUNT(*) FROM users")
.query(Integer.class)
.single();
}
}
컬럼 이름이 User record의 필드 이름으로 연결되는 지점이 JdbcClient가 해 주는 일입니다.
주요 코드 설명
JdbcClient: Spring Boot가DataSource위에 만들어 둔 Bean입니다. 생성자로 받습니다(생성자 주입).jdbc.sql("..."): 실행할 SQL을 지정합니다.:id와.param("id", id): 이름 있는 파라미터입니다. SQL의:이름에.param("이름", 값)을 연결합니다..query(User.class): 결과 컬럼을record User(long id, String name, String email, int age)의 생성자 인자에 이름으로 연결합니다. 따로RowMapper를 쓰지 않아도 됩니다..list(),.optional(),.single(): 결과를 목록, 0~1건, 정확히 1건으로 받습니다.optional()은 값이 없으면 빈 값을 돌려주고 예외를 던지지 않습니다. Chapter 04의Optional패턴이 그대로 이어집니다..query(Integer.class): 한 컬럼짜리 결과를 기본 타입으로 받습니다.
public record User(long id, String name, String email, int age) {
}
조회한 컬럼 이름(id, name, email, age)이 record의 필드 이름과 같아서 연결됩니다. 이름이 다르면 아래 “자주 만나는 오류와 해결 방법” 절의 오류 3, Column ... not found를 만납니다.
파라미터 바인딩과 SQL 주입
사용자가 입력한 값을 SQL 문자열에 +로 이어 붙이면 위험합니다. 입력이 SQL의 일부가 되어 조건을 바꿀 수 있기 때문입니다. 이를 SQL 주입이라고 합니다.
int matched = jdbc.sql("SELECT COUNT(*) FROM users WHERE name = :name")
.param("name", "x' OR '1'='1")
.query(Integer.class)
.single();
assertEquals(0, matched); // 모든 행이 걸리지 않는다
공격 문자열 x' OR '1'='1을 이름으로 넘겼습니다. 이어 붙이는 방식이라면 WHERE name = 'x' OR '1'='1'이 되어 모든 행이 걸립니다. 하지만 바인딩하면 값으로만 쓰여서 이름이 정확히 x' OR '1'='1인 사용자를 찾을 뿐이고, 결과는 0건입니다.
| 방식 | 입력이 | 결과 |
|---|---|---|
| 문자열 이어 붙이기 | SQL 문장의 일부 | 조건이 바뀔 수 있음(위험) |
| 파라미터 바인딩 | 값으로만 사용 | 안전 |
사용자 입력이 들어가는 SQL은 항상 바인딩을 씁니다. 이 원칙은 MyBatis의 #{}와 ${} 차이에서 다시 중요해집니다(Chapter 08).
컨트롤러
@GetMapping("/{id}")
public ResponseEntity<User> get(@PathVariable long id) {
return repository.findById(id)
.map(ResponseEntity::ok)
.orElseGet(() -> ResponseEntity.notFound().build());
}
Chapter 04의 컨트롤러와 거의 같습니다. 저장소가 메모리에서 DB로 바뀌었는데 컨트롤러는 그대로인 것이 계층을 나눈 이점입니다(Chapter 05).
따라 하기
curl http://localhost:8080/users # 3명
curl http://localhost:8080/users/2 # lee
curl -i http://localhost:8080/users/99 # 404
SQL 주입 시도는 이 Chapter의 저장소 테스트가 대신 확인합니다. ./gradlew :examples:ch08-datasource-h2:test --tests '*UserRepositoryTests*'를 실행해 4건이 통과하는지 보세요.
자주 하는 실수
| 실수 | 증상 | 해결 |
|---|---|---|
SQL의 :id와 .param("idx", ...)가 다름 |
No value supplied for the SQL parameter 'id' |
이름을 글자 그대로 맞춤 |
SELECT에서 record 필드에 해당하는 컬럼을 뺌 |
Column "age" not found |
컬럼 또는 별칭을 필드 이름과 맞춤 |
+로 SQL에 값을 이어 붙임 |
SQL 주입 위험 | 항상 파라미터 바인딩 |
.single()에 결과가 0건 |
예외 발생 | 없을 수 있으면 .optional() |
확인 문제
.optional()과.single()의 차이는 무엇인가요?- 파라미터 바인딩이 SQL 주입을 막는 원리를 한 문장으로 설명해 보세요.
답: 1) optional()은 0~1건을 Optional로 받고 없으면 빈 값, single()은 정확히 1건을 기대해 없으면 예외입니다. 2) 입력이 SQL 문장이 아니라 값으로만 전달되어 조건식의 일부가 될 수 없기 때문입니다.
직접 해 보기
findAll에WHERE age >= :minAge조건을 가진findByMinAge(int minAge)를 추가해 보세요..param("id", id)의 이름을"idx"로 틀리게 쓰면 어떤 오류가 나는지 확인하세요(메시지는 “자주 만나는 오류와 해결 방법” 절의 오류 2에 있습니다).- 바인딩 대신
"... WHERE name = '" + name + "'"로 이어 붙인 임시 메서드를 만들어 공격 문자열을 넣어 보고 모든 행이 걸리는지 비교해 보세요. 실험 후 반드시 삭제하세요.
DB 위의 API 실행과 테스트 11건
지금까지 설정, 초기화, 조회를 각각 봤습니다. 이 절에서는 실제로 서버를 켜서 응답을 확인하고, 이 Chapter의 테스트 11건이 무엇을 고정하는지 정리합니다.
실행
| OS | 실행 | 이 모듈만 빌드 |
|---|---|---|
| Linux / macOS | ./gradlew :examples:ch08-datasource-h2:bootRun |
./gradlew :examples:ch08-datasource-h2:build |
| Windows | gradlew.bat :examples:ch08-datasource-h2:bootRun |
gradlew.bat :examples:ch08-datasource-h2:build |
GET /users
-> 200 [{"id":1,"name":"kim","email":"kim@example.com","age":28},{"id":2,"name":"lee","email":"lee@example.com","age":35},{"id":3,"name":"park","email":"park@example.com","age":42}]
GET /users/2
-> 200 {"id":2,"name":"lee","email":"lee@example.com","age":35}
GET /users/999
-> 404
data.sql의 세 사용자가 DB에서 조회되어 나옵니다. 메모리 저장소 때와 응답 모양이 같지만, 이제 데이터가 H2에서 옵니다. 서버를 재시작하면 인메모리라 다시 초기 데이터 세 건으로 돌아갑니다.
테스트 11건
| 테스트 클래스 | 건수 | 고정하는 약속 |
|---|---|---|
Ch08ApplicationTests |
1 | 컨텍스트가 뜸 |
DataSourceTests |
3 | 설정이 풀에 반영됨, H2에 연결됨, close()는 반납 |
UserRepositoryTests |
4 | 초기 데이터 로딩, 이름 파라미터, 없는 id는 빈 값, 바인딩은 값으로만 |
UserApiTests |
3 | 목록이 DB 행을 돌려줌, 없는 id는 404, /db/info가 풀 설정을 보여 줌 |
표의 아래 행으로 갈수록 바깥(HTTP)에 가깝고, 위쪽 테스트가 실패하면 아래 테스트도 함께 실패하는 경우가 많습니다. 그래서 테스트가 실패하면 표의 위쪽부터 보세요.
@Test
void bootCreatesHikariPoolFromProperties() {
HikariDataSource hikari = assertInstanceOf(HikariDataSource.class, dataSource);
assertEquals("curriculum-pool", hikari.getPoolName());
assertEquals(5, hikari.getMaximumPoolSize());
assertEquals(2, hikari.getMinimumIdle());
}
assertInstanceOf는 타입을 확인하면서 그 타입으로 값을 돌려줍니다. 설정의 숫자가 객체에 반영되었는지를 테스트가 대신 확인해 줍니다. Chapter 03에서 쓴 방식입니다.
./gradlew :examples:ch08-datasource-h2:build
11건이 모두 통과했습니다.
따라 하기
./gradlew :examples:ch08-datasource-h2:build를 실행해 11건 통과를 확인합니다.data.sql의 한 줄을 지우고 다시 실행하면 어느 테스트가 실패하는지 확인합니다. 초기 데이터에 의존하는 테스트의 약속을 눈으로 보는 실험입니다.- 원래대로 되돌려 다시 통과시킵니다.
서버 재시작과 데이터
이 모듈(ch08-datasource-h2)의 API는 GET /users, GET /users/{id} 조회뿐이고 데이터를 만드는 POST는 없습니다. 그래서 재시작 효과는 H2 콘솔이나 SQL로 행을 추가한 뒤 bootRun을 종료하고 다시 실행해 보면 확인할 수 있습니다. 추가한 행은 사라지고 data.sql의 초기 3건으로 돌아갑니다. 인메모리 H2의 성질이며, 데이터를 추가하는 기능이 있는 앱이든 아니든 파일이나 서버형 DB를 쓰면 데이터가 남습니다. Chapter 11에서 Oracle로 바꾸는 이유 중 하나입니다.
자주 하는 실수
| 실수 | 증상 | 해결 |
|---|---|---|
| 포트 8080이 사용 중 | Port 8080 was already in use |
이전 서버 종료 |
| 서버 재시작 후 데이터가 사라졌다고 당황 | 인메모리 DB의 특성 | 초기 데이터 3건으로 돌아가는 것이 정상 |
| 테스트 순서에 의존하는 데이터 가정 | 순서에 따라 결과가 달라짐 | 테스트마다 필요한 데이터를 준비 |
확인 문제
- DB 위의 API는 메모리 저장소 때와 비교해 응답과 데이터 출처가 어떻게 달라졌나요?
- 이 Chapter의 테스트 11건은 무엇을 각각 고정하나요?
답: 1) 응답은 같고 데이터 출처가 DB로 달라졌습니다. 2) 설정 반영, 연결, 초기화, 바인딩을 각각 고정합니다.
직접 해 보기
UserRepositoryTests에count()가 3인지 확인하는 테스트를 추가해 보세요.- 서버를 켜고
/db/info와/users를 번갈아 호출하며url의 UUID가 요청마다 바뀌지 않는지 확인하세요(앱이 살아 있는 동안은 같은 DB입니다). - 서버를 재시작하고
/db/info의url이 달라지는지 확인하세요.
자주 만나는 오류와 해결 방법
DB 연결 쪽 오류는 메시지가 길지만 읽는 자리가 정해져 있습니다. 아래는 이 예제에서 같은 실수를 일부러 만들어 얻은 메시지입니다(긴 줄은 줄였습니다). H2와 Spring Boot 4.1.1 기준이고, 망가뜨린 코드는 되돌렸습니다.
오류 1: Table “USERS” not found (this database is empty)
spring.sql.init.mode를 never로 바꾸면 스키마 스크립트가 실행되지 않습니다. 테스트 11건 중 6건이 이 오류로 실패했습니다.
org.springframework.jdbc.BadSqlGrammarException: PreparedStatementCallback; bad SQL grammar [SELECT COUNT(*) FROM users]
Caused by: org.h2.jdbc.JdbcSQLSyntaxErrorException: Table "USERS" not found (this database is empty); SQL statement:
this database is empty가 단서입니다. SQL이 틀린 것이 아니라 테이블을 만드는 스크립트가 돌지 않았다는 뜻입니다. 쿼리를 고치기 전에 schema.sql 위치와 sql.init.mode를 확인합니다(“schema.sql과 data.sql로 초기화하기” 절).
오류 2: No value supplied for the SQL parameter ‘id’
SQL에는 :id인데 .param("idx", id)로 이름을 틀리게 넘긴 경우입니다.
InvalidDataAccessApiUsageException: No value supplied for the SQL parameter 'id': No value registered for key 'id'
SQL의 이름과 .param()의 이름이 글자 그대로 같아야 합니다. 메시지가 빠진 이름('id')을 알려 줍니다.
오류 3: Column “age” not found
SELECT에서 age를 빼면 User record의 생성자 인자가 모자랍니다.
BadSqlGrammarException: ... bad SQL grammar [SELECT id, name, email FROM users ORDER BY id]
Caused by: org.h2.jdbc.JdbcSQLSyntaxErrorException: Column "age" not found [42122-240]
JdbcClient가 record의 인자 이름으로 컬럼을 찾기 때문에, 조회 결과의 컬럼 이름이 record의 필드 이름을 모두 채워야 합니다. 컬럼 이름을 AS로 바꿔 조회했다면 별칭도 필드 이름과 같아야 합니다(“JdbcClient로 조회하기” 절).
오류 4: 서버가 아예 뜨지 않는다 — URL 오타
jdbc:h2:mem:을 jdbc:h3:mem:으로 잘못 적었습니다. 컨텍스트가 만들어지지 않아 테스트 11건이 모두 실패했습니다.
Driver org.h2.Driver claims to not accept jdbcUrl, jdbc:h3:mem:curriculum-6385ea89-...
실패가 userController, userRepository 같은 Bean 이름으로 길게 이어지지만, 원인은 맨 아래의 Driver ... claims to not accept jdbcUrl입니다. 위쪽 Unsatisfied dependency 줄은 결과일 뿐이므로 Caused by를 끝까지 내려가 읽습니다. Chapter 03에서 익힌 방법과 같습니다.
오류 5: Table “USERS” already exists — 고정된 DB 이름
처음에는 URL을 jdbc:h2:mem:curriculum;DB_CLOSE_DELAY=-1처럼 고정된 이름으로 적었습니다. DB_CLOSE_DELAY=-1은 연결이 모두 닫혀도 JVM이 살아 있는 동안 데이터를 유지하라는 옵션입니다. 그런데 테스트에서 @SpringBootTest와 @AutoConfigureMockMvc를 쓴 클래스가 서로 다른 컨텍스트를 만들자 두 번째 컨텍스트가 뜨지 못했습니다.
Failed to execute SQL script statement #1 of file [.../schema.sql]: CREATE TABLE users ( ...
Caused by: org.h2.jdbc.JdbcSQLSyntaxErrorException: Table "USERS" already exists
이름이 같으면 같은 인메모리 DB이고, 첫 컨텍스트가 이미 schema.sql을 실행했기 때문입니다. 테스트 11건 중 4건이 실패했고, 하나는 connectionPointsToInMemoryH2 단정까지 깨졌습니다. 컨텍스트마다 별도 DB를 쓰도록 이름 뒤에 ${random.uuid}를 붙여 해결했습니다. URL을 아예 적지 않으면 Boot가 고유한 이름을 자동으로 만들어 주지만, 이 예제는 설정을 보이게 하려고 직접 적었습니다. “혼자 돌리면 통과하는데 전체를 돌리면 실패한다”면 컨텍스트가 DB를 공유하는지 의심합니다.
DB 오류를 읽는 순서
먼저 서버가 기동되었는지 봅니다. 기동하지 못했다면 로그 맨 아래 Caused by에서 URL, 드라이버, 스크립트를 확인합니다. 기동은 되었는데 요청 처리 중에 실패했다면 BadSqlGrammarException의 Caused by에서 테이블과 컬럼 이름을 확인합니다. 둘 다 아니라면 DB 문제가 아닙니다.
정리하면 기동 단계의 실패는 설정(URL, 스크립트, 드라이버)을, 요청 단계의 실패는 SQL과 매핑을 의심합니다. 길게 이어지는 Bean 이름 줄은 건너뛰고 맨 아래 Caused by를 읽는 습관은 Chapter 01의 오류 절에서 익힌 방법 그대로입니다.
따라 하기: 가장 흔한 두 오류 재현
application.yml의spring.sql.init.mode를never로 바꿔./gradlew :examples:ch08-datasource-h2:test를 실행하고this database is empty가 나오는지 봅니다.- 되돌린 뒤
UserRepository의.param("id", id)를.param("idx", id)로 바꿔No value supplied for the SQL parameter 'id'가 나오는지 봅니다. 확인 후 반드시 되돌립니다.
증상별 점검표
| 증상 | 가장 먼저 볼 것 |
|---|---|
Table "..." not found (this database is empty) |
spring.sql.init.mode, 스크립트 위치 |
No value supplied for the SQL parameter |
SQL의 :이름과 .param("이름") |
Column "..." not found |
SELECT 컬럼과 record 필드 이름 |
claims to not accept jdbcUrl |
URL 형식, 드라이버 의존성 |
Table ... already exists |
DB 이름 고정 여부, 컨텍스트 공유 |
직접 해 보기
- 복사한 저장소에서 위 오류를 하나씩 재현해 메시지를 비교해 보세요. 확인 후 되돌립니다.
- 오류 4에서
Caused by만 골라 읽는 연습을 해 보세요. 가장 아래 줄이 원인입니다. - 오류 5에서 테스트 클래스를 하나씩만 실행하면 통과하는지 확인해 보세요.
용어와 참고 자료
이 Chapter에 나온 용어와 참고 사이트를 모았습니다. Chapter 02와 Chapter 05에서 설명한 용어는 다시 쓰지 않습니다.
참고한 자료
- Spring Boot Reference: Database Initialization: 임베디드 DB에서
schema.sql,data.sql이 자동 실행되는 규칙과spring.sql.init.mode기본값을 확인했습니다. - HikariCP README: 풀 설정 항목(
maximumPoolSize,minimumIdle)의 의미를 확인했습니다. - Spring Framework Reference: JdbcClient: 이름 있는 파라미터와 record 결과 매핑 방식을 확인했습니다.
- H2 Database 공식 사이트
- Oracle JDBC 튜토리얼
데이터베이스 접속
| 용어 | 설명 |
|---|---|
| JDBC | 자바에서 데이터베이스에 접속하고 SQL을 실행하는 표준 API입니다. |
| JDBC 드라이버 | 데이터베이스별 JDBC 구현체입니다. |
| JDBC URL | jdbc:h2:mem:이름처럼 DB 종류와 위치를 적은 접속 주소입니다. |
DataSource |
데이터베이스 연결을 빌려주는 표준 인터페이스입니다. |
| 커넥션 풀 | 연결을 미리 만들어 두고 빌려주고 돌려받아 재사용하는 방식입니다. |
| HikariCP | Spring Boot의 기본 커넥션 풀입니다. |
maximum-pool-size / minimum-idle |
풀의 최대 연결 수 / 놀고 있어도 유지할 최소 연결 수입니다. |
| 커넥션 누수 | 빌린 연결을 반납하지 않아 풀이 고갈되는 문제입니다. |
try-with-resources |
블록을 벗어날 때 자원의 close()를 자동 호출하는 Java 문법입니다. |
H2와 초기화
| 용어 | 설명 |
|---|---|
| H2 | JVM 안에서 동작하는 가벼운 데이터베이스입니다. jdbc:h2:mem:은 메모리에만 존재합니다. |
| 임베디드 데이터베이스 | 애플리케이션 안에 포함되어 실행되는 데이터베이스입니다. |
schema.sql / data.sql |
시작할 때 자동 실행되는 테이블 생성 / 초기 데이터 스크립트입니다. |
spring.sql.init.mode |
스크립트 실행 여부(always, embedded, never)를 정합니다. |
IDENTITY |
값을 DB가 자동 증가시켜 주는 컬럼 방식입니다. |
${random.uuid} |
설정 파일에서 무작위 UUID를 만드는 표현식입니다. |
조회
| 용어 | 설명 |
|---|---|
JdbcClient |
SQL을 직접 실행하고 결과를 객체로 받는 Spring의 간단한 API입니다. |
| 이름 있는 파라미터 | SQL의 :이름 자리에 .param("이름", 값)으로 값을 넣는 방식입니다. |
| 바인딩 | 값을 SQL 문장에 이어 붙이지 않고 파라미터 자리에 따로 넘기는 방식입니다. |
| SQL 주입 | 입력값이 SQL 문장의 일부가 되어 조건이 바뀌는 공격입니다. 바인딩으로 막습니다. |
BadSqlGrammarException |
SQL 문법·테이블·컬럼 문제로 Spring이 던지는 예외입니다. |
예제 코드 파일
본문에서 다룬 파일은 예제 저장소의 다음 위치에 있습니다.
| 대상 | 링크 |
|---|---|
| 설정 | application.yml |
| DataSource 정보 | DataSourceInfoController.java |
| 빌드 파일 | build.gradle |
| 풀 테스트 | DataSourceTests.java |
| 스키마 | schema.sql |
| 초기 데이터 | data.sql |
| JdbcClient 저장소 | UserRepository.java |
| 컨트롤러 | UserController.java |
| API 테스트 | UserApiTests.java |
| 저장소 테스트 | UserRepositoryTests.java |
직접 해보기
./gradlew :examples:ch08-datasource-h2:build로 테스트 11건이 통과하는지 확인한 뒤,bootRun으로 서버를 켜고/db/info와/users를 호출해 보세요.application.yml의maximum-pool-size를 바꾸고/db/info의 응답과DataSourceTests의 결과가 어떻게 달라지는지 비교하세요. 설정 값이 객체의 상태가 되는 과정을 테스트로도 확인하는 실험입니다.UserRepository에WHERE age >= :minAge조건을 가진 조회 메서드를 추가하고,UserRepositoryTests에 그 결과를 확인하는 테스트를 하나 써 보세요.- “자주 만나는 오류와 해결 방법” 절의 오류 다섯 가지 중 하나를 재현하고, “DB 오류를 읽는 순서”대로 기동 단계인지 요청 단계인지부터 구분한 뒤 원래 코드로 되돌리세요.
이번 장의 정리
- 메모리 저장소는 재시작하면 사라지고 서버가 여럿이면 어긋나므로 데이터베이스가 필요합니다. JDBC는 접속 표준,
DataSource는 연결을 얻는 창구, 커넥션 풀은 연결을 재사용하는 관리자입니다. spring-boot-starter-jdbc와 H2 드라이버, 몇 줄의spring.datasource.*설정이 자동 구성을 거쳐HikariDataSource와JdbcClient가 됩니다.- 풀에서 빌린 연결의
close()는 끊지 않고 반납합니다. 반납하지 않으면 풀이 고갈되므로 연결을 직접 다룰 때는 항상try-with-resources를 씁니다. - 임베디드 DB는 시작할 때
schema.sql,data.sql순서로 스크립트를 실행하고, 외부 DB에서는spring.sql.init.mode기본값이never입니다. JdbcClient는 이름 있는 파라미터와 record 매핑으로 조회를 간결하게 하고, 파라미터 바인딩은 입력을 값으로만 써서 SQL 주입을 막습니다.- DB 오류는 기동 단계면 설정을, 요청 단계면 SQL과 매핑을 의심하고, 맨 아래
Caused by부터 읽습니다.
다음 Chapter 08 MyBatis 기본과 CRUD에서는 SQL을 XML로 분리하고 결과 매핑을 MyBatis에 맡깁니다.