# 관련링크 - [몰입코딩 - MySQL 개발환경 세팅 - slog.gg/p/13867 - 4강 ~ 5강](https://slog.gg/p/13867#f) # 요구사항 ## build.gradle.kts(자바 23) ```kotlin plugins { id("java") } group = "com.ll" version = "1.0-SNAPSHOT" repositories { mavenCentral() } dependencies { compileOnly("org.projectlombok:lombok:1.18.36") annotationProcessor("org.projectlombok:lombok:1.18.36") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") runtimeOnly("com.mysql:mysql-connector-j:9.1.0") testImplementation("org.assertj:assertj-core:3.26.3") implementation("com.fasterxml.jackson.core:jackson-databind:2.18.2") implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.2") } tasks.test { useJUnitPlatform() } ``` ## com.ll.simpleDb.simpleDbTest.java ```java package com.ll.simpleDb; import com.ll.Article; import org.junit.jupiter.api.*; import java.time.LocalDateTime; import java.time.temporal.ChronoUnit; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.IntStream; import static org.assertj.core.api.Assertions.assertThat; @TestMethodOrder(MethodOrderer.MethodName.class) public class SimpleDbTest { private static SimpleDb simpleDb; @BeforeAll public static void beforeAll() { simpleDb = new SimpleDb("localhost", "root", "lldj123414", "simpleDb__test"); simpleDb.setDevMode(true); createArticleTable(); } @BeforeEach public void beforeEach() { truncateArticleTable(); makeArticleTestData(); } private static void createArticleTable() { simpleDb.run("DROP TABLE IF EXISTS article"); simpleDb.run(""" CREATE TABLE article ( id INT UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), createdDate DATETIME NOT NULL, modifiedDate DATETIME NOT NULL, title VARCHAR(100) NOT NULL, `body` TEXT NOT NULL, isBlind BIT(1) NOT NULL DEFAULT 0 ) """); } private void makeArticleTestData() { IntStream.rangeClosed(1, 6).forEach(no -> { boolean isBlind = no > 3; String title = "제목%d".formatted(no); String body = "내용%d".formatted(no); simpleDb.run(""" INSERT INTO article SET createdDate = NOW(), modifiedDate = NOW(), title = ?, `body` = ?, isBlind = ? """, title, body, isBlind); }); } private void truncateArticleTable() { simpleDb.run("TRUNCATE article"); } @Test @DisplayName("insert") public void t001() { Sql sql = simpleDb.genSql(); /* == rawSql == INSERT INTO article SET createdDate = NOW() , modifiedDate = NOW() , title = '제목 new' , body = '내용 new' */ sql.append("INSERT INTO article") .append("SET createdDate = NOW()") .append(", modifiedDate = NOW()") .append(", title = ?", "제목 new") .append(", body = ?", "내용 new"); long newId = sql.insert(); // AUTO_INCREMENT 에 의해서 생성된 주키 리턴 assertThat(newId).isGreaterThan(0); } @Test @DisplayName("update") public void t002() { Sql sql = simpleDb.genSql(); // id가 0, 1, 2, 3인 글 수정 // id가 0인 글은 없으니, 실제로는 3개의 글이 삭제됨 /* == rawSql == UPDATE article SET title = '제목 new' WHERE id IN ('0', '1', '2', '3') */ sql.append("UPDATE article") .append("SET title = ?", "제목 new") .append("WHERE id IN (?, ?, ?, ?)", 0, 1, 2, 3); // 수정된 row 개수 int affectedRowsCount = sql.update(); assertThat(affectedRowsCount).isEqualTo(3); } @Test @DisplayName("delete") public void t003() { Sql sql = simpleDb.genSql(); // id가 0, 1, 3인 글 삭제 // id가 0인 글은 없으니, 실제로는 2개의 글이 삭제됨 /* == rawSql == DELETE FROM article WHERE id IN ('0', '1', '3') */ sql.append("DELETE") .append("FROM article") .append("WHERE id IN (?, ?, ?)", 0, 1, 3); // 삭제된 row 개수 int affectedRowsCount = sql.delete(); assertThat(affectedRowsCount).isEqualTo(2); } @Test @DisplayName("selectRows") public void t004() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT * FROM article ORDER BY id ASC LIMIT 3 */ sql.append("SELECT * FROM article ORDER BY id ASC LIMIT 3"); List> articleRows = sql.selectRows(); IntStream.range(0, articleRows.size()).forEach(i -> { long id = i + 1; Map articleRow = articleRows.get(i); assertThat(articleRow.get("id")).isEqualTo(id); assertThat(articleRow.get("title")).isEqualTo("제목%d".formatted(id)); assertThat(articleRow.get("body")).isEqualTo("내용%d".formatted(id)); assertThat(articleRow.get("createdDate")).isInstanceOf(LocalDateTime.class); assertThat(articleRow.get("createdDate")).isNotNull(); assertThat(articleRow.get("modifiedDate")).isInstanceOf(LocalDateTime.class); assertThat(articleRow.get("modifiedDate")).isNotNull(); assertThat(articleRow.get("isBlind")).isEqualTo(false); }); } @Test @DisplayName("selectRow") public void t005() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT * FROM article WHERE id = 1 */ sql.append("SELECT * FROM article WHERE id = 1"); Map articleRow = sql.selectRow(); assertThat(articleRow.get("id")).isEqualTo(1L); assertThat(articleRow.get("title")).isEqualTo("제목1"); assertThat(articleRow.get("body")).isEqualTo("내용1"); assertThat(articleRow.get("createdDate")).isInstanceOf(LocalDateTime.class); assertThat(articleRow.get("createdDate")).isNotNull(); assertThat(articleRow.get("modifiedDate")).isInstanceOf(LocalDateTime.class); assertThat(articleRow.get("modifiedDate")).isNotNull(); assertThat(articleRow.get("isBlind")).isEqualTo(false); } @Test @DisplayName("selectDatetime") public void t006() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT NOW() */ sql.append("SELECT NOW()"); LocalDateTime datetime = sql.selectDatetime(); long diff = ChronoUnit.SECONDS.between(datetime, LocalDateTime.now()); assertThat(diff).isLessThanOrEqualTo(1L); } @Test @DisplayName("selectLong") public void t007() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT id FROM article WHERE id = 1 */ sql.append("SELECT id") .append("FROM article") .append("WHERE id = 1"); Long id = sql.selectLong(); assertThat(id).isEqualTo(1); } @Test @DisplayName("selectString") public void t008() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT title FROM article WHERE id = 1 */ sql.append("SELECT title") .append("FROM article") .append("WHERE id = 1"); String title = sql.selectString(); assertThat(title).isEqualTo("제목1"); } @Test @DisplayName("selectBoolean") public void t009() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT isBlind FROM article WHERE id = 1 */ sql.append("SELECT isBlind") .append("FROM article") .append("WHERE id = 1"); Boolean isBlind = sql.selectBoolean(); assertThat(isBlind).isEqualTo(false); } @Test @DisplayName("selectBoolean, 2nd") public void t010() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT 1 = 1 */ sql.append("SELECT 1 = 1"); Boolean isBlind = sql.selectBoolean(); assertThat(isBlind).isEqualTo(true); } @Test @DisplayName("selectBoolean, 3rd") public void t011() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT 1 = 0 */ sql.append("SELECT 1 = 0"); Boolean isBlind = sql.selectBoolean(); assertThat(isBlind).isEqualTo(false); } @Test @DisplayName("select, LIKE 사용법") public void t012() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT COUNT(*) FROM article WHERE id BETWEEN '1' AND '3' AND title LIKE CONCAT('%', '제목' '%') */ sql.append("SELECT COUNT(*)") .append("FROM article") .append("WHERE id BETWEEN ? AND ?", 1, 3) .append("AND title LIKE CONCAT('%', ? '%')", "제목"); long count = sql.selectLong(); assertThat(count).isEqualTo(3); } @Test @DisplayName("appendIn") public void t013() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT COUNT(*) FROM article WHERE id IN ('1', '2', '3') */ sql.append("SELECT COUNT(*)") .append("FROM article") .appendIn("WHERE id IN (?)", 1, 2, 3); long count = sql.selectLong(); assertThat(count).isEqualTo(3); } @Test @DisplayName("selectLongs, ORDER BY FIELD 사용법") public void t014() { Long[] ids = new Long[]{2L, 1L, 3L}; Sql sql = simpleDb.genSql(); /* SELECT id FROM article WHERE id IN ('2', '3', '1') ORDER BY FIELD (id, '2', '3', '1') */ sql.append("SELECT id") .append("FROM article") .appendIn("WHERE id IN (?)", ids) .appendIn("ORDER BY FIELD (id, ?)", ids); List foundIds = sql.selectLongs(); assertThat(foundIds).isEqualTo(Arrays.stream(ids).toList()); } @Test @DisplayName("selectRows, Article") public void t015() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT * FROM article ORDER BY id ASC LIMIT 3 */ sql.append("SELECT * FROM article ORDER BY id ASC LIMIT 3"); List

articleRows = sql.selectRows(Article.class); IntStream.range(0, articleRows.size()).forEach(i -> { long id = i + 1; Article article = articleRows.get(i); assertThat(article.getId()).isEqualTo(id); assertThat(article.getTitle()).isEqualTo("제목%d".formatted(id)); assertThat(article.getBody()).isEqualTo("내용%d".formatted(id)); assertThat(article.getCreatedDate()).isInstanceOf(LocalDateTime.class); assertThat(article.getCreatedDate()).isNotNull(); assertThat(article.getModifiedDate()).isInstanceOf(LocalDateTime.class); assertThat(article.getModifiedDate()).isNotNull(); assertThat(article.isBlind()).isEqualTo(false); }); } @Test @DisplayName("selectRow, Article") public void t016() { Sql sql = simpleDb.genSql(); /* == rawSql == SELECT * FROM article WHERE id = 1 */ sql.append("SELECT * FROM article WHERE id = 1"); Article article = sql.selectRow(Article.class); Long id = 1L; assertThat(article.getId()).isEqualTo(id); assertThat(article.getTitle()).isEqualTo("제목%d".formatted(id)); assertThat(article.getBody()).isEqualTo("내용%d".formatted(id)); assertThat(article.getCreatedDate()).isInstanceOf(LocalDateTime.class); assertThat(article.getCreatedDate()).isNotNull(); assertThat(article.getModifiedDate()).isInstanceOf(LocalDateTime.class); assertThat(article.getModifiedDate()).isNotNull(); assertThat(article.isBlind()).isEqualTo(false); } // 테스트 메서드를 정의하고, 테스트 이름을 지정합니다. @Test @DisplayName("use in multi threading") public void t017() throws InterruptedException { // 쓰레드 풀의 크기를 정의합니다. int numberOfThreads = 10; // 고정 크기의 쓰레드 풀을 생성합니다. ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads); // 성공한 작업의 수를 세는 원자적 카운터를 생성합니다. AtomicInteger successCounter = new AtomicInteger(0); // 동시에 실행되는 작업의 수를 세는 데 사용되는 래치를 생성합니다. CountDownLatch latch = new CountDownLatch(numberOfThreads); // 각 쓰레드에서 실행될 작업을 정의합니다. Runnable task = () -> { try { // SimpleDB에서 SQL 객체를 생성합니다. Sql sql = simpleDb.genSql(); // SQL 쿼리를 작성합니다. sql.append("SELECT * FROM article WHERE id = 1"); // 쿼리를 실행하여 결과를 Article 객체로 매핑합니다. Article article = sql.selectRow(Article.class); // 기대하는 Article 객체의 ID를 정의합니다. Long id = 1L; // Article 객체의 값이 기대하는 값과 일치하는지 확인하고, // 일치하는 경우 성공 카운터를 증가시킵니다. if (article.getId() == id && article.getTitle().equals("제목%d".formatted(id)) && article.getBody().equals("내용%d".formatted(id)) && article.getCreatedDate() != null && article.getModifiedDate() != null && !article.isBlind()) { successCounter.incrementAndGet(); } } finally { // 커넥션 종료 simpleDb.close(); // 작업이 완료되면 래치 카운터를 감소시킵니다. latch.countDown(); } }; // 쓰레드 풀에서 쓰레드를 할당받아 작업을 실행합니다. for (int i = 0; i < numberOfThreads; i++) { executorService.submit(task); } // 모든 작업이 완료될 때까지 대기하거나, 최대 10초 동안 대기합니다. latch.await(10, TimeUnit.SECONDS); // 쓰레드 풀을 종료시킵니다. executorService.shutdown(); // 성공 카운터가 쓰레드 수와 동일한지 확인합니다. assertThat(successCounter.get()).isEqualTo(numberOfThreads); } @Test @DisplayName("rollback") public void t018() { // SimpleDB에서 SQL 객체를 생성합니다. long oldCount = simpleDb.genSql() .append("SELECT COUNT(*)") .append("FROM article") .selectLong(); // 트랜잭션을 시작합니다. simpleDb.startTransaction(); simpleDb.genSql() .append("INSERT INTO article ") .append("(createdDate, modifiedDate, title, body)") .appendIn("VALUES (NOW(), NOW(), ?)", "새 제목", "새 내용") .insert(); simpleDb.rollback(); long newCount = simpleDb.genSql() .append("SELECT COUNT(*)") .append("FROM article") .selectLong(); assertThat(newCount).isEqualTo(oldCount); } @Test @DisplayName("commit") public void t019() { // SimpleDB에서 SQL 객체를 생성합니다. long oldCount = simpleDb.genSql() .append("SELECT COUNT(*)") .append("FROM article") .selectLong(); // 트랜잭션을 시작합니다. simpleDb.startTransaction(); simpleDb.genSql() .append("INSERT INTO article ") .append("(createdDate, modifiedDate, title, body)") .appendIn("VALUES (NOW(), NOW(), ?)", "새 제목", "새 내용") .insert(); simpleDb.commit(); long newCount = simpleDb.genSql() .append("SELECT COUNT(*)") .append("FROM article") .selectLong(); assertThat(newCount).isEqualTo(oldCount + 1); } } ``` # 1강 - [24 11 02, p 13869, 1강, 자바 23에서 일단은 해당 의존성과 테스트케이스를 변경하지 말고 만족시켜보세요.](https://youtu.be/nGbspXi6Ep8) # 2강 - [24 12 03, p 13869, 2강, 프로젝트 생성, GITHUB 리포지터리 연결](https://youtu.be/wTWMW_-oyUI) - [리포지터리 - https://github.com/jhs512/simple-db-2024-12-03](https://github.com/jhs512/simple-db-2024-12-03) - [커밋](https://github.com/jhs512/simple-db-2024-12-03/commit/d91f775) - ![img](https://i.imgur.com/R2ZXrIg.png) # 3강 - [24 12 03, p 13869, 3강, 의존성 추가](https://youtu.be/kRc5UwZhLS0) - [커밋](https://github.com/jhs512/simple-db-2024-12-03/commit/41abf72) # 4강 - [24 12 03, p 13869, 4강, SimpleDb 클래스 생성](https://youtu.be/2Jw7V_jqVdw) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/243b58c) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/4369785) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/9887f3e) # 5강 - [24 12 03, p 13869, 5강, DB 연결하여 Connection 객체 얻음, @BeforeAll 에서 article 테이블 재생성](https://youtu.be/KMLh23cGOoI) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/0890fa9) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/5e3bd6e) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/de423be) - beforeAll 함수가 실행될 수 있도록 t000(비어있는 테스트케이스)을 추가하야 구조 개선 - ChatGPT를 통해서 진짜로 DB에 SQL을 전송하는 코드를 적용 ## mysql-1 도커 컨테이너 실행중인지 확인 - ![img](https://i.imgur.com/3n170YG.png) ## DB 생성 ```sql CREATE DATABASE simpleDb__test; ``` ## ChatGPT 질문/답변 : SimpleDb.java 에서 run 메서드 작성 ### 질문 1 ````markdown # 환경 - 자바 23 - 인텔리제이 - MySQL 8 # 소스코드 ## build.gradle.kts ```kotlin plugins { id("java") } group = "com.ll" version = "1.0-SNAPSHOT" repositories { mavenCentral() } dependencies { compileOnly("org.projectlombok:lombok:1.18.36") annotationProcessor("org.projectlombok:lombok:1.18.36") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") runtimeOnly("com.mysql:mysql-connector-j:9.1.0") testImplementation("org.assertj:assertj-core:3.26.3") implementation("com.fasterxml.jackson.core:jackson-databind:2.18.2") implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.2") } tasks.test { useJUnitPlatform() } ``` # SimpleDbTest.java ```java package com.ll.simpleDb; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.MethodOrderer; import org.junit.jupiter.api.TestMethodOrder; @TestMethodOrder(MethodOrderer.MethodName.class) public class SimpleDbTest { private static SimpleDb simpleDb; @BeforeAll public static void beforeAll() { simpleDb = new SimpleDb("localhost", "root", "lldj123414", "simpleDb__test"); createArticleTable(); } private static void createArticleTable() { simpleDb.run("DROP TABLE IF EXISTS article"); simpleDb.run(""" CREATE TABLE article ( id INT UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), createdDate DATETIME NOT NULL, modifiedDate DATETIME NOT NULL, title VARCHAR(100) NOT NULL, `body` TEXT NOT NULL, isBlind BIT(1) NOT NULL DEFAULT 0 ) """); } } ``` ## SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; public void run(String sql) { } } ``` # 요구사항 - SimpleDbTest 클래스의 createArticleTable 메서드가 작동하면 DB에 article 테이블이 생성 ```` ### 답변 1 - [답변](https://gist.github.com/jhs512/31d91b65cd4907dce86e5e340a5a989f) # 6강 - [24 12 03, p 13869, 6강, JDBC, Connection, Statement 등의 개념을 전혀 모를 땐 ChatGPT에게 이렇게 물어보세요.(꼬리물기 질문 필수)](https://youtu.be/Y46YMRWcZC4) ## ChatGPT 질문/답변 : SimpleDb.java 에서 run 메서드 작성 ### 질문 1 ````markdown # 환경 - 자바 23 - 인텔리제이 - MySQL 8 # SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; private Connection connection; // 데이터베이스 연결 초기화 private void connect() { if (connection == null) { String url = String.format("jdbc:mysql://%s/%s?useSSL=false", host, dbName); try { connection = DriverManager.getConnection(url, username, password); } catch (SQLException e) { throw new RuntimeException("Failed to connect to database", e); } } } // SQL 실행 메서드 public void run(String sql) { connect(); // 연결 초기화 try (Statement statement = connection.createStatement()) { statement.execute(sql); } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql, e); } } // 자원 해제 public void close() { if (connection != null) { try { connection.close(); } catch (SQLException e) { throw new RuntimeException("Failed to close database connection", e); } } } } ``` # 요구사항 - 나는 자바 초보이고, JDBC에 대해서 하나도 몰라 - 나는 비유적이고 쉬운 설명을 좋아해 - 소스코드에 상세한 주석을 달아서 설명해줘 ```` ### 답변 1 - [답변](https://gist.github.com/jhs512/b3d147893d43be5452ada68b9355d09e) ### 질문 2 ````markdown - 나는 JDBC와 관련 클래스들에 대해서 하나도 몰라. - 나는 이것을 단계적으로 이해하고 싶어. - 근본적이고 쉬운개념부터 단계적으로 알려줘. - 10단계 이상으로 나눠서 설명해줘. - 초등학생에게 설명하듯이 비유적인 설명을 많이 해주면 좋을 것 같다. ```` ### 답변 2 - [답변](https://gist.github.com/jhs512/4f22aff9358e364fc037d175f2bde5c5) ### 질문 3 ````markdown 더 자세히 알고 싶어. 좋은 추가질문들 추천해줘 ```` ### 답변 3 - [답변](https://gist.github.com/jhs512/9fbd217e8404645e0d9ea96b0e7f8a8f) # 7강 - [24 12 04, p 13869, 7강, beforeEach 함수 구현](https://youtu.be/m94Zf7IX1SI) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/0752488) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/d4c2719) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/7674672) ## ChatGPT 질문/답변 ### 질문 1 : SimpleDb.java 의 run 메서드에서 파라미터 바인드(`?`에 실제 파라미터를 치환하여 실행될 SQL 생성) ````markdown # SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; private Connection connection; // 데이터베이스 연결 초기화 private void connect() { if (connection == null) { String url = String.format("jdbc:mysql://%s/%s?useSSL=false", host, dbName); try { connection = DriverManager.getConnection(url, username, password); } catch (SQLException e) { throw new RuntimeException("Failed to connect to database", e); } } } // SQL 실행 메서드 public void run(String sql, Object... params) { connect(); // 연결 초기화 try (Statement statement = connection.createStatement()) { statement.execute(sql); } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql, e); } } // 자원 해제 public void close() { if (connection != null) { try { connection.close(); } catch (SQLException e) { throw new RuntimeException("Failed to close database connection", e); } } } } ``` # simpleDb.run 사용 ```java simpleDb.run(""" INSERT INTO article SET createdDate = NOW(), modifiedDate = NOW(), title = ?, `body` = ?, isBlind = ? """, title, body, isBlind); ``` # 요구사항 - 기본적인 방식으로 구현해줘 - run 메서드에서 sql 에 포함된 ?를 params 의 값으로 치환하고 싶어 ```` ### 답변 1 - [답변](https://gist.github.com/jhs512/b3ff7cdd238102d97ef4d158c63a0cc6) ### 질문 2 : PreparedStatement 는 뭔데? ````markdown PreparedStatement 는 뭔데? ```` ### 답변 2 - [답변](https://gist.github.com/jhs512/43b226d17fcad27659aceff298b935fe) ### 질문 3 : 간단한 리팩토링 요청 ````markdown ## SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.SQLException; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; private Connection connection; // 데이터베이스 연결 초기화 private void connect() { if (connection == null) { String url = String.format("jdbc:mysql://%s/%s?useSSL=false", host, dbName); try { connection = DriverManager.getConnection(url, username, password); } catch (SQLException e) { throw new RuntimeException("Failed to connect to database", e); } } } // SQL 실행 메서드 public void run(String sql, Object... params) { connect(); // 연결 초기화 try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) { for (int i = 0; i < params.length; i++) { preparedStatement.setObject(i + 1, params[i]); // ? 인덱스는 1부터 시작 } // SQL 실행 preparedStatement.executeUpdate(); } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql, e); } } // 자원 해제 public void close() { if (connection != null) { try { connection.close(); } catch (SQLException e) { throw new RuntimeException("Failed to close database connection", e); } } } } ``` # 요구사항 - 리팩토링 할 부분이 있다면 해줘 - 너무 구조를 크게 바꾸지는 말아줘 - 왜냐하면 나는 리팩토링을 점진적으로 할거야. ```` ### 답변 3 - [답변](https://gist.github.com/jhs512/9e2ba15b4a5f49037adf78278831d2aa) # 8강 - [24 12 04, p 13869, 8강, insert 함수 꼼수로 구현](https://youtu.be/eZ8uobC1c7U) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/849a6b5) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/79c8fda) - [커밋 - BLUE - 없음]() # 9강 - [24 12 04, p 13869, 9강, update 함수 꼼수로 구현](https://youtu.be/-Cqi8yEVj70) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/be90350) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/97ea167) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/3a0f754) # 10강 - [24 12 04, p 13869, 10강, delete 함수 꼼수로 구현](https://youtu.be/elZxkH2jQsY) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/54ed651) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/33e8a36) - [커밋 - BLUE - 없음]() # 11강 - [24 12 04, p 13869, 11강, selectRows 함수 꼼수로 구현](https://youtu.be/95wSr-XUXwY) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/4a9b1df) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/82efcad) - [커밋 - BLUE - 없음]() # 12강 - [24 12 04, p 13869, 12강, selectRow 함수 꼼수로 구현](https://youtu.be/dBfcjQWifXA) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/67f86d5) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/9598314) - [커밋 - BLUE - 없음]() # 13강 - [24 12 04, p 13869, 13강, selectDatetime 함수 꼼수로 구현](https://youtu.be/1vnaZ4sJe2c) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/a55aaa1) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/08d4d2f) - [커밋 - BLUE - 없음]() # 14강 - [24 12 04, p 13869, 14강, selectLong 함수 꼼수로 구현](https://youtu.be/VaesgAuVbSE) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/b62e848) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/511fff7) - [커밋 - BLUE - 없음]() # 15강 - [24 12 04, p 13869, 15강, selectString 함수 꼼수로 구현](https://youtu.be/1MLBetE3cU8) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/1623f74) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/59fd842) - [커밋 - BLUE - 없음]() # 16강 - [24 12 04, p 13869, 16강, selectBoolean 함수 꼼수로 구현](https://youtu.be/e0xnNqWdXfw) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/2405eb7) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/c388bce) - [커밋 - BLUE - 없음]() # 17강 - [24 12 05, p 13869, 17강, selectBoolean 2nd 함수 꼼수로 구현](https://youtu.be/AcL5TUDiJLw) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/89b44a3) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/a9f8099) - [커밋 - BLUE - 없음]() # 18강 - [24 12 05, p 13869, 18강, selectBoolean 3rd 함수 구현](https://youtu.be/JIsnmR-Zivk) - [커밋 - RED/GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/af2f55a) - [커밋 - BLUE - selectBoolean 메서드가 모아둔 SQL을 실제로 실행하도록 simpleDb 객체에게 위임](https://github.com/jhs512/simple-db-2024-12-03/commit/6f0d04f) # 19강 - [24 12 05, p 13869, 19강, SimpleDb 클래스의 run 메서드와 selectBoolean 메서드의 중복을 해결](https://youtu.be/64kqrOuQUGw) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/5e8d42c) # 20강 - [24 12 05, p 13869, 20강, selectString 을 실제로 구현](https://youtu.be/xMuOg_IyWpo) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/e322f93) # 21강 - [24 12 05, p 13869, 21강, 리턴타입 제너릭 처리로 _run 함수 호출 마다 필요로 했던 형변환을 안해도 됨](https://youtu.be/O6vK4k-3x2U) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/2824995) # 22강 - [24 12 05, p 13869, 22강, selectLong 을 실제로 구현](https://youtu.be/BKSpwM9T7UA) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/0579a7d) # 23강 - [24 12 05, p 13869, 23강, selectDatetime 을 실제로 구현](https://youtu.be/DeZyVG2cYmU) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/48da4a7) # 24강 - [24 12 05, p 13869, 24강, selectRow 를 실제로 구현](https://youtu.be/bFxn-bNioAA) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/56443a0) # 25강 - [24 12 05, p 13869, 25강, selectRow 와 관련된 코드를 범용적으로 변경, 이제는 article 테이블 뿐 아니라 다른 테이블에도 적용 가능](https://youtu.be/nmOTPlKeFgw) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/da8a488) ## ChatGPT 질문/답변 : row 를 Map으로 변환하는 코드를 만들어줘 ### 질문 1 ````markdown # 환경 - 자바 23 - 인텔리제이 - 현재 혼자힘으로 JDBC 유틸리티 클래스를 만들고 있어 # SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; import java.sql.*; import java.time.LocalDateTime; import java.util.LinkedHashMap; import java.util.Map; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; private Connection connection; // 데이터베이스 연결 초기화 private void connect() { if (connection != null) { return; // 이미 연결되어 있으면 아무 작업도 하지 않음 } String url = String.format("jdbc:mysql://%s/%s?useSSL=false", host, dbName); try { connection = DriverManager.getConnection(url, username, password); } catch (SQLException e) { throw new RuntimeException("Failed to connect to database: " + e.getMessage(), e); } } // 자원 해제 public void close() { if (connection == null) { return; // 연결이 없는 경우 아무 작업도 하지 않음 } try { connection.close(); } catch (SQLException e) { throw new RuntimeException("Failed to close database connection: " + e.getMessage(), e); } } public Sql genSql() { return new Sql(this); } // PreparedStatement 파라미터 바인딩 분리 private void bindParameters(PreparedStatement preparedStatement, Object... params) throws SQLException { for (int i = 0; i < params.length; i++) { preparedStatement.setObject(i + 1, params[i]); } } // SQL 실행 메서드 private T _run(String sql, Class cls, Object... params) { connect(); try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) { bindParameters(preparedStatement, params); if (sql.startsWith("SELECT")) { ResultSet resultSet = preparedStatement.executeQuery(); resultSet.next(); if (cls == String.class) { return (T) resultSet.getString(1); } else if (cls == Map.class) { Map row = new LinkedHashMap<>(); row.put("id", resultSet.getLong("id")); row.put("createdDate", resultSet.getTimestamp("createdDate").toLocalDateTime()); row.put("modifiedDate", resultSet.getTimestamp("modifiedDate").toLocalDateTime()); row.put("title", resultSet.getString("title")); row.put("body", resultSet.getString("body")); row.put("isBlind", resultSet.getBoolean("isBlind")); return (T) row; } else if (cls == LocalDateTime.class) { return (T) resultSet.getTimestamp(1).toLocalDateTime(); } else if (cls == Long.class) { return (T) (Long) resultSet.getLong(1); } else if (cls == Boolean.class) { return (T) (Boolean) resultSet.getBoolean(1); } } return (T) (Integer) preparedStatement.executeUpdate(); } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql + ". Error: " + e.getMessage(), e); } } public int run(String sql, Object... params) { return _run(sql, Integer.class, params); } public boolean selectBoolean(String sql) { return _run(sql, Boolean.class); } public String selectString(String sql) { return _run(sql, String.class); } public long selectLong(String sql) { return _run(sql, Long.class); } public LocalDateTime selectDatetime(String sql) { return _run(sql, LocalDateTime.class); } public Map selectRow(String sql) { return _run(sql, Map.class); } } ``` # 요구사항 - _run 메서드에서 결과를 Map으로 반환하는 코드를 하드코딩 하지마. - ResultSet의 칼럼정보를 바탕으로 자동으로 Map 객체를 만들어줘 - 참고로 id 칼럼의 타입은 long 으로 할게 ```` ### 답변 1 - [답변](https://gist.github.com/jhs512/2dfed7eb827847e08ca12f14fb9c012f) # 26강 - [24 12 05, p 13869, 26강, selectRows 를 실제로 구현](https://youtu.be/gGEky92AwLU) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/ae806da) # 27강 - [24 12 05, p 13869, 27강, parseResultSetToMap 도입하여 row 를 Map 으로 변환하는 코드가 중복되는 것을 막음](https://youtu.be/3jyq9sVF_zU) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/afa1238) # 28강 - [24 12 05, p 13869, 28강, delete 를 실제로 구현](https://youtu.be/s5gH-xQLveU) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/0ff1358) # 29강 - [24 12 05, p 13869, 29강, `sqlFormat.toString()` 를 `toSql()` 로 변경, 모든 쿼리 메서드에 파라미터 인자 전달](https://youtu.be/4CphNkhypXw) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/0521001) # 30강 - [24 12 05, p 13869, 30강, update 를 실제로 구현](https://youtu.be/YU_9HOWVzig) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/68f2876) # 31강 - [24 12 05, p 13869, 31강, insert 를 실제로 구현](https://youtu.be/qlXT97dci3I) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/4183c94) # 32강 - [24 12 05, p 13869, 32강, 운영모드가 아닐 때(개발모드/테스트모드 일 때) simpleDb 에 의해 실행되는 SQL이 출력](https://youtu.be/2CTRFBTARUQ) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/ab8fc50) # 33강 - [24 12 05, p 13869, 33강, SQL 출력할 때 파라미터가 바인드](https://youtu.be/bknj20y8vjE) - [커밋 - BLUE - 구현](https://github.com/jhs512/simple-db-2024-12-03/commit/79e2741) - [커밋 - BLUE - 리팩토링](https://github.com/jhs512/simple-db-2024-12-03/commit/c582738) # 34강 - [24 12 05, p 13869, 34강, SimpleDb 클래스 리팩토링](https://youtu.be/lbcHzKId8hU) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/86df4d1) ## ChatGPT 질문/답변 : SimpleDb 클래스 리팩토링 해줘 ### 질문 1 ````markdown # 환경 - 자바 23 - 인텔리제이 # SimpleDb.java ```java package com.ll.simpleDb; import lombok.RequiredArgsConstructor; import java.sql.*; import java.time.LocalDateTime; import java.util.*; @RequiredArgsConstructor public class SimpleDb { private final String host; private final String username; private final String password; private final String dbName; private Connection connection; private boolean isNotProdMode() { return true; } // 데이터베이스 연결 초기화 private void connect() { if (connection != null) { return; // 이미 연결되어 있으면 아무 작업도 하지 않음 } String url = String.format("jdbc:mysql://%s/%s?useSSL=false", host, dbName); try { connection = DriverManager.getConnection(url, username, password); } catch (SQLException e) { throw new RuntimeException("Failed to connect to database: " + e.getMessage(), e); } } // 자원 해제 public void close() { if (connection == null) { return; // 연결이 없는 경우 아무 작업도 하지 않음 } try { connection.close(); } catch (SQLException e) { throw new RuntimeException("Failed to close database connection: " + e.getMessage(), e); } } public Sql genSql() { return new Sql(this); } // SQL과 파라미터를 입력받아 치환된 SQL 반환 private String rawSql(String sql, Object[] params) { StringBuilder processedSql = new StringBuilder(sql); int lastIndex = 0; for (Object param : params) { lastIndex = processedSql.indexOf("?", lastIndex); if (lastIndex == -1) break; // 더 이상 치환할 물음표가 없으면 중단 String replacement = formatRawSqlParam(param); // 파라미터 포맷 처리 processedSql.replace(lastIndex, lastIndex + 1, replacement); lastIndex += replacement.length(); } return processedSql.toString(); } // 파라미터에 따라 적절한 SQL 값으로 변환 private String formatRawSqlParam(Object param) { if (param instanceof Boolean) { return param.toString().toUpperCase(); // Boolean을 대문자로 } return "'" + Objects.toString(param, "") + "'"; // 문자열로 변환 } // PreparedStatement 파라미터 바인딩 분리 private void bindParameters(PreparedStatement preparedStatement, Object... params) throws SQLException { for (int i = 0; i < params.length; i++) { preparedStatement.setObject(i + 1, params[i]); } } // SQL 실행 메서드 private Map parseResultSetToMap(ResultSet resultSet) throws SQLException { ResultSetMetaData metaData = resultSet.getMetaData(); int columnCount = metaData.getColumnCount(); Map row = new LinkedHashMap<>(); for (int i = 1; i <= columnCount; i++) { String columnName = metaData.getColumnLabel(i); Object value; switch (metaData.getColumnType(i)) { case Types.BIGINT: value = resultSet.getLong(columnName); break; case Types.TIMESTAMP: Timestamp timestamp = resultSet.getTimestamp(columnName); value = (timestamp != null) ? timestamp.toLocalDateTime() : null; break; case Types.BOOLEAN: value = resultSet.getBoolean(columnName); break; default: value = resultSet.getObject(columnName); break; } row.put(columnName, value); } return row; } private T parseResultSet(ResultSet resultSet, Class cls) throws SQLException { if (cls == String.class) { resultSet.next(); return (T) resultSet.getString(1); } else if (cls == List.class) { List> rows = new ArrayList<>(); while (resultSet.next()) { rows.add(parseResultSetToMap(resultSet)); } return (T) rows; } else if (cls == Map.class) { resultSet.next(); return (T) parseResultSetToMap(resultSet); } else if (cls == LocalDateTime.class) { resultSet.next(); return (T) resultSet.getTimestamp(1).toLocalDateTime(); } else if (cls == Long.class) { resultSet.next(); return (T) (Long) resultSet.getLong(1); } else if (cls == Boolean.class) { resultSet.next(); return (T) (Boolean) resultSet.getBoolean(1); } throw new IllegalArgumentException("Unsupported class type: " + cls); } private T _run(String sql, Class cls, Object... params) { connect(); sql = sql.trim(); if (isNotProdMode()) { System.out.println("== rawSql =="); System.out.println(rawSql(sql, params)); } if (sql.startsWith("INSERT")) { try (PreparedStatement preparedStatement = connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS)) { bindParameters(preparedStatement, params); int affectedRows = preparedStatement.executeUpdate(); if (cls == Integer.class) { return (T) (Integer) affectedRows; } ResultSet generatedKeys = preparedStatement.getGeneratedKeys(); if (generatedKeys.next()) { return (T) (Long) generatedKeys.getLong(1); } } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql + ". Error: " + e.getMessage(), e); } } try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) { bindParameters(preparedStatement, params); if (sql.startsWith("SELECT")) { ResultSet resultSet = preparedStatement.executeQuery(); return parseResultSet(resultSet, cls); } return (T) (Integer) preparedStatement.executeUpdate(); } catch (SQLException e) { throw new RuntimeException("Failed to execute SQL: " + sql + ". Error: " + e.getMessage(), e); } } public int run(String sql, Object... params) { return _run(sql, Integer.class, params); } public boolean selectBoolean(String sql, Object... params) { return _run(sql, Boolean.class, params); } public String selectString(String sql, Object... params) { return _run(sql, String.class, params); } public long selectLong(String sql, Object... params) { return _run(sql, Long.class, params); } public LocalDateTime selectDatetime(String sql, Object... params) { return _run(sql, LocalDateTime.class, params); } public Map selectRow(String sql, Object... params) { return _run(sql, Map.class, params); } public List> selectRows(String sql, Object... params) { return _run(sql, List.class, params); } public int delete(String sql, Object... params) { return _run(sql, Integer.class, params); } public int update(String sql, Object[] params) { return _run(sql, Integer.class, params); } public long insert(String sql, Object[] params) { return _run(sql, Long.class, params); } } ``` # 요구사항 - 리팩토링 - 기존에 있는 public 메서드는 메서드 명 변경금지 ```` ### 답변 1 - [답변](https://gist.github.com/jhs512/954311dac2b2246182f2570ee5a6b83a) # 35강 - [24 12 05, p 13869, 35강, LIKE 테스트케이스 추가](https://youtu.be/SeFaHVRRqiU) - [커밋 - RED/GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/b4f744b) - [커밋 - BLUE - 없음]() # 36강 - [24 12 05, p 13869, 36강, appendIn 구현](https://youtu.be/9ZOzQrzNdjc) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/fe0a3e5) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/d47de21) - [커밋 - BLUE - 없음]() # 37강 - [24 12 05, p 13869, 37강, selectLongs 구현](https://youtu.be/ZMzlsgPoaNg) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/07c505c) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/b78f511) - [커밋 - BLUE - 없음]() # 38강 - [24 12 05, p 13869, 38강, selectRows(Article.class) 구현](https://youtu.be/LquFPDv0yJc) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/fbcb574) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/bfd8086) - [커밋 - BLUE - 없음]() # 39강 - [24 12 05, p 13869, 39강, Sql 클래스에서 Article 제거, 조금 더 범용적인 로직을 이용해서 맵을 객체로 변환](https://youtu.be/sS-8Fp3qACw) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/809864b) # 40강 - [24 12 05, p 13869, 40강, 맵을 객체로 바꾸는 작업을 전문 라이브러리인 잭슨을 이용해서 수행](https://youtu.be/9LvaZBfR4eo) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/f6037e3) # 41강 - [24 12 05, p 13869, 41강, Article 클래스가 39강 작업 이후로는 더 이상 main 에 있을 필요가 없기 때문에 test 로 옮김](https://youtu.be/Ttuc6O0vSjE) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/2f8ef2e) # 42강 - [24 12 05, p 13869, 42강, 데이터를 변환하는 로직은 Sql 클래스가 수행할게 아니라는 생각에 SimpleDb 로 로직 이동](https://youtu.be/gTQqUDAdOPQ) - [커밋 - BLUE](https://github.com/jhs512/simple-db-2024-12-03/commit/6403656) # 43강 - [24 12 05, p 13869, 43강, selectRow(Article.class) 구현](https://youtu.be/23nS7XtvUXY) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/f27c3dc) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/46f5022) - [커밋 - BLUE - 없음]() # 44강 - [24 12 05, p 13869, 44강, SimpleDb 객체를 여러 쓰레드에서 사용할 때 각 쓰레드마다 고유한 커넥션이 생기기 때문에 추후 쓰레드간 트랜잭션이 유지될 수 있음](https://youtu.be/hDvjidGJfB0) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/b69aa51) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/2017a6a) - [커밋 - BLUE - 없음]() ## 44강 이전까지의 멀티 쓰레드 지원 - 44강 이전까지는 하나의 simpleDb 객체안에는 하나의 connection 객체가 있고 - simpleDb 객체를 여러 쓰레드 환경에서 사용하면 여러 쓰레드에서 하나의 connection 을 공유하는 상황이 된다. ## 44강 이후의 멀티 쓰레드 지원 - 서로 다른 쓰레드에서 하나의 simpleDb 객체를 이용하더라도 - simpleDb 객체 내부적으로 커넥션 생성을 현재 이용자(쓰레드)의 커넥션을 별도로 생성한다.(없으면 생성) - 그렇기 때문에 이제는 서로 다른 쓰레드에서는 커넥션을 공유하지 않는다. - 이후에 트랜잭션을 구현할 때 편해지는 상황이 된다. - 보통 WAS(스프링부트 같은) 서버에서는 쓰레드 당 커넥션이 한개 배정된다. - 우리도 그와 같은 방식으로 구현했다. # 45강 - [24 12 06, p 13869, 45강, 보통 쓰레드가 다르면 사로 다른 커넥션을 이용하는게 보통입니다. 즉 쓰레드당 커넥션 1개라고 생각하시면 됩니다.](https://youtu.be/5NFj_i-yv6g) # 46강 - [24 12 06, p 13869, 46강, 이전 강의(44강)의 작업이 잘 되었는지 확인하기 위해서 MySQL 제너럴 로그 확인](https://youtu.be/gck7a7m6hf0) # 47강 - [24 12 06, p 13869, 47강, 트랜잭션, 롤백 구현](https://youtu.be/3uNczQKohZw) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/d8be72d) - [커밋 - GREEN](https://github.com/jhs512/simple-db-2024-12-03/commit/4c0a9aa) - [커밋 - BLUE - 없음]() # 48강 - [24 12 06, p 13869, 48강, 트랜잭션, 커밋 구현](https://youtu.be/NX-zDMSI4rk) - [커밋 - RED](https://github.com/jhs512/simple-db-2024-12-03/commit/b524e6a) - [커밋 - GREEN - 롤백이든 커밋이든 트랜잭션이 종료되면 autocommit 을 다시 1로 돌려야 한다.](https://github.com/jhs512/simple-db-2024-12-03/commit/29a29ef) - [커밋 - BLUE - 없음]()

MySQL/JDBC 유틸리티 클래스 SimpleDb 구현