gi_dor

AWS 배포 EC2 인스턴스

기돌 — Sat, 14 Mar 2026 22:39:59 +0900

1년전에 했던 글을 보면서 새로 적용하면서 정리 했습니다

https://product.kyobobook.co.kr/detail/S000001019679

스프링 부트와 AWS로 혼자 구현하는 웹 서비스 | 이동욱 - 교보문고

스프링 부트와 AWS로 혼자 구현하는 웹 서비스 | 가장 빠르고 쉽게 웹 서비스의 모든 과정을 경험한다. 경험이 실력이 되는 순간!이 책은 제목 그대로 스프링 부트와 AWS로 웹 서비스를 구현합니다

product.kyobobook.co.kr

책이 19년도여서 버전이 많이 안맞는다 .. 또한 사람들은 Ubuntu 또는 리눅스2 를 사용하고 책에서는 리눅스1을
사용하기에 쉽지 않아서 여러 블로그를 보며 하기에 시간이 오래걸렸습니다.

AWS 는 Amazon 에서 제공하는 클라우드 서비스 입니다
간단하게 생각하면 Amazon에서 가상의 컴퓨터를 대여해서 사용한다고 생각하면 됩니다

1. EC2

가상의 컴퓨터를 대여해준다
서버 , 스토리지 , 데이터베이스 등의 서비스를 제공
손쉽게 운영체제 ,CPU , RAM , 용량 구성

2. RDS Relational Database Service

관계형 데이터베이스 서비스
관계형 DB를 대여

Windows
Ubuntu
Java17
Springboot
EC2
RDS
Gradle
MySQL8

1. 인스턴스 생성

2. 새로운 키 생성

EC2 컴퓨터에 접근할때 사용할 비밀번호 같은

3. 네트워크 설정

3. 스토리지 구성

최대 30GB 까지 사용 할수 있다고 합니다
EC2에서 사용할수 있는 하드 디스크라고 생각하면된다

4. 생성

EC2 연결

인스턴스 생성시 만든 key 파일이 있는 곳에서 Git Bash 를 통해 터미널 실행합니다
ssh 명령어를 입력해 인스턴스에 접속

EC2 접속 완료

패키지 업데이트

sudo apt update

0. 시간대 한국으로 변경

sudo ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
date;		// KST

Java17

sudo apt install openjdk-17-jdk -y
java -version

MySQL

sudo apt install mysql-server -y // 설치
sudo systemctl status mysql

sudo mysql
ALTER USER '계정'@'localhost' IDENTIFIED WITH mysql_native_password BY '비밀번호!';
FLUSH PRIVILEGES;

exit;
mysql -u 아이디 -p


CREATE DATABASE 디비명;

show databases;  // DB확인

exit;

로컬 DB dump 만든 파일 EC2에 밀어 넣어 import

scp -i rent-server-key.pem rentinsight-dump.sql ubuntu@xx.xxx.xx.xxx:/home/ubuntu

key 파일이 있는 위치에서 git bash 를 통해 EC2로 보낸다

import

mysql -u 계정 -p rentinsight < rentinsight_dump1.sql
mysql -u 계정 -p rentinsight < rentinsight_dump2.sql
mysql -u 계정 -p rentinsight < rentinsight_dump3.sql
mysql -u 계정 -p rentinsight < rentinsight_dump4.sql

만약 하다가 꼬였다면 mysql 삭제후 재설치

sudo systemctl stop mysql
sudo apt purge mysql-server mysql-client mysql-common mysql-server-core-* mysql-client-core-* -y

sudo rm -rf /etc/mysql
sudo rm -rf /var/lib/mysql
sudo rm -rf /var/log/mysql

sudo apt autoremove -y
sudo apt autoclean

sudo apt update
sudo apt install mysql-server -y

git clone

git clone -b 브랜치명 repository주소

application-local.yml 만들기

해당 파일에는 DB 접속 , API serviceKey , url 정보가 담겨있

cd src/main/resources
nano application-local.yml

spring:
  datasource:
    username: DB접속 ID
    password: DB 접속 PW

api:
  serviceKey: "API키"

  baseUrl:
    officetel: "https://apis.data.go.kr/............."
    multiHouse: "https://apis.data.go.kr/..........."

CTRL + X
Y
Enter

프로젝트 실행 jar 파일빌드

cd ~/Rent-Insight-Helper

chmod +x gradlew

./gradlew clean build -x test --no-daemon
// 테스트 스킵하고 빌드

build 과정에서 너무 오래 걸리는 상황발생
종료후 EC2 메모리 증설
https://gi-dor.tistory.com/262

Spring Boot 개인,토이 프로젝트에서 CI/CD

private Repository - 깃허브 계정 , 토큰 복사 붙여넣기 안하기 위해 git config --global credential.helper storegit pull origin main// id// 토큰 pw이제 그대로 id 와 토큰 값이 저장되어있어 재 입력 하지 않아도된

gi-dor.tistory.com

// 메모리 상태 확인
free -h

// swap 파일을 생성해준다. (메모리 상태 확인 시 swap이 있었지만 디렉토리 파일은 만들어줘야한다.)
sudo mkdir /var/spool/swap
sudo touch /var/spool/swap/swapfile
sudo dd if=/dev/zero of=/var/spool/swap/swapfile count=2048000 bs=1024

// swap 파일을 설정한다.
sudo chmod 600 /var/spool/swap/swapfile
sudo mkswap /var/spool/swap/swapfile
sudo swapon /var/spool/swap/swapfile

// swap 파일을 등록한다.
sudo vim /etc/fstab
파일이 열리면 해당 파일 아래쪽에 하단 내용 입력 후 저장
/var/spool/swap/swapfile    none    swap    defaults    0 0

// 메모리 상태 확인
free -h

java -jar build/libs/*.jar

http://탄력적IP:8080

참고 블로그

팝업 모달 & 24시간 보지 않기 with JS , Cookie

기돌 — Thu, 26 Feb 2026 21:42:32 +0900

개발 중인 미니 프로젝트는 만들어가는 단계 이므로 배포 이후 사용자가 미구현된 버튼을 클릭하고 안되는 기능이나
데이터가 없어서 작동하지 않는 검색조건이 있을수 있어 사용자가 사이트를 이탈하는 것을 방지하기 위해

메인 페이지 진입 시 '서비스 업데이트 로드맵'을 안내하는 팝업 모달 & 검색시 없는 데이터 안내문 ' 을 띄우기로 결정
다만, 매번 접속할 때마다 팝업이 뜨면 피로감을 줄 수 있으므로 '24시간 동안 보지 않기' 기능을 쿠키(Cookie)를 활용해 구현했음

기능 정의

사용자가 웹 사이트에 방문하면 공지사항 팝업이 나타난다
팝업 안에는 24시간 다시보지 않기 체크박스 있다
체크박스를 선택하지 않고 팝업을 닫으면 메인 페이지 재방문시 팝업 발생
체크박스 선택후 팝업을 닫으면 메인 페이지 재방문시 팝업 미 발생

모달html

data-bs-dismiss="modal" Bootstrap이 제공하는 기본 닫기 기능
onclick="closeNoticeModal() 닫기 버튼 누를때 쿠키 생성 처리할 JS 함수

<!-- src/main/resources/templates/common/noticeModal.html -->
<!DOCTYPE html>
<html xmlns:th="[http://www.thymeleaf.org](http://www.thymeleaf.org)">
<div th:fragment="noticeModal">
    <div class="modal fade" id="noticeModal" tabindex="-1" aria-hidden="true">
        <div class="modal-dialog modal-dialog-centered">
            <div class="modal-content border-0 shadow-lg">
                <!-- 모달 헤더 -->
                <div class="modal-header bg-dark text-white">
                    <h5 class="modal-title fw-bold">
                        <i class="bi bi-megaphone-fill me-2"></i>서비스 업데이트 로드맵 안내
                    </h5>
                    <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
                </div>

                <!-- 모달 바디 (로드맵 내용 생략) -->
                <div class="modal-body p-3">
                   <!-- ... 업데이트 예정 기능 목록 ... -->
                </div>

                <!-- 모달 푸터 (24시간 보지 않기) -->
                <div class="modal-footer d-flex justify-content-between bg-light">
                    <div class="form-check mb-0">
                        <input class="form-check-input" type="checkbox" id="hideFor24Hours">
                        <label class="form-check-label text-muted small mt-1" for="hideFor24Hours">
                            24시간 동안 보지 않기
                        </label>
                    </div>
                    <!-- 닫기 버튼 클릭 시 이벤트 발생 -->
                    <button type="button" class="btn btn-secondary btn-sm px-4" data-bs-dismiss="modal" onclick="closeNoticeModal()">닫기</button>
                </div>
            </div>
        </div>
    </div>
</div>
</html>

메인 페이지 html

<!-- src/main/resources/templates/index.html -->
<body>
    <!-- 1. 네비게이션 바 -->
    <nav th:replace="~{common/navbar :: navbar}"></nav>

    <!-- 2. 메인  영역 -->
    <main>

    </main>

    <!-- 3. 공지사항 모달 Fragment 삽입 -->
    <div th:replace="~{common/noticeModal :: noticeModal}"></div>

    <!-- 4. 푸터 -->
    <footer th:replace="~{common/footer :: footer}"></footer>

    <!-- Bootstrap JS (반드시 모달 제어 스크립트보다 위에 위치해야 함!!!!!!) -->
    <script src="[https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js](https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js)"></script>

    <!-- 모달 팝업 제어용 커스텀 JS 영역 -->
</body>

모달 팝업 JS

// 페이지 로드 다되면 쿠키 확인후에 팝업 출력 결정
window.onload = function () {
    // 쿠키 문자열에 'hideNotice=true'가 포함되어 있는지 검사
    if(document.cookie.includes("hideNotice=true")) {
        // 쿠키가 존재하면 아무 동작도 하지 않음 (팝업 숨김)
    } else {
        // 쿠키가 없으면 Bootstrap 모달 객체를 생성
        let noticeModal = new bootstrap.Modal(document.getElementById('noticeModal'));
        noticeModal.show();    // 화면에 표시
    }
}

// 닫기 버튼 클릭 시 동작
function closeNoticeModal() {
    let checkbox = document.getElementById('hideFor24Hours');
    if(checkbox.checked) {
        // 체크박스가 선택된 상태로 닫으면 유효기간 1일짜리 쿠키 생성
        setCookie("hideNotice", "true", 1);
    }
}

// 재사용 가능한 쿠키 생성됨
/**
 * @param {string} name - 생성할 쿠키의 이름
 * @param {string} value - 쿠키에 저장할 값
 * @param {number} days - 쿠키의 유효기간 (일 단위)
 */
function setCookie(name, value, days) {
    let todayDate = new Date();
    // 일(days) 단위의 시간을 밀리초(ms)로 변환
    let duration = days * 24 * 60 * 60 * 1000;

    // 현재 시간에 계산된 밀리초를 더하여 만료 시점을 설정
    todayDate.setTime(todayDate.getTime() + duration);
    let expires = todayDate.toUTCString();

    // 브라우저에 쿠키 저장 (path=/ 옵션으로 사이트 전체에서 쿠키 공유)
    document.cookie = name + "=" + value + "; expires=" + expires + "; path=/";
}

페이지가 열릴때 JS에서 브라우저의 쿠키 저장소를 확인해 팝업그만보기 쿠키가 있는지 확인 ( Ex. hideNotice )
팝업 결정 여부
팝업 생성
- 24시간 보지 않기 체크 후 닫기 누르면 JS는 브라우저에 hideNotice=true

사실 여기까지는 해피엔딩이어씀

includes() 방식과 getCookie()의 필요성

예상치 못한 쿠키 이름 충돌에 매우 취약하다
예를 들어 테스트를 위해 추가된 쿠키 :do_not_hideNotice=true
이제 브라우저에 저장된 document.cookie문자열은 아래와 같은 형태가 된다
"abcdCookie=true; do_not_hideNotice=true; sdaCookie=txxxxxxx; hideNotice=true"

이 상태에서, 페이지가 로드될 때 includes() 코드가 실행되면

코드: if (document.cookie.includes("hideNotice=true")) { ... }
동작 : JavaScript는 전체 문자열 안에서 "hideNotice=true" 라는 텍스트를 찾는다
결과 : "do_not_hideNotice=true" 라는 문자열 안에 "hideNotice=true"가 포함되어 있으므로 해당 조건은 true를 반환

getCookie() 함수는 해당 문제를 해결할수 있다.

document.cookie 문자열을 세미콜론(;)으로 쪼개어, ["...", "do_not_hideNotice=true"] 와 같이 각 쿠키를 분리
정확한 시작점 확인: ("do_not_hideNotice=true")가 찾으려는 정확한 키와 등호 ("hideNotice=") 로 시작하는지(indexOf(...) === 0)를 검사
"do_not_hideNotice=true"는 "hideNotice="로 시작하지 않으므로 무시된다
오직 정확히 "hideNotice=true" 라는 조각을 찾았을 때만 값을 반환

왜 getCookie()를 사용해야 하는가?

includes() : 빠르고 간편하다 (최고!) 다른 쿠키의 이름에 내가 찾는 문자열이 '포함'되는 경우 오작동할 수 있다
getCookie(): 코드는 조금 더 길고 쿠키를 구분하고 정확한 매개변수를 기준으로 값을 찾아오므로 이름 충돌에서 안전

  window.onload = function () {
    if(!getCookie('hideSearchModal')) {
        let noticeModal = new bootstrap.Modal(document.getElementById('noticeModal'));
        noticeModal.show();
  }


// 쿠키 확인 함수
function getCookie(name) {
    let nameCookie = name + "=";
    console.log('nameCookie',nameCookie)    // "hideSearchModal="

    // (2) ['hideNotice=true', ' hideSearchModal=true']
    let splitCookie = document.cookie.split(';');
    console.log('splitCookie',splitCookie)

    for(let i = 0; i < splitCookie.length; i++) {
        let cookie = splitCookie[i];
        console.log('splitCookie[i]',cookie)    // hideNotice=true ,  hideSearchModal=true

        // 두번째 쿠키 부터는 앞에 ' hideSearchModal=true' 이런식으로 공백이있다
        while (cookie.charAt(0) === ' ') {
            cookie = cookie.substring(1, cookie.length);
            console.log('while cookie',cookie)
        }

        if (cookie.indexOf(nameCookie) === 0) {
            console.log('nameCookie.length',nameCookie.length)  // 16
            console.log('cookie.length',cookie.length)          // 20
            console.log('cookieString',cookie)                  // hideSearchModal=true
            return  cookie.substring(nameCookie.length, cookie.length);
        }
    }
    return null;
}

현재 내 무신사 사이트내 쿠키만 37개인데 막말로 문자열 같은 쿠키 있을수도 있잖아!!!!!!

RentInsight _ Index 로 조회 성능 올리기 , MySql Profiling으로 병목 구간 측정

기돌 — Wed, 25 Feb 2026 22:01:04 +0900

EXPLAIN SELECT *
        FROM rent_complete
        WHERE sgg_cd = '11305' AND umd_nm = '미아동'
        AND area BETWEEN 25 AND 36;

type: ALL
- 데이터베이스가 '풀 테이블 스캔(Full Table Scan)'을 수행
- 의미: rent_complete 테이블의 처음부터 끝까지 모든 데이터를 하나하나 다 뒤져서 조건을 검사하고 있다는 뜻
possible_keys: <null>, key: <null>
- 이 검색 쿼리를 빠르게 만들어줄 '인덱스(색인)'가 아예 존재하지 않거나 사용되지 않고 있다
rows: 165,169
- 이 쿼리의 결과를 찾기 위해 DB 엔진이 약 16만 5천 건의 데이터를 읽어야 한다고 `예측` 하고 있다
filtered: 0.11
- 스캔한 16만 5천 건의 데이터 중, 실제 조건(미아동, 25~36㎡)에 맞는 데이터는 **단 0.11%**에 불과할 것이라고 예측하고 있다
Extra: Using where
- 스토리지 엔진에서 일단 데이터를 다 끌어올린 다음, MySQL 엔진 단에서 WHERE 조건을 걸어 불필요한 데이터를 버리고 있다는 의미입니다. (비 효율적이란다)

[현재 상태 : 심각한 병목(Bottleneck) 후보]
현재 16만 건 정도의 데이터에서는 0.1초 만에 결과가 나올 수도 있다. 하지만 현재 매일 데이터를 업데이트 하는중인데
전월세 데이터가 쌓여서 100만 건, 1,000만 건이 되면 어떻게 될까?
사용자가 검색 버튼을 딸깍 누를 때마다 DB는 1,000만 건을 다 뒤져야 하고 동시 접속자가 10명만 되어도 데이터베이스 CPU와 메모리가 폭주하여 서비스가 다운(장애)될 수 있는 매우 위험한 쿼리이다.
16만 건을 뒤져서 고작 0.11%의 진짜 데이터를 찾기 위해 99.89%의 헛고생을 하고 있는 상태인것이다

[해결책: 복합 인덱스(Composite Index) 생성] 이 문제를 해결하기 위해 반드시 인덱스(Index)를 만들어주어야 한다.

검색 조건이 sgg_cd = ? (동등 비교), umd_nm = ? (동등 비교), area BETWEEN ? AND ? (범위 검색) 이므로, 동등 비교를 먼저, 범위 검색을 나중에 두는 복합 인덱스를 생성하는 것이 맞다고 판단된다

인덱스 설정 기준

쿼리에서 자주 사용되는 컬럼
- WHERE , JOIN , ORDER 등등
카디널리티 (값의 분산도 또는 고유성) 수치가 높은 컬럼에 인덱스 설정
sgg_cd시군구 코드 같은경우 서울에 25개 구의 코드가 저장되므로 카더닐리티는 25
- 전체 데이터 수에 비하면 변별력이 충분하다고 생각되므로 인덱스 후보로 좋다
umd_nm 법정동 이름은 시군구 코드보다 더많으므로 인덱스 후보가된다
반대로 contract_type 계약 종류 같은경우 '신규' , '갱신' 두종류의 값만 있기에 인덱스를 걸면 전체의 절반을 스캔 해야해서 효과가 거의 없을것이다
sgg_cd + umn_nm 을 섞은 복합 인덱스를 후보로 보고있다

sgg_cd 단독 인덱스 , sgg_cd + umn_nm복합 인덱스 2개를 만들어서 사용하게 된다면
두개의 인덱스 모두 sgg_cd라는 정보를 중복해서 저장하고 있다

종로구 코드 와 종로구 코드 + 숭인동 이라는 정보를 모두 가지고 있으므로
두개의 인덱스 모두 종로구 라는 정보를
두번 저장되므로 디스크 공간을 더 많이 차지하게된다

(sgg_cd, umd_nm) 복합 인덱스 하나만 있어도 MySQL 옵티마이저는 WHERE sgg_cd = '...' 와 같은 쿼리가 들어왔을 때에 복합 인덱스의 첫 번째 부분(sgg_cd)만 사용해서 검색을 효율적으로 수행한다

추가로 area 컬럼또한 WHERE .... AND area BETWEEN 53 AND 66 으로 사용하기에 선택했다

SELECT
    -- 1. 고유 식별자
    COUNT(DISTINCT id) AS id_cardinality, -- 거의 전체 행 개수와 동일하게 나옴 (매우 높음)

    -- 2. 검색 조건으로 사용될 후보들
    COUNT(DISTINCT sgg_cd) AS sgg_cd_cardinality,          -- 시군구 코드 (중간 정도)
    COUNT(DISTINCT umd_nm) AS umd_nm_cardinality,          -- 법정동 이름 (비교적 높음)
    COUNT(DISTINCT name) AS name_cardinality,            -- 건물 이름 
    COUNT(DISTINCT area) AS area_cardinality,            -- 전용 면적 (매우 높음)
    COUNT(DISTINCT build_year) AS build_year_cardinality,  -- 건축 년도 

    -- 3. 범위 검색에 사용될 값들
    COUNT(DISTINCT deposit) AS deposit_cardinality,      -- 보증금 (매우 높음)
    COUNT(DISTINCT monthly_rent) AS monthly_rent_cardinality, -- 월세 (높음)

    -- 4. 카테고리성 정보 (카디널리티가 낮을 것으로 예상)
    COUNT(DISTINCT contract_type) AS contract_type_cardinality -- 계약 종류 (매우 낮음, 예: '신규', '갱신')
FROM
    rent_complete;

CREATE INDEX idx_rent_complete_sgg_umd_area ON rent_complete (sgg_cd, umd_nm, area);

type: range
- 데이터베이스가 ' 인덱스 범위 스캔 ' 을 수행
- 의미: rent_complete 테이블의 처음부터 끝까지 모든 데이터를 하나하나 다 뒤져서 조건을 검사하고 있다는 뜻
- WHERE 조건으로
  - sgg_cd = ? (동등 비교)
  - umd_nm = ? (동등 비교)
  - area BETWEEN ? AND ? (범위 검색)
possible_keys, key: idx_rent_complete_sgg_umd_area
- 실제로 만든 복합 인덱스가 사용되고 있다
- 풀테이블 스캔 X
rows: 43
- 이전에 풀 테이블 스캔 당시 16만 건을 읽어야 했지만 현재 43건만 탐색하면 된
filtered: 100
- 읽은 데이터 43건이 모두 조건에 만족한다
- 불필요한 데이터가 없다 , 인덱스에서 필터링이 되었
Extra: Using index condition
- InnoDB 스토리지 엔진 레벨에서 WHERE 조건 일부를 미리 필터링하고 있다
  - 인덱스 탐색
  - 인덱스에 포함된 컬럼으로 WHERE 조건 검사
  - 조건을 통과한 것만 실제 테이블에 접근

INDEX 미적용

[인덱스 적용 전 성능 지표]

평균 TPS (초당 처리량): 6,468.8 req/sec
평균 응답 시간: 15.21 ms
한계점: 동시 접속자 수가 99명을 초과하면 에러가 발생하며, 시스템이 더 이상 부하를 감당하지 못했음

INDEX 적용

	인덱스 적용 전	인덱스 적용 후	개선효과
평균 TPS	6,468.8	7,884.2	+21.9% (초당 1,415건 추가 처리)
최고 TPS	7,117.0	8,828.5	+24.0% (순간 최대 처리량 증가)
평균 응답시간	15.21 m s	12.46 ms	-18.1% (응답 속도 향상)

1. 처리 용량 (Throughput) 22% 증가
가장 큰 성과는 평균 TPS가 약 22% 증가한 것이다
동일한 하드웨어 자원으로 같은 시간 동안 22% 더 많은 사용자 요청을 처리할 수 있게 되었음을 의미한다.
풀 테이블 스캔으로 인한 불필요한 I/O 작업이 사라지면서, DB와 서버가 원래의 작업에 더 집중할 수 있게 되었다

2. 사용자 경험
평균 응답 시간이 18% 감소하면서, 사용자는 검색 시 더 빠르고 쾌적한 반응 속도를 체감할수 있을것이다

3. 안정성
99명이 한계였던 시스템이 이제는 더 높은 수인 150명까지 동시 접속을 에러 없이 처리할 수 있게 되었다
데이터가가 더 증가하더라도, 급격한 성능 저하 없이 안정적으로 서비스를 운영할 수 있을것 같다

가상 사용자 500명

에러 발생

Mysql Profiling

MySQL 엔진이 쿼리 하나를 실행하는 실제로 각 단계에서 얼마나 시간이 걸리는지 마이크로초 단위로 측정

show variables like '%profiling%';
set profiling=1;
set profiling_history_size=100;

SELECT *
FROM rent_complete
WHERE sgg_cd = '11215'
  AND umd_nm = '자양동'
  AND area BETWEEN 25 AND 36
order by contract_date DESC;

show profiles;  -- id : 18

-- 해당 쿼리문의 수행 시간을 더 상세한 단위로 확인
show profile for query 255;
show profile for query 344;

인덱스 적용 전: 0.076037 초 (약 76.0 ms)
인덱스 적용 후: 0.001675 초 (약 1.7 ms)

절대 시간 감소: 약 74.3 ms의 시간이 단축
- 성능 향상률: (0.076037 - 0.001675) / 0.076037 * 100 ≈ 97.8%
- 결론: 순수한 DB 쿼리 실행 속도가 약 98% 개선, 즉 약 45배 빨라졌다. (76.0 / 1.7 = 44.7058....

1. 저수준(Low-Level) 성능 분석의 필요성
nGrinder를 통한 부하 테스트는 API의 전체 응답 시간과 처리량을 측정하는 데 유용했다
하지만 실제 병목이 발생하는 데이터베이스 내부의 동작을 직접적으로 보여주지는 못한다.
쿼리 성능 개선 효과를 명확하게 증명하기 위해, MySQL의 내장 기능인 Profiling 을 사용하여 순수 SQL 실행 시간을
마이크로초 단위로 측정

2. Profiling을 통한 병목 구간 측정
인덱스 적용 전, WHERE 절에 여러 조건이 포함된 검색 쿼리의 프로파일을 분석한 결과, 총 실행 시간은 약 76ms가 소요
프로파일 상세 내역을 보면 executing 같은 실제 데이터에 접근하여 WHERE 을 필터링하고 , 데이터를 가져오고 , 정렬하는 등
쿼리의 가장 중요한 부분을 수행하는데 시간이 차이 가 많이난다
풀 테이블 스캔(Full Table Scan) 으로 인한 전형적인 성능 저하 패턴이다

3. 인덱스 적용 후 성능 측정
검색 조건에 최적화된 (sgg_cd, umd_nm, area) 복합 인덱스를 생성한 후, 동일한 쿼리에 대해 다시 프로파일링을 실행

45배의 성능 향상 그 의미는?
프로파일링 결과 순수 DB 쿼리 실행 시간이 76ms에서 1.7ms로 단축되어, 약 45배의 폭발적인 성능 향상을 이루었다
nGrinder 테스트에서 TPS가 22% 향상된 것의 근본적인 원인이 바로 이 쿼리 자체의 최적화에 있음을 명확하게 증명한다.
인덱스는 불필요한 디스크 I/O를 제거하고 MySQL이 필요한 데이터에 직접 접근하도록 유도하고 DB 엔진의 부하를 줄였다

이런 최적화는 단순히 단일 쿼리를 빠르게 만드는 것을 넘어 제한된 DB 서버 자원으로 더 많은 동시 요청을 처리할 수 있게 만들어주고 전체 서비스의 처리 용량과 안정성 향상으로 직결된다

다시 돌아온 페이징처리 SpringBoot + MyBatis // Pageable XX

기돌 — Mon, 23 Feb 2026 23:13:28 +0900

RentCompleteSearchDTO 이름을 RentSearchConditionDTO로 변경해야하는데 수정할곳이 많아서 그냥두기로함

1. 검색 조건을 담을 DTO

HTML 에서 Controller 로 검색 조건들을 전달하기 위해 필요하다

@Getter
@Setter
public class RentCompleteSearchDTO {
    private String sggCd;       // 시군구 코드
    private String umdNm;       // 법정동 이름
    private String name;        // 건물명
    private Integer minDeposit; // 최소 보증금
    private Integer maxDeposit; // 최대 보증금
    private Integer minRent;    // 최소 월세
    private Integer maxRent;    // 최대 월세
}

2. 페이징 계산 처리해줄 DTO

총 데이터 갯수와 , 현재 페이지 번호를 알려주면 SQL 쿼리와 UI 에 필요한 모든 값 ( offset , beginPage, endPage 등등)
자동 계산해준다

package com.realestate.rent_insight.dto;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class RentPaginationDTO {

    //  페이징 계산 담당일찐


    // 입력 받는 값
    private int totalRows;    // DB내의 전체 데이터        -- 쿼리타면 여기에 갯수 들어감
    private int currentPage;  // 사용자가 요청한 페이지 번호 --  URL의 ?page=1


    // 기본 설정 값
    private int rows = 30;    // 페이지당  계약건수 갯수
    private int pages = 5;    // 페이지네이션 바에 보여줄 페이지 갯수 (1 2 3 4 5)


    // 계산되어야하는 값
    private int totalPages;
    private int totalBlocks;
    private int currentBlock;   // 현재 페이지가 속한 블록 번호
    private int beginPage;      // 현재 블록 시작 페이지
    private int endPage;        // 현재 블록 끝 페이지

    private int offset;         // SQL 쿼리에 사용할 offset 값

    // 현재  첫번째 페이지 ,마지막 페이지 구분
    private boolean isFirst;
    private boolean isLast;

    public RentPaginationDTO() {
    }

    public RentPaginationDTO(int currentPage, int totalRows) {
        this.currentPage = currentPage;
        this.totalRows = totalRows;
        // 객체가 생성되면서 모든 페이징 값 계산 해버리기
        init();
    }

    private void init() {

        // 글이 존재하는지
        if (totalRows > 0) {
            // 전체 페이지 갯수 계산하기
            totalPages = (int) Math.ceil((double) totalRows / rows);    // 3000개 데이터 /  30행 = totalPages= 100개

            // (현재페이지 번호 -1) * 한 페이지당 보여줄 데이터
            offset = (currentPage - 1) * rows;

            // 페이징 바 계산기
            totalBlocks = (int)Math.ceil((double) totalPages / pages);
            currentBlock = (int) Math.ceil((double) currentPage / pages);
            beginPage = (currentBlock - 1) * pages + 1;
            endPage = currentBlock * pages;

            // 마지막 블럭의 끝 페이지 번호 - 총 12페이지일 때 3번째 블록(11, 12)의 끝 페이지는 15가 아니라 12가 되어야 함
            if (currentBlock == totalBlocks) {
                endPage = totalPages;
            }
            // 혹시 모를 상황 대비: endPage가 totalPages를 넘지 않도록
            if (endPage > totalPages) {
                endPage = totalPages;
            }
            isFirst = (currentPage == 1);
            isLast = (currentPage == totalPages);
        }
    }


}

3. 최종결과를 담아줄 DTO

화면으로 보낼 결과물은 데이터목록 + 페이징 정보 두가지다
이것을 처리할 DTO

package com.realestate.rent_insight.dto;

import lombok.Getter;

import java.util.List;

@Getter
public class RentPaginationResultDTO<T> {

    private List<T> list;
    private RentPaginationDTO rentPaginationDTO;        // init() 계산끝난 페이징 정보객체

    public RentPaginationResultDTO(List<T> list, RentPaginationDTO rentPaginationDTO) {
        this.list = list;
        this.rentPaginationDTO = rentPaginationDTO;
    }
}

4. 데이터베이스에 실제 SQL 명력을 내릴 Mapper

@Param : 여러 개의 파라미터를 XML에 전달할 때 각각의 파라미터에 이름표 를 붙여준다

package com.realestate.rent_insight.domain.mapper;

import com.realestate.rent_insight.domain.entity.RentComplete;
import com.realestate.rent_insight.dto.RentCompleteSearchDTO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * resources/mappers/RentCompleteMapper.xml 파일에 정의된 SQL 쿼리 연결
 */
@Mapper
public interface RentCompleteMapper {

    List<RentComplete> findByComplexConditions(
            @Param("searchDto") RentCompleteSearchDTO searchDto,
            @Param("limit") int limit,
            @Param("offset") int offset);


    int countByComplexConditions(@Param("searchDto") RentCompleteSearchDTO searchDto);
}

5. 실제 실행될 SQL 쿼리 작성

<sql> 태그 를 사용하여 중복되는 WHERE 절 분리 (사실 같은거 길어서 꼴보기 싫었음)
<if> 태그 검색 조건 (searchDto) 에 값이 있을때만 AND 조건 동적으로 추가한다

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.realestate.rent_insight.domain.mapper.RentCompleteMapper">

    <select id="findByComplexConditions"
            resultType="com.realestate.rent_insight.domain.entity.RentComplete">
        SELECT
            id,                             -- 계약 고유번호
            contract_date AS contractDate,  -- 계약일
            sgg_cd AS sggCd,                -- 시군구 코드
            sgg_nm AS sggNm,                -- 시군구 이름
            umd_nm AS umdNm,                -- 법정동 이름
            jibun,                          -- 지번 주소
            name,                           -- 오피스텔 단지명
            deposit,                        -- 보증금
            monthly_rent AS monthlyRent,    -- 월세
            area,                           -- 전용 면적
            build_year AS buildYear,        -- 건축 년도
            floor,                          -- 층수
            contract_term AS contractTerm,  -- 계약 기간
            contract_type AS contractType   -- 계약 종류 (신규/갱신)
        FROM
            rent_complete
        <include refid="whereCondition"></include>
        ORDER BY contract_date DESC
        LIMIT #{limit} OFFSET #{offset}
    </select>

    <sql id="whereCondition">
        <where>
            <if test="searchDto.sggCd != null and searchDto.sggCd != ''">
                AND sgg_cd = SUBSTRING(#{searchDto.sggCd}, 1, 5)
            </if>
            <if test="searchDto.umdNm != null and searchDto.umdNm != ''">
                AND umd_nm = #{searchDto.umdNm}
            </if>
            <if test="searchDto.name != null and searchDto.name != ''">
                AND name LIKE CONCAT('%', #{searchDto.name}, '%')
            </if>
            <if test="searchDto.minDeposit != null and searchDto.maxDeposit != null">
                AND deposit BETWEEN #{searchDto.minDeposit} AND #{searchDto.maxDeposit}
            </if>
            <if test="searchDto.minRent != null and searchDto.maxRent != null">
                AND monthly_rent BETWEEN #{searchDto.minRent} AND #{searchDto.maxRent}
            </if>
        </where>
    </sql>

    <select id="countByComplexConditions" resultType="int">
        SELECT COUNT(*)
        FROM rent_complete
        <include refid="whereCondition" />
    </select>

</mapper>

6. 비즈니스 로직 처리 - 페이징 처리 모든 과정을 순서대로 사용한다고 보면된다

package com.realestate.rent_insight.service;

import com.realestate.rent_insight.domain.entity.RentComplete;
import com.realestate.rent_insight.domain.mapper.RentCompleteMapper;
import com.realestate.rent_insight.dto.RentCompleteSearchDTO;
import com.realestate.rent_insight.dto.RentPaginationDTO;
import com.realestate.rent_insight.dto.RentPaginationResultDTO;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 전월세 계약 정보를 검색기능
 * MyBatis 매퍼를 사용하여 복합적인 조건의 검색
 */
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true) // 기본적으로 읽기 전용 트랜잭션으로 실행
public class RentCompleteSearchService {

    private final RentCompleteMapper rentCompleteMapper;

    public RentPaginationResultDTO<RentComplete> searchRent(RentCompleteSearchDTO rentCompleteSearchDTO, int page) {
        int totalRows = rentCompleteMapper.countByComplexConditions(rentCompleteSearchDTO);
        RentPaginationDTO rentPaginationDTO = new RentPaginationDTO(page,totalRows);

        List<RentComplete> list = rentCompleteMapper.findByComplexConditions(
                rentCompleteSearchDTO,
                rentPaginationDTO.getRows(),
                rentPaginationDTO.getOffset()
        );
        return new RentPaginationResultDTO<>(list, rentPaginationDTO);
    }


}

7. 웹에서 사용자가 요청을 주면 , 서비스에게 일시키고 그 결과를 화면에 전달만 하는 컨트롤러

최종결과를 Model 에 담아 HTML 파일에 보냄

package com.realestate.rent_insight.controller;

import com.realestate.rent_insight.domain.entity.DataUpdateLog;
import com.realestate.rent_insight.domain.entity.Region;
import com.realestate.rent_insight.domain.entity.RentComplete;
import com.realestate.rent_insight.domain.repository.DataUpdateLogRepository;
import com.realestate.rent_insight.dto.RentCompleteSearchDTO;
import com.realestate.rent_insight.dto.RentPaginationResultDTO;
import com.realestate.rent_insight.service.RegionService;//import com.realestate.rent_insight.service.RentSearchService;

import com.realestate.rent_insight.service.RentCompleteSearchService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.List;
import java.util.Optional;

@Controller
@RequiredArgsConstructor
@RequestMapping("/rent")
public class RentSearchController {

    private final RentCompleteSearchService rentCompleteSearchService;
    private final RegionService regionService;
    private final DataUpdateLogRepository dataUpdateLogRepository;

    @GetMapping("/search")
    public String searchForm(@ModelAttribute("searchDto") RentCompleteSearchDTO rentCompleteSearchDTO,
                             @RequestParam(value ="page" , defaultValue = "1") int page,
                             Model model) {
        // 1. RegionService를 사용하여 시군구 목록(코드, 이름 포함)을 조회
        List<Region> sigunguList = regionService.getSigunguList();
        model.addAttribute("sigunguList", sigunguList);

        // 2. 서비스 계층을 호출하여 검색 조건에 맞는 데이터를 조회
        RentPaginationResultDTO rentSearchResult = rentCompleteSearchService.searchRent(rentCompleteSearchDTO,page);
        model.addAttribute("rentSearchResult", rentSearchResult);

        // 3. SUCCESS 로그 조회
        Optional<DataUpdateLog> lastLog = dataUpdateLogRepository.findFirstByStatusOrderByIdDesc("SUCCESS");
        if(lastLog.isPresent()) {
            DataUpdateLog log = lastLog.get();
            model.addAttribute("lastLog", log.getCompletionTime());
        }

        // 4. 뷰
        return "rent/search";
    }

}

<!-- 페이지네이션 UI -->
<div class="card-footer bg-white" th:if="${rentSearchResult.rentPaginationDTO.totalRows > 0}">
    <nav aria-label="Page navigation">
        <ul class="pagination justify-content-center mb-0">
            <!-- '처음' 버튼 -->
            <li class="page-item" th:classappend="${rentSearchResult.rentPaginationDTO.first} ? 'disabled'">
                <a th:if="${!rentSearchResult.rentPaginationDTO.first}" class="page-link" th:href="@{/rent/search(page=1, sggCd=${searchDto.sggCd}, umdNm=${searchDto.umdNm}, name=${searchDto.name}, minDeposit=${searchDto.minDeposit}, maxDeposit=${searchDto.maxDeposit}, minRent=${searchDto.minRent}, maxRent=${searchDto.maxRent})}">&laquo;</a>
                <span th:if="${rentSearchResult.rentPaginationDTO.first}" class="page-link">&laquo;</span>
            </li>
            <!-- '이전' 버튼 -->
            <li class="page-item" th:classappend="${rentSearchResult.rentPaginationDTO.currentPage == 1} ? 'disabled'">
                <a th:if="${rentSearchResult.rentPaginationDTO.currentPage > 1}" class="page-link" th:href="@{/rent/search(page=${rentSearchResult.rentPaginationDTO.currentPage - 1}, sggCd=${searchDto.sggCd}, umdNm=${searchDto.umdNm}, name=${searchDto.name}, minDeposit=${searchDto.minDeposit}, maxDeposit=${searchDto.maxDeposit}, minRent=${searchDto.minRent}, maxRent=${searchDto.maxRent})}">&lt;</a>
                <span th:if="${rentSearchResult.rentPaginationDTO.currentPage == 1}" class="page-link">&lt;</span>
            </li>
            <!-- 페이지 번호 버튼 -->
            <li th:each="pageNumber : ${#numbers.sequence(rentSearchResult.rentPaginationDTO.beginPage, rentSearchResult.rentPaginationDTO.endPage)}" class="page-item" th:classappend="${pageNumber == rentSearchResult.rentPaginationDTO.currentPage} ? 'active'">
                <a class="page-link" th:href="@{/rent/search(page=${pageNumber}, sggCd=${searchDto.sggCd}, umdNm=${searchDto.umdNm}, name=${searchDto.name}, minDeposit=${searchDto.minDeposit}, maxDeposit=${searchDto.maxDeposit}, minRent=${searchDto.minRent}, maxRent=${searchDto.maxRent})}" th:text="${pageNumber}">1</a>
            </li>
            <!-- '다음' 버튼 -->
            <li class="page-item" th:classappend="${rentSearchResult.rentPaginationDTO.currentPage == rentSearchResult.rentPaginationDTO.totalPages} ? 'disabled'">
                <a th:if="${rentSearchResult.rentPaginationDTO.currentPage < rentSearchResult.rentPaginationDTO.totalPages}" class="page-link" th:href="@{/rent/search(page=${rentSearchResult.rentPaginationDTO.currentPage + 1}, sggCd=${searchDto.sggCd}, umdNm=${searchDto.umdNm}, name=${searchDto.name}, minDeposit=${searchDto.minDeposit}, maxDeposit=${searchDto.maxDeposit}, minRent=${searchDto.minRent}, maxRent=${searchDto.maxRent})}">&gt;</a>
                <span th:if="${rentSearchResult.rentPaginationDTO.currentPage == rentSearchResult.rentPaginationDTO.totalPages}" class="page-link">&gt;</span>
            </li>
            <!-- '마지막' 버튼 -->
            <li class="page-item" th:classappend="${rentSearchResult.rentPaginationDTO.last} ? 'disabled'">
                <a th:if="${!rentSearchResult.rentPaginationDTO.last}" class="page-link" th:href="@{/rent/search(page=${rentSearchResult.rentPaginationDTO.totalPages}, sggCd=${searchDto.sggCd}, umdNm=${searchDto.umdNm}, name=${searchDto.name}, minDeposit=${searchDto.minDeposit}, maxDeposit=${searchDto.maxDeposit}, minRent=${searchDto.minRent}, maxRent=${searchDto.maxRent})}">&raquo;</a>
                <span th:if="${rentSearchResult.rentPaginationDTO.last}" class="page-link">&raquo;</span>
            </li>
        </ul>
    </nav>
</div>

Spring Security 로그인 실패 시 에러메세지 SimpleUrlAuthenticationFailureHandler

기돌 — Mon, 23 Feb 2026 18:41:37 +0900

로그인과 회원가입 기능을 Security로 구현했지만 로그인에 실패하면 사용자 로그인이 왜 안되는지 알수 없다
로그인에 실패할 경우 사용자에게 안내 문구를 제공해 왜 로그인이 되지 않는지 명확히 알려주는 것이 필요하다고 생각했다

아무런 실패 처리가 되어있지 않고 있는 상태

  @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .csrf(csrf -> csrf.disable())
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/", "/css/**", "/js/**", "/images/**", "/members/login", "/members/join").permitAll()
                        .requestMatchers("/members/mypage").authenticated()
                        .anyRequest().authenticated()
                )
                // 폼 기반 로그인 설정
                .formLogin(form -> form
                        .loginPage("/members/login")
                        .loginProcessingUrl("/members/login")
                        .usernameParameter("email")
                        .defaultSuccessUrl("/", true) // 로그인 성공 시 항상 메인 페이지로 이동
                        .permitAll() // 로그인 페이지 자체는 누구나 접근 가능
                )
                // 로그아웃 설정
                .logout(logout -> logout
                        .logoutUrl("/members/logout") // 로그아웃을 처리할 URL
                        .logoutSuccessUrl("/") // 로그아웃 성공 후 리다이렉트될 URL
                        .invalidateHttpSession(true) // 세션 무효화
                        .deleteCookies("JSESSIONID") // 쿠키 삭제
                );

        return http.build();
    }

failureHandler()

failureHandler() 메서드는 추가해야 예외를 캐치할수 있다
파라미터로 AuthenticationFailureHandler 인터페이스 구현체를 받는다고 한다

예외 처리를 위한 핸들러 - LoginFailHandler

로그인 실패에 대해서 관리하는 핸들러 AuthenticationFailureHandler 인터페이스를 구현함

AuthenticationFailureHandler 인터페이스를 구현해야한다
AuthenticationFailureHandler 인터페이스를 구현한 구현체인 SimpleUrlAuthenticationFailureHandler

public interface AuthenticationFailureHandler {

	/**
	 * Called when an authentication attempt fails.
	 * @param request the request during which the authentication attempt occurred.
	 * @param response the response.
	 * @param exception the exception which was thrown to reject the authentication
	 * request.
	 */
	void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
			AuthenticationException exception) throws IOException, ServletException;

}

@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
        AuthenticationException exception) throws IOException, ServletException {
    if (this.defaultFailureUrl == null) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Sending 401 Unauthorized error since no failure URL is set");
        }
        else {
            this.logger.debug("Sending 401 Unauthorized error");
        }
        response.sendError(HttpStatus.UNAUTHORIZED.value(), HttpStatus.UNAUTHORIZED.getReasonPhrase());
        return;
    }
    saveException(request, exception);
    if (this.forwardToDestination) {
        this.logger.debug("Forwarding to " + this.defaultFailureUrl);
        request.getRequestDispatcher(this.defaultFailureUrl).forward(request, response);
    }
    else {
        this.redirectStrategy.sendRedirect(request, response, this.defaultFailureUrl);
    }
}

public void setDefaultFailureUrl(String defaultFailureUrl) {
    Assert.isTrue(UrlUtils.isValidRedirectUrl(defaultFailureUrl),
            () -> "'" + defaultFailureUrl + "' is not a valid redirect URL");
    this.defaultFailureUrl = defaultFailureUrl;
}

SimpleUrlAuthenticationFailureHandler 를 사용한 EU
- setDefaultFailureUrl () 를 사용하기 위함
  - 로그인 실패시 URL 을 지정 해준다
onAuthenticationFailure 메서드를 오버라이딩해서 예외처리 , 에러메시지를 띄운다
한글 인코딩 깨지는 것을 방지 하기위해 UTF-8 처리 . URLEncoder.encode(errorMessage, "UTF-8");

@Configuration
public class LoginFailHandler extends SimpleUrlAuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        String errorMessage = null;

        if (exception instanceof BadCredentialsException) {
            errorMessage = "아이디와 비밀번호를 확인해주세요.";
        } else if (exception instanceof InternalAuthenticationServiceException) {
            errorMessage = "내부 시스템 문제로 로그인할 수 없습니다. 관리자에게 문의하세요.";
        } else if (exception instanceof UsernameNotFoundException) {
            errorMessage = "존재하지 않는 계정입니다.";
        } else {
            errorMessage = "알 수없는 오류입니다.";
        }

        errorMessage = URLEncoder.encode(errorMessage, "UTF-8");
        setDefaultFailureUrl("/members/login?error=" + errorMessage);
        super.onAuthenticationFailure(request, response, exception);

    }
}

super.onAuthenticationFailure(request, response, exception);

실제 동작을 수행하는 부분 부모 클래스인 SimpleUrlAuthenticationFailureHandler의 기본 동작을 그대로 호출

  this.redirectStrategy.sendRedirect(request, response, this.defaultFailureUrl);

주소(defaultFailureUrl)로, 사용자에게 리다이렉트
RedirectStrategy 는 브라우저에게 defaultFailureUrl로 재접속하라는 명령을 내린다

LoginFailHandler는 defaultFailureUrl을 /members/login?error=에러메시지로 설정
super.onAuthenticationFailure(...)를 호출했음
1, 2, 3단계를 모두 건너뛰고, 마지막 4단계에 도달하여, 우리가 설정한 바로 그 URL로 리다이렉트를 실행시킨 것이다

위에서 말한대로

setDefaultFailureUrl() 사용 → 로그인 실패 시, 다음에 이동할 URL은 /members/login?error=에러메시지
onAuthenticationFailure() 오버라이딩
URLEncoder.encode(errorMessage, "UTF-8"); 사용 완료

@Bean
public LoginFailHandler loginFailHandler() {
    return new LoginFailHandler();
}




// 폼 기반 로그인 설정
.formLogin(form -> form
        .loginPage("/members/login")
        .loginProcessingUrl("/members/login")
        .failureHandler(loginFailHandler())		// 로그인 실패
        .usernameParameter("email")
        .defaultSuccessUrl("/", true) // 로그인 성공 시 항상 메인 페이지로 이동
        .permitAll() // 로그인 페이지 자체는 누구나 접근 가능
)

<form th:action="@{/members/login}" method="post" th:object="${memberDTO}">
    <!-- 로그인 실패 시 에러 메시지 표시 -->
    <div th:if="${param.error}" class="alert alert-danger" th:text="${param.error}" role="alert">
        에러 메시지 표시
    </div>
</form>

param : 타임리프가 제공하는 객체
error : setDefaultFailureUrl("/members/login?error=" + errorMessage); 에서 가져온 error

Spring Security 로그인 / 로그아웃

기돌 — Sun, 22 Feb 2026 19:58:50 +0900

과거 : 직접 세션을 다루는 로그인

   @PostMapping("/login")
    public String loginComplete(@Valid @ModelAttribute MemberDTO memberDTO,BindingResult bindingResult,HttpServletRequest request) {
        // DTO에서 정의한 입력값 검증하기
        if (bindingResult.hasErrors()) {
            return "login"; // login.html
        }

        // memberService에서 login 메서드 호출
        Member loginMember = memberService.login(memberDTO.getEmail(), memberDTO.getPassword());


        // 로그인 실패 처리 - 아이디 공백 , 비밀번호 틀릴경우
        if (loginMember == null) {
            bindingResult.reject("loginFail", "아이디 또는 비밀번호가 맞지 않습니다.");
            log.warn("로그인 실패 : {} ,{}",memberDTO.getEmail(),memberDTO.getPassword());
            return "login";
        }

        // 로그인 성공 (세션 생성)
        HttpSession session = request.getSession();
        session.setAttribute("loginMember", loginMember);

        return "redirect:/";
    }
    
        // 로그아웃
    @PostMapping("/logout")
    public String logout(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session != null) {
            session.invalidate();
        }
        return "redirect:/";

    }

<!-- 로그인하지 않은 경우 -->
<th:block th:if="${session.loginMember == null}">
    <a th:href="@{/members/login}">로그인</a>
</th:block>

<!-- 로그인한 경우 -->
<th:block th:if="${session.loginMember != null}">
    <form th:action="@{/members/logout}" method="post">
        <button type="submit">로그아웃</button>
    </form>
</th:block>

로그인 : POST /members/login 요청은 Spring Security 가 가로채기에 MemberService 에서 loadUserByUserName을 통해 인증을 처리한다
로그아웃 : POST /members/logout 요청은 Spring Security가 세션을 무효화 하고 쿠키 삭제를 해서 처리해준다
상태확인 : HTML 에서 sec:authorize을 통해 컨트롤러 도움없이 로그인 상태를 확인할 수있다

Spring Security에게 모든 것을 위임해버리기

implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'

<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security">

UserDetails와 UserDetailsService

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class) // 생성일/수정일 자동 관리
@Entity // JPA가 관리하는 엔티티가됨
@Getter // getter 필드 값 가져오기
@Table(name = "member") // 테이블 이름을 명시적으로 지정
public class Member implements UserDetails { // Java에는 Member 객체있음 , DB에는 member 라는 테이블 있음 이걸 1:1 매핑해주는 Entity
    // UserDetails 상속받아서 인증객체로 사용


    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 내가 건들이지 않고 DB가 알아서 증가시킴
    private Long id;        // 회원 고유 ID

    @Column(nullable = false, unique = true)        // 중복 불가
    private String email;   // 이메일 (로그인 ID)

    @Column(nullable = false)
    private String password;

    private String name;

    @Column(nullable = false, unique = true)
    private String nickname;    // 사용자 커뮤니티나 마이정보에서 사용할 닉네임

    // 나중에 카카오 로그인을 위해 미리 만들어둠 "google", "kakao", "naver" 등
    private String provider;

    // 사용자인지 , 관리자인지 구분 - 기본 회원가입시 사용자 default값 설정
    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 10)
    private MemberRole memberRole;

    // 등록일
    @CreatedDate
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;

    // 수정일
    @LastModifiedDate
    private LocalDateTime updatedAt;


    @Builder
    public Member(String email, String password, String name, String nickname, String provider, MemberRole memberRole) {
        this.email = email;
        this.password = password;
        this.name = name;
        this.nickname = nickname;
        this.provider = provider;
        this.memberRole = memberRole;
    }

    @Builder
    public Member(String email, String password) {
        this.email = email;
        this.password = password;
    }

    // 권한반환
    @Override
    @NonNull
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(new SimpleGrantedAuthority("ROLE_"+ memberRole.name()));
    }

    // 사용자의 id를 반환 - 고유한값
    @Override
    @NonNull
    public String getUsername() {
        return this.email;
    }

    // 계정이 만료되었는지 확인
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    // 계정이 잠금되어있는 지 확인
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    // 패스워드 만료 확인
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    // 계정 사용 여부 확인
    @Override
    public boolean isEnabled() {
        return true;
    }
}

@Service
@RequiredArgsConstructor 
@Transactional(readOnly = true) /
public class MemberService implements UserDetailsService {

    private final MemberRepository memberRepository;
    // 비밀번호를 암호화하기 위한 도구 (SecurityConfig에 만들어둠)
    private final PasswordEncoder passwordEncoder;


    @NonNull
    @Override
    public UserDetails loadUserByUsername(@NonNull String email) {
        return memberRepository.findByEmail(email)
                .orElseThrow(() -> new UsernameNotFoundException("해당하는 이메일을 찾을 수 없습니다 : " + email));
    }

SecurityConfig를 설정하여, 로그인/로그아웃 절차를 구체적으로 지시

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // http 객체를 사용하여 메서드 체이닝 방식으로 보안 설정을 구성합니다.
        http
                .csrf(csrf -> csrf.disable())
                .authorizeHttpRequests(authorize -> authorize
                        .requestMatchers("/", "/css/**", "/js/**", "/images/**", "/members/login", "/members/join").permitAll()
                        .requestMatchers("/members/mypage").authenticated()
                        // 그외 페이지는 인증 요구할꺼임
                        .anyRequest().authenticated()
                )
                // 폼 기반 로그인 설정
                .formLogin(form -> form
                        .loginPage("/members/login") // 로그인 페이지 URL GET
                        .loginProcessingUrl("/members/login") // 로그인 처리 URL POST
                        .usernameParameter("email")
                        .defaultSuccessUrl("/", true) // 로그인 성공 시 항상 메인 페이지로 이동
                        .permitAll() // 로그인 페이지 자체는 누구나 접근 가능
                )
                // 로그아웃 설정
                .logout(logout -> logout
                        .logoutUrl("/members/logout") // 로그아웃을 처리할 URL
                        .logoutSuccessUrl("/") // 로그아웃 성공 후 리다이렉트될 URL
                        .invalidateHttpSession(true) // 세션 무효화
                        .deleteCookies("JSESSIONID") // 쿠키 삭제
                );

        return http.build();
    }



}

.loginPage("/members/login")

컨트롤러의 GET 요청과 매핑이라고 생각하면된다

.loginProcessingUrl("/members/login")

Security 가 POST 요청을 보고 , 중간에 가로채서 MemberSerivce 안에 있는 loadUserByUserName 을 호출
컨트롤러 XXX
.loginProcessingUrl()에 설정된 URL은 Spring Security의 인증 필터를 깨우는 '가상의' 주소

설정	목적	HTTP 메서드	매핑 대상	컨트롤러에 메서드 필요한가
.loginPage()	로그인 화면 보기	GET	MemberController	O
.loginProcessingUrl()	로그인 정보 제출/처리	POST	Spring Security	X

<!-- 로그인하지 않은 경우 -->
<!-- sec:isAnonymous() : 현재 사용자가 익명(비로그인) 상태인지 확인 -->
<th:block sec:authorize="isAnonymous()">
    <li class="nav-item ms-2">
        <a class="btn btn-outline-light btn-sm" th:href="@{/members/login}">로그인</a>
    </li>
    <li class="nav-item ms-2">
        <a class="btn btn-primary btn-sm" th:href="@{/members/join}">회원가입</a>
    </li>
</th:block>

<!-- 로그인한 경우 -->
<!-- sec:isAuthenticated() : 현재 사용자가 인증(로그인)된 상태인지 확인 -->
<th:block sec:authorize="isAuthenticated()">
    <li class="nav-item">
        <!-- sec:authentication="name" : 현재 인증된 사용자의 이름을 표시 -->
        <span class="nav-link text-white">환영합니다 <span sec:authentication="principal.nickname"></span>님</span>
    </li>
    <li class="nav-item ms-2">
        <form th:action="@{/members/logout}" method="post" class="d-inline">
            <button type="submit" class="btn btn-outline-light btn-sm">로그아웃</button>
        </form>
    </li>
</th:block>

[Jackson] API 필드명 @JsonProperty .araboja

기돌 — Sat, 21 Feb 2026 22:31:45 +0900

외부 API를 연동하거나 JSON/XML 데이터를 다룰 때 '필드 이름 불일치' 문제를 해결해준다

필드 다 만들었는데, 왜 데이터가 안 들어오는거지 ?

SpringBoot로 이번 사이드 프로젝트를 개발하면서 RestTemplate 으로 외부 API를 호출하고 그 결과를 DTO 로 변환했다.
그런데 API 응답 데이터의 필드 이름과 내 DTO의 필드 이름이 미묘하게 달라서 데이터가 매핑되지 않고 null 값만 들어왔다

API는 user_id라고 주는데 내 DTO에는 Java 스타일인 userId라고 선언하거나
API가 offiNm처럼 알기 어려운 줄임말 ? 축약어 ? 를 사용하고 있을 때 문제가 발생한다

@JsonProperty , 데이터와 객체를 이어준다

"데이터(JSON/XML)의 필드 이름(Key)과 Java 객체의 필드 이름이 서로 다를 때, 이 둘을 정확하게 연결해주는 '매핑(Mapping) 정보' 역할을 합니다."

@JsonProperty 이럴 때 사용하자

명명 규칙(Naming Convention)이 다를 때
데이터 형식과 프로그래밍 언어는 각자 선호하는 명명 규칙이 다르다
- JSON/XML: snake_case (user_id), kebab-case (user-id) 등
  Java: camelCase (userId)
  이럴 때 @JsonProperty를 사용하면 나만의 Java 코딩 스타일을 해치지 않으면서 데이터를 매핑할 수 있다

public class UserDto {
    // JSON의 "user_id"를 Java의 "userId" 필드에 매핑
    @JsonProperty("user_id")
    private String userId;

    // JSON의 "user_name"을 Java의 "userName" 필드에 매핑
    @JsonProperty("user_name")
    private String userName;
}

2. API의 필드 이름이 모호하거나 마음에 안 들 때
- 개인 프로젝트 rent-insight 에서 겪었던 문제다
- 공공데이터 API는 그들만의 기준으로 필드 이름을 제공한다
- excluUseAr: "전용 면적"이라는 뜻이지만, 처음 봤을때 이게 뭔가 ? 싶어서 API 문서를 까봤다
- offiNm: "오피스텔 이름"이라는 뜻이지만, 너무 축약되어 가독성이 떨어졌다

// ApiRentDTO.java의 일부

// API의 모호한 'excluUseAr'를 'area'로 사용
@JsonProperty("excluUseAr")
private double area; // 전용면적

// API의 축약된 'offiNm'을 'name'으로 사용
@JsonProperty("offiNm")
private String name; // 오피스텔 이름

3. 필드 이름으로 사용할 수 없는 문자가 포함될 때
JSON의 key는 문자열이므로 하이픈(-)이나 공백을 포함할 수 있지만, Java의 변수 이름은 사용불가
@JsonProperty는 이럴 때 사용하자

public class ProductDto {
    @JsonProperty("product-id")
    private String productId;

    @JsonProperty("stock count")
    private int stockCount;
}

rent-insight 프로젝트에서 공공데이터 API 응답을 받기 위해 만든 ApiRentDTO는 @JsonProperty 를 잘 써먹었다

@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class ApiRentDTO {

    @JsonProperty("buildYear")
    private Integer buildYear;

    // API의 'excluUseAr' ->'area'
    @JsonProperty("excluUseAr")
    private double area;

    // API의 'offiNm' -> 'name'
    @JsonProperty("offiNm")
    private String name;

    // API 응답에서 "18,000" 처럼 쉼표가 포함된 문자열로 오기 때문에
    // 일단 String으로 받은 뒤, 나중에 서비스 계층에서 숫자로 가공함
    @JsonProperty("deposit")
    private String deposit;

    @JsonProperty("monthlyRent")
    private String monthlyRent;

    // --- 나머지 필드들 ---
    @JsonProperty("contractTerm")
    private String contractTerm;

    @JsonProperty("contractType")
    private String contractType;

    @JsonProperty("dealDay")
    private Integer dealDay;

    @JsonProperty("dealMonth")
    private Integer dealMonth;

    @JsonProperty("dealYear")
    private Integer dealYear;

    @JsonProperty("floor")
    private Integer floor;

    @JsonProperty("jibun")
    private String jibun;

    @JsonProperty("sggCd")
    private String sggCd;

    @JsonProperty("sggNm")
    private String sggNm;

    @JsonProperty("umdNm")
    private String umdNm;

    @JsonProperty("preDeposit")
    private String preDeposit;

	// 여기도 하려했는데 귀찮음
    @JsonProperty("useRRRight")
    private String useRRRight;
}

가독성 향상: 내 코드에서는 내가 스스로 이해하기 쉽게 개발 할수 있다
유연성 확보: 외부 API의 필드명이 변경되더라도, DTO의 @JsonProperty 값만 수정하면 되므로 유지보수가 굿

Spring Security와 BCrypt 해싱

기돌 — Wed, 4 Feb 2026 21:25:55 +0900

사이드 프로젝트를 진행하면서 입력한 비밀번호 값이 데이터베이스에 화끈하게 다 보이고있는 상태다

암호화 되지 않은 야생의 비밀번호 그 자체이기 때문에 데이터베이스를 누군가 탈취한다면 비밀번호가 그대로 저장되어있어
DB가 유출된다면 모든 사용자의 비밀번호가 유출되는 상황이 올수 있다

(과거 프로젝트 만들면서 DB 접속 호스트랑 비밀번호를 깃허브에 올려서 화끈하게 해킹 당한적이있음)

자바 스프링을 놓고 솔루션만 개발한지 시간이 지나 대부분 다 까먹어서 하나씩 알아가면서 하려고 한다

현재 HttpSession 을 통해 로그인 로그아웃을 만들어놓은 상태이다

Spring Security

Spring으로 만든 웹 애플리케이션의 인증(Authentication)과 권한 부여(Authorization)를 전문적으로 담당하는 프레임워크

역할
- 인증 (Authentication) : 사용자가 누구인지 확인하는 과정입니다. (예: 아이디/비밀번호로 로그인)
- 권한 부여 , 인가 (Authorization) : 인증된 사용자가 어떤 작업을 수행할 수 있는지 허가해주는 과정.
  (예: '사용자 USER'는 사용자페이지만 접근 가능)
왜 쓰는지 ? 우리가 직접 로그인/로그아웃, 세션 관리, 페이지 접근 제어 같은 복잡하고 실수하기 쉬운 보안 로직을 만들 필요 없이, Spring Security가 제공하는 표준적이고 안전한 방법을 그대로 사용하기 위해

BCrypt

비밀번호를 안전하게 암호화하기 위해 사용하는 해시(Hash) 함수 중 하나이다. Spring Security에서 기본으로 권장하는 방식

단방향 해시 : 비밀번호를 암호화된 문자열(해시 값)로 바꿀 수는 있지만, 암호화된 문자열을 다시 원래 비밀번호로 되돌릴 수는 절대 없다. (관리자도 모름 , ** 가장 중요 **)
해커가 DB를 탈취해도 원래 비밀번호를 알아낼 수 없
솔트 (Salt) 사용: 같은 비밀번호를 입력해도, 암호화할 때마다 매번 다른 결과가 나온다.
- 왜? 암호화 시 '솔트' 라는 임의의 데이터를 비밀번호에 섞어서 암호화하기 때문
  해커들이 미리 계산된 해시 값 목록(레인보우 테이블)을 사용한 공격을 할 수 없게 된다.
어떻게 로그인 처리해?:
- 사용자가 로그인 시 입력한 '날것'의 비밀번호와 DB에 저장된 '암호화된' 비밀번호를 BCrypt에게 함께 전달.
  그러면 BCrypt가 알아서 "이 두 개가 같은 비밀번호가 맞는지" 검증하여 true 또는 false를 알려준다.
  우리는 그 결과만 믿고 사용하면 된다
- 검증(Verification) : 두 문자열이 같은지 ==로 비교하는 것이 아니라, BCrypt가 제공하는 matches() 기능을 통해 원본 비밀번호와 저장된 해시값이 수학적으로 일치하는지 확인

SecurityConfig 파일

일단 개발 초기이니 전부다 허가 해놓는다

@Configuration
@EnableWebSecurity
public class SecurityConfig {

// @Bean: 이 메서드가 반환하는 객체(PasswordEncoder)를 Spring 컨테이너가 관리하는 Bean으로 등록
// BCrypt 암호화 도구를 생성해서 Spring에 등록.
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    
       @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // http 객체를 사용하여 메서드 체이닝 방식으로 보안 설정을 구성합니다.
        http.csrf(csrf -> csrf.disable())
        .authorizeHttpRequests(authorize -> authorize.requestMatchers("/**").permitAll());
        // 개발 편의상 일단 로그인을 안 한 사람이든 한 사람이든 상관없이 검사하지 말고 들여보낸다
        return http.build();
    }
    
}

MemberService 변경전

public class MemberService {

	@Transactional
    public Long join(String email, String password, String name ,String nickname) {
        validateDuplicateEmail(email);
        validateDuplicateNickName(nickname);

        //  member 객체 생성할때 createAt은 null로 들어감
        // repository.save 호출
        // DB 넣기 전에 @EntityListeners 가 작동해서 저장할때 현재 시간을 주입해줌
        Member member = Member.builder()
                .email(email)
                .password(password)
                .name(name)
                .nickname(nickname)
                .memberRole(MemberRole.USER)
                .build();

        Member savedMember = memberRepository.save(member);
        return savedMember.getId();
    }
    
    public Member login(String email, String password) {
        Member member =  memberRepository.findByEmail(email);

        if(member == null) {
            return null;
        }

        if(!member.getPassword().equals(password)) {
            return null;
        }

        return member;
	}


	    /**
     * 이메일 중복 체크
     */
    private void validateDuplicateEmail(String email) {
        if (memberRepository.existsByEmail(email)) {
            throw new DuplicateFieldException("email","이미 존재하는 회원(이메일)입니다.");
        }
    }

    /**
     * 닉네임 중복 체크
     */
    private void validateDuplicateNickName(String nickname) {
        if (memberRepository.existsByNickname(nickname)) {
            throw new DuplicateFieldException("nickname","이미 존재하는 닉네임 입니다.");
        }
    }

}

MemberService 변경후

public class MemberService {


	@Transactional // 이 메서드는 데이터베이스에 정보를 저장(쓰기)하므로, @Transactional을 붙여서 쓰기 모드로 설정합니다.
	public Long join(String email, String password, String name ,String nickname) {
        // 호옥시 이미 가입된 이메일이나 닉네임인지 확인하기 (중복 체크)
        validateDuplicateEmail(email);
        validateDuplicateNickName(nickname);

        //  Member(회원) 객체를 만듬
        Member member = Member.builder()
                .email(email)
                // 사용자가 입력한 비밀번호를 그대로 저장하면 해킹 시 위험
                // 비밀번호를 아무도 알아볼 수 없는 암호문으로 바꿔준다 개꿀. (예: $2a$10$...)
                .password(passwordEncoder.encode(password))
                .name(name)
                .nickname(nickname)
                .memberRole(MemberRole.USER) // 처음 가입하는 사람은 모두 일반 사용자(USER)
                .build();

        // 완성된 회원 정보를 데이터베이스에 저장(save)
        Member savedMember = memberRepository.save(member);

        // 데이터베이스에 저장된 회원의 ID 번호를 알려준다
        return savedMember.getId();
    }
    
     public Member login(String email, String password) {
        // 사용자가 입력한 이메일로 데이터베이스에서 회원 찾기
        Member member =  memberRepository.findByEmail(email);

        // 만약 그런 이메일을 가진 회원이 없다면, 당연히 로그인 실패이므로 null을 반환하고 끝낸다
        if(member == null) {
            return null;
        }

        // 데이터베이스에 저장된 암호문(member.getPassword())과
        // 사용자가 방금 입력한 날것의 비밀번호(password)가 서로 짝이 맞는지 확인
        // equals() , ==  이딴거 쓰기 XXXX   passwordEncoder.matches() 사용
        if(!passwordEncoder.matches(password, member.getPassword())) {
            // 만약 짝이 맞지 않는다면, 비밀번호가 틀린 것이므로 null을 반환하고 끝낸다
            return null;
        }

        // 이메일도 존재하고 비밀번호도 짝이 맞는다면 로그인 성공
        // 찾았던 회원 정보를 통째로 반환
        return member;
    }


}

왜 PasswordEncoder가 필요한가

비밀번호는 절대 DB에 그대로 저장하면 안 된다.
DB가 유출되는 순간, 모든 사용자의 계정이 즉시 위험해진다

그래서 Spring Security에서는 비밀번호를 저장할 때
단방향 해시(Hash) 함수를 사용하도록 강제하고 있고 그 역할을 담당하는 인터페이스가 바로 PasswordEncoder

PasswordEncoder는 다음 두 가지 역할을 가진다.

사용자가 입력한 평문 비밀번호를 해시값으로 변환
로그인 시 입력한 비밀번호가 저장된 해시값과 일치하는지 검증

즉, 애플리케이션 코드에서
“어떤 해시 알고리즘을 쓸지”, “salt를 어떻게 처리할지”를 직접 고민하지 않도록
Spring Security가 제공하는 보안 추상화 계층이라고 볼 수 있다.

BCryptPasswordEncoder를 사용하는 이유

BCryptPasswordEncoder는 PasswordEncoder의 구현체 중 하나로,
비밀번호 저장에 특화된 단방향 해시 알고리즘 BCrypt를 사용

BCrypt의 특징은 다음과 같다.

내부적으로 랜덤 salt를 자동 생성
동일한 비밀번호라도 매번 다른 해시 결과 생성
연산 비용(cost)을 조절할 수 있어 무차별 대입 공격에 강함

따라서 Spring Security 환경에서는 별도의 이유가 없다면 BCryptPasswordEncoder를 사용하는 것이 표준

비밀번호 저장과정

String encodedPassword = passwordEncoder.encode(rawPassword);

encode() 메서드는

평문 비밀번호
랜덤 salt
Bcrypt 알고리즘 들을 사용해 복호화 불가능한 해시 문자열을 생성한다

matches()는 어떻게 동작하는가

로그인 시에는 비밀번호를 다시 복호화해서 비교하지 않는다.
애초에 BCrypt는 복호화 자체가 불가능한 알고리즘이기 때문

passwordEncoder.matches(rawPassword, encodedPassword);

DB에 저장된 encodedPassword에서 salt 값과 cost 값 추출
사용자가 입력한 rawPassword에 동일한 salt + 동일한 cost로 다시 해시 수행
새로 계산된 해시결과와 DB에 저장된 해시값 비교
같으면 true , 틀리면 false 반환
단순 문자열 비교 XXXXXXXX

왜 equals()로 비교하면 안 되는가

passwordEncoder.encode(rawPassword).equals(encodedPassword);

BCrypt 는 랜덤 salt 를 사용하므로 같은 비밀번호 여도 equals() 결과는 매번 다르다
그러므로 항상 실패 , 반드시 matches() 메서드 사용하기

정리

PasswordEncoder는 비밀번호 해시와 검증을 책임지는 보안 인터페이스다
BCrypt는 복호화가 불가능한 단방향 해시 알고리즘이다
로그인 시에는 복호화가 아니라 재해시 후 비교를 수행한다
비밀번호 비교는 반드시 matches()를 사용해야 한다

풀이
$2a$ : 사용할 BCrypt 알고리즘의 버전

$10$ : 비용(Cost) 또는 작업량(Work Factor)을 의미한다고 함 , 10은 일반적 권장되는 기본값\

sDgalEi17wU7GzWCuy565utADxB8.Qvkd025H2iAH0dD37UjVYUEO

솔트(Salt) : 앞부분 22글자(sDgalEi17wU7GzWCuy565u)는 암호화 시 사용된 '임의의 소금' 값
솔트 덕분에 같은 비밀번호라도 매번 다른 암호문이 생성

해시 결과(Hashed Result) : 뒷부분 31글자(tADxB8.Qvkd025H2iAH0dD37UjVYUEO)가
사용자의 비밀번호와 솔트를 조합한 해시 계산을 한 최종 결과물

gidor_Helper 메모

기돌 — Thu, 5 Sep 2024 13:15:18 +0900

https://github.com/gi-dor/gidor_Helper

GitHub - gi-dor/gidor_Helper: C# 자동화 프로그램

C# 자동화 프로그램 . Contribute to gi-dor/gidor_Helper development by creating an account on GitHub.

github.com

해당 폼이 로드될 때 데이터베이스 연결을 시도하고 연결에 성공, 실패 여부 메세지를 보여준다
또한 버튼 클릭시 데이터를 조회하는 코드이다

namespace Helper
{
    public partial class CommonCod : Form
    {

        // 데이터베이스 연결
        public static String uid = "";
        public static String password = "";  // 비밀번호가 없으므로 빈 문자열
        public static String database = "";
        public static String server = "";

        public static String conStr = $"Server={server}; Database={database}; User Id={uid}; Password={password}; Integrated Security=True";
        SqlConnection conn = new SqlConnection(conStr);
        
    private void CommonCod_Load(object sender, EventArgs e)
      {
         try
            {
                conn.Open();
                MessageBox.Show("Success , DB 연결 되었습니다  ", "DB 연결메세지", MessageBoxButtons.OK, MessageBoxIcon.Information);

                // 해당 컬럼의 ReadOnly 속성 true 
                cod_dataGridView1.ReadOnly = true;
                cod_dataGridView1.SelectionMode = DataGridViewSelectionMode.FullRowSelect;

                } catch(Exception ex){
                	MessageBox.Show($"DB 연결실패 \r\n Error : {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
      }
        
	private void CodeManageButton_Click(object sender, EventArgs e)
        {
            try
            {
             
                String sqlQuery = " SELECT * FROM dbo.COD order by COD_NO ASC";
                // SQL 쿼리를 실행하기 위한 객체
                SqlCommand cmd = new SqlCommand(sqlQuery, conn);

                // SqlDataAdapter 는 DB에서 데이터를 가져와 Data Table을 채운다
                SqlDataAdapter dataAdapter = new SqlDataAdapter(cmd);

                // 가져온 데이터를 담기
                DataTable dataTable = new DataTable();

                // 데이터 어댑터를 통해 데이터를 데이터 테이블에 채움
                dataAdapter.Fill(dataTable);

                // 데이터 테이블을 DataGridView에 연결
                cod_dataGridView1.DataSource = dataTable;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"데이터 조회 실패 \r\n Error : {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        
    }
        
}

데이터베이스에 연결이 열리면 , 연결을 끊는 로직이 필요 할수가 있다
연결을 끊지 않으면 리소스가 소모되므로 , 폼이 닫힐 때 연결을 해제하는것이 좋다

이것을위해 2가지 방법이 있다고 한다 using 과 Dispose()

SqlConnection과 SqlCommand는 둘 다 Dispose()를 구현한 객체지만 사용자가 Dispose()를 호출하지 않았기 때문에 finalizer가 호출될 때까지 메모리에 남게 된다.

using { } 구문은 코드의 블럭이 끝나면 자동으로 Dispose()를 호출한다 , 이것을 통해 Dispose() 를 호출하지 않아도
안전하게 리소스를 해제할수 있다

using{ } 구문을 사용해 코드 수가 감소함

namespace Helper
{
    public partial class CommonCod : Form
    {
        // 데이터베이스 연결
        public static String uid = "";
        public static String password = "";  // 비밀번호가 없으므로 빈 문자열
        public static String database = "";
        public static String server = "";

        public static String conStr = $"Server={server}; Database={database}; User Id={uid}; Password={password}; Integrated Security=True";

        public CommonCod()
        {
            InitializeComponent();
        }

        private void CommonCod_Load(object sender, EventArgs e)
        {
            try
            {
                using (SqlConnection conn = new SqlConnection(conStr))
                {
                    conn.Open();
                    MessageBox.Show("Success, DB 연결 되었습니다", "DB 연결 메시지", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    // 해당 컬럼의 ReadOnly 속성 true
                    cod_dataGridView1.ReadOnly = true;
                    cod_dataGridView1.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"DB 연결 실패 \r\n Error: {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void CodeManageButton_Click(object sender, EventArgs e)
        {
            try
            {
                String sqlQuery = "SELECT * FROM dbo.COD ORDER BY COD_NO ASC";
                
                // using 구문을 사용하여 SqlConnection을 자동으로 닫음
                using (SqlConnection conn = new SqlConnection(conStr))
                {
                    SqlCommand cmd = new SqlCommand(sqlQuery, conn);
                    SqlDataAdapter dataAdapter = new SqlDataAdapter(cmd);
                    DataTable dataTable = new DataTable();
                    dataAdapter.Fill(dataTable);

                    // 데이터 테이블을 DataGridView에 연결
                    cod_dataGridView1.DataSource = dataTable;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"데이터 조회 실패 \r\n Error: {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

명시적인 Disposs()

namespace Helper
{
    public partial class CommonCod : Form
    {
        // 데이터베이스 연결
        public static String uid = ";
        public static String password = "";  // 비밀번호가 없으므로 빈 문자열
        public static String database = "";
        public static String server = "";

        public static String conStr = $"Server={server}; Database={database}; User Id={uid}; Password={password}; Integrated Security=True";

        public CommonCod()
        {
            InitializeComponent();
        }

        private void CommonCod_Load(object sender, EventArgs e)
        {
       	try{
        	  MessageBox.Show("불러오기 성공", "정보", MessageBoxButtons.OK, MessageBoxIcon.Information);
            
                // 해당 컬럼의 ReadOnly 속성 true
                cod_dataGridView1.ReadOnly = true;
                cod_dataGridView1.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"DB 연결 실패 \r\n Error: {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void CodeManageButton_Click(object sender, EventArgs e)
        {
            SqlConnection conn = null;

            try
            {
                String sqlQuery = "SELECT * FROM dbo.COD ORDER BY COD_NO ASC";
                conn = new SqlConnection(conStr);
                SqlCommand cmd = new SqlCommand(sqlQuery, conn);
                SqlDataAdapter dataAdapter = new SqlDataAdapter(cmd);
                DataTable dataTable = new DataTable();
                dataAdapter.Fill(dataTable);

                // 데이터 테이블을 DataGridView에 연결
                cod_dataGridView1.DataSource = dataTable;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"데이터 조회 실패 \r\n Error: {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                // 연결을 닫고 자원을 해제
                if (conn != null)
                {
                    conn.Dispose();  // 명시적으로 Dispose() 호출
                }
            }
        }
    }
}

using (SqlConnection conn = new SqlConnection(conStr))
{
    conn.Open();
    // 데이터베이스 작업 수행
}  // using 블록을 벗어나면 자동으로 Dispose()가 호출됨

Dispose() 수동으로 리소스를 해제 하기 위해 코드를 명시적으로 작성해 호출한다

SqlConnection conn = new SqlConnection(conStr);

try
{
    conn.Open();
    // 데이터베이스 작업 수행
}
finally
{
    // 리소스를 수동으로 해제
    if (conn != null)
    {
        conn.Dispose();  // 명시적으로 Dispose() 호출
    }
}

** C# GC에 대해

C#은 가비지 컬렉터가 메모리를 자동으로 관리한다
대신 필요없는 클래스의 인스턴스를 메모리에서 바로 지우는게 아니라 조건이 될 때까지 기다렸다가 지우기 때문에 클래스를 지웠다고 해도 그게 실제로 바로 삭제되는 것은 아니다.

Dispose를 호출하는 걸 깜박하면 어떻게 될까?

그럴 경우에는 GC에서 해당 인스턴스를 제거할 때, (소멸자에서) Dispose를 호출해준다.
다만 다음과 같은 부작용이 생길 수 있다고 한다.

1.GC가 해당 인스턴스를 언제 지울 지 알 수 없다.
Dispose가 언제 호출될지 알 수 없다. 애플리케이션이 종료될 때까지 호출이 안될 수도 있다. 중요한 리소스를 사용하거나, 메모리를 많이 먹는 클래스라면 위험할 수도 있겠다.

2.GC가 해당 인스터스를 지울 때 Dispose를 호출하게 되면 그 순간 부하가 걸린다.
즉, 랜덤하게 랙을 유발할 수도 있다. 성능에 예민한 앱이라면 주의가 필요하다.

3.GC가 해당 인스턴스를 지울 때 Dispose에서 예외가 발생하면 어플 자체가 크래시 할 수도 있다.
수동으로 Dispose를 할 때에는 try/catch로 보호할 수 있지만, 자동제거일 경우 예외를 잡을 수 없기 때문에 매우 위험할 수도 있다

자바의 가비지 컬렉션은 프로그래머가 GC를 호출할수 없으며 , JVM이 메모리 상황을 모니터링하다가 필요시 GC를 자동으로 실행한다

C# 에서 가비지 컬렌셕도 메모리가 부족하거나 특정조건이 될 때 GC가 실행되며 직접적인 컨트롤없이 처리를한다
다만 GC.Collect()를 메서드를 호출하면 프로그래머가 GC를 유발할수 있지만 시스템에 부하를 준다고 한다

자바는 기본적으로 시스템이 메모리를 관리하고 하며 , 개발자는 신경쓰지 않게 설계 되어있다
C#은 개발자에게 약간의 메모리 관리 권한을 부여하며 Dispose() 와 using { } 구문을 통해 리소스를 해체하는 패턴을 사용

자원을 다룰 때 using 키워들 이용하자
- using 키워드를 이용하면 괄호( {} )를 빠져나올 때 자동으로 Dispose를 해준다.
여기서 자원이란 파일, 폰트 등과 같은 Resource를 말한다.

데이터베이스 연결 및 리소스 관리

프로젝트에서 데이터베이스와의 연결을 효과적으로 관리하기 위해, using 구문을 사용하여 SqlConnection 객체를 처리하였습니다. using 구문을 사용하면 데이터베이스 연결과 같은 리소스가 자동으로 해제되므로, 연결을 수동으로 닫는 것을 잊을 염려가 없으며, 리소스 누수 문제를 예방할 수 있습니다. 이를 통해 코드의 안정성과 유지보수성을 향상시킬 수 있었습니다.

코드 예시:

private void CodeManageButton_Click(object sender, EventArgs e)
{
    try
    {
        String sqlQuery = "SELECT * FROM dbo.COD ORDER BY COD_NO ASC";

        using (SqlConnection conn = new SqlConnection(conStr))
        {
            conn.Open();

            SqlCommand cmd = new SqlCommand(sqlQuery, conn);
            SqlDataAdapter dataAdapter = new SqlDataAdapter(cmd);
            DataTable dataTable = new DataTable();
            dataAdapter.Fill(dataTable);

            cod_dataGridView1.DataSource = dataTable;
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"데이터 조회 실패 \r\n Error : {ex.Message}", "DB Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

주요 사항:

자동 리소스 관리: using 구문을 활용하여 SqlConnection 객체를 생성하고 사용 후 자동으로 리소스를 해제합니다. 이는 메모리 누수 및 리소스 낭비를 방지합니다.
에러 처리: 데이터베이스와의 상호작용 중 발생할 수 있는 예외를 적절히 처리하여 사용자에게 친절한 에러 메시지를 제공하고, 프로그램의 안정성을 높였습니다.
폼 종료 시 연결 해제: 폼이 닫힐 때 데이터베이스 연결을 안전하게 종료하도록 using 구문을 사용하면 SqlConnection 객체는 블록이 끝나면 자동으로 닫히기 때문에, FormClosing 이벤트에서 별도로 연결을 해제하는 코드를 작성할 필요가 없습니다 블록을 벗어나면 자동으로 Dispose() 메서드가 호출되어 리소스가 정리

따라서 CodeManageButton_Click 메서드와 같은 경우에는 SqlConnection을 using 구문으로 처리하여 리소스 관리를 자동으로 할 수 있으며, 폼이 닫힐 때 별도로 연결을 해제할 필요는 없습니다.

dateGridView에서 해당컬럼 선택시 해당하는 컬럼의 값만 복사가 되었는데

엑셀 작업으로 데이터를 전송하는 경우가 자주 발생해 해당 컬럼 선택시 해당하는 행의 모든 컬럼의 값을 가져오기 위해
SelectionMode의 값을 FullColumnSelect를 선택된 행의 전부선택되게 설정했습니다.

에러

dataGridView에서 DB에 맞게 해당 테이블의 컬럼을 설정하여 만들었다

컬럼이 중복이 되어 조회되는것을 확인했다

해결책이 몇가지 있어 시도를했다

1. winform 에서 dataGridView에 설정한 컬럼을 삭제한뒤에 사용
→ 사용자 입장으로서 최악의 선택이다 버튼을 클릭시 해당 컬럼과 값은 제대로 들어가지만 조회 버튼 누르기 전까지는 하얀 빈공간으로 보여진다

2. dataGridView에 컬럼을 작성 후에 조회 클릭이벤트를 발생하는 메서드에
cod_dataGridView1.Columns.Clear(); 를 사용해 기존에있던 컬럼들을 모두 삭제하고
데이터를 삽입한다
이렇게하면 초기화면에서 사용자는 컬럼명들을 볼수 있고
조회 이벤트 발생시 중복된 컬럼없이 알맞은 데이터들을 볼수 있다

또한 코드로 컬럼을 생성하지 않고 winform에서 속성창을 이용해서 컬럼을 만들기에 더 쉽고 간편하고 코드의 양이 줄어든다

dataGrideView1 에서 송장을 클릭하게되면 해당 송장번호에 맞는 상세 정보들을 볼수 있다
하단에 비어있는 행을 클릭후 삭제 요청시

String INV_NO = ScanDataGridView2.SelectedRows[0].Cells["INV_NO"].Value.ToString();

System.Windows.Forms.DataGridViewCell.Value.get이(가) null을(를) 반환했습니다.

System.NullReferenceException은 Value 속성이 null인 경우 발생한다
ToString() 메서드를 호출하기 전에 Value가 null인지 확인하는 것이 필요하다
지금까지 사용했던 String.IsNullOrWhiteSpace는 null 값뿐만 아니라 빈 문자열이나 공백 문자열도 처리할 수 있지만, Value 속성이 null인 경우에는 ToString()을 호출하기 전에 확인이 필요하다

해당 예외를 처리하기 위해 2가지 방법이있다
1. Value?.ToString()
2. ScanDataGridView2에 AllowUserToAddRTows 속성을 FALSE 로 설정한다

Value?.ToString() 를 사용하게되면 Value의 값이 null이라면 ToString() 메서드가 호출되지 않아서
INV_NO는 null 이되며 NULL 참조 오류를 방지할 수 있다

AllowUserToAddRTows 속성은 행의 추가 옵션이 사용자에게 표시되는지 여부를 보여주는 속성이다
ScanDataGridView2에 AllowUserToAddRTows 속성의 기본값은 TRUE 이지만 FALSE 로 설정하게되면

해당 사진처럼 하단에 비어있는 행이 추가 되지 않아 선택조차 할수 없게 설정할 수 있다.

만약 INSERT 를 하는 기능을 구현한다면 Value?.ToString() 을 사용해야 하지만
해당 프로그램은 ScanData에 대해 데이터 추가기능은 제한 하기에 늘어나는 코드양도 없으며 손쉽게 구현할수 있기에
AllowUserToAddRTows 속성을 선택했다

String sqlQuery = "SELECT top 100000 " +
                        " A.INV_NO       as '송장번호'   ," +
                        " A.BRA_ID       as '영업소'   , " +
                        " A.SCANN_SLT    as '스캔 상태'   , " +
                        " B.COD_CONT     as '코드 내용'   , " +
                        " A.SCANN_DATE   as '스캔 일자'  , " +
                        " A.SCANN_TIME   as '스캔 시간'   , " +
                        " A.CAR_ID       as '배송 차량'   , " +
                        " A.SCANN_USR_ID as '스캔 ID'   , " +
                        " A.TRS_ID       as '처리자 ID'   , " +
                        " A.TRS_NAME     as '처리자 명'   , " +
                        " A.TRS_DATE     as '처리 일자'" +
                     " FROM SLIS_MASTER.dbo.LS101T0 A " +
                     " INNER JOIN SLIS_MASTER.dbo.LS901T0 B " +
                     " ON A.SCANN_SLT = B.COD "+
                     " ORDER BY A.SCANN_DATE DESC , A.SCANN_TIME DESC";

[MySQL] 스토리지 엔진

기돌 — Thu, 29 Aug 2024 17:57:41 +0900

프로젝트 배포 당시 MySQL8.xxx 버전을 사용했으며 취준당시
면접 예상 질문으로 5버전과 8 버전대의 차이점에 대한 알아보면서 취업 이후 어느새 까먹어버려서 간단하게
기록 해보려고한다.

스토리지 엔진 ?

데이터베이스 엔진 또는 스토리지 엔진으로 부르며 , 데이터를 조회 , 추가 , 수정 , 삭제 하는 담당

MySQL 에서는 여러 스토리지 엔진을 지원한다고 한다

InnoDB 엔진
MyISAM 엔진
Memory 엔진
Archive 엔진
CSV 엔진
Federated 엔진

최근 프로젝트를 통해 사용했던 8.xx 버전의 사용된 InnoDB 엔진과 그 전 버전인 MyISAM엔진에 대해알아보려고한다

MyISAM

2009.12월 까지 기본엔진으로 MyISAM이 사용 되었다

특징
- COMMIT , ROLLBACK 같은 충돌 복구 기능을 가진다
- 트랜잭션을 제공하지 않는다
장점
- 전체적인 속도가 InnoDB보다 빠르다
- SELECT 작업 시 속도가 빨라서 읽기 작업에 적합
단점
- 데이터 무결성에 대한 보장이 되지 않는다
- Table-level Lock을 사용하기 때문에 갱신 작업 속도가 느리다

주로 데이터 조회가 자주 발생하는 시스템에서 유용하다. 대체로 티스토리 블로그 , 뉴스 , 통계 시스템 같은 읽기 작업이 주된 곳에서 쓰이면 유용하다

InnoDB

5.5 버전 이후부터는 InnoDB 를 기본엔진으로 사용

특징
- MyISAM과 마찬가지로 COMMIT , ROLLBACK 충돌 복구 기능을 가진다
- 외부 키를 지원한다 Foreign Key
- Row- Level Lock 을 제공한다.
- 트랜잭션을 제공하며 ACID 속성을 보장한다
  - 원자성(Atomicity), 일관성(Consistency), 격리(Isolation) 지속성(Durability)
장점
- MyISAM 보다 COMMIT , ROLLBACK 충돌 복구 기능이 뛰어나다
- Row Level Lock을 사용하기에 갱신 작업 속도가 빠르다
단점
- 시스템의 자원을 많이 사용한다

전자상거래 eCommerce 같이 구매,결제,재고파악등 다양한 트랜잭션이 발생하는 환경
금융서비스 , 커뮤니티사이트 ( 작성 , 댓글 등 읽기 쓰기 수정 작업이 혼합된 환경 )에 사용 하기 적합하다

Table Level Lock

테이블에 대한 잠금방식을 의미
테이블 전체를 잠그며 , 어떤 작업이 테이블에 있는 데이터에 접근할 때 , 모든 테이블 전체가 잠긴다
하나의 쓰기 작업이 진행중이라면 다른 모든 읽기와 쓰기에 대한 작업이 대기해야한다.
커뮤니티같은 익명의 여러 사람들이 글을 작성하거나 읽을시 문제가 생긴다

Row Level Lock

특정 행만 잠근다 , 특정 행만 잠그기에 다른행은 여전히 접근이 가능하다
- A라는 사용자가 하나의 행을 수정 할 때 , A 사용자는 다른 행을 잠글 필요가 없다
- 여러 사용자가 동시에 서로 다른 행을 수정하거나 읽을 수 있다

User 테이블이 있고 user_id 와 user_name 컬럼이 있다
여러 사용자가 동시에 회원 정보인 user_name을 수정한다면
MyISAM 같은 경우 user_id = 1 인 사용자가 user_name을 수정하는동안 다른 사용자는 테이블에서 읽기와 쓰기 작업을 할수 없다

InnoDM 경우 user_id = 1 인 사용자가 user_name을 수정하는 동안 다른 사용자인 user_id = 2 인 사용자는
user_name을 수정 할 수 있다.

간단하게 두 엔진의 차이점

FK 지원유무
트랜잭션 지원유무
Table Lock 과 Row Lock

SELECT 
	d.department_name, 
	e.name AS manager_name
FROM departments d , employees 
WHERE d.manager_id = e.id;

JOIN 은 외래 키 제약이 없더라도 두 테이블의 관련 데이터를 조회할 수 있다.
외래 키가 설정된 경우, 데이터의 무결성을 유지하면서 JOIN 연산을 수행
쿼리 작성 방법은 외래 키가 있는 경우와 없는 경우 동일하지만, 외래 키는 데이터의 정확성과 일관성을 보장

데이터 무결성은 DB에서 데이터를 정확하고 일관되게 유지하는 것이다

https://velog.io/@mooh2jj/Mysql-InnoDB-vs-MyISAM

[MySQL] - InnoDB vs MyISAM & 5.7 vs 8.0

InnoDB는 사용자의 데이터를 보호하고 내결함성을 제공하는 commit, rollback 및 충돌 복구 기능과 같은 기능을 갖춘 MySQL용 transaction-safe (ACID 호환)스토리지 엔진이다.row-level locking을 사용하며 non-lockin

velog.io