[LG CNS AM INSPIRE 6기] 24일차 TIL: DB 기초 마무리, JDBC·Spring Boot 시작

오늘의 한 줄 요약

쇼핑몰 ERD 기반 SQL 연습으로 DB 학습을 마무리하고 JDBC의 연결 구조와 Spring Boot 프로젝트 생성 과정을 학습하며 프론트엔드·백엔드·DB가 연결되는 전체 흐름을 이해했다.

---

배운 내용

• 쇼핑몰 ERD 기반 테이블 생성 및 데이터 처리
• MariaDB와 Oracle의 SQL 문법 차이
• DROP, DELETE, TRUNCATE의 차이
• UPDATE JOIN과 서브쿼리를 이용한 수정 방식 비교
• 프론트엔드·백엔드·DB의 전체 요청 처리 과정
• JDBC의 역할과 기본 처리 절차
• MariaDB JDBC Driver 등록 및 연결
• PreparedStatement와 ResultSet 사용
• 조회 결과를 DTO 목록으로 변환
• Request DTO와 Response DTO 구분
• JDBC를 이용한 UPDATE 처리
• JPA, Hibernate, MyBatis의 차이
• Spring Initializr를 이용한 Spring Boot 프로젝트 생성
• Spring Boot 의존성의 역할
• Spring과 Java, Gradle, 라이브러리 버전 호환성
• JSP와 React·Vue 기반 SPA의 차이

---

핵심 개념

1. 쇼핑몰 ERD 기반 데이터베이스 구조

오늘 연습문제에서는 다음 네 개의 테이블을 사용했다.

customers
    ↓ 1:N
orders
    ↓ 1:N
orderdetail
    ↑ N:1
products

각 테이블의 역할은 다음과 같다.

테이블	역할
customers	고객 정보 관리
orders	주문 기본 정보 관리
products	상품과 재고 관리
orderdetail	주문별 상품, 수량, 판매 단가 관리

orderdetail은 orders와 products를 연결하는 중간 테이블이며, orderno와 pno를 복합 기본키로 사용한다.

PRIMARY KEY (orderno, pno)

2. MariaDB와 Oracle의 문법 차이

문제지에는 VARCHAR2, NUMBER, SYSDATE 등 Oracle 형식이 제시되어 있었지만 실제 실습 환경은 MariaDB였다.

Oracle	MariaDB
VARCHAR2(20)	VARCHAR(20)
NUMBER(5)	INT 또는 DECIMAL(5,0)
SYSDATE - 3	DATE_SUB(SYSDATE(), INTERVAL 3 DAY)
TRUNC(date)	DATE(date)
INSERT ALL	다중 행 INSERT
FROM dual	사용하지 않음
문자열 연결 \|\|	CONCAT()
날짜 차이	DATEDIFF()

JDBC는 Java의 DB 접근 방식을 표준화하지만, DBMS별 SQL 문법과 함수의 차이까지 완전히 없애주지는 않는다.

3. DROP과 DELETE의 차이

DROP

테이블의 구조와 데이터 자체를 모두 삭제한다.

DROP TABLE customers;

삭제되는 대상:

• 테이블 구조
• 저장된 데이터
• 기본키와 외래키
• 인덱스와 제약조건

외래키 관계가 있다면 자식 테이블부터 삭제해야 한다.

DROP TABLE IF EXISTS orderdetail;
DROP TABLE IF EXISTS orders;
DROP TABLE IF EXISTS products;
DROP TABLE IF EXISTS customers;

DELETE

테이블 구조를 유지하면서 행 데이터만 삭제한다.

DELETE FROM customers
WHERE cno = 101;

전체 데이터를 삭제하더라도 테이블은 남는다.

DELETE FROM customers;

TRUNCATE

테이블 구조를 유지하면서 전체 데이터를 빠르게 초기화한다.

TRUNCATE TABLE customers;

명령어	데이터	테이블 구조	WHERE
DROP	삭제	삭제	불가능
DELETE	일부 또는 전체 삭제	유지	가능
TRUNCATE	전체 삭제	유지	불가능

4. UPDATE JOIN과 서브쿼리

특정 학생의 학점을 수정하는 방법으로 UPDATE JOIN과 서브쿼리를 비교했다.

UPDATE JOIN

UPDATE tb_grade G
JOIN tb_student S
  ON G.STUDENT_NO = S.STUDENT_NO
JOIN tb_class C
  ON G.CLASS_NO = C.CLASS_NO
JOIN tb_department D
  ON S.DEPARTMENT_NO = D.DEPARTMENT_NO
SET G.POINT = 3.5
WHERE S.STUDENT_NAME = '김명훈'
  AND D.DEPARTMENT_NAME = '의학과'
  AND C.CLASS_NAME = '피부생리학'
  AND G.TERM_NO = '200501';

서브쿼리

UPDATE tb_grade
SET POINT = 3.5
WHERE STUDENT_NO IN (
    SELECT S.STUDENT_NO
    FROM tb_student S
    JOIN tb_department D
      ON S.DEPARTMENT_NO = D.DEPARTMENT_NO
    WHERE S.STUDENT_NAME = '김명훈'
      AND D.DEPARTMENT_NAME = '의학과'
)
AND CLASS_NO IN (
    SELECT CLASS_NO
    FROM tb_class
    WHERE CLASS_NAME = '피부생리학'
)
AND TERM_NO = '200501';

이 문제에서는 테이블의 관계와 학과 조건이 명확하게 표현되는 UPDATE JOIN 방식이 적절했다.

다만 실제 성능은 다음 요소에 따라 달라질 수 있다.

• 데이터의 양
• 인덱스 여부
• MariaDB 옵티마이저
• 조건에 해당하는 행의 수
• 실행계획

5. 프론트엔드·백엔드·DB의 전체 흐름

지금까지 학습한 전체 서비스 구조는 다음과 같다.

사용자
  ↓
React 프론트엔드
  ↓ HTTP 요청
Spring Boot 백엔드
  ↓
Controller
  ↓
Service
  ↓
Repository 또는 DAO
  ↓
JPA·MyBatis·JDBC
  ↓
MariaDB
  ↓
조회 및 처리 결과
  ↓ JSON 응답
React 화면 갱신

각 계층의 책임은 다음과 같다.

계층	역할
React	사용자 화면, 상태, 이벤트, HTTP 요청
Controller	요청과 응답 처리
Service	비즈니스 로직 처리
Repository·DAO	데이터 접근
JDBC·JPA·MyBatis	Java와 DB 연결
MariaDB	데이터 저장과 SQL 실행

좋은 프로그램 구조는 다음을 지향한다.

높은 응집도 + 낮은 결합도

• 높은 응집도: 하나의 계층이 하나의 책임에 집중
• 낮은 결합도: 구체적인 구현에 지나치게 의존하지 않음

6. Spring Boot 내부 요청 처리

Spring Boot의 웹 요청은 내장 Tomcat과 DispatcherServlet을 중심으로 처리된다.

HTTP 요청
  ↓
Tomcat
  ↓
DispatcherServlet
  ↓
Controller
  ↓
Service
  ↓
Repository·DAO

Tomcat의 주요 구성 요소:

구성 요소	역할
Coyote	HTTP 요청과 응답 처리
Catalina	Servlet 실행과 관리
Jasper	JSP를 Servlet 코드로 변환

DispatcherServlet은 모든 요청을 먼저 받아 적절한 Controller로 전달하는 Front Controller다.

7. JDBC의 역할

JDBC(Java Database Connectivity)는 Java에서 DB에 접근하기 위한 표준 API다.

Java 애플리케이션
       ↓
JDBC 표준 인터페이스
       ↓
벤더별 JDBC Driver
       ↓
MariaDB·Oracle·Db2

대표적인 JDBC 인터페이스와 클래스는 java.sql 패키지에 포함되어 있다.

import java.sql.*;

구성 요소	역할
DriverManager	JDBC Driver 관리 및 DB 연결
Connection	Java와 DB의 연결
PreparedStatement	SQL 준비, 파라미터 전달 및 실행
ResultSet	SELECT 결과 처리
SQLException	JDBC 관련 예외 처리

각 DBMS 벤더는 JDBC 표준 인터페이스를 자신의 제품에 맞게 구현한 Driver를 제공한다.

JDBC 인터페이스
    ↑ implements
MariaDB JDBC Driver
Oracle JDBC Driver
Db2 JDBC Driver

8. JDBC 기본 처리 절차

1. Driver 로딩
2. Connection 생성
3. SQL 및 PreparedStatement 준비
4. SQL 실행
5. ResultSet 처리
6. JDBC 자원 종료

드라이버 로딩

Class.forName("org.mariadb.jdbc.Driver");

DB 연결

Connection conn =
        DriverManager.getConnection(
                URL,
                USER,
                PASSWORD
        );

SQL 준비

PreparedStatement pstmt =
        conn.prepareStatement(sql);

SELECT 실행

ResultSet rset =
        pstmt.executeQuery();

INSERT, UPDATE, DELETE 실행

int result =
        pstmt.executeUpdate();

자원 종료

JDBC 자원은 생성한 순서의 역순으로 닫는다.

생성: Connection → PreparedStatement → ResultSet
종료: ResultSet → PreparedStatement → Connection

if (rset != null) {
    rset.close();
}

if (pstmt != null) {
    pstmt.close();
}

if (conn != null) {
    conn.close();
}

9. MariaDB JDBC Driver 등록

MVN Repository에서 다음 Driver를 내려받았다.

mariadb-java-client-3.5.10.jar

저장 위치:

inspire_java_grammar_6th/
└─ lib/
   └─ mariadb-java-client-3.5.10.jar

VS Code Java 프로젝트에서 lib 폴더의 JAR 파일을 클래스패스에 등록해야 한다.

{
    "java.project.referencedLibraries": [
        "lib/**/*.jar"
    ]
}

java.sql.*는 표준 API이며 실제 MariaDB 통신은 MariaDB JDBC Driver가 담당한다.

10. JDBC 접속 정보

JDBC 연결에서 가장 먼저 정확하게 확인해야 하는 정보는 다음 네 가지다.

private static final String DRIVER =
        "org.mariadb.jdbc.Driver";

private static final String USER =
        "root";

private static final String PASSWORD =
        "본인의 MariaDB 비밀번호";

private static final String URL =
        "jdbc:mariadb://localhost:3306/lgcns";

설정	의미
DRIVER	사용할 JDBC Driver 클래스
USER	MariaDB 접속 계정
PASSWORD	MariaDB 계정 비밀번호
URL	접속할 서버, 포트, 데이터베이스

URL의 구조:

jdbc:mariadb://localhost:3306/lgcns
└──┬───────┘  └───┬───┘ └─┬─┘ └─┬─┘
 접속 방식       서버 주소    포트   DB명

특히 localhost의 철자와 DriverManager.getConnection()의 대소문자에 주의해야 한다.

11. final과 static final

private final String url;

private final은 객체마다 별도의 값을 가질 수 있지만, 한 번 초기화한 후 다시 대입할 수 없는 인스턴스 변수다.

private static final String URL = "...";

private static final은 클래스에 하나만 존재하며 모든 객체가 공유하는 상수다.

구분	private final	private static final
소속	객체	클래스
생성 개수	객체마다 생성	클래스당 하나
값 공유	객체별 보유	모든 객체가 공유
대표 용도	객체별 고정값	공통 상수

모든 DAO가 같은 DB 접속 설정을 사용할 경우 static final이 적절하다.

12. ResultSet을 DTO 목록으로 변환

학과 목록을 조회한 뒤 각 행을 DepartmentResponseDTO로 변환했다.

pstmt = conn.prepareStatement(sql);
rset = pstmt.executeQuery();

while (rset.next()) {
    list.add(
        DepartmentResponseDTO.builder()
            .DEPT_ID(rset.getString(1))
            .DEPT_NAME(rset.getString(2))
            .LOC_ID(rset.getString(3))
            .build()
    );
}

SQL의 조회 컬럼 순서와 getString()의 번호가 일치해야 한다.

SELECT DEPT_ID,       -- getString(1)
       DEPT_NAME,     -- getString(2)
       LOC_ID         -- getString(3)
FROM department;

rset.next()는 다음 행으로 이동하며 읽을 데이터가 있으면 true, 더 이상 데이터가 없으면 false를 반환한다.

이처럼 ResultSet의 한 행을 Java DTO로 변환하는 과정을 ResultSet Mapping으로 이해할 수 있다.

13. Request DTO와 Response DTO

SQL의 INSERT와 UPDATE에 필요한 데이터를 전달하기 위해 DepartmentRequestDTO를 새로 만들었다.

DepartmentRequestDTO
→ INSERT·UPDATE에 필요한 요청값 전달

DepartmentResponseDTO
→ SELECT 결과 반환

DTO	데이터 이동 방향	역할
Request DTO	App·Controller → DAO	등록 및 수정 데이터 전달
Response DTO	DAO → App·Controller	조회 결과 전달

@Builder
@Getter
@ToString
public class DepartmentRequestDTO {

    private String dept_id;
    private String dept_name;
}

14. PreparedStatement를 이용한 UPDATE

public int update(DepartmentRequestDTO request) {

    Connection conn = null;
    PreparedStatement pstmt = null;

    String sql = """
            UPDATE department
            SET    dept_name = ?
            WHERE  dept_id   = ?
            """;

    try {
        conn = DriverManager.getConnection(
                URL,
                USER,
                PASSWORD
        );

        pstmt = conn.prepareStatement(sql);

        pstmt.setString(
                1,
                request.getDept_name()
        );

        pstmt.setString(
                2,
                request.getDept_id()
        );

        return pstmt.executeUpdate();

    } catch (Exception e) {
        e.printStackTrace();

    } finally {
        try {
            if (pstmt != null) {
                pstmt.close();
            }

            if (conn != null) {
                conn.close();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    return 0;
}

SQL의 물음표 번호는 등장 순서에 따라 결정된다.

UPDATE department
SET    dept_name = ?  -- 1번
WHERE  dept_id   = ?  -- 2번

pstmt.setString(1, request.getDept_name());
pstmt.setString(2, request.getDept_id());

executeUpdate()는 영향을 받은 행의 수를 반환한다.

반환값	의미
1	한 행 처리 성공
2 이상	여러 행 처리
0	조건에 맞는 행이 없거나 처리 실패

15. 테이블명 대소문자

MariaDB의 테이블명 대소문자 구분은 운영체제와 설정에 따라 달라질 수 있다.

현재 실제 테이블명이 department이므로 SQL에서도 같은 형태로 작성했다.

FROM department

설정은 다음 명령으로 확인할 수 있다.

SHOW VARIABLES LIKE 'lower_case_table_names';

값	의미
0	대소문자 구분
1	소문자로 저장하고 구분 없이 비교
2	입력 형태를 보존하지만 소문자로 비교

환경이 바뀌어도 문제가 발생하지 않도록 실제 테이블명과 동일하게 작성하는 것이 안전하다.

16. JPA, Hibernate, MyBatis

JPA

JPA는 Java 객체와 DB 테이블을 연결하기 위한 ORM 표준이다.

Java 객체 ↔ DB 테이블

JPA는 기본적인 CRUD SQL을 자동으로 생성해 SQL 작성량을 줄여준다.

그러나 다음 내용은 반드시 이해해야 한다.

• 테이블과 컬럼
• 기본키와 외래키
• ERD의 개체 관계
• 일대일, 일대다, 다대일 관계
• JOIN과 트랜잭션
• 자동 생성 SQL과 성능

Hibernate

Hibernate는 JPA 표준을 실제로 구현한 ORM 프레임워크다.

Spring Data JPA
       ↓
JPA 표준
       ↓
Hibernate 구현체
       ↓
JDBC
       ↓
DBMS

MyBatis Framework

MyBatis는 SQL을 개발자가 직접 작성하고 Java 객체와 결과를 연결하는 SQL Mapper다.

<select id="findAll"
        resultType="DepartmentResponseDTO">
    SELECT dept_id,
           dept_name,
           loc_id
    FROM department
</select>

구분	MyBatis	Hibernate/JPA
접근 방식	SQL Mapper	ORM
SQL 작성	직접 작성	기본 SQL 자동 생성
중심	SQL	Java 객체와 관계
복잡한 조회	SQL로 세밀하게 제어	JPQL·QueryDSL·Native SQL 활용
CRUD	SQL 각각 작성	Repository로 간결하게 처리
중요 역량	SQL 작성과 튜닝	객체 관계와 생성 SQL 분석

현장에서는 프로젝트에 따라 두 기술을 모두 사용할 수 있으므로 MyBatis와 Hibernate/JPA를 모두 이해할 필요가 있다.

단순 CRUD
→ JPA/Hibernate 활용 가능

복잡한 통계·리포트·다중 JOIN
→ MyBatis 활용 가능

대규모 프로젝트에서는 DB팀이나 DBA가 별도로 존재할 수 있지만, 백엔드 개발자도 SQL의 의미와 성능을 이해해야 한다. 소규모 프로젝트에서는 백엔드 개발자가 ERD 설계와 SQL 작성까지 직접 담당할 가능성이 높다.

17. Spring Initializr

Spring Initializr는 Spring Boot 프로젝트의 기본 구조와 설정 파일을 자동 생성해 주는 공식 도구다.

설정 가능한 주요 항목:

• Gradle 또는 Maven
• Java, Kotlin, Groovy
• Spring Boot 버전
• Group과 Artifact
• Package name
• Jar 또는 War
• Java 버전
• Dependencies

VS Code에서는 다음 과정으로 프로젝트를 생성했다.

Ctrl + Shift + P
→ Spring Initializr: Create a Gradle Project

프로젝트 설정:

Build Tool   : Gradle
Language     : Java
Spring Boot  : 4.0.8
저장 위치     : C:\inpire_6th\BE

18. Spring Boot 의존성

선택한 의존성은 총 7개다.

의존성	역할
Spring Boot DevTools	코드 변경 감지와 자동 재시작
Spring Configuration Processor	설정 파일 자동완성 및 메타데이터 지원
Spring Web	Spring MVC 및 REST API 개발
Spring Data JPA	JPA Repository 기반 데이터 접근
MyBatis Framework	SQL 직접 작성 및 객체 매핑
MariaDB Driver	Spring Boot와 MariaDB 연결
Lombok	Getter, Builder, 생성자 등 반복 코드 감소

Gradle을 사용하면 JDBC 실습처럼 JAR 파일을 직접 lib 폴더에 넣지 않아도 된다.

build.gradle
    ↓
Gradle
    ↓
필요한 라이브러리 자동 다운로드 및 관리

19. Spring의 버전 호환성

Spring에서는 최신 버전을 무조건 사용하는 것보다 다음 버전의 호환성을 맞추는 것이 중요하다.

Spring Boot
   ├─ Spring Framework
   ├─ Java
   ├─ Gradle
   ├─ Tomcat
   └─ JPA·Hibernate 등의 라이브러리

버전 선택 시 주의점:

• 특별한 이유가 없다면 정식 버전 사용
• SNAPSHOT은 개발 중인 버전
• M1은 정식 출시 전 마일스톤 버전
• 수업에서 지정한 Spring Boot와 Java 버전 유지
• Starter 라이브러리 버전을 임의로 지정하지 않기
• 프로젝트에 포함된 Gradle Wrapper 사용

4.0.8           → 정식 버전
4.0.9-SNAPSHOT  → 개발 중인 버전
4.2.0-M1        → 정식 출시 전 시험 버전

Windows에서 Gradle Wrapper를 통해 실행할 수 있다.

.\gradlew.bat bootRun

20. JSP와 React·Vue의 차이

JSP

JSP(JavaServer Pages)는 서버에서 데이터와 HTML을 결합하여 완성된 페이지를 브라우저에 전달하는 기술이다.

브라우저 요청
    ↓
Spring Controller
    ↓
Model에 데이터 저장
    ↓
JSP가 HTML과 데이터 결합
    ↓
완성된 HTML 응답

JSP는 Tomcat의 Jasper에 의해 Servlet 코드로 변환되어 실행된다.

JSP
 ↓ Jasper
Servlet Java 코드
 ↓ 컴파일
Servlet 클래스
 ↓ 실행
HTML 응답

React·Vue 기반 SPA

React나 Vue는 Spring Boot에서 완성된 HTML이 아니라 주로 JSON 데이터를 전달받는다.

React
  ↓ 비동기 API 요청
Spring Boot
  ↓
JSON 데이터
  ↓
React가 브라우저에서 화면 생성

구분	JSP	React·Vue
화면 생성 위치	서버	브라우저
백엔드 응답	HTML Page	JSON Data
렌더링	서버 사이드	클라이언트 사이드
Controller	@Controller 중심	@RestController 중심
화면 전환	새 페이지 요청	SPA 내부 화면 변경

JSP에서도 JavaScript와 AJAX를 사용할 수 있으므로 비동기 통신이 불가능한 것은 아니다. 핵심 차이는 화면을 최종적으로 어디에서 생성하는가에 있다.

@Controller
// JSP 같은 View 이름 반환

@RestController
// Java 객체를 JSON으로 반환

현재 React와 Spring Boot를 연결하는 프로젝트에서는 다음 구조를 중심으로 학습하게 된다.

React
  ↓ axios 또는 fetch
@RestController
  ↓
Service
  ↓
JPA 또는 MyBatis
  ↓
MariaDB
  ↓
DTO
  ↓ JSON
React 화면 갱신

---

새롭게 알게 된 점

• JDBC는 Java와 DB를 연결하는 표준 API이고 실제 통신은 벤더별 JDBC Driver가 담당한다.
• java.sql.*에는 Connection, PreparedStatement, ResultSet 등의 JDBC 표준 타입이 포함되어 있다.
• MariaDB JDBC Driver는 JDBC 인터페이스의 MariaDB용 구현체다.
• JDBC 연결에서는 Driver, URL, User, Password 설정을 정확하게 확인하는 것이 가장 중요하다.
• PreparedStatement의 물음표 번호는 SQL에 등장한 순서와 일치해야 한다.
• executeQuery()는 ResultSet을, executeUpdate()는 영향을 받은 행의 수를 반환한다.
• Request DTO는 등록과 수정 데이터를 전달하고, Response DTO는 조회 결과를 반환한다.
• JPA는 SQL 작성을 줄여주지만 ERD와 SQL에 대한 이해까지 없애주지는 않는다.
• Hibernate는 JPA의 대표적인 구현체이고 MyBatis는 SQL Mapper다.
• Spring Initializr를 이용하면 프로젝트 구조와 의존성 설정을 자동으로 생성할 수 있다.
• Spring Boot Starter를 사용하면 호환되는 라이브러리 버전을 Spring Boot가 관리한다.
• JSP는 서버에서 HTML을 만들고, React는 JSON 데이터를 받아 브라우저에서 화면을 만든다.

---

헷갈렸던 점

DROP을 실행해도 테이블이 남는가?

DROP TABLE은 데이터뿐만 아니라 테이블 구조까지 삭제한다.

테이블 구조를 유지하려면 DELETE 또는 TRUNCATE를 사용해야 한다.

UPDATE JOIN과 서브쿼리 중 무엇이 더 효율적인가?

이번 문제에서는 관계를 명확하게 표현하고 동명이인과 학과 조건을 함께 적용할 수 있는 UPDATE JOIN 방식이 적절했다. 그러나 실제 성능은 실행계획과 인덱스를 확인해야 정확하게 판단할 수 있다.

JPA를 사용하면 SQL을 몰라도 되는가?

JPA가 기본 SQL을 자동으로 생성하기 때문에 직접 작성하는 양은 줄어든다. 하지만 ERD, JOIN, 트랜잭션, 인덱스와 생성된 SQL의 성능을 이해해야 제대로 사용할 수 있다.

JSP에서는 비동기 통신을 할 수 없는가?

JSP에서도 JavaScript와 AJAX를 사용할 수 있다. JSP와 React의 핵심적인 차이는 비동기 가능 여부가 아니라 최종 화면을 서버와 브라우저 중 어디에서 만드는가에 있다.

---

실습 및 적용

직접 해본 것

• 쇼핑몰 ERD를 보고 네 개의 테이블 관계 분석
• MariaDB 기준 테이블 생성문 작성
• 고객과 상품 데이터 입력
• 주문 및 주문 상세 데이터 입력
• 주문 수량에 따른 상품 재고 차감
• 전체 주문 내역 JOIN 조회
• 일별 매출 합계 조회
• DROP, DELETE, TRUNCATE 비교
• JDBC Driver JAR 파일 다운로드 및 클래스패스 등록
• MariadbDao 생성
• DepartmentResponseDTO 생성
• JdbcApp에서 DAO 객체 생성
• DriverManager.getConnection()을 통한 MariaDB 연결
• PreparedStatement로 SQL 실행
• ResultSet을 DTO 목록으로 변환
• DepartmentRequestDTO 생성
• UPDATE 메서드 작성
• Spring Boot 관련 VS Code 확장 프로그램 설치
• Spring Initializr로 Gradle 기반 Spring Boot 프로젝트 생성
• Spring Web, JPA, MyBatis Framework, MariaDB Driver 등의 의존성 추가

결과

• 프론트엔드부터 DB까지 이어지는 전체 요청 및 응답 흐름을 연결해서 이해했다.
• JDBC가 표준 인터페이스와 벤더별 Driver를 통해 DBMS에 접근하는 원리를 확인했다.
• Java 코드에서 MariaDB 연결과 SQL 실행을 위한 기본 구조를 작성했다.
• 조회 결과를 DTO에 담아 리스트로 반환하는 과정을 이해했다.
• UPDATE 실행 결과가 영향받은 행의 수로 반환된다는 점을 확인했다.
• Spring Boot 프로젝트 생성과 의존성 관리의 기본 구조를 확인했다.
• 내일부터 본격적인 Spring Boot 학습을 시작할 준비를 마쳤다.

---

문제와 해결

막힌 부분

• 문제지가 Oracle 자료형과 함수를 사용하고 있었지만 실습 DBMS는 MariaDB였다.
• DROP과 DELETE가 테이블에 미치는 차이가 혼동됐다.
• UPDATE JOIN과 서브쿼리 중 어떤 방식이 적절한지 판단이 필요했다.
• JDBC Driver JAR 파일을 어디에 두고 어떻게 연결하는지 확인이 필요했다.
• MariadbDao에서 DTO import와 반환값이 누락될 수 있었다.
• localhoast와 getconnection()처럼 연결 주소와 메서드명에 오타가 있었다.
• Response DTO와 Request DTO의 역할이 구분되지 않았다.
• JPA, Hibernate, MyBatis의 관계가 혼동될 수 있었다.
• JSP와 React가 데이터를 화면에 표시하는 방식의 차이를 정리할 필요가 있었다.

해결 방법

• Oracle 문법을 MariaDB 문법으로 변경했다.
• 테이블 자체 삭제는 DROP, 행 데이터 삭제는 DELETE로 구분했다.
• 이번 수정 문제에서는 학과 조건까지 포함한 UPDATE JOIN을 사용했다.
• MariaDB Driver JAR을 lib 폴더에 추가하고 Referenced Libraries에 등록했다.
• DepartmentResponseDTO를 import하고 빈 리스트를 생성한 뒤 반환하도록 수정했다.
• URL을 localhost로, 메서드를 DriverManager.getConnection()으로 바로잡았다.
• 등록과 수정에는 Request DTO, 조회 결과에는 Response DTO를 사용했다.
• JPA는 표준, Hibernate는 JPA 구현체, MyBatis는 SQL Mapper로 구분했다.
• JSP는 서버에서 HTML을 만들고 React는 JSON을 받아 브라우저에서 화면을 만드는 방식으로 구분했다.

---

다음에 할 일

• Spring Boot 프로젝트 구조와 실행 흐름 확인
• application.properties 또는 application.yml 설정 학습
• Spring Boot와 MariaDB 연결
• Controller, Service, Repository 계층 구성
• Spring Data JPA 기본 CRUD 실습
• MyBatis Mapper와 SQL 작성 실습
• React와 Spring Boot REST API 연동
• Spring에서 의존성 주입과 IoC Container 학습

---

24일차를 마치며

오늘은 DB 학습을 마무리하면서 쇼핑몰 ERD를 기반으로 테이블 생성, 데이터 입력, 주문 처리, 재고 수정, JOIN과 집계까지 종합적으로 복습했다.

DB 학습 이후에는 JDBC를 통해 Java가 MariaDB와 실제로 연결되는 과정을 살펴봤다. DriverManager, Connection, PreparedStatement, ResultSet이 각각 어떤 역할을 담당하는지 확인했고, SQL 조회 결과를 DTO로 변환하거나 Request DTO를 이용해 데이터를 수정하는 과정도 실습했다.

또한 지금까지 학습한 React, Java, DB를 하나의 서비스 흐름으로 연결했다. React가 HTTP 요청을 보내면 Spring Boot가 Controller, Service, Repository 또는 DAO를 거쳐 데이터를 처리하고, JPA·MyBatis·JDBC를 통해 MariaDB에 접근한 후 JSON으로 응답한다는 전체 구조를 이해할 수 있었다.

마지막으로 Spring Initializr를 이용해 Gradle 기반 Spring Boot 프로젝트를 생성하고, Spring Web, JPA, MyBatis Framework, MariaDB Driver, Lombok 등의 의존성을 추가했다. 오늘은 Spring의 본격적인 구현보다 전체 구조와 준비 과정을 확인했으며, 다음 학습일부터 Spring Boot의 핵심 구조와 기능을 본격적으로 학습할 예정이다.