핀란드 교환학생의 개발일지

[프로그래머스/Java] 입국심사(이분탐색 문제)

iinana — Thu, 1 May 2025 10:51:19 +0900

프로그래머스 알고리즘 고득점 Kit의 이분탐색 문제에 해당하는 '입국심사'를 자바로 풀어보았습니다.

https://school.programmers.co.kr/learn/courses/30/lessons/43238#

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 접근

처음 이 문제를 접하고 들었던 생각은 어떻게 이 문제를 이분탐색으로 풀지?라는 것이었다. 내가 배워왔던 이분탐색과는 다른 느낌이었다. 하지만 '매개변수 탐색'이라는 개념을 접하고 나니 어떻게 이 문제를 풀어야 할지 알 수 있었다. 매개변수 탐색이란, 이분탐색을 이용해 최종답안에 가까워져 가는 탐색 방식을 말한다. 결국 '답이 될 결과'를 이분탐색하는 것이다.

그래서 값이 될 수 있는 최솟값을 왼쪽 끝값으로, 최댓값을 오른쪽 끝값으로 두고, 이분탐색을 시행하면서 정답을 찾는 접근법으로 이 문제를 풀이해봤다.

문제 풀이 코드

import java.util.*;

class Solution {
    public long solution(int n, int[] times) {       
        // low, high, mid 설정
        Arrays.sort(times);
        long l = times[0], h = (long) times[times.length-1] * n;
        long m = (l + h) / 2;
        
        // 매개변수 이분탐색
        while (l < h) {
        	// 현재 탐색 중인 시간(m)에서 수용 가능한 n (avail_n) 계산
            long avail_n = 0;
            for (int t : times) {
                avail_n += (m / t);
            }
            
            // 이분탐색을 위한 h, l, m 재설정
            if (avail_n >= n) h = m;
            else l = m + 1;
            m = (l + h) / 2;
        }
        return m;
    }
}

시행착오 (주의할 점)

이 문제에서 내가 겪었던 시행착오는 아래 두 가지이다.

1. low와 high 설정 관련 문제

여기서 주의할 점은 총 두 가지이다.

(1) low를 high와 비슷한 "times[0] * n"으로 설정해서는 안된다.

low를 n번 곱하는 것보다 다른 심사대를 적절하게 섞어 쓰는 것이 더 적은 시간의 결과를 낼 수 있는 것은 당연하다. (만약 low에 n명이 모두 가는 것이 최솟값이었다면, 이 문제의 답은 그냥 low*n이 될 것이다.) 따라서 low값은 0이나 최소 소요 시간을 가진 심사대 값 자체로 설정해 두는 것이 좋다.

(2) high 값을 구할 때 (long) 형 변환자를 꼭 써주어야 한다.

만약 써주지 않는다면 high를 설정하면서 overflow가 발생하여 이상한 값이 high에 들어가 의도하지 않은 결과가 나올 수 있다.

long l = times[0], h = (long) times[times.length-1] * n;

2. high, mid, low 재설정 관련 문제

if (avail_n >= n) h = m;
else l = m + 1;

위 코드에서는 avail_n이 n 이상일 경우 h = m으로 설정한다. 이는 m이 유효한 답일 수 있으므로, m 값은 범위 내에 계속해서 포함하면서도 범위를 왼쪽으로 좁히기 위한 코드이다. 그런데 처음에는 아래 코드도 비슷하게 성립할 수 있다고 생각했다.

if (avail_n > n) h = m - 1;
else l = m;

겉보기에는 비슷한 조건처럼 보이지만, 이 두 조건은 이진 탐색의 수렴 방식에서 중요한 차이를 만든다. 실제로 두 번째 방식은 일부 입력에서 무한 루프에 빠지는 문제가 발생했다.

그 이유는 m의 계산 방식 때문이다. m = (l + h) / 2는 정수 나눗셈이기 때문에 소수점 이하는 버려지며, 항상 l 쪽으로 치우친 값(floor 값)이 된다. 따라서 l = m을 하면 l이 변하지 않고 루프를 무한으로 돌면서도 계속 같은 값으로 초기화되는 상황이 발생할 수 있다. 예를 들면 아래와 같은 상황이 있다.

l = 3, h = 4
m = (3 + 4) / 2 = 3
l = m → l은 여전히 3 + h는 4 → 다음에도 m = 3 → 무한 반복

비슷한 논리로 만약 Math.ceil()을 사용해서 m이 올림값이 되도록 한다면 반대로 두 번째 코드를 사용해야 무한 루프를 방지할 수 있을 것이다.

[python / colab] 증권사 리포트 pdf 파일 크롤링하기

iinana — Thu, 24 Apr 2025 10:14:58 +0900

대표적으로 증권사 리포트를 확인할 수 있는 사이트인 한경컨센서스와 네이버금융리서치를 크롤링하여 리포트 pdf를 구글 드라이브에 저장하는 작업을 코랩에서 수행해 봤다.

공통 단계

사전 준비

# 구글 드라이브 마운트 (구글 드라이브와 코드 연결)
from google.colab import drive
drive.mount('/content/drive')

# selenium 설치
!pip install selenium
!apt-get update

# 구글 드라이브에 choremdriver 설치 (최초 1회)
!apt install chromium-chromedriver
!cp /usr/bin/chromedriver "/" #chorme driver 설치할 dir
!pip install chromedriver-autoinstaller

# 그 외 필요한 패키지들 다운
!pip install requests
!pip install PyPDF2

실행 준비

# 라이브러리 임포트
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
import sys
from selenium.webdriver.common.keys import Keys
import urllib.request
import os
from urllib.request import urlretrieve

import time
import pandas as pd
import chromedriver_autoinstaller  # setup chrome options

# chrome_options 설정 (크롬드라이버 실행 옵션)
## chromedriver 경로 명시
chrome_path = "" # chrome driver dir
sys.path.insert(0,chrome_path)

chrome_options = webdriver.ChromeOptions()
## colab은 새 창을 지원하지 않기 때문에 --headless 옵션 필요 (브라우저 창을 띄우지 않고 백그라운드에서 실행)
chrome_options.add_argument('--headless')
## 보안 샌드박스 없이 실행 (제한된 환경인 colab에서 필요한 설정)
chrome_options.add_argument('--no-sandbox')
## colab의 용량 제한으로 인한 오류 방지
chrome_options.add_argument('--disable-dev-shm-usage')
## chrome 언어 한국어로 설정
chrome_options.add_argument('lang=ko_KR')

## set the target URL
chromedriver_autoinstaller.install()

위 옵션 설정에서 중요한 부분은 argument 중 하나인 --headless는 colab이 새 창을 지원하지 않기 때문에 필요한 옵션으로, 만약 로컬 환경을 사용한다면 추가하지 않아도 된다. 이러한 특성 때문에 실제로 크롤링이 돌아가는 창을 확인하며 내가 의도한 대로 실행되는지 확인할 수 없다는 단점이 있다. 나는 그래서 디버깅을 할 때 아래 코드를 이용해 문제가 된다고 예상되는 파트에서 백그라운드로 실행 중인 화면의 스크린숏을 남겨 확인했다.

driver.save_screenshot("screen.png")
from IPython.display import Image
Image("screen.png")

크롤링 - 한경 컨센서스

https://markets.hankyung.com/consensus

한경 컨센서스 | 한국경제

주간 목표 상향 TOP10 리포트 조회 검색결과가 없습니다. 코리아마켓 금융 정보는 각 콘텐츠 제공업체로부터 받는 투자 참고사항이며, 오류가 발생하거나 지연될 수 있습니다. 한경닷컴과 콘텐츠

markets.hankyung.com

# url과 driver set
main_url = "https://markets.hankyung.com/consensus"
login_url = "https://id.hankyung.com/login/login.do"
driver =  webdriver.Chrome(options=chrome_options)

한경 컨센서스의 경우 로그인을 해야 리포트 파일에 접근 가능하기 때문에 본격적인 크롤링 전 꼭 로그인 단계를 원격으로 실행해줘야 한다.

# 한경 컨센서스 로그인
driver.get(login_url)
user_id = driver.find_element(By.ID, 'userId')
user_id.send_keys("") #한경컨센서스 아이디 입력

user_pw = driver.find_element(By.ID, 'userPass')
user_pw.send_keys("") #한경컨센서스 비밀번호 입력
user_pw.send_keys(Keys.RETURN)

리포트를 순회하면서 가져오는 방식은 현재 페이지에서 가장 첫 번째 리포트의 id를 가져오고 맨 끝 페이지로 이동해서 맨 마지막 리포트의 id를 가져와서 순회하는 식이다. 가장 첫 리포트부터 마지막 리포트까지 하나씩 감소하면서 id가 부여되는 방식이며 리포트 pdf의 url이 base_url + id의 형식을 지켰기에 가능한 방식이었다.

또한, 마지막 리포트에 접근할 때는 검색 탭에서 기간을 설정하여 접근 가능하도록 코드를 작성했다.

# report 시작 id 가져오기
import re

driver.get(main_url)
time.sleep(3)

a_tags = driver.find_elements(By.CSS_SELECTOR, 'a.ellip')
href = a_tags[0].get_attribute('href')
start_id = re.search(r'/consensus/view/(\d+)', href).group(1)
start_id = int(start_id)

# report 끝 id 가져오기
from selenium.webdriver.support.ui import Select

driver.get(main_url)
time.sleep(3)

## 기간 선택 (시작 id에서는 불필요)
dropdown_arrow = driver.find_element(By.CLASS_NAME, 'select2-selection__arrow')
dropdown_arrow.click()
time.sleep(1)

# "최근 7일", "1개월", "6개월", "1년"
recent_7 = driver.find_element(By.XPATH, '//li[contains(text(), "최근 7일")]')
recent_7.click()
time.sleep(1)

search_button = driver.find_element(By.CLASS_NAME, "btn-primary")
search_button.click() # 검색 버튼 클릭
time.sleep(1)

## 끝 페이지로 이동
end_page=driver.find_element(By.CLASS_NAME, 'btn-page-end')
end_page.click()

a_tags = driver.find_elements(By.CSS_SELECTOR, 'a.ellip')
href = a_tags[-1].get_attribute('href')
end_id = re.search(r'/consensus/view/(\d+)', href).group(1)
end_id = int(end_id)

마지막으로 마지막 리포트의 id ~ 첫 리포트의 id를 순회하면서 pdf를 지정된 구글 드라이브 directory에 저장하며 끝낸다.

import requests
from io import BytesIO
from PyPDF2 import PdfReader

base_url = "https://markets.hankyung.com/consensus/view/"
# Selenium 세션에서 쿠키 가져오기
cookies = driver.get_cookies()

# requests 세션 생성
session = requests.Session()
for cookie in cookies:
    session.cookies.set(cookie['name'], cookie['value'])

for i in range(end_id, start_id):
  driver.get(base_url + str(i))
  time.sleep(3)

  title=driver.find_element(By.CLASS_NAME, "report-tit")
  title=title.text.strip()
  title=re.sub(r'[\\/*?:"<>|]', "", title)

  file_url=driver.find_element(By.CSS_SELECTOR, 'a.btn.btn-default').get_attribute('href')
  driver.get(file_url)
  time.sleep(3)

  response = session.get(file_url)
  if response.status_code == 200:
      with open("#pdf 저장할 dir"+title+".pdf", "wb") as f:
          f.write(response.content)
      print("PDF 다운로드 완료.")
  else:
      print("PDF 파일 다운로드 실패.")

크롤링 - 네이버 증권 리서치

https://finance.naver.com/research/

리서치 : 네이버페이 증권

관심종목의 실시간 주가를 가장 빠르게 확인하는 곳

finance.naver.com

네이버 증권 리서치의 장점은 로그인 없이 리포트 pdf 파일에 접근할 수 있다는 점이다. 한경 컨센서스처럼 별도로 원격 로그인 하는 코드를 쓸 필요가 없다. 다만, 종목/산업/시황/투자정보 리포트가 약간 다른 형태의 html로 주어져서 관련해서 살짝만 수정해 주면 된다. 또, 종목/산업 리포트끼리는 형식이 같고, 시황/투자정보 리포트끼리도 형식이 같다. 나는 종목/산업 분석 리포트를 중심으로 작성했다. 사실 시황/투자정보라고 하더라도 인덱스만 확인하고 살짝 수정해주면 된다.

# url과 driver set
url = "https://finance.naver.com/research/company_list.naver?&page=" #종목분석 리포트
#url = "https://finance.naver.com/research/industry_list.naver?page=" #산업분석 리포트

save_dir = "/" # pdf 저장할 directory
driver =  webdriver.Chrome(options=chrome_options)

앞선 한경 컨센서스 크롤링에서는 검색탭에 주어지는 기간 설정을 이용했지만, 네이버 금융 리서치의 경우 그냥 직접 날짜를 확인하는 편이 더 간편해 보여서 그렇게 진행했다.

# 크롤링 기간 설정
from datetime import datetime, timedelta

end_date = datetime.now() # 오늘 날짜
start_date = end_date - timedelta(days=7) # n일 전 날짜

import requests
from io import BytesIO
from PyPDF2 import PdfReader

# Selenium 세션에서 쿠키 가져오기
cookies = driver.get_cookies()

# requests 세션 생성
session = requests.Session()
for cookie in cookies:
    session.cookies.set(cookie['name'], cookie['value'])

page = 1
while True:
  try:
    driver.get(url + str(page))
    time.sleep(3)
  except Exception:
    continue

  reports_tab = driver.find_element(By.XPATH, "/html/body/div[3]/div[2]/div[2]/div[1]/div[2]/table[1]/tbody")
  reports = reports_tab.find_elements(By.TAG_NAME, "tr") # 리포트 목록
  
  for r in reports:
    tds = r.find_elements(By.TAG_NAME, "td")
    if len(tds) < 4:
       continue

    company = tds[0].text.strip() # 회사 이름
    date = tds[4].text.strip() # 작성일

    ## 기간 확인
    try:
      report_date = datetime.strptime(date, "%y.%m.%d")
    except ValueError:
            continue
    if not (start_date <= report_date <= end_date):
        continue  # 원하는 날짜 범위가 아니면 스킵

    ## pdf 파일 url 추출
    file = tds[3].find_element(By.TAG_NAME, "a").get_attribute("href")
    driver.get(file)
    time.sleep(3)
    
    ## pdf 파일 저장
    response = session.get(file)
    time.sleep(3)
    if response.status_code == 200:
        with open(save_dir+company+"_"+date+".pdf", "wb") as f:
            f.write(response.content)
        print("PDF 다운로드 완료.")
    else:
        print("PDF 파일 다운로드 실패.")

  page += 1

[SpringBoot/JWT] 로그인/회원가입에 Refresh Token 도입하기

iinana — Sun, 20 Apr 2025 16:46:11 +0900

0. JWT 기반 로그인/회원가입 구현

기존에 구현되어 있던 JWT 기반 로그인/회원가입에서 보안과 안정성 향상을 위해 refresh token을 추가해 줬다. 이미 구현된 JWT 기반 로그인/회원가입과 왜 refresh token이 필요한지에 대한 내용은 아래 글에서 확인할 수 있다.

https://programming-diary-ina.tistory.com/126

[Spring Boot/JWT] JWT로 로그인/로그아웃 구현하기

토큰 기반 인증 1. 토큰 기반 인증이란 토큰을 사용하여 인증하는 방식이다. 서버가 토큰을 생성해서 클라이언트에게 제공하면, 클라이언트는 이 토큰을 가지고 있다가 여러 요청을 토큰과 함

programming-diary-ina.tistory.com

refresh token의 추가로, 기존 코드에서는 access를 위한 한 종류의 token만 존재했지만, 이제는 refresh token과 access token, 두 가지 종류의 토큰이 존재하게 된다. refresh token은 쉽게 말하면 access token 재발급을 위한 token이다.

1. RefreshToken entity 및 repository 생성

refresh token을 생성 및 저장하기 위해 entity와 repository를 만들어준다. entity 코드는 아래와 같다.

/** domain/RefreshToken.java **/
import jakarta.persistence.*;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Entity
public class RefreshToken {
    // refresh token 자체의 id
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 사용자 id
    @Column(name = "user_id", nullable = false, unique = true)
    private Long userId;

    // refresh token 값
    @Column(name = "refresh_token", nullable = false)
    private String refreshToken;

    public RefreshToken(Long userId, String refreshToken) {
        this.userId = userId;
        this.refreshToken = refreshToken;
    }

    public RefreshToken update(String newRefreshToken) {
        this.refreshToken = newRefreshToken;
        return this;
    }
}

다음은 생성된 refresh token entity를 저장할 repository이다. JPA 기반으로 생성해준다.

/** repository/RefreshTokenRepository.java **/
import com.survey.server.domain.RefreshToken;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
    Optional<RefreshToken> findByUserId(Long userId);
    Optional<RefreshToken> findByRefreshToken(String refreshToken);

    void deleteByUserId(Long userId);
}

2. token service와 refresh token service

다음으로 앞서 설계해둔 refresh token 로직을 실질적으로 사용하기 위해 refresh token service와 token serivce를 만들어준다. refresh token service는 refresh token을 생성하고 삭제하기 위한 service이고, token service는 refresh token을 기반으로 access token을 생성하기 위한 service이다.

/** service/RefreshTokenService.java **/
import com.survey.server.config.jwt.TokenProvider;
import com.survey.server.domain.RefreshToken;
import com.survey.server.repository.RefreshTokenRepository;
import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import java.time.Duration;

@RequiredArgsConstructor
@Service
public class RefreshTokenService {
    private final TokenProvider tokenProvider;
    private final RefreshTokenRepository refreshTokenRepository;
    private static final Long REFRESH_EXPIRATION = Duration.ofDays(14).toMillis();

    // refresh token 찾기
    public RefreshToken findByRefreshToken(String refreshToken) {
        return refreshTokenRepository.findByRefreshToken(refreshToken)
                .orElseThrow(() -> new IllegalArgumentException("Unexpected Refresh Token"));
    }
    
    // 새로운 refresh token 생성
    public String createNewRefreshToken(Long userId) {
        // refresh token 값 생성
        String refreshToken = tokenProvider.makeToken(userId, null, REFRESH_EXPIRATION);
        // roles = null로 설정 (refresh token은 null 값 필요하지 않음)

        // refresh token entity 생성 및 저장
        RefreshToken refreshTokenEntity = new RefreshToken(userId, refreshToken);
        refreshTokenRepository.save(refreshTokenEntity);

        return refreshToken;
    }

    // 이미 사용한 refresh token 업데이트
    public RefreshToken updateRefreshToken(Long userId, String refreshToken) {
        RefreshToken refreshTokenEntity = findByRefreshToken(refreshToken);
        if (refreshTokenEntity == null) {
            System.err.println("Refresh Token not found");
            throw new IllegalArgumentException("Unexpected Refresh Token");
        }
        refreshTokenEntity.update(tokenProvider.makeToken(userId, null, REFRESH_EXPIRATION));
        return refreshTokenRepository.save(refreshTokenEntity);
    }

    // 로그아웃 시 refresh token 삭제
    @Transactional
    public void delete() {
        // 현재 로그인 되어있는 유저 찾기
        String token = SecurityContextHolder.getContext().getAuthentication().getCredentials().toString();
        Long userId = tokenProvider.getUserId(token);
        
        // 해당 유저의 refresh token 삭제
        refreshTokenRepository.deleteByUserId(userId);
    }

    // refresh token 만료 시 DB에서 삭제
    public void expire(String refreshToken) {
        RefreshToken refreshTokenEntity = findByRefreshToken(refreshToken);
        if (refreshTokenEntity != null) {
            refreshTokenRepository.deleteByUserId(refreshTokenEntity.getUserId());
        }
    }
}

다음은 token service이다. 여기서는 refresh token이 유효한지 검증하고, 유효하다면 access token을 새로 발급하면서, 이미 사용된 refresh token도 폐기하고 다시 생성한다.

/** service/TokenService.java **/
import com.survey.server.config.jwt.TokenProvider;
import com.survey.server.domain.RefreshToken;
import com.survey.server.model.User;
import com.survey.server.repository.RefreshTokenRepository;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Set;
import java.util.stream.Collectors;

@RequiredArgsConstructor
@Service
public class TokenService {
    private final TokenProvider tokenProvider;
    private final RefreshTokenService refreshTokenService;

    // 새로운 access token 생성
    public String createNewAccessToken(String refreshToken, Set<String> roles) {
        // refresh token 유효성 검증
        if (!tokenProvider.isValidToken(refreshToken)) {
            refreshTokenService.expire(refreshToken); // 만료된 refresh token 삭제
            throw new IllegalArgumentException("Invalid refresh token");
        }

        Long userId = refreshTokenService.findByRefreshToken(refreshToken).getUserId();
        
        // refresh token update
        refreshTokenService.deleteByUserId(userId);
        refreshTokenService.createNewRefreshToken(userId);

        // access token 재발급
        return tokenProvider.makeToken(userId, roles);
    }
}

3. 로그인에 refresh token 생성 로직 추가

로그인 시에 바로 access token을 생성하던 것에서 refresh token을 생성한 후 이를 기반으로 access token을 생성하는 것으로 로직을 수정한다.

/** controller/UserController.java **/
@PostMapping("/login")
public ResponseEntity<LoginResponseDTO> login(@RequestBody @Validated LoginRequestDTO request, HttpServletResponse response) {
    try {
        LoginResponseDTO result = userService.login(request, response);
        return ResponseEntity.ok(result);
    } catch (IllegalStateException e) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

/** service/UserService.java **/
public LoginResponseDTO login(LoginRequestDTO request, HttpServletResponse response) {
    Optional<User> optionalUser = userRepository.findByUserIdent(request.getUserIdent());
    if (optionalUser.isEmpty() ||
            !bCryptPasswordEncoder.matches(request.getUserPassword(), optionalUser.get().getPasswordHash())) {
        throw new IllegalStateException("로그인 실패: invalid_credentials");
    }

    // refresh token 생성
    User user = optionalUser.get();
    String refreshToken = refreshTokenService.createNewRefreshToken(user.getUserId());
    CookieUtil.addCookie(response, "refresh_token", refreshToken, 7 * 24 * 60 * 60); //7일

    // access token 생성
    Set<String> roles = user.getAuthorities().stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toSet());
    String accessToken = tokenService.createNewAccessToken(refreshToken, roles);

    return new LoginResponseDTO(
            accessToken,
            user.getUserIdent(),
            roles
    );
}

6. TokenController 작성으로 클라이언트로부터 access token 발급 요청받기

마지막으로 access token이 만료되었을 때, 클라이언트가 refresh token을 가지고 재발급받을 수 있도록 TokenController를 작성한다.

/** controller/TokenController.java **/
import com.survey.server.dto.CreateAccessTokenRequest;
import com.survey.server.dto.CreateAccessTokenResponse;
import com.survey.server.service.RefreshTokenService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.survey.server.service.TokenService;

import java.util.Set;

@Controller
@RequestMapping("/api")
@RequiredArgsConstructor
public class TokenController {
    private final TokenService tokenService;
    private final RefreshTokenService refreshTokenService;

    /**
     * access token 발급 endpoint
     * @param request access token 발급 요청
     * @return token 발급 응답 DTO를 담은 Response Entity
     */
    @PostMapping("/token")
    public ResponseEntity<CreateAccessTokenResponse> createNewAccessToken(@RequestBody CreateAccessTokenRequest request) {
        try {
            String newAccessToken = tokenService.createNewAccessToken(request.getRefreshToken(), Set.of("ROLE_USER"));
            return ResponseEntity.status(HttpStatus.CREATED)
                    .body(new CreateAccessTokenResponse(newAccessToken));
        } catch (IllegalArgumentException e) {
            // 유효하지 않은 refresh token
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(null);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
}

[Spring Boot/JWT] JWT로 로그인/로그아웃 구현하기

iinana — Sat, 12 Apr 2025 22:22:27 +0900

토큰 기반 인증

1. 토큰 기반 인증이란

토큰을 사용하여 인증하는 방식이다. 서버가 토큰을 생성해서 클라이언트에게 제공하면, 클라이언트는 이 토큰을 가지고 있다가 여러 요청을 토큰과 함께 신청한다. 서버는 토큰을 보고 유효한 사용자인지 검증하여 요청을 수행해준다.

2. 세션 기반 인증과 토큰 기반 인증

세션 기반 인증은 사용자마다 사용자의 정보를 담은 세션을 생성하고 저장해서 인증하는 방식이다. 세션 기반 인증과 토큰 기반 인증의 가장 큰 차이는 요청과 함께 전달하는 정보의 양 차이이다. 토큰 기반 인증의 경우, 검증에 필요한 정보를 모두 담은 토큰을 요청과 함께 전달한다. 즉, 토큰에 회원정보와 유효기간 같은 검증에 필요한 정보도 담겨있어, 토큰만 확인하면 회원의 유효성을 입증할 수 있다. 하지만 세션 기반 인증의 경우, 토큰과 달리 최소한의 정보만을 담아서 요청과 함께 서버에 보낸다. 그러면 서버에서는 메모리나 DB에 저장된 정보에서 전달받은 정보를 기반으로 유효한 사용자인지 검증을 하는 방식이다. 하지만 토큰 기반 인증의 경우, 토큰만 확인하면 되기 때문에 따로 정보를 저장해둘 필요도, 이를 검색하여 유효성을 검증할 필요도 없다.

3. 토큰 기반 인증의 특징

위에서 세션 기반 인증과의 차이점으로 인해 발현되는 토큰 기반 인증의 특징들이 있다. 특징이자 jwt의 장점이기도 하다. 그 특징들은 아래와 같다.

무상태성: 서버에 별도로 인증 정보를 저장할 필요 없음 (클라이언트가 토큰을 가지고 있음)
확장성: 서버 확장 시 상태 관리에 신경 쓸 필요가 없음 (하나의 토큰으로 다양한 서버에 요청을 보낼 수 있음)
무결성: 토큰을 발급한 이후 누군가 토큰 정보를 변경하는 행위를 할 수 없음

JWT (Json Web Token)

1. JWT의 토큰 구성

발급받은 JWT를 이용해 인증을 하려면 HTTP 요청 헤더 중 Authorization 키 값에 "Bearer " + JWT 토큰값을 넣어 보내야 한다. JWT 토큰값은 헤더(header), 내용(payload), 서명(signature)로 구성된다. 이 구성 정보들을 BASE64로 인코딩한 값이 JWT 토큰값이 된다.

(1) 헤더(header): 토큰의 타입과 해싱 알고리즘을 지정하는 정보

{
    "typ": "JWT",
    "alg": "HS256"
}

(2) 내용(payload): 토큰과 관련된 정보를 담음. 내용 한 덩어리를 클레임(claim)이라고 하며, 공개되어도 상관없는 클레임인 공개 클레임, 공개되면 안되는 클레임인 비공개 클레임, 마지막으로 JWT 자체에서 등록된 등록된 클레임이 있다. 등록된 클레임은 아래와 같다.

iss : issuer (토큰 발급자)
sub : subject (토큰 제목)
aud: audience (토큰 대상자)
exp: experation (토큰 만료 시간, NumericDate 형식)
nbf: not before (토큰의 활성 날짜, NumericDate 형식)
iat: issued at (토큰 발급 시간)
jti: JWT의 고유 식별자 (일회용 토큰에서 주로 사용)

(3) 서명(signiture): 토큰이 조작되었거나 변경되지 않았음을 확인하는 용도로 사용된다. header와 payload의 인코딩 값을 합친 후 secret key를 넣는다.

2. refresh token

토큰의 유효기간이 길면 토큰 탈취의 위험이 있고, 유효기간이 짧으면 재발급의 불편이 있으므로, 이를 해결하기 위해 refresh token이 사용된다. 액세스 토큰의 유효기간을 짧게 설정하고, refresh token의 유효기간은 길게 설정하면, 엑세스 토큰이 탈취당해도 짧은 유효기간 이후에 사용할 수 없으므로 보다 안전해진다.

작동하는 방식은 액세스 토큰으로 요청을 전달했는데, 만료된 액세스 토큰인 경우 refresh token과 함께 액세스 토큰 발급 요청을 해서 새로운 액세스 토큰을 받는 방식이다.

3. JWT로 인증 구현 시 주의할 점 (https://www.youtube.com/watch?v=XXseiON9CV0)

(1) 헤더 부분의 알고리즘을 none으로 채우지 말 것

알고리즘을 none으로 만들면, 이를 이용해서 공격하는 것으로부터 안전할 수 없다. 따라서, none으로 만든 JWT 입장권들을 거절하는 기능이 있는지 확인해야 한다. 최신 라이브러리(HS256 등)를 잘 사용하면 안전하다.

{
    "alg": "none", //위험 -> "HS256" 사용
    "typ": "JWT"
}

(2) 최소한의 정보만 넣기

JWT는 변환이 쉽기 때문에, 민감한 정보들은 빼고, 인증을 위한 최소한의 정보만 넣는 것이 좋다.

(3) 시크릿키를 제대로 작성

너무 짧거나 추측하기 쉬운 secret key로 설정을 하게 되면, 예측이 쉬워져서 bruteforce attack을 받을 수 있다. secret key가 유출되면 token이 외부에 의해 마음대로 발행되는 일이 발생할 수 있다. 따라서 키를 매우 길게 설정하고, 공유하지 않는 것이 중요하다. 조금 더 엄격하게 관리하고 싶다면, 생성용키와 검증용키를 따로 생성하여 사용하는 방법도 있다.

JWT로 로그인/로그아웃 구현하기

├── src
│ ├── main
│ │ ├── java
│ │ │ └── com.study.blog_project
│ │ │ ├── config
│ │ │ ├── jwt
│ │ │ ├── JwtProperties.java // 토큰제공자&secretKey 변수로 가져오기
│ │ │ ├── TokenAuthenticationFilter.java // 토큰 필터
│ │ │ └── TokenProvider.java // 토큰생성&유효성검증&인증정보가져오기
│ │ │ ├── RedisConfig.java // 인증코드 저장을 위한 Redis 저장소 설정
│ │ │ └── WebSecurityConfig.java // 접근권한, password encoder 설정
│ │ │ ├── controller
│ │ │ └── UserController.java
│ │ │ ├── dto // 편의상 알파벳 순이 아닌 서비스 로직 순으로 작성
│ │ │ ├── SignupRequestDTO.java // 회원가입
│ │ │ ├── SignupResponseDTO.java
│ │ │ ├── IdentConfirmDTO.java // 아이디 중복확인 (회원가입 시)
│ │ │ ├── LoginRequestDTO.java // 로그인
│ │ │ ├── LoginResponseDTO.java
│ │ │ ├── FindIdentRequestDTO.java // 아이디, 비밀번호 찾기
│ │ │ ├── FindIdentResponseDTO.java
│ │ │ ├── FindPasswordRequestDTO.java
│ │ │ ├── PasswordUpdateDTO.java // 비밀번호 변경 (비밀번호 찾기 시)
│ │ │ ├── VerificationEmailSendDTO.java // 인증메일 전송
│ │ │ └── CodeVeriyDTO.java // 인증번호 확인
│ │ │ ├── model
│ │ │ └── User.java
│ │ │ ├── repository
│ │ │ ├── UserRepository.jva
│ │ │ └── VerificationRepository.java // 인증번호 저장용 Redis Repository
│ │ │ └── service
│ │ │ ├── MailService.java
│ │ │ └── UserService.java
│ │ └── resources
│ │ │ ├── application.yml
│ │ │ └── application-secret.yml
│ └── build.gradle

0. 기본 준비

(1) 의존성 추가하기

/** build.gradle **/
dependencies {
    // spring web
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // validation
    implementation 'org.springframework.boot:spring-boot-starter-validation'

    // java mail sender
    implementation 'org.springframework.boot:spring-boot-starter-mail'

    // jwt
    implementation 'io.jsonwebtoken:jjwt:0.9.1'
    implementation 'javax.xml.bind:jaxb-api:2.3.1'

    // lombok
    implementation 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'

    // spring security
    implementation 'org.springframework.boot:spring-boot-starter-security'
    testImplementation 'org.springframework.security:spring-security-test'

    // DB & caching
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'  // jpa
    implementation 'org.mariadb.jdbc:mariadb-java-client:3.1.2' // maria db
    implementation 'org.springframework.boot:spring-boot-starter-data-redis' // redis

    // gson for redis config
    implementation 'com.google.code.gson:gson:2.8.6'

    // test
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'io.projectreactor:reactor-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

(2) application.yml 설정

민감한 정보는 application-secret.yml에 따로 빼서 넣었다. 어떤 정보가 있는지는 주석으로 표기되어 있다.

## application.yml ##
spring:
  application:
    name: survey-server

  # DB 연결
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    url: jdbc:mariadb://127.0.0.1:3306/survey?serverTimezone=Asia/Seoul

  # 인증 메일 전송
  mail:
    host: smtp.gmail.com
    port: 587
    properties:
      mail.smtp.auth: true
      mail.smtp.starttls.enable: true

  # jwt token
  jwt:
    expiration: 3600000 #1시간(단위:ms)

  config:
    import: application-secret.yml
    #datasource:
    #  username: username
    #  password: password
    #jwt:
    #  issuer: issuer_email
    #  secret_key: secret_key
    #  expiration: 3600000
    #mail:
    #  username: email_address
    #  password: email_password

  # db 연결용 jpa
  jpa:
    properties:
      hibernate:
        show_sql: true
        format_sql: true
    hibernate:
      ddl-auto: create
    database-platform: org.hibernate.dialect.MySQLDialect

# 로깅
logging:
  level:
    root: DEBUG
    com.survey: DEBUG

1. JWT Token 관련 로직

(1) application.yml에서 설정한 jwt properties 불러오기

application.yml 파일에 설정해 둔 token issuer, secretKey, 그리고 토큰 만료 기간에 해당하는 expiration을 주입 받아 사용할 수 있도록 JwtProperties 파일을 만들어서 불러온다.

/** JwtProperties.java **/
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@ConfigurationProperties("spring.jwt")
@Getter
@Setter
@Component
public class JwtProperties {
    private String issuer;
    private String secretKey;
    private Long expiration;
}

(2) TokenProvider 서비스 작성

/** TokenProvider.java **/
import java.util.Collections;
import java.util.Date;
import java.util.Set;
import java.util.stream.Collectors;

import com.survey.server.model.User;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Header;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Service;
import org.springframework.security.core.Authentication;

@RequiredArgsConstructor
@Service
public class TokenProvider {
    private final JwtProperties jwtProperties;
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 주어진 사용자 정보로 새로운 JWT 토큰 생성
     *
     * @param userEmail 사용자 이메일 (사용자 구분할 unique한 값)
     * @param roles 사용자 권한 (ROLE_USER이 담긴 set)
     * @return 생성된 JWT 토큰 문자열
     */
    public String makeToken(String userEmail, Set<String> roles) {
        log.info("토큰 발행 프로세스 시작: email={}, roles={}", userEmail, roles);
        Date now = new Date();

        log.debug("토큰 정보: expiration={}", jwtProperties.getExpiration());
        Date validity = new Date(now.getTime() + jwtProperties.getExpiration());

        log.debug("토큰 리턴: issuer={}, secret_key={}", jwtProperties.getIssuer(), jwtProperties.getSecretKey());
        return Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE)  //header type : JWT
                .setIssuer(jwtProperties.getIssuer())
                .setIssuedAt(now)
                .setSubject(userEmail)
                .claim("roles", roles)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecretKey())
                // signiture (secret key와 함께 해시값을 HS256 방식으로 암호화)
                .compact();
    }

    /**
     * 토큰 유효성 검증
     *
     * @param token 검증할 JWT 토큰
     * @return 토큰이 유효하면 true
     */
    public boolean isValidToken(String token) {
        try {
            Jwts.parser()
                    .setSigningKey(jwtProperties.getSecretKey())
                    .parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 유효한 토큰 기반으로 인증 정보 가져오기
     *
     * @param token 유효한 JWT 토큰
     * @return 사용자 정보와 기본 권한을 포함한 Authentication 객체
     */
    public Authentication getAuthentication(String token) {
        // 토큰에서 클레임 추출
        Claims claims = Jwts.parser()
                .setSigningKey(jwtProperties.getSecretKey())
                .parseClaimsJws(token)
                .getBody();

        // 기본 권한 설정 (ROLE_USER)
        Set<SimpleGrantedAuthority> authorities = Collections
                .singleton(new SimpleGrantedAuthority(("ROLE_USER")));

        // Authentication 객체 리턴
        return new UsernamePasswordAuthenticationToken(
                new org.springframework.security.core.userdetails.User( // 사용자 정보
                        claims.getSubject(),"", authorities),  // - email, password(JWT 기반 인증에서 불필요), 권한정보(ROLE_USER)
                token, authorities); // 인증정보(token), 권한 리스트(authorities)
    }
}

[ method 01: makeToken() ] 토큰 생성: 아래와 같은 내용을 인코딩하여 토큰을 만든다

#header
{
    "typ": "JWT",
    "alg": "HS256"
}

#payload
{
    "iss": {jwtProperties에서 가져온 issuer},
    "iat": {현재 시간: new Date() 값},
    "exp": {method argument로 받은 expiry},
    "roles": {사용자에게 부여할 접근 권한 set},
    "sub": {subject로 user email 사용}
}

#signiture: jwProperties에서 가져온 secretKey

[ method 02: validToken() ] 토큰 유효성 검증

여기서 Jwts.parser()는 입력받은 토큰을 비밀값으로 복호화해서 토큰이 유효한지 확인하는 역할을 한다. setSigningKey로 입력받은 토큰을 복호화 할 secret key를 설정하고, parseClaimsJws(token)으로 인자인 'token'이 유효한 토큰인지를 검증한다.

[ method 03: getAuthentication() ] 토큰 기반으로 인증 정보 가져오기

token으로부터 claim 추출
사용자 권한 설정
- 부여되는 권한 : ROLE_USER (일반 사용자 권한, 관리자 권한은 ROLE_ADMIN으로 부여)
- Set Collection Framework 사용 : 사용자가 여러개의 권한을 가질 수 있음을 의미. Set은 중복이 불가능하고 contains() 메서드가 있어 이용자 권한을 쉽게 저장하고 확인할 수 있음
- Collections.singleton() : authorization set에 변경이 불가능한 단일 요소만 추가. 따라서 authorization set에는 "ROLE_USER"만 포함 가능 => 이용자는 ROLE_USER 권한만 가질 수 있음 (참고자료: https://ittrue.tistory.com/563)
인증 정보 생성 (UsernamePasswordAuthenticationToken이라는 spring security 인증 객체 생성)
- 첫번째 인자: User 객체 (사용자 정보)
- 두번째 인자: token
- 세번째 인자: authorities (사용자 권한

(3) Token Filter 생성

각 요청마다 토큰이 유효한지 검증하고, 유효한 토큰만 context holder에 저장할 수 있도록 한다. 이때 context holder에 저장한다는 것은 추후 사용자가 인증이 필요한 페이지에 접근할 경우 인증된 사용자라는 것을 알 수 있도록 spring security에 알리는 것을 말한다. 추후 로그인이 필요한 서비스에서 사용될 예정이다.

/** TokenAuthenticationFilter.java **/
import com.survey.server.config.jwt.TokenProvider;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@RequiredArgsConstructor
public class TokenAuthenticationFilter extends OncePerRequestFilter {
    private final TokenProvider tokenProvider;
    private final static String HEADER_AUTHORIZATION = "Authorization";
    private final static String TOKEN_PREFIX = "Bearer ";


    /**
     * 모든 요청에 대해 JWT 토큰을 검증하고 인증 처리를 수행
     *
     * @param request HTTP 요청
     * @param response HTTP 응답
     * @param filterChain 필터체인
     * @throws ServletException
     * @throws IOException
     */
    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        // 요청 헤더에서 토큰 추출
        String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);
        String token = (authorizationHeader != null && authorizationHeader.startsWith(TOKEN_PREFIX))
                ? authorizationHeader.substring(TOKEN_PREFIX.length()) : null;

        // 유효한 토큰일 경우 context holder에 인증 정보 저장
        // - 현재 요청을 보낸 사용자가 인증되었음을 Spring Security에 알림
        if (tokenProvider.isValidToken(token)) {
            Authentication authentication = tokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }
}

(4) Web Security Configuration 생성

다음으로, 비밀번호 암호화와 페이지 접근 권한 설정을 위해 Web Security에 대한 Configuration을 작성해준다.

먼저 페이지 접근 권한 설정 부분을 보면, 앞서 만든 Token Filter를 등록하여 인증이 필요한 모든 요청에 대해 JWT 토큰 기반 인증을 수행하도록 설정한다. 단, 로그인, 회원가입, 이메일 인증 등과 같이 인증 없이 접근 가능한 일부 페이지는 permitAll()을 통해 예외 처리되어 있다.

또한, PasswordEncoder는 비밀번호를 DB에 평문으로 저장하는 것이 아닌 해시 값으로 안전하게 저장하기 위해 사용된다. 사용자가 로그인 시 입력한 비밀번호는 저장된 해시 값과 비교되어 인증되며, 이를 위해 passwordEncoder.matches() 메서드가 사용된다.

/** WebSecurityConfig.java **/
import com.survey.server.config.jwt.TokenAuthenticationFilter;
import com.survey.server.config.jwt.TokenProvider;
import com.survey.server.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;


@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class WebSecurityConfig {
    private final TokenProvider tokenProvider;

    /**
     * 페이지 접근 권한 설정
     *  - 특정 HTTP 요청에 대해 웹기반 보안 구성
     */
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
                // CSRF 비활성화 (JWT에서는 불필요)
                .csrf(AbstractHttpConfigurer::disable)

                // JWT 기반 인증을 위한 Token Filter 추가
                .addFilterBefore(new TokenAuthenticationFilter(tokenProvider),
                        org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter.class)

                // 로그인 + 회원가입 관련 페이지 회원이 아니더라도 접근 허용
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers(
                                "/user/signup",
                                "/user/login",
                                "/user/verification/**"
                        ).permitAll()
                        .anyRequest().authenticated())
                .build();
    }

    @Bean
    public AuthenticationManager authenticationManager(HttpSecurity http, BCryptPasswordEncoder passwordEncoder, UserService userService) throws Exception {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userService);
        authProvider.setPasswordEncoder(passwordEncoder);
        return new ProviderManager(authProvider);
    }

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

2. Entity 및 DTO 생성

(1) User Entity 생성

User Entity의 구조는 다음과 같다. (실제로 지금 개발 중인 서비스의 ERD는 이와 조금 달랐으나, 편의상 지금 구현 중인 로그인/회원가입에 필요한 요소만으로 구성했다.)

컬럼명	자료형	nullable	설명	특이사항
user_id	int unsigned	false	일련번호, 기본키	자동 생성
email	varchar(255)	false	이용자 이메일	중복 불가
user_id	varchar(50)	false	사용자 입력 아이디	중복 불가
password_hash	varchar(50)	fasle	encoding된 사용자 비밀번호	bcrytypt encoder 사용
created_at	DATE	false	회원가입일 (이용자 생성일)	자동 생성
privacy_agree	boolean	fasle	개인정보보호 동의 여부	false 값일 수 없음 (가입 불가)
marketing_agree	boolean	false	마케팅수신 동의 여부	선택 약관

자동생성이라고 표기된 id는 @GenerateValue 어노테이션으로 일련번호가 자동 생성되고, created_at의 경우에도 @PrePersist 어노테이션과 함께 사용된 onCreate method로 자동으로 회원가입 시의 날짜가 부여된다.

그리고 User Entity는 UserDetails를 implement 한다. UserDetails를 Spring Security에서 사용자의 인증 정보를 담아 두는 interface이다. 해당 객체를 토앻 인증 정보를 가져오려면 필수로 몇가지 method들을 override해야 한다.

/** User.java **/
import com.survey.server.constant.SEX;
import jakarta.persistence.*;
import lombok.*;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;
import java.util.Date;
import java.util.List;

@Entity
@Table(name="users")
@Getter
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id", updatable=false)
    private Long userId;

    @Column(name="user_name", nullable = false)
    private String userName;

    @Column(name="email", nullable=false, unique=true)
    private String email;

    @Column(name="user_ident", nullable=false, unique=true)
    private String userIdent;

    @Column(name="password_hash", nullable=false)
    private String passwordHash;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="created_at", nullable=false, updatable=false)
    private Date createdAt;

    @Column(name="privacy_agree", nullable=false)
    private Boolean privacyAgree;

    @Column(name="marketing_agree", nullable=false)
    private Boolean marketingAgree;

    // 비밀번호 변경
    public void updatePassword(String newPasswordHash) {
        this.passwordHash = newPasswordHash;
    }

    // createdAt 자동 생성
    @PrePersist
    protected void onCreate() {
        this.createdAt = new Date();
    }

    // 사용자가 가지고 있는 권한 목록 반환
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(new SimpleGrantedAuthority("ROLE_USER"));
    }

    // 사용자 이름 반환
    @Override
    public String getUsername() {
        return userName;
    }

    // encoding 된 비밀번호 반환
    @Override
    public String getPassword() {
        return passwordHash;
    }

    // 계정 만료 여부 반환
    @Override
    public boolean isAccountNonExpired() {
        return true; //만료되지 않았음
    }

    // 계정 잠금여부 반환
    @Override
    public boolean isAccountNonLocked() {
        return true; //잠금되지 않았음
    }

    // 패스워드 만료여부 반환
    @Override
    public boolean isCredentialsNonExpired() {
        return true; //만료되지 않았음
    }

    // 계정 사용 가능 여부 반환
    @Override
    public boolean isEnabled() {
        return true; //계정 사용 가능
    }
}

(2) SignupRequestDTO 생성

DTO의 경우 너무 많은 파일이 존재하기 때문에, 기본적으로 DTO를 쓸 때 신경 썼던 부분이 모두 담겨있는 SignupRequestDTO만 기록하고 넘어가려 한다. DTO들에서 값의 패턴이나 조건을 확인하는 어노테이션을 많이 사용했다. 형식에 맞는 값이 아니라면 DTO 생성에서부터 exception을 발생시켜 다음 단계를 진행할 수 없도록 코드를 작성했다.

우선 전반적으로 빈 값이면 안되는 값들에 대해 @NotBlank 어노테이션을 사용했다. 무조건 입력되어야 하는 값들에 사용할 수 있는 어노테이션이 세가지 있는데, 그 내용은 아래와 같다. 결론부터 말하자면 나는 가장 엄격하게 입력값을 확인하는 어노테이션을 사용했다.

	Null 값 허용	빈칸 허용	공백만 있는 값 허용	설명
@NotNull	X	O	O	Null값인지 확인
@NotEmpty	X	X	O	입력값의 길이를 확인
@NotBlank	X	X	X	공백을 제거한 입력값의 길이를 확인

비밀번호 형식의 경우 @Pattern 어노테이션을 사용했다. regexp가 지켜저야 하는 비밀번호 형식에 해당하는데, 나는 8자리 이상의 숫자, 알파벳, 특수문자 중 모두를 조합한 비밀번호인지 확인했다.

그리고 privacyArgee, 즉 개인정보이용동의 항목 같은 경우, 동의하지 않으면 회원가입을 진행할 수 없다. 따라서 이 경우 @AssertTrue 어노테이션을 활용하여 true 값이 아니면 exception을 발생시켰다. 비슷한 로직으로 userPassword와 passwordConfirm, 즉 비밀번호 입력란과 비밀번호 확인란의 값이 같은지, DTO내 method인 isPasswordMatching()에 @AssertTrue 어노테이션을 달아 확인한다.

/** SignupRequestDTO.java **/
import jakarta.validation.constraints.AssertTrue;
import jakarta.validation.constraints.Pattern;
import lombok.AllArgsConstructor;
import lombok.Getter;
import jakarta.validation.constraints.NotBlank;

@AllArgsConstructor
@Getter
public class SignupRequestDTO {
    @NotBlank(message = "user_name cannot be empty")
    String userName;
    @NotBlank(message = "user_email cannot be empty")
    String userEmail;
    @NotBlank(message = "user_ident cannot be empty")
    String userIdent;

    @NotBlank(message = "user_password cannot be empty")
    @Pattern(
            regexp = "^(?=.*[A-Za-z].*)(?=.*\\d.*|.*[^A-Za-z0-9].*).{8,}$",
            message = "Password must be at least 8 characters long and contain at least two of the following: letters, numbers, or special characters"
    )
    String userPassword;
    String passwordConfirm;
    @AssertTrue(message = "Passwords do not match")
    public boolean isPasswordMatching() {
        return userPassword.equals(passwordConfirm);
    }

    @AssertTrue(message = "user should agree with privacy agreement")
    Boolean privacyAgree;
    Boolean marketingAgree;

    @AssertTrue(message = "user should check ident duplication first")
    Boolean identConfirmed;
    @AssertTrue(message = "user should verify email first")
    Boolean emailVerified;
}

3. User 관련 주요 로직 작성 (controller, service, repository)

(1) User Controller 작성

/** UserController.java **/
import com.survey.server.dto.*;
import com.survey.server.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.NoSuchElementException;

@RequiredArgsConstructor
@RestController
@RequestMapping("/user")
public class UserController {
    private final UserService userService;

    /**
     * 회원 가입 endpoint
     *
     * @param request 회원가입 요청 DTO
     * @return 회원가입 응답 DTO를 포함한 ResponseEntity
     */
    @PostMapping("/signup")
    public ResponseEntity<SignupResponseDTO> signup(@RequestBody SignupRequestDTO request) {
        try {
            SignupResponseDTO response = userService.signup(request);
            return ResponseEntity.status(HttpStatus.CREATED).body(response);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 아이디 중복확인 endpoint
     *
     * @param request 아이디 중복확인 요청 DTO
     * @return 중복 확인 결과 Boolean 값 (중복되지 않을 시, 즉 아이디를 사용 가능한 경우 true)
     */
    @PostMapping("/signup/id")
    public ResponseEntity<Boolean> confirmIdent(@RequestBody IdentConfirmDTO request) {
        try {
            Boolean result = userService.confirmIdent(request);
            return ResponseEntity.ok(result);
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body(false);
        }
    }

    /**
     * 로그인 endpoint
     *
     * @param request 로그인 요청 DTO
     * @return 로그인 응답 DTO를 포함한 ResponseEntity
     */
    @PostMapping("/login")
    public ResponseEntity<LoginResponseDTO> login(@RequestBody @Validated LoginRequestDTO request) {
        try {
            LoginResponseDTO response = userService.login(request);
            return ResponseEntity.ok(response);
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 아이디 찾기 endpoint
     *
     * @param request 아이디 찾기 요청 DTO
     * @return 아이디 찾기 응답 DTO를 포함한 ResponseEntity
     */
    @PostMapping("/ident")
    public ResponseEntity<FindIdentResponseDTO> findIdent(@RequestBody FindIdentRequestDTO request) {
        try {
            FindIdentResponseDTO response = userService.findIdent(request);
            return ResponseEntity.ok(response);
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 비밀번호 찾기 endpoint
     *
     * @param request 비밀번호 찾기 요청 DTO
     * @return 회원정보와 일치하는 회원의 존재여부 (회원 정보 + 인증 번호 모두 맞아야 true)
     */
    @PostMapping("/password")
    public ResponseEntity<Boolean> findPassword(@RequestBody FindPasswordRequestDTO request) {
        try {
            Boolean result = userService.findPassword(request);
            return ResponseEntity.ok(result);
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 인증 메일 전송 endpoint
     *
     * @param sendDTO 이메일 전송 요청 DTO
     * @return 이메일 전송 결과 String
     */
    @PostMapping("/verification/email")
    public ResponseEntity<String> sendVerificationEmail(@RequestBody VerificationEmailSendDTO sendDTO) {
        try {
            userService.sendVerificationEmail(sendDTO);
            return ResponseEntity.ok("Verification email sent");
        } catch (IllegalStateException e) { // 회원가입 시 이메일 중복
            return ResponseEntity.status(HttpStatus.CONFLICT).body("signup: existing email");
        } catch (Exception e) {
            return ResponseEntity.internalServerError().build();
        }
    }

    /**
     * 인증번호 확인 endpoint
     *
     * @param verifyDTO 인증번호 확인 요청 DTO
     * @return 인증번호 확인 결과 Boolean (번호 일치할 경우 true)
     * 이메일 존재하지 않을 경우 UNAUTHORIZED(401)
     */
    @PostMapping("/verification")
    public ResponseEntity<Boolean> verifyCode(@RequestBody CodeVerifyDTO verifyDTO) {
        try {
            Boolean result = userService.verifycode(verifyDTO);
            return ResponseEntity.ok(result);
        } catch (NoSuchElementException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 비밀번호 변경 endpoint
     *
     * @param passwordUpdateDTO 비밀번호 변경 요청 DTO
     * @return 비밀번호 변경 결과 String
     */
    @PostMapping("/password/new")
    public ResponseEntity<String> updatePassword(@RequestBody PasswordUpdateDTO passwordUpdateDTO) {
        try {
            userService.updatePassword(passwordUpdateDTO);
            return ResponseEntity.ok("Password updated");
        } catch (IllegalStateException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        } catch (Exception e) {
            return ResponseEntity.internalServerError().build();
        }
    }
}

(2) User Service 작성

/** UserService.java **/
import com.survey.server.config.jwt.TokenProvider;
import com.survey.server.dto.*;
import com.survey.server.repository.UserRepository;
import com.survey.server.model.User;
import lombok.RequiredArgsConstructor;
import org.apache.logging.log4j.util.InternalException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

@RequiredArgsConstructor
@Service
public class UserService implements UserDetailsService {
    private final BCryptPasswordEncoder bCryptPasswordEncoder;
    private final UserRepository userRepository;
    private final TokenProvider tokenProvider;
    private final MailService mailService;

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 회원가입 요청을 처리하여 사용자 정보를 저장하고 반환
     *
     * @param request 회원가입 요청 DTO
     * @return 회원가입 응답 DTO
     */
    public SignupResponseDTO signup(SignupRequestDTO request) {
        log.info("회원가입 프로세스 시작: ident={}, email={}", request.getUserIdent(), request.getUserEmail());

        String passwordHash = bCryptPasswordEncoder.encode(request.getUserPassword());
        log.debug("회원가입: 비밀번호 encoding 완료");
        User user = User.builder()
                .userName(request.getUserName())
                .userIdent(request.getUserIdent())
                .email(request.getUserEmail())
                .passwordHash(passwordHash)
                .point(0L)
                .privacyAgree(request.getPrivacyAgree())
                .marketingAgree(request.getMarketingAgree())
                .build();
        log.debug("회원가입: user entity 생성 완료");

        try {
            userRepository.save(user);
            log.info("사용자 정보 저장 완료: ident={}, name={}", request.getUserIdent(), request.getUserName());
        } catch (Exception e) {
            log.error("회원가입 실패: ident={}, error={}", request.getUserIdent(), e.getMessage());
            throw new RuntimeException("회원 정보 저장 실패");
        }

        return new SignupResponseDTO(
                user.getUserIdent(),
                user.getUsername()
        );
    }

    /**
     * 아이디 중복확인하고 결과 반환
     *
     * @param request 아이디 중복확인 요청 DTO
     * @return 중복되지 않을 시 true, 중복되는 경우 exception 발생
     */
    public Boolean confirmIdent(IdentConfirmDTO request) {
        log.info("아이디 중복확인 시작: ident={}", request.getUserIdent());

        if (!userRepository.existsByUserIdent(request.getUserIdent())) {
            log.info("사용 가능한 아이디: ident={}", request.getUserIdent());
            return true;
        } else {
            log.info("중복된 아이디: ident={}", request.getUserIdent());
            throw new IllegalStateException("이미 사용하고 있는 아이디입니다.");
        }
    }

    /**
     * 로그인 처리하고 결과 반환
     * @param request 로그인 요청 DTO
     * @return 로그인 응답 DTO
     */
    public LoginResponseDTO login(LoginRequestDTO request) {
        log.info("로그인 시도: ident={}", request.getUserIdent());

        Optional<User> optionalUser = userRepository.findByUserIdent(request.getUserIdent());
        if (optionalUser.isEmpty() ||
                !bCryptPasswordEncoder.matches(request.getUserPassword(), optionalUser.get().getPasswordHash())) {
            log.warn("로그인 실패: ident={}, reason=invalid_credentials", request.getUserIdent());
            throw new IllegalStateException("로그인 실패: invalid_credentials");
        }
        log.debug("로그인 조건 충족 (valid id and password)");

        // 토큰 생성
        User user = optionalUser.get();
        Set<String> roles = user.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toSet());

        log.debug("토큰 생성: ident={}, roles={}", request.getUserIdent(), roles);
        String token = tokenProvider.makeToken(user.getEmail(), roles);

        log.info("로그인 성공: ident={}", request.getUserIdent());
        return new LoginResponseDTO(
                token,
                user.getUserIdent(),
                roles
        );
    }

    /**
     * 아이디 찾기 (인증 코드 확인하고 아이디 반환)
     * @param request 아이디 찾기 요청 DTO
     * @return 아이디 찾기 응답 DTO
     * @throws Exception (verification code 확인하며 발생한 exception throw)
     */
    public FindIdentResponseDTO findIdent(FindIdentRequestDTO request) throws Exception {
        log.info("아이디 찾기 시작: email={}", request.getUserEmail());

        User user = userRepository.findByEmail(request.getUserEmail())
                .orElseThrow(() -> new IllegalStateException("Invalid user credentials"));
        log.debug("아이디 찾기 대상 user 찾기 성공 (valid email)");
        if (!user.getUsername().equals(request.getUserName())) {
            log.warn("아이디 찾기 실패: email={}, reason=invalid_credentials", request.getUserEmail());
            throw new IllegalStateException("Invalid user credentials");
        }

        // 인증 번호 확인
        if(!mailService.verifycode(request.getUserEmail(), request.getVerificationCode())) {
            log.warn("아이디 찾기 실패: email={}, reason=invalid_verification_code", request.getUserEmail());
            throw new IllegalStateException("Invalid verification code");
        }

        log.debug("아이디 찾기 성공: email={}, ident={}", user.getEmail(), user.getUserIdent());
        return new FindIdentResponseDTO(
                user.getUserIdent()
        );
    }

    /**
     * 비밀번호 찾기 (비밀번호 변경으로 넘어가기 전 확인)
     * @param request 비밀번호 찾기 요청 DTO
     * @return true면 비밀번호 변경으로 이동 가능 (조건 충족)
     * @throws Exception verifyCode에서 받은 exception throw
     */
    public Boolean findPassword(FindPasswordRequestDTO request) throws Exception {
        log.info("비밀번호 찾기 시작: email={}", request.getUserEmail());
        User user = userRepository.findByEmail(request.getUserEmail())
                .orElseThrow(() -> new IllegalStateException("Invalid user credentials"));
        log.debug("비밀번호 찾기 대상 user 찾기 성공 (valid email)");
        if (!user.getUsername().equals(request.getUserName())) {
            log.warn("비밀번호 찾기 실패: email={}, reason=invalid_credentials", request.getUserEmail());
            throw new IllegalStateException("Invalid user credentials");
        }

        // 인증 번호 확인
        Boolean isValidCode = mailService.verifycode(request.getUserEmail(), request.getVerificationCode());
        if (isValidCode) {
            log.info("비밀번호 찾기 성공: email={}", request.getUserEmail());
        } else {
            log.info("비밀번호 찾기 실패: email={}, reason=invalid_verification_code", request.getUserEmail());
            throw new IllegalStateException("Invalid user credentials");
        }
        return isValidCode;
    }

    /**
     * 인증 코드 확인
     * @param verifyDTO 인증 코드 확인 요청 DTO
     * @return 인증 코드가 일치하면 true, 아니면 false
     */
    public Boolean verifycode(CodeVerifyDTO verifyDTO) {
        log.debug("인증코드 확인: email={}", verifyDTO.getUserEmail()); //mailService에서 로깅
        return mailService.verifycode(verifyDTO.getUserEmail(), verifyDTO.getVerificationCode());
    }

    /**
     * 인증 메일 전송
     * @param sendDTO 인증 메일 전송 요청 DTO
     * @throws Exception 메일 전송 시 발생한 exception throw
     */
    public void sendVerificationEmail(VerificationEmailSendDTO sendDTO) throws Exception {
        log.info("인증 메일 전송 시작: email={}", sendDTO.getUserEmail());
        if (sendDTO.getRequestType() == VerificationEmailSendDTO.RequestType.SIGNUP
                && userRepository.existsByEmail(sendDTO.getUserEmail())) {
            log.warn("인증 메일 전송 실패: email={}, reason=invalid_credentials", sendDTO.getUserEmail());
            throw new IllegalStateException("existing email");
        }

        if (!mailService.sendVerificationEmail(sendDTO.getUserEmail())) {
            log.error("인증 메일 전송 실패: email={]", sendDTO.getUserEmail());
            throw new RuntimeException("failed to send verification email");
        }
        log.info("인증 메일 전송 성공: email={}", sendDTO.getUserEmail());
    }

    /**
     * 비밀번호 변경
     * @param request 비밀번호 변경 요청 DTO
     */
    public void updatePassword(PasswordUpdateDTO request) {
        log.info("비밀번호 변경 시작: email={}", request.getUserEmail());

        User user = userRepository.findByEmail(request.getUserEmail())
                .orElseThrow(() -> new IllegalStateException("Invalid user credentials"));
        log.debug("비밀번호 변경 대상 user 찾기 성공(valid email)");

        String passwordHash = bCryptPasswordEncoder.encode(request.getUserPassword());
        user.updatePassword(passwordHash);
        userRepository.save(user);
        log.info("비밀번호 변경 성공");
    }
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // Fetch user by username from the database
        User user = userRepository.findByUserName(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));

        // Return a UserDetails object based on your User class
        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                user.getAuthorities()
        );
    }
}

(3) User Repository 작성

/** UserRepository.java **/
import com.survey.server.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String userEmail);
    Optional<User> findByUserIdent(String userIdent);

    Boolean existsByEmail(String userEmail);
    Boolean existsByUserIdent(String userIdent);
}

4. 인증번호 관련 주요 로직 작성(service, repository)

인증번호 관련 서비스는 아래 글에 보다 자세히 기록했다. https://programming-diary-ina.tistory.com/120

[SpringBoot/Java] JavaMailSender로 인증 메일 전송하기

회원가입 및 로그인 기능을 구현하면서, 인증코드를 담은 메일을 보내는 기능을 구현해야 했다. JavaMailSender를 이용하면 어렵지 않게 구현할 수 있다. 크게 아래 두 가지 기능을 구현해 보았다.1.

programming-diary-ina.tistory.com

[운영체제 실습] thread 이용해보기

iinana — Sat, 12 Apr 2025 18:37:01 +0900

실습 명세

1. Implement a simple counter using threads.

2. Calculate the time difference between a version using a single process and a version using multiple threads. (consider the time difference based on the number of threads.)

3. Determine how the results differ when using locks versus not using locks with threads.

4. Advanced: Implement a producer-consumer pattern using condition variables.

POSIX thread (pthread) 함수

1. pthread API

(1) int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void *(start_routine)(void *), void *arg);

(역할) 새로운 thread 생성
(param) thread : 새로운 thread의 ID (out)
(param) attr: thread attribute configuration (기본 속성 사용 시, NULL)
(param) start_routine: thread가 해야 하는 일
(param) arg: arguments pass to start_routine
(return) success=0, error=error_num

(2) int pthread_join(pthread_t thread, void** ret_val);

(역할) 자식 thread가 종료될 때까지 기다리는 함수 (mater thread는 하나의 worker thread 만들고 끝날 때까지 기다렸다가 다음 일을 한다.)
(param) thread_t: terminate 될 target thread의 ID
(param) ret_val: terminated thread의 return value (out)
(return) success=0

(3) void pthread_exit(void* ret_val);

(역할) terminates the thread (thread를 시작하는 함수의 return call은 암묵적으로 pthread_exit을 호출)
(param) ret_val: terminated thread의 return value.

2. MUTEX (critical section을 사용하기 위해 보호해 주는 역할)

(1) int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

(역할) initialize a mutex object
(param) mutex: mutex가 초기화될 pointer (in/out)
(param) attr: mutex attributes (default=NULL)
(return) succes=0, error=error_num

(2) int pthread_mutex_lock(pthread_mutex_t *mutex);

(역할) lock a mutex
(param) mutex: lock을 걸 mutex pointer
(return) success=0, error=error_num

(3) int pthread_mutex_unlock(pthread_mutex_t *mutex);

(역할) unlock a mutex
(param) mutex: unlock할 mutex pointer
(return) success=0, error=error_num

3. condition variable (특정 조건을 만족하기를 기다리는 변수)

(1) int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

(역할) condition variable 초기화 for inter-thread signaling (thread 간 signaling)
(param) cond: 초기화될 condition variable의 pointer (in/out)
(param) attr: condition variable attributes
(return) success=0, error=error_num

(2) int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

(역할) condition variable이 signal 될 때까지 기다림
(param) cond: wait하고 있는 condition variable의 pointer (in/out)
(param) mutex: condition을 protect 하고 있는 mutex의 pointer (in/out)
→ 호출 시 mutex를 자동으로 unlock하고, 조건이 충족되어 signal을 받으면 mutex를 다시 lock (deadlock 방지)
(return) success=0, error=error_num

(3) int pthread_cond_signal(pthread_cond_t *cond);

(역할) condition variable에 기다리고 있는 thread 하나에 signaling (wake up at least one thread waiting on the condition)
(param) cond: signal 할 conditon variable의 pointer
(return) success=0, error=error_num

(4) int pthread_cond_broadcast(pthread_cond_t *cond);

(역할) 해당 condtion variable에서 기다리는 모든 thread를 signal
(param) cond: broadcas 할 conditon variable의 pointer
(return) success=0, error=error_num

(5) 주의할 점

condition variable도 공유되는 변수이므로 mutually exclusive해야 한다.
반드시 if문이 아닌 while문으로 조건을 확인해야 한다
(ex) if문 조건을 확인할 때는 wait 조건을 충족하지 않았는데, 중간에 interrupt가 발생되어 wait 조건을 충족하게 됨
=> wait을 해야 하지만 하지 않는 상황 발생

3. pthread를 linux 환경에서 실행하기

아래 명령어를 통해 리눅스에서 pthread를 사용한 파일을 컴파일할 수 있다. window 환경에서는 pthread.h를 사용할 수 없다.

gcc -o counter counter.c -lpthread

Implementaion

1. simple counter 구현 (lock이 없는 버전)

#include <pthread.h>
#include <stdio.h>

#define NUM_THREADS 4
#define NUM_INCREMENTS 1000000

int counter = 0;

void* increment(void* arg) {
    for (int i = 0; i < NUM_INCREMENTS; i++) {
        counter++;
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];

    // NUM_THREADS 개의 thread 생성
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, increment, NULL);
    }

    // 모두 실행할 때까지 기다림
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    // Expected counter보다 actual value가 과소하게 출력됨
    printf("Expected counter: %d\n", NUM_THREADS * NUM_INCREMENTS);
    printf("Actual value:     %d\n", counter);
}

결과는 아래와 같다. Race Condition의 발생으로 counter의 기댓값보다 실제값이 더 작은 것을 확인할 수 있다.

$ ./counter_no_lock
Expected counter: 4000000
Actual value:     1775492

2. single process를 사용할 때와 thread를 사용할 때의 시간 차이

아래 코드로 NUM_THREADS와 NUM_LOOP만 수정해줘 가면서 시간 차이를 테스트해 봤다. race condition 없이 순수 실행 시간만 비교하기 위해 counter로 구현하는 대신 그냥 loop만 돌렸다.

#include <pthread.h>
#include <stdio.h>
#include <sys/time.h>
#include <unistd.h>

#define NUM_THREADS 3
#define NUM_LOOP 100000000

long get_elapsed_usec(struct timeval start, struct timeval end) {
    return (end.tv_sec - start.tv_sec) * 1000000L + (end.tv_usec - start.tv_usec);
}

void* loop(void* arg) {
    for (int i = 0; i < NUM_LOOP; i++);
    return NULL;
}

long with_thread() {
    pthread_t threads[NUM_THREADS];
    struct timeval start, end;

    gettimeofday(&start, NULL);
    // NUM_THREADS 개의 thread 생성
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, loop, NULL);
    }

    // 모두 실행할 때까지 기다림
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    gettimeofday(&end, NULL);
    return get_elapsed_usec(start, end); 
}

long without_thread() {
    struct timeval start, end;

    gettimeofday(&start, NULL);
    for (int i = 0; i < NUM_THREADS; i++) {
        loop(NULL);
    }
    
    gettimeofday(&end, NULL);
    return get_elapsed_usec(start, end); 
}

int main() {
    printf("duration using thread:   %8ld\n", with_thread());
    printf("duration without thread: %8ld\n", without_thread());    
}

첫번째로, NUM_THREAD=2, NUM_LOOP=1,000 일 때의 실행 결과이다.

$ ./measure_time
duration using thread:        474
duration without thread:        5

보다시피 thread를 사용했을 때 오히려 더 많은 시간이 걸리는 것을 알 수 있다. 보통 thread를 사용하면 더 효율적으로, 더 짧은 시간으로 실행할 수 있을 것이라는 게 배웠던 내용인데, 오히려 thread로 사용하는 것이 더 오래 걸린다.

다양한 원인이 있을 수 있지만, 설정한 thread 수가 2개로 아주 적고, 반복 횟수가 작아, 한 thread 안에서의 작업이 그렇게 많지 않을 것이다. 그래서 오히려 thread로 인해 줄일 수 있는 시간보다 context switching으로 인해 늘어나는 시간이 더 커져서 발생하는 현상이라고 볼 수 있다. (multi thread를 사용한다는 것은 커널이 thread를 계속 바꿔가면서 써야 한다는 것이기 때문에 context switching 비용이 발생한다.)

따라서 다음은 우선 NUM_LOOP=100,000,000으로 충분한 수로 늘려서 다시 실행해 봤다.

$ ./measure_time
duration using thread:     279984
duration without thread:   517649

이제 thread를 사용하는 편의 시간이 더 짧아졌다. 즉, contex switching 비용보다 thread로 절약할 수 있는 시간이 더 커졌다는 의미이다.

마지막으로 여기서 NUM_THREAD=4로 thread의 개수만 늘려보았다.

$ ./measure_time
duration using thread:     362409
duration without thread:  1031092

thread를 사용한 것과 사용하지 않은 시간 간의 더 명확한 차이가 발생하는 것을 볼 수 있다.

결론적으로 하려는 일이 충분히 오랜 시간이 걸리는 경우 thread를 사용하는 것이 더 유리하다.

3. mutex lock을 적용한 counter 구현

처음에 구현한 simple counter에서 increament 함수에서 crtical region에 해당하는 counter 증가 부분 앞뒤로 lock을 걸어주고 풀어주기만 하면 된다. (main 함수는 같아서 생략했다.)

#include <pthread.h>
#include <stdio.h>

#define NUM_THREADS 4
#define NUM_INCREMENTS 1000000

int counter = 0;
pthread_mutex_t lock;

void* increment(void* arg) {
    for (int i = 0; i < NUM_INCREMENTS; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

// 생략

결과는 아래와 같다. lock을 걸지 않았을 때는 기댓값과 실제값이 달랐지만, lock을 걸고 나니 기댓값과 실제값이 똑같은 것을 알 수 있다. 즉, Race Condition으로 인한 문제가 해결되었다.

$ ./counter_with_lock
Expected counter: 4000000
Actual value:     4000000

4. producer-consumer pattern 구현

producer-consumer pattern을 아래와 같이 구현해 봤다. printf와 main 함수는 모두 디버깅 로그를 기록하기 위함이다. (결과 확인용)

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define BUFFER_SIZE 5
#define LOOP 10

int count = 0;
int in = 0, out = 0;
int buffer[BUFFER_SIZE];

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
// buffer 비어있을 때 wait 시킬 condtion variable
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
// buffer 가득 찼을 때 wait 시킬 condition variable
pthread_cond_t full = PTHREAD_COND_INITIALIZER;

void put(int val) {
    buffer[in] = val;
    in = (in + 1) % BUFFER_SIZE;
    count++;
}

int get() {
   int val = buffer[out]; 
   out = (out + 1) % BUFFER_SIZE;
   count--;
   return val;
}

void* producer(void* arg) {
    for (int i = 0; i < LOOP; i++) {
        pthread_mutex_lock(&lock);
        while (count >= BUFFER_SIZE) {
            printf("producer: buffer full...\n");
            pthread_cond_wait(&full, &lock);
            // consumer가 element 하나 소비하고 signal 해줄 때까지 wait
        }

        put(rand() % 100);
        printf("producer: in=%d, count=%d\n", in, count);

        pthread_cond_signal(&empty);
        // consumer에 새로운 element 넣었다고 signal

        pthread_mutex_unlock(&lock);
    }
}

void* consumer(void* arg) {
    for (int i = 0; i < LOOP; i++) {
        pthread_mutex_lock(&lock);
        while (count <= 0) {
            printf("consumer: buffer empty...\n");
            pthread_cond_wait(&empty, &lock);
            // producer가 새로운 element 넣고 signal 해줄 때까지 wait
        }

        printf("consumer: get value: %d\n", get());

        pthread_cond_signal(&full);
        // producer에 element 하나 소비했다고 signal
        pthread_mutex_unlock(&lock);
    }
}

int main() {
    pthread_t prod, cons;

    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);
}

결과는 아래와 같이 나왔다. 결과가 너무 길어 뒷부분은 생략했다. 디버깅 메시지가 출력되는 것을 보면, 처음에 producer가 지정된 buffer size(10)만큼 모두 채워서 full이 출력되고 더 이상 produer가 동작하지 못한다. 그리고 consumer가 동작하고, full condition variable에 signal을 주고 나서 다시 produer가 동작 가능해진 것도 볼 수 있다. consumer의 동작도 마찬가지이다.

$ ./prod_cons
producer: in=1, count=1  
producer: in=2, count=2  
producer: in=3, count=3  
producer: in=4, count=4  
producer: in=0, count=5  
producer: buffer full... 
consumer: get value: 83  
consumer: get value: 86  
consumer: get value: 77  
consumer: get value: 15  
consumer: get value: 93  
consumer: buffer empty...
producer: in=1, count=1  
producer: in=2, count=2  
producer: in=3, count=3  
producer: in=4, count=4
producer: in=0, count=5
consumer: get value: 35
consumer: get value: 86
consumer: get value: 92
consumer: get value: 49
consumer: get value: 21

[논문 Review] Development of an Automated ESG Document Review System using Ensemble-Based OCR and RAG Technologies

iinana — Wed, 9 Apr 2025 16:02:59 +0900

ESG 관련 내용은 제하고, 졸업 프로젝트에 필요한 RAG 기술 관련 내용을 중심으로 정리했다.

Technology Overview (only about RAG)

1. RAG 작동 과정

Data Gathering(데이터 수집): 다양한 원천 데이터(PDF, TXT, CSV, 웹 URL 등)를 사용해 LLM에 최신 지식이나 심층 지식 전달
Data Loading: 수집한 데이터를 시스템으로 불러오는 단계 (데이터 구조 파악, 불필요한 텍스트 제거 등)
Data Splitting: 데이터를 Chunk 단위의 작은 조각으로 나누는 단계. LLM에 불필요한 정보가 제공되는 것을 최소화. (다만 청크 사이즈가 너무 작으면 핵심 정보 누락, 텍스트 맥락의 모호성 발생)
Data Embedding: 청크 단위로 분할된 텍스트를 숫자 벡터로 전환하는 단계. 의미론적 특성 보존을 위해 원천 데이터세 사용된 언어로 충분히 학습한 임베딩 모델 선정 필요
Data Storing(데이터 저장): 벡터 데이터베이스에 임베딩된 청크와 메타 정보 저장. (벡터 데이터베이스는 Approximate Nearest Neighbor) 알고리즘을 사용하여 고차원 벡터를 효율적으로 인덱싱 하고 검색)
Retrieval(문서 검색): 사용자의 질문과 관련된 정보 검색 (코사인 유사도, 앙상블 기법 등 적용)
Generation(답변 생성): Few-shot learning이나 기타 특화된 프롬프트 템플릿 등을 사용하면 답변 품질 향상 가능. 프롬프트 엔지니어링을 통해 오픈소스 LLM을 최적화.

2. RAG 시스템 구축에 활용되는 오케스트레이션 프레임워크

(1) LangChain

모듈화된 구조와 풍부한 통합 기능 제공으로 복잡한 LLM 애플리케이션 개발에 용이
다양한 LLM, 임베딩 모델, 벡터 저장소에 높은 호환성 제공
Chain과 Agent라는 개념을 토대로 복잡한 작업을 효율적으로 구현 가능

(2) LlamaIndex

대규모 데이터셋에 효율적인 인덱싱과 쿼리 기능
다양한 데이터 소스에 대한 커넥터 제공
고급 쿼리 엔진 옵션을 통해 정확하고 신속한 정보 검색 지원

3. Limitation of RAG Systems

(1) RAG 시스템의 성능이 구성 요소의 개별 성능에 크게 의존

데이터 분할 시 청크 사이즈 => 필요한 정보 누락 가능성 => retriever와 LLM 등 RAG 시스템 전반에 악영향
임베딩 모델의 품질 => 의미적 유사성 포착에 영향 => 연관 정보 검색에 영향
검색기의 성능 => LLM에 전달되는 정보의 품질 => 답변의 정확도

(2) 중간 정보 소실

컨텍스트가 길어지면 LLM 정보처리 작업에 오류 발생 가능 (전체 정보를 균형 있게 처리하지 못하고 시작과 끝부분에 위치한 정보에 집중)
복잡하고 긴 컨텍스트를 다룰 때는 정보 소시 문제를 완화하기 위한 별도의 알고리즘 적용 필요

(3) 환각 현상 발생 가능성

외부 지식 베이스를 사용한다고 하더라도 검색 정보를 잘못 해석하거나 누락하여 환각 현상 발생 가능
LLM의 응답에 대한 추가적인 검증 과정 도입 필요

연구 내용

1. Proposed method for RAG System (한계점 극복 및 모델 개선을 위한 제안)

(1) 원본 문서의 레이아웃 분석을 위한 알고리즘 개발

문서에서 텍스트 추출 시 레이아웃에 대한 고려가 없으면 데이터 무결성 훼손
- 결과적으로는 검색기 성능을 저하시켜 LLM이 부적절한 답변일 생성할 확률을 높인다
문서의 레이아웃을 분석하는 알고리즘을 개발하고, 텍스트 추출에 앞서 적용
- 원본 문서의 의미론적 구조 보존
- RAG 시스템의 정보 검색 및 답변 생성 성능 향상

(2) ensemble retriever(앙상블 검색기) 구현

다양한 검색 모델을 결합하여 정보 검색의 정확성과 신뢰성을 향상하는 기법
hybrid search (sparse retriever + dense retriever)
- sparse retriever: 키워드 기반 문서 탐색
  - 장점: 임베딩 과정 불필요, 검색 속도 빠름
  - 단점: 동의어나 유사어 인식에 취약
- dense retriever: 의미적 유사성을 기반으로 관련 정보 검색
  - 장점: 동의어나 유사어 등을 감안하여 검색 결과 제공 가능
  - 단점: 고성능 임베딩 모델이 전제되지 않으면 연관 문서 검색 성능 크게 저하 가능. 핵심 키워드가 누락된 청크를 가장 관련성 높은 정보로 선별하는 오류를 일으키기도 함.
BM25(sparse retriever) + FAISS(dense retriever) => ensemble retrivever 구현

(3) Re-ranking 알고리즘 적용

검색된 정보의 정확성을 높이고, 일부 주요 정보 누락 가능성 개선 목적
문서 검색 다녜 이후에 재정렬 알고리즘을 적용하여, 검색된 연관 정보의 순서를 효과적으로 재구성

(4) 다층적 Fact-cheking 메커니즘 도입

선행 검증: 최종 결론 도출에 앞서, 앙상블 기법이나 프롬프트 엔지니어링 등을 활용하여 LLM 답변을 내부적으로 검증
- Multi-model Ensemble 기법을 활용하여 여러 모델에서 얻은 출력을 비교
- Self-consistency Check을 통해 동일 모델의 다양한 출력 평가
후행 검증
- LLM이 산출한 최종 결론에 대해 인간 전문가가 직접 답변의 정확성 평가
- 답변의 사실적 정확성, 맥락적 적절성, 일관성, 윤리적 측면까지 종합적으로 평가

3. 회사 내규 검토 과정 (6단계)

(1) 레이아웃 분석

다단구조 여부 파악
헤더, 푸터 텍스트 확인 (헤더, 푸터 텍스트를 딕셔너리 형태로 저장)

(2) 데이터 로드&전처리

원본 문서의 구조적 특성을 감안하여 텍스트 추출
헤더/푸터 딕셔너리를 바탕으로 불필요한 텍스트 삭제

(3) 데이터 분할

2단계에 걸쳐 전처리된 텍스트가 여러 개의 작은 청크로 분할
[1차 분할] 조항번호 등을 구분 값으로 하여 비교적 큰 사이즈의 청크 생성
[2차 분할] 1차청크가 더 작은 단위의 청크로 분할되면서, 연관정보 검색에 최적화된 소형 청크 생성

(4) 임베딩

허깅페이스에 공개된 'ko-sroberta' 모델 기반
2차 분할된 청크를 고차원 숫자 벡터로 변환 (벡터 검색을 위한 데이터로 활용)

(5) 연관정보 검색

Ensemble retriever 활용
사용자 질의와 연관된 정보 검색 -> re-ranking으로 재정렬 -> LLM에 전달

(6) 답변 생성

LLM 프롬프트와 재정렬된 연관 정보 참고하여 최종 답변 생성
답변에 참고한 정보를 함께 제공

Eun-Sil Choi. (2024). Development of an Automated ESG Document Review System using Ensemble-Based OCR and RAG Technologies. Journal of The Korea Society of Computer and Information, 29(9), 25-37.

[논문 Review] 복지 정책 정보 제공을 위한 RAG 기반 대화형 시스템 개발

iinana — Wed, 9 Apr 2025 11:09:26 +0900

연구 목적

1. LLM의 한계

사용자가 정확한 용어를 알고 있어야 함
검색 결과 중 원하는 정보를 직접 찾아야 함

2. RAG 도입의 기대효과

정책 정보에 대한 접근성 향상
자연어 기반 질의응답 시스템을 통해 정확하고 관련성 높은 정보 제공
복잡한 정책 내용을 이해하기 쉬운 형태로 제공
최신 정보를 실시간으로 반영할 수 있는 시스템 구축

연구 내용

1. 사용 기술

(1) RAG(Retriever-Augmented Generation)

대형 언어 모델의 생성 능력과 외부 지식베이스를 결합하는 기술
사용자 쿼리와 관련된 문서나 정보를 외부 지식베이스에서 검색하는 Retriever, 검색된 정보와 쿼리를 바탕으로 응답을 생성하는 Generator로 나뉜다
장점 : 외부 지식 베이스를 활용한다
- 최신 정보를 반영할 때, 모델을 재학습할 필요가 없이 외부 데이터베이스만 교체하면 된다
- 기존에 모델이 알고 있던 정보로만 답변을 생성하는 것보다 더 정확한 응답 생성이 가능하다
- 읽어온 정보의 출처를 알 수 있어 답변의 근거를 제시할 수 있다
- 특정 분야에 대한 지식베이스를 활용하여 전문성 있는 응답이 가능하다

(2) Prompt Engineering

2. 파이프라인

FAISS(Faceobok AI Similarity Search) 기반 벡터 검색과 BM25(Best Matching 25)검색을 결합한 앙상블 검색 시스템 구축
Cross Encoder Reranker를 적용하여 검색 결과 품질 향상
GPT를 활용하여 자연스러운 응답 생성

3. 시스템 설계

채팅 UI: HTML, CSS, JavaScript 이용해 설계
언어모델이 동작하는 백엔드: FastAPI
RAG 파이프라인 구축을 위해 LangChain 라이브러리 사용
시스템 구조 도식화

4. 데이터 수집 및 문서 임베딩

PDF 형태로 정책 자료 수집
PDF 파싱을 위해 파이썬 PyMuPD 라이브러라 사용
- 이 외 라이브러리: PDFMiner, PyMuPDF, PDFPlumber, PyPDFium2 등
- 본 연구에서 PyMuPD 선정 이유
  - 텍스트 추출의 정확성이 높음
  - 표와 이미지가 포함된 복잡한 레이아웃도 안정적으로 처리
  - 유니코드 문자를 올바르게 처리하여 다국어 문서 지원 우수
임베딩을 위해 OpenAI의 임베딜 모델 사용
- 기존 PDF 문서를 800자 단위로 분리하고 100자 단위로 중첩되도록 설정
- 임베딩 모델을 통해 벡터 형태로 변환하여 데이터 베이스에 저장
데이터베이스로 FAISS 사용
- 일반적으로 사용되는 벡터 데이터베이스는 FAISS, Chroma, Pinecone 등이 있다
- FAISS 선정 이유
  - 오픈 소스
  - 고차원 벡터의 빠른 유사도 검색 지원
  - 대량의 데이터처리 시에 뛰어난 성능을 보임

5. 질의 처리 및 검색

질의의 의미적 특성을 벡터공간에 매핑하여 문서 벡터들과의 유사도 비교
- Ensemble Retriever(FAISS와 BM25 결합) 기법 사용
검색 결과 품질 향상을 위해 Cross Encoder Reranker 적용
- 질의와 문서를 동시에 인코딩하여 더 정확한 관련성 점수 계산
- BAAI/bge-reranker-v2-m3 모델 사용하여 재순위화 수행
- 초기 검색 결과 중 상위 5개의 가장 높은 관련성을 가진 문서만 선발하여 최종 답변 생성에 활동

6. GPT-4o-mini를 이용한 RAG 구현

오픈소스 LLM 대신 GPT를 채택한 이유
- 오픈소스 LLM 구동을 위한 높은 하드웨어 비용 (고성능 GPU 필요)
- 모델 운영을 위한 유지보수 비용이 지속적으로 발생한다
- 내부 데이터 유출 가능성이 존재하나 본 연구에서 사용되는 문서는 공개된 정보이기 때문에 문제 없음
RAG 파이프라인에서 검색된 관련 정보를 바탕으로 답변을 생성하는 역할 수행
- 프롬프트 엔지니어링을 통해 모델이 정책 정보를 정확히 이해하고 사용 친화적인 답변을 생성하도록 유도
- 최대한 정확한 정보 전달을 위해 모델의 창의성을 조정하는 temperature 변수 0.1로 설정

7. LangChain에서 제공하는 모니터링 도구인 LangSmith를 활용하여 시스템 모니터링 및 비용관리

RAG 시스템의 전반적인 성능과 비용 추적
검색과 응답 생성에 소요되는 시간 모니터링하여 시스템 성능 최적화
시스템 운영 중 발생하는 다양한 에러들 추적, 기록
Ensemble Retriever와 Cross Encoder Reranker 성능을 지속적으로 모니터링
디버깅 기능으로 RAG의 파이프라인의 각 단계별 처리 과정 상세히 분석 가능

전동빈, 김희철 and 김경이. (2025). 복지 정책 정보 제공을 위한 RAG 기반 대화형 시스템 개발. 한국정보통신학회논문지, 29(2), 209-217.

[운영체제 실습] Scheduling Practice

iinana — Fri, 4 Apr 2025 15:16:49 +0900

운영체제 project를 시작하기 전, 교안에 있는 실습 자료로 sceduling 내용에 관한 practice를 진행했다.

practice 01

In xv6, yield is implemented but it is not the system call.
First, implement yield system call so that user can call yield. (yield gives up its CPU)
Make a user program in xv6 that created child process with fork(), and show that parent and child process print "Parent" and "Child" respectively in loop.

문제에서 언급된 대로, yield 함수는 이미 구현이 되어있기 때문에 따로 구현하지 않아도 된다. 구현되어 있는 이 함수를 system call에 추가해주기만 하면 된다.

/** proc.c **/
// Give up the CPU for one scheduling round.
void
yield(void)
{
  struct proc *p = myproc();
  acquire(&p->lock);
  p->state = RUNNABLE;
  sched();
  release(&p->lock);
}

1. wrapper function 구현

우선 구현되어 있는 yield 함수의 wrapper function을 만들어준다. wrapper function이기 때문에 추가적인 기능 없이 그냥 yield 함수를 호출해 주면 된다.

다만, 주의할 점은 return type은 꼭 uint64로 해야 한다는 점이다. yield 함수는 return type이 void이다. 즉, 아무것도 리턴할 필요가 없다. 하지만 xv6의 system call table에 등록되는 모든 함수는 반드시 uint64를 반환하도록 정해져 있다. 따라서 나는 그냥 0을 리턴해주고 return type을 uint64로 설정해 주었다.

/** [add code] kernel/sysproc.c **/
uint64
sys_yield(void)
{
  yield();
  return 0;
}

2. 새로운 system call인 yield를 register

/** [add code] kernel/syscall.h **/
#define SYS_yield  22

/** [add code] kernel/syscall.c **/
extern uint64 sys_yield(void); //add

static uint64 (*syscalls[])(void) = {
//생략
[SYS_yield]   sys_yield, //add
};

3. user.h에 함수 선언

/** [add code] user/user.h **/
void yield(void);

4. usys.pl에 macro 추가

/** [add code] user/usys.pl **/
entry("yield");

5. user directory에 user function 구현

마지막으로 user function을 만들어줘서, system call로 등록된 yield가 잘 동작하는지 확인해 준다. fork()로 자식 프로세스를 만들어 서로에게 cpu를 넘겨주며 실행하게 된다.

다만 여기서 주의할 점은 확인을 위해 "Parent"와 "Child"를 콘솔에 출력할 때, printf가 아닌 write를 써야 한다는 점이다. printf는 비동기적으로 실행되기 때문에 출력이 섞이거나 깨지는 현상 발생할 수 있다.

/** [new file] user/yield.c **/
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

void print(const char *msg) {
    write(1, msg, strlen(msg));  // write()를 사용하여 출력
}

int main(int argc, char *argv[])
{
    int pid = fork();
    if (pid < 0) {
        print("Fork failed!\n");
        exit(1);
    } else if (pid == 0) {
        for (int i = 0; i < 10; i++) {
            print("Child\n");
            yield();
        }
    } else {
        for (int i = 0; i < 10; i++) {
            print("Parent\n");
            yield();
        }
    }
}

7. user function의 code 파일 Makefile에 추가

/** Makefile **/
UPROGS=\
  // 생략
  $U/_yield\

8. 결과: Children과 Parent가 번갈아가면서 실행됨.

practice 02

One basic way to debug is to simpl print the variables, and check if they have intended values.
Print current value of ticks variable, and the pid and the name of the process to the console, whenever the sceduler picks a process to run. (Use printf function)
Make a user program that runs an infinite loop and execute it. (The same process should be picked on ever timer interrupt)

1. scheduler function에 현재 상태 print하는 코드 추가

/** [add code] kernel/proc.c **/
void
scheduler(void)
{
  struct proc *p;
  struct cpu *c = mycpu();

  c->proc = 0;
  for(;;){
    // 생략
    int found = 0;
    for(p = proc; p < &proc[NPROC]; p++) {
      acquire(&p->lock);
      if(p->state == RUNNABLE) {
        printf("ticks = %u, pid = %u, name = %s\n", ticks, p->pid, p->name); //add
        // 생략
    }
    // 생략
}

2. test를 위해 user function 만들기

현재 실행 중인 process의 상태를 print하는 것이므로, 그냥 while문을 통해 해당 프로세스가 무한히 돌아가도록 해주면 된다.

/** [new file] ueser/test_print.c **/
#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int main(int argc, char *argv[])
{
    while(1) {}
    return 0;
}

3. makefile에 user function code 파일 추가

/** Makefile **/
UPROGS=\
  // 생략
  $U/_test_printf\

4. 결과

test_printf 프로세스가 사용자에 의해 terminate 될 때까지 무한히 돌아가는 것을 볼 수 있다.

[SpringBoot/Java] JavaMailSender로 인증 메일 전송하기

iinana — Fri, 4 Apr 2025 08:34:38 +0900

회원가입 및 로그인 기능을 구현하면서, 인증코드를 담은 메일을 보내는 기능을 구현해야 했다. JavaMailSender를 이용하면 어렵지 않게 구현할 수 있다. 크게 아래 두 가지 기능을 구현해 보았다.

1. 사용자의 이메일로 6자리의 인증코드를 담은 메일 전송
- 인증 코드 생성
- 인증 코드 저장
- 메일 전송
2. 사용자가 입력한 코드가 저장된 인증코드와 일치하는지 확인

구현은 아래와 같이 했다. 우선 build.gradle 파일에 JavaMailSener를 사용하기 위한 의존성을 추가해 준다.

/** build.gradle */
dependencies {
    // java mail sender 의존성 추가
    implementation 'org.springframework.boot:spring-boot-starter-mail' 
}

그리고 application.yml 파일에 메일 전송 관련 설정을 작성해 준다. host는 보내려고 하는 메일의 도메인에 따라 작성하면 된다. 나는 이 코드를 작성할 때 속해있던 랩실 이메일이 naver 메일이었기 때문에 naver를 선택했다. username에는 보내는 사람, 즉 내 이메일을 작성하면 되고, password에는 해당 이메일에 설정된 비밀번호를 작성하면 된다.

port의 경우 사용 가능한 몇가지 옵션이 있지만, 최근 587이 가장 많이 사용되고 추천된다.

/** application.yml */
spring:
  mail:
    host: smtp.naver.com
    port: 587
    username: {sender_email}
    password: {sender_password}
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enable: true

그리고 인증 코드를 저장할 repository 만들기 위해 RedisConfig를 먼주 구축해준다.

package com.survey.server.config;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;

@Configuration
public class RedisConfig {
    // Redis 서버 연결을 위한 ConnectionFactory Bean
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory("localhost", 6379);
    }

    // LocalDateTime을 위한 커스텀 TypeAdapter
    private static class LocalDateTimeAdapter extends TypeAdapter<LocalDateTime> {
        @Override
        public void write(JsonWriter out, LocalDateTime value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                out.value(value.toString());
            }
        }

        @Override
        public LocalDateTime read(JsonReader in) throws IOException {
            String value = in.nextString();
            return value == null ? null : LocalDateTime.parse(value);
        }
    }

    // RedisSerializer Bean
    @Bean
    public RedisSerializer<Object> gsonRedisSerializer() {
        return new RedisSerializer<>() {
            private final Gson gson = new GsonBuilder()
                    .registerTypeAdapter(LocalDateTime.class, new LocalDateTimeAdapter())
                    .create();

            @Override
            public byte[] serialize(Object source) {
                if (source == null) {
                    return new byte[0];
                }
                return gson.toJson(source).getBytes(StandardCharsets.UTF_8);
            }

            @Override
            public Object deserialize(byte[] bytes) {
                if (bytes == null || bytes.length == 0) {
                    return null;
                }
                String json = new String(bytes, StandardCharsets.UTF_8);
                return gson.fromJson(json, Object.class);
            }
        };
    }

    // RedisTemplate Bean
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        StringRedisSerializer serializer = new StringRedisSerializer();
        template.setKeySerializer(serializer);
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(serializer);
        template.setHashValueSerializer(serializer);

        return template;
    }
}

이제 인증코드를 저장해 둘 repository를 작성한다. 만료시간이 있는 인증코드의 특성상, 편리하게 사용할 수 있는 RedisTemplate으로 설정했다. 유효시간(TTL)은 5분으로 설정했다.

/** VerificationRepository.java */
package com.survey.server.repository;

import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import java.util.Optional;
import java.util.concurrent.TimeUnit;

@Repository
@RequiredArgsConstructor
public class VerificationRepository {
    private final RedisTemplate<String, Object> redisTemplate;
    private static final Long TTL_MINUTES = 5L; // 인증번호 유효시간 5분
    private static final String KEY_PREFIX = "verification: ";

    /**
     * 인증 코드 저장
     * - 이메일, 전송된 랜덤 인증코드, TTL 설정
     */
    public void saveVerifyCode(String userEmail, String verifyCode) {
        redisTemplate.opsForValue()
                .set(getVerificationKey(userEmail), verifyCode,
                        TTL_MINUTES * 60, TimeUnit.SECONDS);
    }

    public Optional<Object> getVerifyCode(String userEmail) {
        Object code = redisTemplate.opsForValue()
                .get(getVerificationKey(userEmail));
        return Optional.ofNullable(code);
    }

    public void deleteVerifyCode(String userEmail) {
        redisTemplate.delete(getVerificationKey(userEmail));
    }

    public String getVerificationKey(String userEmail) {
        return KEY_PREFIX + userEmail;
    }
}

마지막으로 아래는 이메일을 전송하고, 인증코드를 확인하는 MailService이다. 내가 짠 프로그램에서는 UserService를 거쳐서 사용되기 때문에 예외처리는 주로 UserService에서 해주었다.

내용 자체는 어렵지 않다. @Value 어노테이션으로 application.yml 파일에서 작성했던 username을 보내는 사람의 이메일로 불러온다. 그리고 6자리 코드를 생성해서 앞서 생성한 레포지토리에 저장하고 이를 바탕으로 메일을 전송해 주면 된다.

인증 번호를 확인할 때는 레포지토리에서 메일 주소를 key로 하여 저장된 인증 번호를 가져와주고, 사용자의 입력값과 일치하는지 확인해 준다. 일치하면 레포지토리에서 해당 코드를 삭제해 주며 true를 리턴하고 일치하지 않으면 false를 리턴한다.

/** MailService.java */
package com.survey.server.service;

import com.survey.server.dto.CodeVerifyDTO;
import com.survey.server.dto.VerificationEmailSendDTO;
import com.survey.server.repository.VerificationRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;

import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

import java.util.NoSuchElementException;

@Service
@RequiredArgsConstructor
public class MailService {
    private final VerificationRepository verificationRepository;
    private final JavaMailSender javaMailSender;

    @Value("${spring.mail.username}")
    private String sender;

    public void sendVerificationEmail(String email) {
        String code = String.valueOf(Math.random() * 1000000);
        verificationRepository.saveVerifyCode(email, code);

        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(sender);
        message.setSubject("[서비스 이름] 이메일 인증 코드");
        message.setTo(email);
        message.setText("[인증코드] " + code);

        javaMailSender.send(message);
    }

    /**
     * 인증 코드 확인
     * @param email 확인 요청자 이메일
     * @param inputCode 사용자가 입력한 코드
     * @return 사용자 입력 코드가 저장된 인증 코드와 일치하면 true
     */
    public Boolean verifycode(String email, String inputCode) {
        String code = verificationRepository.getVerifyCode(email)
                .map(Object::toString)
                .orElseThrow(() -> new NoSuchElementException("Verification code not found"));
        if (code.equals(inputCode)) {
            verificationRepository.deleteVerifyCode(email);
            return true;
        }
        return false;
    }
}

[SpringBoot/오류 해결] Maria DB에 table이 추가되지 않는 문제

iinana — Thu, 3 Apr 2025 08:11:56 +0900

Maria DB를 활용하여 User 관련 기능들을 개발하던 중, user table이 DB에 추가되지 않는 문제가 발생했다. 이상한 점은 refresh token table은 잘 추가가 되었는데, User table만 추가되지 않았다는 점이다.

아래 코드는 각각 refresh token과 user에 관한 코드이다.

/** RefreshToken.java **/
@NoArgsConstructor
@Getter
@Entity
public class RefreshToken {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id", updatable=false)
    private Long id;

    @Column(name="user_id", nullable=false, unique=true)
    private Long userId;

    @Column(name="refresh_token", nullable=false)
    private String refreshToken;

    /** 생략 */
}

/** User.java **/
@Entity
@Table(name="users")
@Getter
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id", updatable=false)
    private UUID userId;

    @Column(name="email", nullable=false, unique=true)
    private String email;

    @Column(name="user_ident", nullable=false, unique=true)
    private String userIdent;

    @Column(name="password", nullable=false)
    private String password;

    /** 생략 */
}

여러 차이점을 후보로 두고 생각했지만, 결국 문제는 id field의 type이었다. MariaDB에서 UUID 타입을 @GeneratedValue(strategy = GenerationType.IDENTITY)와 함께 사용하는 경우 문제가 될 수 있다고 한다. 따라서 User entity에서도 id의 type을 모두 Long으로 수정해 주었다.

/** User.java **/
@Entity
@Table(name="users")
@Getter
public class User implements UserDetails {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id", updatable=false)
    private Long userId;

    @Column(name="email", nullable=false, unique=true)
    private String email;

    @Column(name="user_ident", nullable=false, unique=true)
    private String userIdent;

    @Column(name="password", nullable=false)
    private String password;

    /** 생략 */
}