연향동큰손

[C#] onetime, oneway, twoway, onewaytosource

연향동큰손 — Thu, 19 Feb 2026 15:36:30 +0900

onetime

MODE를 onetime으로 설정하게 되면 ViewModel의 요소를 최초에 한번 수정했을때는 View의 값이 변경되고,

이후에는 연결이 끊어지게 되면서 ViewModel의 요소를 변경하더라도 View에 반영되지 않는다.

oneway

소스의 값 -> 인터페이스의 값 한 방향으로만 바인딩을 허용한다는 의미이다.

ViewModel에서 요소를 변경했을때 View에 변경된 내용이 반영되지만 View에서의 변경이 ViewModel에 반영되지는 않는다.

twoway

ViewModel에서 요소를 변경했을때 View에 변경된 내용이 반영되고, 반대로 View에서의 변경도 ViewModel에 반영 된다.

onewaytosource

oneway의 정 반대라고 보면 된다.

[C#] LINQ(데이터 쿼리)

연향동큰손 — Thu, 19 Feb 2026 11:11:04 +0900

LINQ (Language Integrated Query)는 컬렉션을 SQL처럼 질의하는 문법이다.

foreach + if문을 통해 조건에 맞는 요소를 찾는 것을 구현하게 되면 코드가 길어지면서 가독성이 떨어지는 문제가 발생하지만 LINQ를 통해 구현하게 되면 코드 한줄을 통해 원하는 행위를 명확하게 표현할 수 있다.

Where

Where는 컬렉션에서 조건을 만족하는 요소만 골라내는 필터다.

List<string> list = new List<string>();
list.Add("Apple");
list.Add("Grape");
list.Add("Banana");
list.Add("AAA");
list.Add("BDFA");


IEnumerable<string> q = list
    .Where(p => p.StartsWith("A"));
    
foreach(var item in q)
{
    Console.WriteLine(item); // Apple, AAA 출력
}

Select

Select는 컬렉션의 각 요소를 다른 값이나 형태로 변환하는 기능이다.

List<string> list = new List<string>();
list.Add("Apple");
list.Add("Grape");
list.Add("Banana");
list.Add("AAA");
list.Add("BDFA");


IEnumerable<string> q = list
    .Where(p => p.StartsWith("A"))
    .Select(p=>p.ToUpper());

foreach(var item in q)
{
    Console.WriteLine(item); // APPLE, AAA 출력
}

Any

컬렉션에 조건에 맞는 요소가 하나라도 있으면 true, 아니면 false를 반환

bool hasA = list.Any(q => q.StartsWith("A"));

FirstOrDefault

조건에 맞는 첫 번째 요소를 가져오고, 없으면 기본값을 반환하는 메서드다.

var ddd = list.FirstOrDefault(q => q.StartsWith("A"));

값이 없는 경우 → default(T)

참조 타입: null
값 타입: 0, false 등

스레딩

연향동큰손 — Tue, 13 Jan 2026 16:58:54 +0900

스레드란 명령어를 실행하기 위한 스케줄링 단위

윈도우는 프로세스를 생성할 때 기본적으로 한 개의 스레드를 함께 생성(메인 스레드)

프로그램 실행 종료에 영향을 미치는 스레드를 가리켜 전경 스레드(foreground thread)라 한다.

배경 스레드(background) => 프로그램 종료에 영향 X

static void Main(string[] args)
{
    Thread t = new Thread(threadFunc);
    t.IsBackground = true;
    t.Start(); //실행 안됨
}

static void threadFunc()
{
    Console.WriteLine("60초 후에 프로그램 종료");
    Thread.Sleep(1000 * 10);

    Console.WriteLine("스레드 종료!");
}

 static void Main(string[] args)
 {
     Thread t = new Thread(threadFunc);
     t.IsBackground = true;
     t.Start();

     t.Join(); //t스레드 종료까지 대기
     Console.WriteLine("주 스레드 종료!");
 }

 static void threadFunc()
 {
     Console.WriteLine("10초 후에 프로그램 종료");
     Thread.Sleep(1000 * 10);

     Console.WriteLine("스레드 종료!");
 }

오래 걸리는 연산에 대한 중도 종료 기능 구현

static void Main(string[] args)
{
    while (true)
    {
        Console.WriteLine("x입력 시 종료");
        string str = Console.ReadLine();
        if (str.Equals("x", StringComparison.OrdinalIgnoreCase) == true)
        {
            Console.WriteLine("프로그램 종료");
            break;
        }
        Thread t = new Thread(DDD);
        t.IsBackground = true; //t스레드는 프로세스 종료에 영향을 안미침
        t.Start(str);
    }
    Console.WriteLine("주 스레드 종료!");
}

static void DDD(object a)
{
    string s = "";
    for(int i=0; i<100000; i++)
    {
        s = s+ "1";
    }

    Console.WriteLine("DDD 종료");
}

위 코드를 보면 t스레드를 Background 스레드로 설정하였기 때문에 t스레드의 연산이 실행 중이더라도 x를 누르면 메인 스레드에서 while문을 탈출하고 프로그램이 종료되는 것을 확인할 수 있다.

반면 t.IsBackground = true를 주석처리하면 foreground 스레드로 설정이 되어 프로그램 종료에 영향을 미치는 스레드가 된다.

따라서 아래 사진과 같이 주 스레드가 종료되어도 프로그램이 종료되지 않고 t스레드가 종료되어야 프로그램이 완전히 종료되는 것을 확인 가능하다.

멀티 스레드

쿼드코어 CPU에서는 총 4개의 스레드를 동시에 실행할 수 있지만, 윈도우 작업 관리자를 확인해보면 4개 이상의 프로세스가 동시에 실행중임을 확인 가능하다.

이것이 가능한 이유는 CPU가 하나의 스레드를 짧은 시간 동안 실행한 후 그 스레드를 멈추고 다음 스레드를 선택해서 실행하는 과정을 반복하기 때문이다.

멀티 스레드 환경에서는 공유 리소스에 대한 동기화 처리가 매우 중요하다.

동기화 처리의 방법중 하나는 공유자원에 대해 한순간에 오직 한 스레드만 접근할 수 있도록 하는 방법이 있다.

이를 위해서 BCL에서 Monitor 클래스를 제공한다.

BCL

연향동큰손 — Sat, 10 Jan 2026 18:23:57 +0900

IsNullOrEmpty

문자열이 비어있는지 확인

string name = "";
if(string.IsNullOrEmpty(name) == true)
{
    Console.WriteLine("비어있음.");
}
else
{
    Console.WriteLine(name);
}

System.DateTime

시간과 관련된 기능 제공

DateTime now = DateTime.Now;
Console.WriteLine(now); //현재 날짜, 시간 출력

DateTime dayForChildren = new DateTime(now.Year, 5, 5);
Console.WriteLine(dayForChildren);

//출력 결과
2026-01-10 오후 5:14:33
2026-05-05 오전 12:00:00

System.TimeSpan

DateTime 타입에 대해 사칙 연산 중에서 유일하게 허용되는 것이 빼기 이며 빼기의 연산 결괏값은 2개의 DateTime사이의 시간 간격을 나타내는 TimeSpan으로 나온다.

 DateTime endOfYear = new DateTime(DateTime.Now.Year, 12, 31);
 DateTime now = DateTime.Now;

 Console.WriteLine("오늘 날짜: " + now);

 TimeSpan gap = endOfYear - now;
 Console.WriteLine("올해의 남은 날짜: " + gap.TotalDays);

System.Diagnostics.Stopwatch

BCL에서 제공하는 고정밀 시간 측정 클래스

※코드 특정 구간의 성능을 측정할 때 자주 사용된다.

Stopwatch sw = new Stopwatch();

sw.Start();
// 측정하고 싶은 코드
Thread.Sleep(500);
sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds + " ms");

System.String

string타입에 대한 다양한 기능을 제공

https://learn.microsoft.com/ko-kr/dotnet/api/system.string?view=net-8.0

String 클래스 (System)

텍스트를 UTF-16 코드 단위의 시퀀스로 나타냅니다.

learn.microsoft.com

아래 코드의 출력 결과는 모두 True이다.

string txt = "Hello";
Console.WriteLine(txt == "Hello");
Console.WriteLine(txt.Equals("Hello"));

== 연산은 값 형식에서는 값 자체를 비교하고, 참조 형식에서는 주소를 비교하는데

왜 txt == "Hello"가 True를 반환할까?

이유는 System.String에서 == 연산을 값을 비교할 수 있도록 오버로딩 했기 때문이다.

Format

string str = "Hello {0}: {1}";
string output = string.Format(str, "World", "Anderson");
Console.WriteLine(output);

//실행 결과
Hello World: Anderson

Format Item 구조

{index[,alignment][:formatString]}

요소의미

index	인자 번호
alignment	정렬 (생략 가능)
formatString	출력 형식 (생략 가능)

System.Text.StringBuilder

string 타입은 불변 객체이기 때문에 string에 대한 모든 변환은 새로운 메모리 할당을 발생시킨다.

문자열 변경에서의 문제점(StringBuilder X)

string txt = "Hello World";
for(int i=0; i<300000; i++)
{
    txt = txt + "1";
}

위 코드의 동작 방식

힙에 Hello World 문자열 공간 할당
스택에 txt변수의 주소를 저장
txt + "1" 동작을 수행하기 위해 txt.Length + "1".Length 크기의 메모리를 힙에 할당하고 txt와 "1"을 복사하여 붙힘
3번 과정을 통해 새롭게 할당된 힙 주소를 스택에 저장
3번 4번 과정을 30만번 반복

StringBuilder를 통해 문자열을 더했을때

 string txt = "Hello World";
 Stopwatch sw = Stopwatch.StartNew();

 for(int i=0; i<300000; i++)
 {
     txt = txt + "1";
 }
 sw.Stop();
 Console.WriteLine(sw.ElapsedMilliseconds);

 string txt2 = "Hello World";

 Stopwatch sw2 = Stopwatch.StartNew();
 StringBuilder sb = new StringBuilder();
 sb.Append(txt2);

 for (int i = 0; i < 300000; i++)
 {
     sb.Append("1");
 }
 string newText = sb.ToString();
 sw2.Stop();
 Console.WriteLine(sw2.ElapsedMilliseconds);

StringBuilder가 내부적으로 일정한 양의 메모리를 항당
Append 메서드에 들어온 인자를 미리 할당한 메모리에 복사
2번 과정만 30만번 반복, 만약 Append로 추가된 문자열이 미리 할당된 메모리보다 많아지면 여유분의 메모리를 할당

 +로 문자열을 더했을때 걸린 시간 : 23580 ms
StringBuilder로 문자열을 더했을때 걸린 시간 : 2 ms

[WPF] 계산기 만들기

연향동큰손 — Fri, 9 Jan 2026 17:06:59 +0900

WPF

Windows Presentation Foundation의 약자
마이크로소프트에서 만든 UI 프레임워크
.NET으로 빌드가 가능

MVVM 패턴

model : 데이터를 다루는 부분, 비즈니스 로직을 포함

View : 레이아웃과 화면을 보여주는 역할, 사용자 인터페이스 담당

ViewModel

View에서 발생하는 이벤트 감지하고, 해당 이벤트에 맞는 비즈니스 로직을 수행
Model과 상호작용하여 데이터를 가져오거나 업데이터
View에 데이터를 업데이터하는 역할
View에 표시할 데이터를 가공하여 제공

MVVM패턴 동작과정

사용자의 Action이 View를 통해 들어온다.
View에 Action이 들어오면 ViewModel에 Action을 전달
ViewModel은 Model에게 데이터를 요청
Model이 ViewModel에게 데이터를 전달
ViewModel이 응답받은 데이터를 가공하여 저장
View는 Data Binding을 이용해 UI를 갱신

MVVM 패턴의 장점
- 뷰 로직과 비즈니스 로직을 분리하여 생산성 증가
- 테스트 수월
- 하나의 ViewModel을 여러 View가 공유할 수 있다( 하나의 로그인 ViewModel을 모바일뷰,PC뷰,테블릿뷰가 공유할 수 있다. (코드 재사용성 용이)

MVVM 패턴의 단점
- 설계가 복잡함
- 데이터 바인딩으로 인한 메모리 소모가 심하다.
- ViewModel 설계가 복잡함

XAML

eXtensible Markup Language
WPF에서 View를 그리기위해 사용하는 언어
Markup Language이기 때문에 태그를 사용

계산기 만들어보기

partial : 하나의 클래스를 여러 파일에 나눠서 작성할 수 있게 해주는 키워드

WPF 프로젝트를 보면 UI와 로직을 분리해서 관리하고 이 둘이 합쳐져서 하나의 클래스를 정의하기 때문에 partial키워드를 넣어준다.

public partial class MainWindow : Window 부분을 보면 Window클래스를 상속받는 것을 확인할 수 있다.

Window클래스는 창 하나에 필요한 모든 기본 기능을 구현해둔 클래스이고 이 클래스를 MainWindow에서 상속받기 때문에 창을 만들 때 필요한 여러 값이나 기능을 사용할 수 있게 된다.

MainWindow 클래스를 생성할때 InitializeComponent()를 통해 XAML을 읽고, Display나 Button등의 컨트롤 객체를 생성하는 등의 초기화 작업이 이루어 진다.

public MainWindow()
{
    InitializeComponent(); // XAML UI 초기화
}

값을 저장하기 위한 멤버 변수

private double _currentValue = 0; // 현재 계산 값
private string _currentOperator = ""; // 현재 연산자
private bool _isNewEntry = true; // 새 입력 여부

Number_Click메서드는 숫자 버튼을 눌렀을 때 실행되는 이벤트 로직이다.

object sender : 이벤트를 발생시킨 객체
- 왜 object 타입일까? : 이벤트를 발생 시키는 객체가 Button, TextBox, Window등 다양할 수 있기 때문이다.
- 왜 Button button = sender as Button; 와 같이 sender를 Button타입으로 바꿔줄까? : sender가 object타입이기 때문에 버튼 클래스의 메서드나 속성에 접근하기 위해서 형변환을 해준다.
RoutedEventArgs e : WPF 이벤트에 대한 추가 정보

private void Number_Click(object sender, RoutedEventArgs e)
{
    Button button = sender as Button;
    if (_isNewEntry) //지금 숫자 입력이 첫 숫자 입력인가?
    {
        Display.Text = button.Content.ToString(); //지금 누른 숫자를 화면에 넣음
        _isNewEntry = false;
    }
    else //숫자 입력중일때는 
    {
        Display.Text += button.Content.ToString(); //새 숫자를 뒤에 붙임.
    }
}

해당 메서드는 입력된 연산자에 따라 계산결과를 화면에 출력하는 메서드이다.

private void Calculate(double newValue)
{
    switch (_currentOperator)
    {
        case "+":
            _currentValue += newValue;
            break;
        case "-":
            _currentValue -= newValue;
            break;
        case "×":
            _currentValue *= newValue;
            break;
        case "÷":
            _currentValue /= newValue;
            break;
    }
    Display.Text = _currentValue.ToString();
}

연산자 버튼을 누를때 수행되는 Operator_Click 메서드

private void Operator_Click(object sender, RoutedEventArgs e) //연산자 버튼을 누를때 수행
{
    Button button = sender as Button;
    if (double.TryParse(Display.Text, out double newValue)) //화면에 있는 값을 숫자로 변환
    {
        if (!_isNewEntry)
        {
            Calculate(newValue);
        }
        _currentOperator = button.Content.ToString(); //현재 연산자 저장

        if (_currentOperator == "%")
        {
            double percentValue = _currentValue * (newValue / 100);
            Calculate(percentValue);
            _currentOperator = "";
        }
        else
        {
            _currentValue = newValue;
        }
        _isNewEntry = true;

    }
}

= 버튼을 누를때 계산이 수행되도록 하는 메서드

 private void Result_Click(object sender, RoutedEventArgs e)
 {
     if(double.TryParse(Display.Text, out double newValue))
     {
         Calculate(newValue); //계산 수행
         _currentOperator = ""; //연산자 초기화
         _isNewEntry = true; //새로운 값을 받을 준비
     }
 }

<전체 코드>

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfApp1
{
    /// <summary>
    /// MainWindow.xaml에 대한 상호 작용 논리
    /// </summary>
    public partial class MainWindow : Window
    {
        private double _currentValue = 0; // 현재 계산 값
        private string _currentOperator = ""; // 현재 연산자
        private bool _isNewEntry = true; // 새 입력 여부

        public MainWindow()
        {
            InitializeComponent(); // XAML UI 초기화
        }

        private void Number_Click(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;
            if (_isNewEntry)
            {
                Display.Text = button.Content.ToString();
                _isNewEntry = false;
            }
            else
            {
                Display.Text += button.Content.ToString();
            }
        }

        private void Operator_Click(object sender, RoutedEventArgs e) //연산자 버튼을 누를때 수행
        {
            Button button = sender as Button;
            if (double.TryParse(Display.Text, out double newValue)) //화면에 있는 값을 숫자로 변환
            {
                if (!_isNewEntry)
                {
                    Calculate(newValue);
                }
                _currentOperator = button.Content.ToString(); //현재 연산자 저장

                if (_currentOperator == "%")
                {
                    double percentValue = _currentValue * (newValue / 100);
                    Calculate(percentValue);
                    _currentOperator = "";
                }
                else
                {
                    _currentValue = newValue; //지금 화면에 있는 값을 피연산 값으로 저장
                }
                _isNewEntry = true;

            }
        }


        private void Calculate(double newValue)
        {
            switch (_currentOperator)
            {
                case "+":
                    _currentValue += newValue;
                    break;
                case "-":
                    _currentValue -= newValue;
                    break;
                case "×":
                    _currentValue *= newValue;
                    break;
                case "÷":
                    _currentValue /= newValue;
                    break;
            }
            Display.Text = _currentValue.ToString();
        }


        //지우기 버튼: 초기화
        private void Clear_Click(object sender, RoutedEventArgs e)
        {
            _currentValue = 0;
            _currentOperator = "";
            Display.Text = "0";
            _isNewEntry = true;
        }

        private void Backspace_Click(object sender, RoutedEventArgs e)
        {
            if (Display.Text.Length > 1)
            {
                Display.Text = Display.Text.Substring(0, Display.Text.Length - 1); //지우기

            }
            else
            {
                Display.Text = "0"; //화면의 숫자는 0으로 설정
                _isNewEntry = true; // 값을 새롭게 받음
            }
        }

        private void Point_Click(object sender, RoutedEventArgs e)
        {
            if (_isNewEntry) //새롭게 숫자를 받아야 하는데 .을 찍으면 0.으로 표기
            {
                Display.Text = "0.";
                _isNewEntry = false;
                return;
            }

            if (!Display.Text.Contains("."))
            {
                Display.Text += ".";
                
            }
        }

        private void Result_Click(object sender, RoutedEventArgs e)
        {
            if(double.TryParse(Display.Text, out double newValue))
            {
                Calculate(newValue); //계산 수행
                _currentOperator = ""; //연산자 초기화
                _isNewEntry = true; //새로운 값을 받을 준비
            }
        }
    }
}

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Calculator"
        Height="520"
        Width="360"
        WindowStartupLocation="CenterScreen"
        ResizeMode="NoResize">

    <Grid Margin="10">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="99*"/>
            <ColumnDefinition/>
        </Grid.ColumnDefinitions>
        <!-- 전체 레이아웃: 표시창 + 버튼 -->
        <Grid.RowDefinitions>
            <RowDefinition Height="100"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!-- ================= 표시창 ================= -->
        <TextBox x:Name="Display"
                 Grid.Row="0"
                 Text="0"
                 FontSize="36"
                 IsReadOnly="True"
                 TextAlignment="Right"
                 VerticalContentAlignment="Center"
                 Padding="10"
                 Margin="0,0,0,10" Grid.ColumnSpan="2"/>

        <!-- ================= 버튼 영역 ================= -->
        <Grid Grid.Row="1" Grid.ColumnSpan="2">
            <Grid.RowDefinitions>
                <RowDefinition/>
                <RowDefinition/>
                <RowDefinition/>
                <RowDefinition/>
                <RowDefinition/>
            </Grid.RowDefinitions>

            <Grid.ColumnDefinitions>
                <ColumnDefinition/>
                <ColumnDefinition/>
                <ColumnDefinition/>
                <ColumnDefinition/>
            </Grid.ColumnDefinitions>

            <!-- 1행 -->
            <Button Content="C"  Grid.Row="0" Grid.Column="0" Click="Clear_Click"/>
            <Button Content="CE" Grid.Row="0" Grid.Column="1" Click="Clear_Click"/>
            <Button Content="⌫"  Grid.Row="0" Grid.Column="2" Click="Backspace_Click"/>
            <Button Content="÷"  Grid.Row="0" Grid.Column="3" Click="Operator_Click"/>

            <!-- 2행 -->
            <Button Content="7" Grid.Row="1" Grid.Column="0" Click="Number_Click"/>
            <Button Content="8" Grid.Row="1" Grid.Column="1" Click="Number_Click"/>
            <Button Content="9" Grid.Row="1" Grid.Column="2" Click="Number_Click"/>
            <Button Content="×" Grid.Row="1" Grid.Column="3" Click="Operator_Click"/>

            <!-- 3행 -->
            <Button Content="4" Grid.Row="2" Grid.Column="0" Click="Number_Click"/>
            <Button Content="5" Grid.Row="2" Grid.Column="1" Click="Number_Click"/>
            <Button Content="6" Grid.Row="2" Grid.Column="2" Click="Number_Click"/>
            <Button Content="-" Grid.Row="2" Grid.Column="3" Click="Operator_Click"/>

            <!-- 4행 -->
            <Button Content="1" Grid.Row="3" Grid.Column="0" Click="Number_Click"/>
            <Button Content="2" Grid.Row="3" Grid.Column="1" Click="Number_Click"/>
            <Button Content="3" Grid.Row="3" Grid.Column="2" Click="Number_Click"/>
            <Button Content="+" Grid.Row="3" Grid.Column="3" Click="Operator_Click"/>

            <!-- 5행 -->
            <Button Content="0" Grid.Row="4" Grid.Column="1" Click="Number_Click"/>
            <Button Content="." Grid.Row="4" Grid.Column="2" Click="Point_Click"/>
            <Button Content="=" Grid.Row="4" Grid.Column="3" Click="Result_Click"/>
        </Grid>
    </Grid>
</Window>

[C#] 대리자(delegate)

연향동큰손 — Thu, 8 Jan 2026 17:01:44 +0900

delegate는 메서드를 값처럼 전달하기 위해서 사용한다.

이를 통해 메서드를 변수처럼 저장하고, 매개변수로 전달하거나, 다른 메서드로부터 반환받을 수 있다.

대리자 사용 방법

대리자 선언 : 대리자 타입을 선언하고, 대리자가 참조할 메서드의 반환 타입과 매개변수를 정의한다.
대리자 인스턴스화 : 선언된 대리자 타입을 사용하여 대리자 인스턴스를 생성한다.(여기서 대리자가 참조할 메서드를 지정한다.)
대리자 호출 : 대리자 인스턴스를 통해 메서드를 호출

대리자는 .NET 고급 프로그래밍의 핵심을 이루며, 콜백 메커니즘 구현, 이벤트 처리, 비동기 프로그래밍 등 다양한 영역에서 광범위하게 활용된다.

콜백 메커니즘 구현

콜백 메커니즘은 프로그램에서 어떤 작업이 완료된 후 특정 동작을 실행할 수 있게 하는 편리한 방법이다.

그리고 대리자를 사용하는 콜백 메커니즘 구현은 프로그래밍에서 매우 강력한 패턴 중 하나이다.

대리자를 통해 메서드를 다른 메서드의 매개변수로 전달할 수 있게 되며, 이를 통해 실행 될 콜백을 유연하게 지정할 수 있게 해준다.

<대리자 사용 전 코드>

namespace ConsoleApp1
{
    public interface ICallback
    {
        void OnComplete();
    }

    public class CallbackHandler : ICallback
    {
        public void OnComplete()
        {
            Console.WriteLine("콜백 메서드 호출");
        }
    }

    public class WithoutDelegate 
    { 
        public void ProcessTask(ICallback callback)
        {
            Console.WriteLine("Task is being processed");

            callback.OnComplete();
        }
    }


    public class Program
    {
        
        static void Main(string[] args)
        {
            WithoutDelegate wd = new WithoutDelegate();
            ICallback callback = new CallbackHandler();

            wd.ProcessTask(callback);
        }
    }
}

<대리자를 사용한 콜백 메커니즘>

namespace ConsoleApp1
{
    public delegate void Callback();

    public class WithDelegate
    {
        public void ProcessTask(Callback callback) //대리자를 매개변수로 받는 메서드
        {
            Console.WriteLine("Task is being processed");

            //콜백 메서드 실행
            callback?.Invoke(); //?.는 null이면 호출X null이 아니면 호출
        }
    }
    public class Program
    {
        public static void MyCallback() //콜백 메서드
        {
            Console.WriteLine("Task completed. Now running the callback.");
        }

        static void Main(string[] args)
        {
            WithDelegate wd = new WithDelegate();

            //Callback callback = () => Console.WriteLine("Task completed. Now running the callback.");
            Callback callback = new Callback(MyCallback);

            wd.ProcessTask(callback);
        }
    }
}

이벤트 처리

이벤트 처리란 어떤 일이 발생했을 때 미리 등록해 둔 코드가 자동으로 실행되도록 하는 구조이다.

이벤트 처리를 구현할때도 대리자를 사용하면 이벤트를 훨씬 간단하게 정의하고 관리할 수 있다.

<인터페이스 기반 이벤트 처리>

namespace ConsoleApp1
{
    public interface IEventHandler
    {
        void HandleEvent();
    }

    public class EventHandler1 : IEventHandler
    {
        public void HandleEvent()
        {
            Console.WriteLine("EventHadler1 called");
        }
    }
    public class EventHandler2 : IEventHandler
    {
        public void HandleEvent()
        {
            Console.WriteLine("EventHadler2 called");
        }
    }

    public class WithoutDelegate
    {
        private List<IEventHandler> subscribers = new List<IEventHandler>();
        public void Subscribe(IEventHandler handler)
        {
            subscribers.Add(handler);
        }

        public void Unsubscribe(IEventHandler handler)
        {
            subscribers.Remove(handler);
        }
        public void TriggerEvent()
        {
            foreach (var handler in subscribers)
            {
                handler.HandleEvent();
            }
        }
        public class Program
        {
            static void Main(string[] args)
            {
                var publisher = new WithoutDelegate();

                var handler1 = new EventHandler1();
                var handler2 = new EventHandler2();

                publisher.Subscribe(handler1);
                publisher.Subscribe(handler2);

                publisher.TriggerEvent();

                publisher.Unsubscribe(handler1);

                publisher.TriggerEvent();
            }
        }
    }
}

<대리자 기반의 이벤트 처리>

namespace ConsoleApp1
{
    public class WithDelegate
    {
        public event Action MyEvent;

        public void TriggerEvent()
        {
            MyEvent?.Invoke();
        }
    }
    public class Program
    {
        static void Main(string[] args) 
        {
            WithDelegate wd = new WithDelegate();

            // 이벤트 핸들러, Action에 람다식(익명 메서드)을 대입
            Action handler1 = () => Console.WriteLine("Event1 triggered!");
            Action handler2 = () => Console.WriteLine("Event2 triggered!");

            // 이벤트 구독
            wd.MyEvent += handler1;
            wd.MyEvent += handler2;

            // 이벤트 발생
            wd.TriggerEvent();

            // 이벤트 구독 해제
            wd.MyEvent -= handler2;

            // 이벤트 발생
            wd.TriggerEvent();
        }
    }
}

대리자를 사용하지 않으면, 모든 구독자는 동일한 메서드 시그니처를 구현해야 하고, 이벤트 관리를 위해 추가적인 코드가 필요하지만, 대리자를 이용하면 이벤트 구독과 발행 과정이 더 유연하고 간결해지고 다양한 시그니처의 메서드를 쉽게 처리할 수 있다.

<사용 예제>

public class Program
{
    // 대리자 선언
    public delegate void MyDelegate(string message);

    // 대리자가 참조할 메서드
    public static void DisplayMessage(string message)
    {
        Console.WriteLine(message);
    }

    static void Main(string[] args)
    {
        // 대리자 인스턴스화
        MyDelegate del = new MyDelegate(DisplayMessage);

        // 대리자 호출
        del("안녕하세요~~");
    }
}

using Project1;
using System;
using System.Diagnostics;



class Program
{
    delegate int Calc(int a, int b);

    int Add(int a, int b)
    {
        return a + b;
    }

    int Sub(int a, int b)
    {
        return a - b;
    }

    void Execute(Calc calc)
    {
        Console.WriteLine(calc(10, 5));
    }
    static void Main(string[] args)
    {
        Program p = new Program();

        Calc add = new Calc(p.Add);
        Calc sub = new Calc(p.Sub);

        p.Execute(add);
        p.Execute(sub);
    }
}

public class Mathematics
{
    delegate int CalcDelegate(int x, int y);

    static int Add(int x, int y) { return x + y; }
    static int Sub(int x, int y) { return x - y; }
    static int Multiply(int x, int y) { return x * y; }
    static int Divide(int x, int y) { return x / y; }

    CalcDelegate[] methods;

    public Mathematics()
    {
        methods = new CalcDelegate[] { Add, Sub, Multiply, Divide };
    }

    public void Calculate(char opCode, int operand1, int operand2)
    {
        switch (opCode)
        {
            case '+':
                Console.WriteLine(methods[0](operand1,operand2));
                break;
            case '-':
                Console.WriteLine(methods[1](operand1, operand2));
                break;
            case '*':
                Console.WriteLine(methods[2](operand1, operand2));
                break;
            case '/':
                Console.WriteLine(methods[3](operand1, operand2));
                break;
        }
    }

    class Program
    {
        delegate void WorkDelegate(char arg1, int arg2, int arg3);
        public static void Main()
        {
            Mathematics math = new Mathematics();
            WorkDelegate work = math.Calculate;

            work('+', 10, 5);

        }
    }
}

[C#] Collection / Generic Collection

연향동큰손 — Sun, 4 Jan 2026 15:35:03 +0900

Collection

Collection은 여러 자료구조를 공통된 인터페이스와 규칙으로 묶어 놓은 자료구조들의 집합이며,

.Net 프레임워크에서 비제네릭 컬렉션 클래스를 담당하는 대표적인 네임스페이스이다.

Collection 주요 클래스

ArrayList : 크기가 가변적인 배열, 인덱스를 통해 데이터에 접근 가능
Hashtable : Key-Value 저장
Queue : FIFO
Stack : LIFO

	// ArrayList 예제
        ArrayList al = new ArrayList();
        al.Add(10);
        al.Add("Hello");

        foreach(var item in al){
            Console.WriteLine(item);
        }

        // Hashtable 예제
        Hashtable table = new Hashtable();

        table["id"] = 1;
        table["name"] = "우현";

        Console.WriteLine("ID: " + table["id"]);
        Console.WriteLine("Name: " + table["name"]);

        // Queue 예제
        Queue queue = new Queue();

        queue.Enqueue(1);
        queue.Enqueue("Hello");

        Console.WriteLine(queue.Dequeue());
        Console.WriteLine(queue.Dequeue());

        // Stack 예제
        Stack stack = new Stack();

        stack.Push(1);
        stack.Push(2);

        Console.WriteLine(stack.Pop());
        Console.WriteLine(stack.Pop());

Generic Collection

Generic Collection은 Collection과 다르게 데이터 타입을 필수적으로 명시해야 한다.

이를 통해 타입 안정성이 확보되며 컴파일 시 타입 검사를 수행해 런타임 오류가 줄어드는 장점을 가져갈 수 있다.

또한 박싱과 언박싱의 과정이 이루어지지 않기 때문에 성능이 올라간다.

Generic Collection 주요 클래스

List<T> : 가변 크기 배열, 인덱스로 데이터에 접근 가능

추가	Add(T item)	맨 뒤에 추가
삽입	Insert(int index, T item)	중간 삽입
삭제	Remove(T item)	값으로 삭제
삭제	RemoveAt(int index)	인덱스로 삭제
조회	list[index]	인덱스 접근
검색	Contains(T item)	포함 여부
검색	IndexOf(T item)	인덱스 반환
개수	Count	요소 수
초기화	Clear()	전체 삭제

Dictionary<TKey, TValue> : Key-Value 저장

추가	Add(key, value)	Key-Value 추가
추가/수정	dict[key] = value	없으면 추가, 있으면 수정
조회	dict[key]	Key로 값 조회
삭제	Remove(key)	Key 삭제
검사	ContainsKey(key)	Key 존재 여부
검사	ContainsValue(value)	Value 존재 여부
전체 키	Keys	Key 컬렉션
전체 값	Values	Value 컬렉션
개수	Count	쌍 개수

Queue<T>, Stack<T> : Collection의 큐,스택과 동일한 저장방식, 다만 자료형을 미리 명시 해줘야 함.

Queue<T>

추가	Enqueue(T item)	뒤에 추가
제거	Dequeue()	앞에서 제거
조회	Peek()	제거 없이 조회
개수	Count	요소 수
초기화	Clear()	전체 삭제

Stack<T>

추가	Push(T item)	맨 위에 추가
제거	Pop()	맨 위 제거
조회	Peek()	제거 없이 조회
개수	Count	요소 수
초기화	Clear()	전체 삭제

HashSet<T> : 중복 데이터 저장 허용X, 데이터 존재 여부를 빠르게 검사 가능

추가	Add(T item)	중복 시 false
삭제	Remove(T item)	값 제거
검사	Contains(T item)	존재 여부
집합	UnionWith()	합집합
집합	IntersectWith()	교집합
집합	ExceptWith()	차집합
개수	Count	요소 수
초기화	Clear()	전체 삭제

System.Collections.SortedList : 키값을 기준으로 정렬된 상태를 유지하며 저장(Add를 통해 데이터를 추가하면 자동으로 정렬 수행)

Artillery 애플리케이션 부하 테스트

연향동큰손 — Wed, 19 Nov 2025 22:22:57 +0900

Artillery란?

Artillery는 node.js기반의 애플리케이션 부하 테스트 도구이며, HTTP,HTTPS, Websocket등의 다양한 프로토콜을 지원한다.

또한, 테스트 시나리오를 JSON 또는 YAML파일로 작성하여 테스트 하는 점이 특징이다.

기존에 사용하던 JMeter와 비교했을때 설치가 쉽지만 테스트 케이스를 YAML/JSON로 직접 작성해야 된다는 단점이 있다고 느꼈다.

하지만 이 부분은 어느정도 사용해보면 적응할 수 있을 것 같다.

Artillery 설치 방법

Set up Artillery CLI · Artillery

Learn how to get up and running with Artillery with reference docs, guides, tutorials and other resources.

www.artillery.io

Node.js가 미리 설치 되어있는 환경에서 위 홈페이지로 들어가면 나오는 명령어를 터미널에 입력해주면 다운로드가 진행된다.

npm install -g artillery@latest

테스트 시나리오 작성

테스트 시나리오를 작성할때는 가상 사용자 수, 요청횟수, 초당 요청 수, 테스트 URL, HTTP Method 등을 선택할 수 있다.

이번 테스트에서 작성한 YAML파일은 다음과 같다.

config:
  target: "서버 주소"  # 테스트를 보낼 서버 주소
  phases:
    - duration: 100     # 테스트 실행 시간(초)
      arrivalRate: 10   # 시작 시 초당 요청 수
      rampTo: 100       # 점진적으로 증가할 최대 초당 요청 수
  payload:
    path: "urls.csv"    # 사용할 CSV 파일
    fields:
      - "url"           # CSV의 컬럼명 → {{ url }} 변수로 사용

scenarios:
  - name: "create shortenUrl"   # 시나리오 이름
    flow:
      - post:
          url: "/shortenUrl"    # 호출할 API 경로
          json:
            originalUrl: "{{ url }}"   # CSV에서 읽은 url 값을 요청 body에 삽입

테스트 방법

테스트 시나리오를 작성하면 테스트 수행 후 결과를 확인해볼 수 있다.

터미널에서 바로 결과를 확인할 수도 있고, 테스트 결과를 파일로 저장할 수도 있지만, Artillery에 회원가입 후 API 키값을 이용하면 테스트 결과를 Artillery 홈페이지에서 테스트 결과를 다양한 시각화 자료와 함께 확인 가능하다.

artillery run read-load-test.yaml --record --key <API_KEY>
# read-load-test.yaml 파일을 실행하고 실행 결과를 Artillery Cloud 대시보드에 기록(업로드)함

artillery run read-load-test.yaml -o read-load-report.json
# read-load-test.yaml 테스트 실행 후 결과를 read-load-report.json 파일로 로컬에 저장

artillery report --output read-load-report.html read-load-report.json
# read-load-report.json 파일을 html 리포트로 변환

테스트를 수행하면 터미널에서 다음과 같은 결과를 얻을 수 있다.

min : 가장 빠른 응답 시간
max : 가장 느린 응답 시간
mean : 평균 응답시간
median : 응답시간을 빠른 순으로 정렬했을 때 정확히 중간값
p95 : 상위 95%가 이 시간 이하로 응답(5%는 이 시간보다 느렸다.)
p99 : 상위 99%가 이 시간 이하로 응답(1%는 이 시간보다 느렸다.)
vusers.failed : 실패한 가상 사용자

Artillery 대시보드

Artillery에서 발급해주는 API Key값을 이용해 Artillery 대시보드에서 테스트 결과를 확인해볼 수 있다.

Artillery 로그인
Settings -> API Key 확인
터미널에서 artillery run read-load-test.yaml --record --key <API_KEY> 실행

[JPA] N+1 문제

연향동큰손 — Fri, 7 Nov 2025 17:01:38 +0900

N+1 문제는 ORM 기술에서 특정 객체를 대상으로 수행한 쿼리가 해당 객체가 가지고 있는 연관관계 또한 조회하게 되면서 N번의 추가적인 쿼리가 발생하는 문제를 말한다.

N+1문제로 인해 불필요하게 많은 쿼리를 보내면 성능 저하로 이어질 수 있기 때문에 적절한 방법을 통해 N+1을 예방하는 것이 중요하다.

실습

실습에서 사용된 엔티티간의 연관 관계는 다음과 같다.

국가 : 도시 (1:N)
한 국가에 여러 도시가 리스트로 포함

<CountryEntity>

@Entity
@Getter
@Setter
public class CountryEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String country;

    @OneToMany(mappedBy = "countryEntity")
    private List<CityEntity> cityEntities = new ArrayList<>();

    public void addCityEntity(CityEntity cityEntity) {
        cityEntities.add(cityEntity);
        cityEntity.setCountryEntity(this);
    }
}

<CityEntity>

@Entity
@Getter
@Setter
public class CityEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String city;

    @ManyToOne
    private CountryEntity countryEntity;
}

아래와 같이 3개의 Country와 각각의 City를 생성해주고 JPA를 이용해 조회를 했을때 쿼리가 몇번 수행되는지 확인해보면 N+1 문제가 발생하는지 확인해볼 수 있다.

korea : seoul, busan, daegu
france : paris
usa : newyork, chicago

1. 국가(부모)를 모두 조회

국가 리스트(CountryEntity)를 조회할 때는 단순히 부모 엔티티만 가져오는 작업이기 때문에 데이터베이스에 쿼리가 한 번만 전달된다. 뷰 템플릿에서도 국가 정보만 출력하고 연관된 도시 컬렉션을 접근하지 않기 때문에 추가적인 쿼리는 발생하지 않는다.

2. 국가(부모) findAll → 도시(자식) 접근

국가와 함께 각 국가에 속한 도시 목록까지 조회하려고 하면 상황이 달라진다. 먼저 국가 목록을 가져오는 쿼리가 한 번 실행되고, 이후 템플릿에서 cityEntities 컬렉션에 접근하는 순간 각 국가마다 해당 도시에 대한 지연 로딩 쿼리가 추가로 발생한다. 그 결과 국가 수(N)만큼 도시 조회 쿼리가 반복 실행되어 총 1 + N개의 쿼리가 발생하는 것을 확인할 수 있다.

3. 도시(자식)만 조회

도시 엔티티를 단독으로 조회하더라도, @ManyToOne의 기본 Fetch 전략이 EAGER이기 때문에 연관된 국가 엔티티도 즉시 함께 조회된다. 그 결과, 국가 정보를 조회할 의도가 없어도 JPA가 부모 엔티티를 자동으로 불러오기 위해 추가 쿼리를 한 번 더 실행하게 된다.

Lazy, Eager

JPA는 연관관계를 가진 엔티티를 언제 DB로 불러올지 결정하는 로딩 전략(Lazy,Eager)이 존재한다.

Lazy Loading (지연 로딩)

필요할 때까지 연관 엔티티를 DB에서 가져오지 않고 실제로 접근할 때 쿼리 실행

Eager Loading(즉시 로딩)

엔티티를 조회할 때 연관 엔티티도 즉시 함께 조회하는 방식

JPA JOIN별 default 값
- OneToOne : Eager
- ManyToOne : Eager
- OneToMany : Lazy

앞서 도시(자식)을 조회할때 국가(부모)를 조회하는 쿼리가 추가된 이유도 도시에 대한 연관 엔티티(국가)가 ManyToOne조인의 default값 Eager로 되어있었기 때문에 자동으로 조회 쿼리가 실행 되었다.

여기서 아래 코드와 같이 ManyToOne의 FetchType을 Lazy(지연 로딩)방식으로 변경해주면 연관 엔티티에 대한 접근이 없다면 쿼리를 추가적으로 실행하지 않게 된다.

@ManyToOne(fetch = FetchType.LAZY)
private CountryEntity countryEntity;

도시에 대한 조회 쿼리만 실행된것을 확인할 수 있다.

연관관계 쿼리 단일화

JPA에서 엔티티 조회 후 연관된 엔티티 접근 시 발생하는 추가 쿼리를 단건의 쿼리로 단일화 시키는 방법에는 다음과 같은 방법이 존재한다.

JPQL @Query로 JOIN FETCH 작성
QueryDSL로 fetchJoin()
@EntityGraph
Lazy 쪽 조회시 Batch 설정을 통한 IN절

JPQL JOIN FETCH 작성

JOIN FETCH란 연관된 엔티티를 즉시 조인하여 한 번의 쿼리로 함께 로딩하는 JPQL 문법이다.

<기본 문법>

SELECT e
FROM Parent e
JOIN FETCH e.children

위 실습에서 국가(부모)를 조회하고 도시(자식)을 조회하는 상황에서는 국가를 조회하고 각 국가마다 해당 도시에 대한 지연 로딩 쿼리가 추가로 발생하였다.

왜냐하면 국가(부모)테이블의 연관 테이블(도시)가 OneToMany로 연결되어있었고 OneToMany의 디폴트 로딩값이 Lazy로딩이기 때문이다.

이 상황은 JPQL의 JOIN FETCH를 통해 해결 가능하다.

@Query("SELECT co FROM CountryEntity co " + "JOIN FETCH co.cityEntities ci")
List<CountryEntity> findAllFetch();

JOIN FETCH를 통해 국가와 도시를 모두 한번에 로딩함으로써 추가 쿼리가 발생하지 않도록 할 수 있다.

테스트 결과 1번의 쿼리만 실행되는 것을 확인할 수 있다.

하지만 이렇게 JOIN FETCH만 사용한다면 누락되는 데이터가 존재할 수 있다.

국가에 Germany를 넣고 도시를 추가하지 않게 되면 조회시 Germany가 조회되지 않는다.

(OneToMany에서 One은 존재하는데, Many가 존재하지 않는 경우)

왜냐하면 그냥 JOIN FETCH만 사용할 경우 INNER JOIN으로 연관된게 있는 교집합이어야 조회가 되기 때문이다.

만약 교집합이 안되는 데이터도 조회하고 싶다면 LEFT JOIN FETCH을 사용하면 된다.

@Query("SELECT co FROM CountryEntity co "+"LEFT JOIN FETCH co.cityEntities ci")
List<CountryEntity> findAllFetch();

LEFT JOIN FETCH

다중 OneToMany Fetch 문제

하나의 엔티티에 2개 이상의 OneToMany가 포함되어 있는데 Fetch 조회를 할 경우 예외가 발생한다.

왜냐하면 JPA의 구현체인 Hibernate에서 2개 이상의 OneToMany Fetch를 강제로 막고 있기 때문이다.

여러개의 OneToMany를 Fetch Join하게 되면 조인 결과가 카티션 곱(Cartesian Product)으로 나와서 결과가 폭발적으로 커질 수 있다.

해결 방법

기준 엔티티의 OneToMany 필드에서 Set을 사용하여 중복을 제거
한쪽만 Fetch, 나머지는 in절 : 이렇게 되면 1+N 쿼리는 아니지만 1+소수 개의 쿼리로 문제를 해결 가능하다.

@Query("SELECT co FROM CountryEntity co "+
        "LEFT JOIN FETCH co.cityEntities ci "+
        "LEFT JOIN  co.religionEntities re")
List<CountryEntity> findAllFetch();

@BatchSize(size = 250) //Lazy로딩할 때 한번에 250개씩 묶어서 로딩
@OneToMany(mappedBy = "countryEntity")
private List<ReligionEntity> religionEntities = new ArrayList<>();

이렇게 BatchSize를 250개로 설정하면 250개의 국가에 대해서 religionEntities 조회 쿼리는 단 1번만 실행된다.

OneToMany fetch시 페이지네이션

@Query("SELECT co FROM CountryEntity co "+
        "LEFT JOIN FETCH co.cityEntities ci ")
List<CountryEntity> findAllFetch(Pageable pageable);

One쪽 엔티티를 기준으로 OneToMany fetch시 페이지네이션을 함께 수행하게 되면 조회는 정상적으로 수행 되지만, 경고가 발생하게 된다.

 WARN 4334 --- [1plusNtest] [nio-8080-exec-1] org.hibernate.orm.query : HHH90003004: firstResult/maxResults specified with collection fetch; applying in memory

경고문이 발생하는 이유는 Fethch Join이 적용된 상태에서 페이징을 수행하게 되면 Hibernate가 DB에 Limit/OFFSET을 적용할 수 없기 때문에 모든 데이터를 조회한 뒤, 메모리에서 강제로 페이징을 수행하므로 메모리 낭비 위험이 있기 때문이다.

이 문제를 해결하는 방법 중 하나는 batch in 절을 사용하여 1+N 개의 쿼리 중 N개의 쿼리에 대해 batch단위로 묶어 1+소수개의 쿼리로 성능을 최적화 할 수 있다.

@BatchSize(size = 250)
@OneToMany(mappedBy = "countryEntity")
private List<CityEntity> cityEntities = new ArrayList<>();

<기존의 Fetch Join방법 대신 findAll로 조회>

public List<CountryEntity> readCountryFetch(){
        Pageable pageable = PageRequest.of(0,5);
//      return countryRepository.findAllFetch(pageable);
        return countryRepository.findAll(pageable).stream().toList();
    }

조회 실행 시 국가(부모)에 대한 목록을 조회하는 쿼리 실행 후 batch in을 통해 현재 페이지에 담긴 여러 국가들의 도시(자식)들을 BatchSize만큼 묶어서 일괄 조회하는 것을 확인할 수 있었다.

Hibernate: select ce1_0.id,ce1_0.country from CountryEntity ce1_0 limit ?,?
Hibernate: select ce1_0.countryEntity_id,ce1_0.id,ce1_0.city from CityEntity ce1_0 where ce1_0.countryEntity_id in (?......?)

정리

단순하게 One(부모) 목록만 보여주고 연관된 Many(자식)한테는 접근을 안함

Lazy로딩 사용해도 무방하다.

List<One> 목록 및 각 연관 Many로 접근 함

- 페이지네이션이 들어가는 경우 : @BatchSize를 통한 IN절 쿼리 수행

- 다중 OneToMany 상황에서 각각의 OneToMany 데이터가 다 필요한 경우 : 하나만 JOIN FETCH, 나머지는 @BatchSize를 통한 IN절 쿼리 수행 OR 전체 @BatchSize를 통한 IN절 쿼리 수행

- SQL 조건으로 가져온 데이터가 다 필요한 경우 OR List<One>의 사이즈가 작고 Many로 접근 함 : JOIN FETCH 사용

Spring Boot 예외 처리 전략 [Custom Exception, ExecptionHandler]

연향동큰손 — Wed, 22 Oct 2025 16:01:38 +0900

Custom Exception

커스텀 예외란 자바의 기본 예외(RuntimeException, IllegalArgumentException 등)를 상속받아 비즈니스 로직에 맞는 의미 있는 예외 클래스를 직접 정의하는 것을 말한다.

자바에서 제공하는 기본 예외를 이용하여 try-catch문을 통해 예외 처리를 해줘도 오류 상황을 면할수는 있지만, 어떤 비즈니스 로직에서 어떤 원인으로 예외가 발생했는지 명확하게 표현하기 힘들다.

기본 예외를 서비스 계층에서 던지게 구현을 했다면 컨트롤러에서 try-catch문을 통해 모두 예외 상황에 맞는 HTTP 상태코드를 지정해줘야 한다.

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity<?> getUser(@PathVariable Long id) {
        try {
            User user = userService.getUser(id);
            return ResponseEntity.ok(user);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                    .body(Map.of("message", e.getMessage()));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Map.of("message", "서버 오류가 발생했습니다."));
        }
    }
}

이러한 과정 때문에 생기는 코드 중복 문제를 해결하고, 일관된 상태 메시지를 제공하기 위해 Custom Exception과 ExecptionHandler를 사용할 수 있다.

구현 과정

BaseException

@Getter
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BaseException extends RuntimeException {

    HttpStatus statusCode;
    String responseMessage;

    public BaseException(HttpStatus statusCode) {
        super();
        this.statusCode = statusCode;
    }

    public BaseException(HttpStatus statusCode, String responseMessage) {
        super(responseMessage);
        this.statusCode = statusCode;
        this.responseMessage = responseMessage;
    }

    public BaseException(ErrorStatus errorStatus) {
        super(errorStatus.getMessage());
        this.statusCode = errorStatus.getHttpStatus();
        this.responseMessage = errorStatus.getMessage();
    }

    public int getStatusCode() {
        return this.statusCode.value();
    }
}

커스텀 예외 클래스들의 부모 클래스 역할을 수행
RuntimeException을 상속
HttpStatus, 에러 메시지를 받는 생성자

ErrorStatus

예외 상황에 맞는 상태코드와 메시지를 한곳에서 관리하는 enum이다.

@Getter
@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
public enum ErrorStatus {
    

    private final HttpStatus httpStatus;
    private final String message;
    
    NOT_FOUND_USER(HttpStatus.NOT_FOUND,"사용자를 찾을 수 없습니다."),
    NOT_FOUND_SAVED_JOB(HttpStatus.NOT_FOUND, "저장 내역이 없습니다."),

	//...
    
    public int getStatusCode() {
        return this.httpStatus.value();
    }
}

Custom Exception

BaseException을 상속받은 구체적인 커스텀 예외 클래스이다.

각 상황에 맞는 ErrorStatus(상태코드, 에러 메시지)를 이용해 BaseExeption의 생성자를 호출해줌으로써 예외가 발생했을 때 HTTP 상태코드와 에러 메시지를 자동으로 세팅할 수 있다.

public class NotFoundException extends BaseException {

    public NotFoundException() {
        super(HttpStatus.NOT_FOUND);
    }

    public NotFoundException(String message) {
        super(HttpStatus.NOT_FOUND, message);
    }
    public NotFoundException(ErrorStatus errorStatus) {
        super(errorStatus);
    }
}

GlobalExceptionHandler

GlobalExceptionHandler 클래스는 스프링 애플리케이션 전역에서 발생하는 모든 예외를 한 곳에서 처리하는 핵심 클래스이다.

@RestControllerAdvice와 @ExceptionHandler로 모든 컨트롤러에서 발생하는 예외를 감지하고 상황에 맞게 처리할 수 있도록 해준다.

@RestControllerAdvice

모든 @RestController에서 발생한 예외를 감지해 공통적으로 처리

@ExceptionHandler

특정 예외 타입이 발생했을 때 실행할 처리 로직을 지정

@RestControllerAdvice
public class GlobalExceptionHandler {

    /** 커스텀 예외(BaseException) */
    @ExceptionHandler(BaseException.class)
    public ResponseEntity<ApiResponse<Void>> handleBase(BaseException ex) {
        final int code = ex.getStatusCode();
        final String msg = ex.getResponseMessage() != null
                ? ex.getResponseMessage()
                : HttpStatus.valueOf(code).getReasonPhrase();
        return ResponseEntity.status(code).body(ApiResponse.fail(code, msg));
    }

    // ...
}

의도적으로 커스텀 예외인 NotFoundException을 발생시켜보면 응답결과가 다음과 같이 상태코드, 메시지와 함께 출력되는 것을 확인할 수 있다.