무휴학 편입 특성상 편입 직전의 집중도 있는 학습과 연속적인 편입 시험으로 너무 바빠서 한동안 벨로그를 작성하지 못했다.

그래서 지난 기간동안 어떤 성과를 냈는지 정리하고 넘어가려고 한다.

길고 길었던 편입 준비가 좋은 결과로 끝났고 새로운 학교에서는 백엔드와 더 깊이있는 코딩테스트 위주로 학습하면서 전공 공부에 매진할 생각이다.

앞으로는 배운 개념이나 이론 위주의 블로그 보다는 프로젝트나 학습하면서 느낀점들 위주로 작성해보려고 한다.

SQLD 취득

바쁜 와중에 데이터베이스설계와 데이터관리 수업을 듣고 SQL에 입문한 뒤 일주일 빠짝 공부해서 SQLD 취득에 성공했다.

어짜피 시험 범위였기에 미리 자격증을 따고 수월하게 A+를 받았다.

체육대전 농구 우승

경영학부의 에이스 선배들 덕분에 많이 뛰지도 않고 우승 트로피를 만졌다.

기여도 4%..? 경기 안뛸때는 벤치에서 응원 열심히 했다.

정작 열심히 한 배구는 예선 탈락했다는 사실..

교내 SW경진대회 장려상 수상

Python, C++ 라이브러리를 활용하는 고학년들의 경쟁속이었다.

C랑 자료구조 알고리즘 공부하면서 백준 골드를 달성한 김에 C언어로 용감하게 대회에 신청하였다.

C언어로 큐를 직접 구현해가면서 문제를 푼 사람은 나밖에 없었던 것 같다.

어짜피 편입 시험 범위니까 공부한다는 생각으로 출전했는데 필요한 자료구조를 직접 구현하며 절반 정도 풀고나니 시간이 부족해서 더 풀 수가 없었다.

그래도 장려상이라도 받았으니 만족스럽다.

경북대학교에서는 Java로 전향하여 백준 플레티넘과 각종 알고리즘 대회 수상을 목표로 나아가려고한다.

시흥실록지리지(로컬 창업 경진대회) 장려상 수상

정말 많은 시간을 할애했지만 아쉽게도 가장 낮은 상을 수상하였다.

한국공학대학교라 그런건지 공학 관련 창업 아이템들이 상을 휩쓸었고 바이럴 마케팅이 메인 주제였던 우리의 서비스는 열띤 발표에도 불구하고 교수님들을 끝내 설득하지 못했다.

그래도 담당 공무원과 인터뷰를 잡고 직접 진행해보고, 각종 전문가들에게 문의하면서 견적내고, 각종 활동에서 여러 멘토님들도 만나면서 인사이트가 많이 넓어진것 같다.

또한 최고급 호텔 스위트룸에서 밤새 프로젝트에 몰두해보기도 하고, 창업 전문가들, 교수님들, 기자들, 수많은 학우들 앞에서 여러 차례 발표해볼 수 있는 좋은 경험이었다.

각종 대회 출전 경험

창업 경진대회에 조원으로 참여하기도 하였고, 제주 공공데이터 활용 공모전에도 과감하게 출전하였으나 예선 탈락하였다.

JSP 쇼핑몰 프로젝트

GITHUB - MERCI JSP

JSP로 개발한 반응형 쇼핑몰 웹사이트 프로젝트이다.

상업적인 목적은 없으며 데이터베이스 연동 학습 목적으로 개발하였다.

https://wellbeingexpress.com

위 사이트의 메인 페이지 디자인을 참고하였으며 의류 이미지를 샘플 데이터로 사용하였다.

*구현한 기능 * 물품 관리 - 등록/수정/삭제 - 품목 별 리뷰 고객 관리 - 회원가입 / 계정 삭제 / 로그인(소셜) 및 비밀번호 변경 - 찾기 / 상품 찜 기능 / 주소지 저장 및 불러오기 (도로명주소 API) 주문 관리 - 결제 확인 및 주문 완료 변경 / 리뷰 등록-수정-삭제 주문 및 결제(장바구니 및 대행사 활용) - AJAX 활용하여 사용 편의성 향상 문의 관리 - QNA 등록 수정 삭제 물품 카테고리별 나열 및 검색 소개 페이지 및 수정 페이지

이외에도 디테일적인 부분들이 많고 결제는 대행사 테스트용 API를 활용했다.

2학년 수료 및 편입 시험 준비

평균 평점 4.41로 한국공학대학교 2학년을 수료하였고 방학 동안은 편입 시험 공부에 집중하였다.

레드 블랙 트리나 AVL 트리의 삭제 등 심화적인 부분까지 대비하였다.

처음엔 이해가 안갔는데 구현해본 코드를 외우고 설명할 정도까지 학습하고 나니까 이젠 쉽게 느껴진다.

C++도 학습하며 STL 라이브러리의 활용과 각종 자료구조를 사용하는 코드를 구현하는걸 타이핑이 아니라 연필로 써가며 무한 반복하였다.

*이산수학 / C / C++ / 자료구조 *등 출제범위가 광범위하기에 내가 아무리 공부해도 모르는게 나와버리면 어떡하지라는 불안감속에서 끊임없이 반복학습하였다.

시험 직전에는 더 이상 공부할게 없었다.

이렇게까지 했는데 내가 못 풀면 남들도 못 푸는 문제다 라는 생각이 들 정도로 대비되어있었다.

다행히 큰 이변 없이 각종 면접과 시험에서 좋은 결과를 냈고 토익 편입으로 갈수 있는 모든 학교에 합격하였다.

그중 IT 분야 강자인 경북대학교로 진학하게 되었다.

앞으로는 ?

Java로 코딩테스트를 학습하면서 객체지향언어에 익숙해질것이다.

동시에 Spring을 깊이있게 학습해 대기업 백엔드 직군에 적합한 인재가 되어보려고 한다.

이 과정에서 바이브 코딩이나 openclaw 등을 활용하며 나의 깊은 지식과 AI의 생산성을 융합시켜 각종 대회에도 진출할 생각이다.

무엇보다도 동아리나 대외활동에 적극 참여하며 같은 분야에 속한 열정적인 학우들과 함께 성장하고싶다.

코딩테스트 문제를 풀때 디버거를 잘 몰라서 printf와 같은 출력문을 반복문 사이사이에 넣어서 풀곤 했었다.

하지만 UNIX를 배우면서 Make Utility와 GCC 컴파일러에 대해 배우면서 GDB에 대해 배울 수 있었다.

이를 배우면서 흥미를 느껴 이에 대해 기록하고 앞으론 IDE에서도 디버거를 활용하려고한다.

디버거란 ?

printf를 코드 곳곳에 삽입하여 변수 값을 확인하는 방식은 간단하지만, 재귀와 같은 알고리즘이 쓰이면서 점점 복잡해지는 프로그램에서는 한계에 부딪힌다.

코드는 지저분해지고, 버그를 잡은 뒤에는 모든 printf를 다시 지워야 하는 번거로움도 존재한다.

GDB(GNU Debugger)는 리눅스(유닉스) 환경에서 이런 원시적인 방법을 대체하는 강력한 디버깅 도구이다.

프로그램을 특정 지점에서 멈추게 하고, 변수 값을 실시간으로 들여다보며, 코드를 한 줄씩 실행하는 등 프로그램의 내부를 정밀하게 분석할 수 있게 해준다.

디버깅 정보 포함하여 컴파일하기

GDB가 소스 코드의 내용을 제대로 인식하고 분석하려면, 컴파일할 때 디버깅 정보를 포함시켜야 한다. GCC 컴파일러에서 -g 옵션을 사용하면 된다.

# -g 옵션을 추가하여 컴파일한다.
gcc -g -o factorial factorial.c

-g 옵션 없이 컴파일된 실행 파일은 GDB로 분석할 수는 있지만, 소스 코드의 몇 번째 줄인지 추적하거나 변수명을 확인하는 등의 핵심 기능을 제대로 사용할 수 없다.

GDB를 사용하려면 -g 옵션을 꼭 사용해야한다.

버그가 있는 팩토리얼 프로그램

아래는 5의 팩토리얼(!5)을 계산하는 코드이지만 버그를 포함하고 있다.

5!는 120이어야 하지만, 이 프로그램은 잘못된 결과를 출력한다.

#include <stdio.h>

// n! (n 팩토리얼)을 계산하는 함수
int calculate_factorial(int n) {
    int result = 1;

    // 버그: i <= n 이 되어야 하지만 i < n 으로 되어있다.
    for (int i = 1; i < n; i++) {
        result = result * i;
    }
    return result;
}

int main(void) {
    int number = 5;
    int result = 0;

    result = calculate_factorial(number);

    printf("%d의 팩토리얼 결과: %d\n", number, result);

    return 0;
}

이 코드를 -g 옵션으로 컴파일하고 실행하면 5의 팩토리얼 결과: 24라는 오답이 나온다.

단계별 디버깅 과정

1) GDB 시작 터미널에 gdb 명령어와 함께 분석할 실행 파일명을 입력한다.

gdb ./factorial

GDB가 시작되면 (gdb) 프롬프트가 나타나며 명령어 입력을 기다린다.

2) 브레이크포인트(Breakpoint) 설정 브레이크포인트는 프로그램 실행 중 의도적으로 멈추고 싶은 지점을 설정하는 것이다.

가장 먼저 main 함수가 시작되는 지점에 설정해보자.

(gdb) break main
Breakpoint 1 at 0x1169: file factorial.c, line 15.

break [함수명] 또는 b [줄 번호] 형식으로 설정할 수 있다.

3) 프로그램 실행 run (축약형 r) 명령어로 프로그램을 실행한다.

프로그램은 실행되다가 이전에 설정한 브레이크포인트(main 함수)를 만나면 즉시 멈춘다.

(gdb) run
Starting program: /path/to/factorial

Breakpoint 1, main () at factorial.c:15
15        int number = 5;

이제 프로그램은 15번째 줄이 실행되기 직전에 멈춰있다.

4) 코드 한 줄씩 실행 : next next (축약형 n) 명령어는 현재 줄을 실행하고 바로 다음 줄에서 멈춘다.

main 함수의 코드를 한 줄씩 따라가 보겠다.

(gdb) next
16        int result = 0;
(gdb) next
18        result = calculate_factorial(number);

5) 변수 값 확인 : print print (축약형 p) 명령어는 현재 시점의 변수 값을 보여준다.

(gdb) print number
$1 = 5
(gdb) print result
$2 = 0

number 변수에는 5가, result 변수에는 0이 올바르게 들어가 있음을 확인했다.

6) 함수 내부로 들어가기: step 다음 실행할 18번 라인은 calculate_factorial 함수 호출이다.

이 함수의 내부 동작을 보고 싶다면 next 대신 step (축약형 s)을 사용한다.

step은 함수 호출을 만나면 그 함수 내부로 진입한다.

(gdb) step
calculate_factorial (n=5) at factorial.c:5
5        int result = 1;

calculate_factorial 함수 내부로 들어왔고, 파라미터 n에 5가 잘 전달된 것을 볼 수 있다.

7) 버그 추적 이제 for문 안에서 변수들이 어떻게 변하는지 next와 print로 추적해보자.

(gdb) next
8        for (int i = 1; i < n; i++) {
(gdb) next
9            result = result * i;
(gdb) print i
$3 = 1
(gdb) print result
$4 = 1
````next`를 반복하며 `i`와 `result`의 변화를 계속 관찰한다.

```gdb
# ... next를 계속 입력 ...

(gdb) next
9            result = result * i;
(gdb) p i
$7 = 4
(gdb) p result
$8 = 6
(gdb) next
8        for (int i = 1; i < n; i++) {
(gdb) p result
$9 = 24
(gdb) next
11        return result;

i가 4일 때 result는 6 * 4 = 24가 되었다.

그리고 i가 5가 되자 i < n (즉, 5 < 5) 조건이 거짓이 되어 루프를 빠져나왔다.

여기서 팩토리얼은 5까지 곱해야 하는데, i가 4일 때까지만 곱하고 루프가 종료되었음을 확인할 수 있다.

for문의 조건이 i < n이 아니라 i <= n이 되어야 한다.

8) 디버깅 종료 원인을 찾았으니 디버깅을 종료한다. quit (축약형 q) 명령어를 입력한다.

(gdb) quit
A debugging session is active.

    Inferior 1 [process 12345] will be killed.

Quit anyway? (y or n) y

GDB 핵심 명령어 정리

Windows의 Visual Studio 같은 통합 개발 환경(IDE)은 매우 편리하지만, 많은 개발 환경, 특히 서버는 그래픽 인터페이스(GUI)가 없는 터미널 기반의 리눅스로 운영된다.

따라서 터미널 환경에서 코드를 작성하고 컴파일하는 능력은 개발자의 기본 소양이다.

이번에 강의에서 UNIX를 다루게 되면서 처음엔 복사 붙여넣기도 제대로 못하고 Vim 모드에서 벗어나기도 힘들었다.

이처럼 윈도우에 익숙해진 나에게 어려운 점이 많아서 오래 기억하고 두고두고 볼 수 있도록 글을 써보려고한다.

Vim(vi) 편집기 사용법

Vim은 키보드만으로 모든 작업을 수행하는 터미널 기반의 강력한 텍스트 편집기이다.

최초의 유닉스용 화면 편집기이고 모든 유닉스/리눅스 시스템이 기본적으로 갖추고 있다.

Vim의 가장 큰 특징은 '모드(Mode)' 라는 개념이 있다는 것이다.

Vim의 3가지 모드

Vim을 효과적으로 사용하려면 아래 3가지 모드를 이해해야 한다.

1. 명령 모드 (Normal Mode) Vim을 실행했을 때의 기본 상태이다. 키를 입력하면 텍스트가 써지는 것이 아니라, 커서 이동, 내용 복사/붙여넣기, 삭제 등의 명령이 실행된다.

2. 입력 모드 (Insert Mode) 실제로 텍스트를 입력하고 코드를 작성할 수 있는 모드이다. 명령 모드에서 i, a, o 등의 키를 눌러 진입할 수 있다. 이 모드에서 나가려면 ESC 키를 누르면 된다.

3. 마지막 행 모드 (Command-Line Mode) 명령 모드에서 :(콜론) 키를 눌러 진입한다. 화면 맨 아래 줄에 명령어를 입력하여 파일 저장, 종료, 검색 등 강력한 기능을 수행한다.

Vim으로 hello.c 파일 작성하기

1) Vim 실행 및 파일 생성 vim혹은 vi 명령어 뒤에 생성할 파일명을 입력한다. 파일이 존재하면 열리고, 없으면 새로 생성된다.

vi hello.c

실행하면 비어있는 화면이 나타나며, 현재는 명령 모드 상태이다.

2) 입력 모드로 전환 코드를 작성하기 위해 키보드에서 i 키를 누른다. 화면 하단에 -- 끼워넣기 -- 혹은 -- INSERT -- 라는 문구가 나타나면 입력 모드로 전환된 것이다.

3) 코드 작성 이제 자유롭게 C 코드를 작성할 수 있다.

#include <stdio.h>

int main(void)
{
    printf("Hello, World!! \n");
    return 0;
}

4) 저장 및 종료 코드 작성을 마쳤다면, 파일을 저장하고 Vim을 종료해야 한다.

1. ESC 키를 눌러 명령 모드로 돌아간다. (-- INSERT -- 문구가 사라진다.)

2. :(콜론)을 입력하여 마지막 행 모드로 전환한다.

3. 원하는 명령어를 입력하고 Enter를 누른다.

   :w : (Write) 현재 파일을 저장한다. :q : (Quit) Vim을 종료한다. (저장되지 않은 변경 사항이 있으면 오류가 발생한다.) :wq : 파일을 저장하고 종료한다. (가장 일반적으로 사용) :q! : 변경 사항을 저장하지 않고 강제로 종료한다.

이제 터미널에 ls 명령어를 입력하면 hello.c 파일이 생성된 것을 확인할 수 있다.

GCC 컴파일러 사용법

GCC(GNU Compiler Collection)는 C, C++, Objective-C 등 다양한 언어를 컴파일할 수 있는 컴파일러 모음이며, 리눅스 환경의 표준 C 컴파일러이다. 컴파일이란 우리가 작성한 C언어 소스 코드(.c 파일)를 컴퓨터가 이해하고 실행할 수 있는 기계어 파일(실행 파일)로 변환하는 과정을 말한다.

GCC로 hello.c 컴파일 및 실행하기

1) 기본 컴파일 gcc 명령어 뒤에 컴파일할 소스 파일명을 입력한다.

gcc hello.c

컴파일 과정에서 오류가 없다면 아무런 메시지 없이 명령어 입력이 끝난다. ls 명령어로 확인해 보면 a.out이라는 파일이 새로 생성된 것을 볼 수 있다. 이 a.out이 바로 실행 파일이다.

2) 프로그램 실행 리눅스 터미널에서 현재 디렉터리에 있는 실행 파일을 실행하려면 파일명 앞에 ./를 붙여야 한다.

./a.out

실행 결과:

Hello, World!

3) 원하는 이름으로 실행 파일 생성 (-o 옵션) a.out이라는 기본 이름 대신 원하는 이름으로 실행 파일을 만들고 싶을 때는 -o (output) 옵션을 사용한다.

#사용법: gcc -o [생성할 실행 파일명] [소스 파일명]
gcc -o hello hello.c

ls 명령어로 확인하면 a.out 대신 hello라는 이름의 실행 파일이 생성된 것을 볼 수 있다. 실행 방법은 동일하다.

./hello```
**실행 결과:**

Hello, World!

Vim 모드별 핵심 명령어 정리

교수님께서도 처음에는 익숙하지 않을 수 있다고 적어놓고 쓰다보면 외워진다고 하셨다.

근데 평소엔 다른 IDE에서 개발하는 나에게는 실습때마다 도저히 안외워져서 정리해보겠다.

Vim을 처음 사용할 때 다른 것은 잊어버리더라도 아래 4가지만 기억하면 기본적인 문서 작성이 가능하다.

hello.c 컴파일에서 사용한 필수 명령어

명령 모드 (Normal Mode) 명령어

Vim의 기본 모드로, 키보드 입력이 명령으로 인식된다. ESC 키를 누르면 언제나 명령 모드로 돌아온다.

커서 이동

편집 (수정 및 삭제)

복사 & 붙여넣기 (Yank & Put)

실행 취소 및 반복

입력 모드 (Insert Mode) 진입 및 탈출 명령어

마지막 행 모드 (Command-Line Mode) 명령어

명령 모드에서 :(콜론)을 입력하여 진입한다. 화면 하단에 명령어를 입력하여 파일 제어, 검색, 설정 변경 등을 수행한다.

파일 제어

검색 및 치환

에디터 설정

한번에 다 외울수는 없겠지만 실습때나 Vi 편집기를 사용할때 켜놓고 최대한 기능을 많이 써보며 IDE를 쓸때만큼 편리하게 쓸 수 있도록 여러 명령어들에 익숙해져야겠다.

사용할줄 아는 수준에서 더 나아가 여러 명령어들이 익숙해져 나중에는 VIM 모드가 더 편할 정도의 수준이 되어서 마우스 없이 나의 생각을 그 즉시 키보드로 빠르게 칠 수 있는 수준의 개발자가 되고싶다.

전공 공부를 병행하면서 꾸준히 코딩테스트 문제를 풀다보니 목표 중 하나였던 백준 골드를 달성하게 되었다.

실버를 달성까지 며칠밖에 안 걸렸어서 골드도 금방 달성할 수 있을 줄 알았지만 그건 내 기본기가 있기 때문이었다.

실버 문제부터는 스택, 큐, 트리, 그래프와 같은 자료구조나 BFS, DFS, DP와 같은 고급 알고리즘이 조금씩 사용되어 한 문제 한 문제 성장하면서 풀어야했기에 시간이 훨씬 오래 걸렸다.

티어를 올리기에 집중하기보단 C언어를 통해 문제에 필요한 자료구조들을 직접 구현해보면서 삽질도 해보고 시간을 많이 썼던 것 같다.

또한 문제를 풀때마다 GitHub에 코드들을 커밋했다.

시간이 너무 오래 걸리기도하고 풀이법이 잘 떠오르지도 않아 초반에는 내가 너무 못하는건 아닌가 걱정도 되었다.

하지만 무작위의 실버 수준의 문제들을 풀어낼 수준이 된다면 웬만한 기업의 코딩테스트는 뚫을 수 있다고 해서 걱정이 좀 줄어들었다.

이 정도면 C를 통한 삽질은 충분히 해봤다고 생각한다.

앞으로는 C++의 구현된 자료구조도 활용해보고 Java를 깊게파며 Spring 프레임워크를 활용한 백엔드 공부도 병행하면서 자료구조나 알고리즘의 구현보다는 활용하는 방법을 위주로 코딩테스트를 준비할 것이다.

이 템포라면 졸업할때쯤엔 플레티넘도 달성하고 부트캠프나 각종 기업의 코딩테스트는 가뿐히 넘을 수 있을 수준이 될 것이라고 생각한다.

TOEIC 925점 달성

RC가 문제라고 생각하고 RC를 보완하고자 ETS 기출문제 3권을 풀어보며 ETS만의 오답을 거르고 정답을 고르는 논리를 이해하고자 노력했다.

또한 어휘와 문법이 부족하다고 생각해 어휘와 문법을 깊게 학습했다.

예를들면 due라는 단어는 to와 함께 ~로인한 이라는 뜻으로 알고있었는데 비즈니스 영어인 토익에서는 membership due = 회비 처럼 생각지도 못한 뜻으로 쓰이는 어휘들의 여러 쓰임들과 여러 뜻을 학습하려고 노력했다.

이뿐만아니라 PART 5, 6 위주로 문법을 처음부터 정리하고 엄청 많은 문제를 풀어보았다.

하지만 100문제 타임어택 독해 시험인 토익의 특성상 RC 성적이 그렇게 드라마틱하게 오르진 않았다.

RC 성적을 400점대에서 안정적인 430-440점대를 만드는데는 성공했지만 더 올리기는 어려웠다.

그래서 LC에 집중하여 LC 만점을 받기위해 노력했고 그 결과 목표와 가까운 925점에 달성하는데에 성공했다.

경영학과 컴퓨터공학을 복수전공하며 공부하다보면 영문 원서로 수업하기도하고, 개인 프로젝트를 하다 생기는 오류나 궁금한점들을 찾아보다보면 양질의 자료들이 영어로 되어있는 경우가 많다.

이뿐만 아니라 요즘 미국주식에도 관심이 많은데 어닝콜을 보더라도 영어는 필수적이다.

LLM이나 파파고로 동시 번역도 가능한 요즘 시대에 영어 실력이 개발자가 되는데에 필수적인건 아니지만 영어를 잘하는 개발자가 여러 측면에서 유리하고 개발 분야뿐 아니라 앞으로 살아가면서도 더 빠르게 성장하는데에 꼭 필요한 능력이라고 생각한다.

졸업을 앞두고 오픽을 준비해서 가장 높은 성적인 AL도 받아보고싶다.

2학기 목표

• 오래 기억하고 싶은 내용 VELOG 꾸준히 작성

• 인스타 키워서 양질의 의류 더 협찬 받기

• 데이터 관리 강의 활용 - SQLD 취득하기

• 시흥시 지역문제 경진대회 수상해서 해외연수 경험해보기

• 제주시 데이터 활용 공모전 참가해보기

• 독서 및 투자 공부

• 운동 및 절주

• 자료구조 알고리즘 보완 -> PCCP 취득 및 교내 SW 경진대회 수상

• 웹프로젝트응용 수업 활용 - 운영중인 웹사이트 보완 및 유지보수

분할 정복 알고리즘(Divide and conquer algorithm)은 그대로 해결할 수 없는 문제를 작은 문제로 분할하여 문제를 해결하는 방법이다.

대표적인 예로는 퀵 정렬이나 합병 정렬과 이진 탐색 등이 있다.

분할 정복 설계

1) Divide

원래 문제가 분할하여 비슷한 유형의 더 작은 하위 문제로 분할이 가능할 때 까지 나눈다.

2) Conquer

각 하위 문제를 재귀적으로 해결한다. 하위 문제의 규모가 나눌 수 없는 단위가 되면 탈출 조건을 설정하고 해결한다.

3) Combine

Conquer한 문제들을 통합하여 원래 문제의 답을 얻어 해결한다.

2630 - 색종이 만들기

백준 - 2630 : 색종이 만들기

문제

코드

#include <stdio.h>

int paper[128][128], zero, one;

int search(int x, int y, int n){
    int count = 0;
    for(int i=x; i<x+n; i++){
        for(int j=y; j<y+n; j++){
            if(paper[i][j]==1) count++; 
        }
    }
    if(count == n * n) one++;
    else if(count == 0) zero++;
    else{
        search(x, y, n/2);
        search(x, y+n/2, n/2);
        search(x+n/2, y, n/2);
        search(x+n/2, y+n/2, n/2);
    }
}

int main(void){
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            scanf("%d", &paper[i][j]);
        }
    }
    search(0, 0, n);
    printf("%d\n%d", zero, one);
}

2차원 배열을 활용했고, 1개의 정사각형을 1, 2, 3, 4사분면으로 나누어 조건이 만족될때마다 count를 높여가며 재귀적으로 문제를 풀었다.

이때 count와 n을 비교한 값을 종료 조건으로 설정하고 n/2으로 절반씩 줄여나가는 방법을 사용했다.

같은 원리로 Z라는 문제를 접근했는데 시간 초과 문제가 생겼다.

1074 - Z

백준 - 1074 : Z

문제

코드

#include <stdio.h>

int count = 0; // 전역변수 초기화
int r, c;

int search(int x, int y, int n) { 
    if (n == 1) {
        if (x == r && y == c) {
            return 1; // 찾았을 때 1 반환
        }
    } else {
        int half = n / 2;

        // 1사분면
        if (r < x + half && c < y + half) {
            return search(x, y, half);
        } else {
            count += half * half;
        }

        // 2사분면
        if (r < x + half && c >= y + half) {
            return search(x, y + half, half);
        } else {
            count += half * half;
        }

        // 3사분면
        if (r >= x + half && c < y + half) {
            return search(x + half, y, half);
        } else {
            count += half * half;
        }

        // 4사분면
        if (r >= x + half && c >= y + half) {
            return search(x + half, y + half, half);
        } else {
            count += half * half;
        }
        return 0;
    }
}

int main() {
    int n;
    scanf("%d %d %d", &n, &r, &c);

    int size = 1 << n; // 2^n 계산하기 위한 비트연산

    search(0, 0, size); // 좌표 0, 0 부터 탐색

    printf("%d\n", count);
    return 0;
}

처음엔 색종이 만들기 문제와 같이 모든 사분면을 조사해보며 함수가 호출 될때마다 count를 증가시키는 방식을 사용했다.

예제까지는 잘 실행됐지만 2의 지수꼴로 조사해야하는 범위가 늘어날수록 시간이 기하 급수적으로 늘어나다보니 시간 초과 문제가 생겼다.

그래서 이를 해결하고자 각 사분면을 하나하나 조사하는게 아닌 count+=n*n을 통해 시간을 엄청나게 줄일 수 있었다.

이렇게 분할 정복에다가 조사하지 않아도 되는 부분을 n*n과 같은 방법으로 넘기는 방법까지 더해지니 2의 지수꼴과 같이 규모가 커짐에 따라 얼마나 크게 실행 속도의 차이를 만들어 내는지 느낄 수 있었다.

이런 알고리즘과 자료구조를 기반으로 효율적으로 구현한 코드 하나하나가 적은 비용으로 효과적으로 운영할 수 있는 서비스의 기반이 되는 것이다.

시프트 연산자(<< / >>)를 활용한 지수 계산

시프트 연산은 좌항에 있는 피연산자를 우항에 있는 수만큼 비트 자리 이동하는 연산을 수행한다.

<< 는 왼쪽 쉬프트 연산자이고 >> 는 오른쪽 쉬프트 연산자이다.

왼쪽 쉬프트 연산을 하면 좌항에 있는 피연산자의 값이 우항에 있는 수만큼 왼쪽으로 자리 이동하고 빈 자리는 0으로 채우게 된다.

이 특성을 이용한다면 2의 거듭제곱을 Z 문제의 코드처럼 쉽게 구할 수 있다.

    printf("%u\n", num1 << 1);    //   2: 0000 0010: 2
    printf("%u\n", num1 << 2);    //   4: 0000 0100: 2^2
    printf("%u\n", num1 << 3);    //   8: 0000 1000: 2^3
    printf("%u\n", num1 << 4);    //  16: 0001 0000: 2^4
    printf("%u\n", num1 << 5);    //  32: 0010 0000: 2^5
    printf("%u\n", num1 << 6);    //  64: 0100 0000: 2^6
    printf("%u\n", num1 << 7);    // 128: 1000 0000: 2^7

재귀 알고리즘 문제를 풀다가 답안을 제출했는데 자꾸 오답처리가 되었다.

알고리즘에도 문제가 없고 내 컴파일러에서는 실행결과에도 아무런 문제가 없었다.

그래서 다른 사람들의 코드와 비교하다가 이유를 찾았다.

오답 코드

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int recursion(const char *s, int l, int r, int *count) {
  (*count)++;
  if (l >= r)
    return 1;
  else if (s[l] != s[r])
    return 0;
  else
    return recursion(s, l + 1, r - 1, count);
}

int isPalindrome(const char *s, int *count) {
  return recursion(s, 0, strlen(s) - 1, count);
}

int main() {
  int num, count, temp;
  char s[1002];
  scanf("%d", &num);
  while (num--) {
    count = 0;
    scanf("%s", s);
    printf("%d %d\n", isPalindrome(s, &count), count);
  }
  return 0;
}

정답 코드
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int recursion(const char *s, int l, int r, int *count) {
  (*count)++;
  if (l >= r)
    return 1;
  else if (s[l] != s[r])
    return 0;
  else
    return recursion(s, l + 1, r - 1, count);
}

int isPalindrome(const char *s, int *count) {
  return recursion(s, 0, strlen(s) - 1, count);
}

int main() {
  int num, count, temp;
  char s[1002];
  scanf("%d", &num);
  while (num--) {
    count = 0;
    scanf("%s", s);
    temp = isPalindrome(s, &count);
    printf("%d %d\n", temp, count);
  }
  return 0;
}

오류 부분
    printf("%d %d\n", isPalindrome(s, &count), count);


수정 후    
    temp = isPalindrome(s, &count);
    printf("%d %d\n", temp, count);

결론부터 말하자면, 채점 서버의 컴파일러가 함수 인자를 처리하는 순서가 사용자의 로컬 환경과 달랐기 때문에 발생한 오류였다.

함수의 인자 평가 순서

C 언어 표준에서는 함수에 여러 개의 인자(argument)를 전달할 때, 컴파일러가 그 인자들의 값을 어떤 순서로 계산(평가)할지에 대해 정해두지 않았다.

즉, 아래와 같은 코드가 있을 때, *printf("%d %d\n", isPalindrome(s, &count), count); * 컴파일러는 두 가지 방식 중 아무거나 선택할 수 있다.

1. 인자를 오른쪽에서 왼쪽으로 평가 (많은 C 컴파일러의 일반적인 방식)

1. printf의 두 번째 인자인 count를 먼저 평가한다.
2. 그 다음, 첫 번째 인자인 isPalindrome(s, &count)를 평가한다.
3. isPalindrome 함수가 실행되면서 내부의 recursion이 호출되고, count의 값이 (예를 들어) 3으로 변경된다. 함수는 팰린드롬 여부에 따라 1 또는 0을 반환한다.
4. printf 함수는 최종적으로 (2)번 단계에서 반환된 값과 (1)번 단계에서 미리 계산해 둔 count의 값(0)을 가지고 출력한다.
5. 결과: 1 0 (오답)

2. 인자를 왼쪽에서 오른쪽으로 평가

1. printf의 첫 번째 인자인 isPalindrome(s, &count)를 먼저 평가한다.
2. 함수가 실행되면서 count의 값이 3으로 변경되고, 함수는 1 또는 0을 반환한다.
3. 그 다음, 두 번째 인자인 count를 평가한다. 이 시점에서 count의 값은 (2)번 단계에서 변경된 3이다다.
4. printf 함수는 (1)번 단계의 반환값과 (3)번 단계에서 계산된 count의 값(3)을 가지고 출력한다.
5. 결과: 1 3 (정답)

백준의 채점 서버의 컴파일러는 방식 1처럼 동작했고, 나의 컴파일러는 방식 2처럼 동작해서 생긴 오류였다.

이처럼 컴파일러나 환경에 따라 결과가 달라질 수 있는 코드는 정의되지 않은 동작(Undefined Behavior)에 의존하는 코드라고 부르며, 프로그래밍 시 반드시 피해야 한다.

temp 변수를 사용한 순서 보장

temp 변수를 사용한 코드는 왜 항상 올바르게 동작할까 ?

temp = isPalindrome(s, &count);       // 1번 라인
printf("%d %d\n", temp, count);      // 2번 라인

C 언어에서 세미콜론(;)은 "시퀀스 포인트(Sequence Point)" 역할을 한다.

시퀀스 포인트는 이전 라인에서 발생한 모든 계산과 부수 효과(side effect)가 다음 라인으로 넘어가기 전에 반드시 완료됨을 보장한다.

1. 1번 라인 실행: isPalindrome(s, &count)가 호출됩니다. 이 함수의 실행이 완전히 끝날 때까지 프로그램은 다음으로 넘어가지 않는다.
   • 이 과정에서 count의 값은 최종값(예: 3)으로 업데이트된다.
   • isPalindrome의 반환값은 temp 변수에 저장된다.
2. 시퀀스 포인트(;): 1번 라인의 모든 동작(count 값 변경 포함)이 완료되었음을 보장한다.
3. 2번 라인 실행: printf가 호출된다.
   • 이 시점에는 temp와 count의 값이 이미 모두 확정된 상태이다.
   • printf의 인자 평가 순서가 어떻게 되든 상관없이, 이미 계산이 끝난 temp의 값과 count의 최종값을 가져와 출력하므로 항상 올바른 결과가 나온다.

앞으론 세미콜론(시퀀스 포인트)을 통해 연산의 순서를 명확하게 강제하는 등 C의 동작과정을 더 이해하고 어떤 컴파일러 환경에서도 동일한 결과를 보장하는 코드를 작성해야겠다.

백준 - 후위 표기식

문제 내용

C에는 스택 라이브러리가 없기 때문에 구현하여 사용해야한다.

그래서 스택을 구현한 김에 더 깊게 이해하고자 스택 문제를 여러 개 풀고 있다.

후위 표기식(Postfix Notation)이란?

우리는 1+2+3 처럼 숫자(피연산자)와 숫자 사이에 연산자(+)를 넣어서 식을 표현하는데

이를 중위 표기식(Infix Notation)이라고 한다.

후위 표기식(Postfix Notation)은 연산자가 피연산자의 뒤에 온다.

1 + 2 + 3 (Infix)

1 2 + 3 + (Postfix)

컴퓨터가 후위 표기식을 사용하는 이유

후위 표기식은 앞에서부터 뒤로 가면서 연산자가 보이면 앞의 두 숫자를 피연산자로 계산하면 된다.

중위 표기식 1+2×3의 경우 후위 표기식으론 123×+이다.

앞에서부터 차례로 읽다가 연산자인 ×가 발견되었을 때 앞에 있는 2개의 피연산자 2 3를 대상으로 2×3=6을 실행한다.

그 뒤의 연산자인 +가 발견되었을 때 앞에 있는 2개의 피연산자 1 6을 대상으로 1+6=7을 실행한다.

컴퓨터는 후위 표기식을 사용하는데, 이런 후위 표기식을 컴퓨터가 사용하는 근본적인 이유는

괄호도 필요없고 연산자 우선 순위를 고려할 필요도 없기 때문이다.

후위 표기식과 스택

이러한 방식의 후위 표기식을 만들거나 후위 표기식을 중위 표기식으로 만들때 스택(Stack) 구조가 사용된다.

간단한 예를 들면 아까처럼 123x+을 중위 표기식으로 사용할때 1/2/3을 스택에 담고 x를 만나면

pop() x pop() 후 연산한 값을 push()한다면 스택에는 1/6이 들어가 있을 것이다.

이 예시는 후위 표기식을 중위 표기식으로 만드는 과정이었고, 이 문제는 반대로 중위 표기식을 후위 표기식으로 만드는 문제이다.

중위 표기식 -> 후위 표기식

먼저 코드를 작성하기 전 4가지 규칙을 찾았다.

1. 피연산자는 출력한다.

2. '('를 만난다면 push한다.

3. ')'를 만난다면 '('가 나올때까지 pop을 진행하고 그 사이의 연산자들을 출력한다.

4. 연산자를 만난다면 push하지만 이때 peek의 우선순위가 연산자의 우선순위보다 크거나 같다면 우선순위가 더 작아질때까지 pop 후 출력하고 연산자를 push한다.

이 조건을 잘 신경쓴다면 문제없이 코드를 구현할 수 있다.

코드

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STACK_SIZE 100

typedef char element;

typedef struct{
  element data[MAX_STACK_SIZE];
  int top; 
}StackType;

void init_stack(StackType *s){
  s->top = -1;
}

int is_empty(StackType *s){
  return(s->top == -1);
}

int is_full(StackType *s){
  return(s->top == MAX_STACK_SIZE-1);
}

void push(StackType *s, element item){
  if(is_full(s)){
    return;
  }
  s->data[++(s->top)] = item;
}

element pop(StackType *s){
  if(is_empty(s)){
    return 0;
  }
  return s->data[(s->top)--];
}

int priority(char c){
  if(c == '(' || c==')')
    return 0; //'()'은 연산에 참가 안하고 따로 처리하므로 후순위로 둠
  else if(c == '+' || c == '-') 
    return 1;
  else if(c == '*' || c == '/')
    return 2;
}

int main(void){
  char input[100] = {0,};
  scanf("%s", input);
  StackType s;
  char temp;
  init_stack(&s);
  for(int i=0; i<strlen(input); i++){
    int ch = input[i];
    switch(ch){
      case '+': case '-' : case '*' : case '/':
        while(!is_empty(&s) && priority(s.data[s.top])>=priority(ch)){ 
        //스택에 있는 연산자의 우선순위가 더 크거나 같으면 출력
          printf("%c", pop(&s));
        }
        push(&s, ch);
        break;

      case '(': 
        push(&s, ch);
        break;

      case ')':
        temp = pop(&s);
        while(temp !='('){
          printf("%c", temp);
          temp = pop(&s);
        }
        break;

      default : //피연산자인 경우
        printf("%c", ch);
        break;
    }
  }
  while(!is_empty(&s)){ //남은 연산자 출력
    printf("%c", pop(&s));
  }
}

백준 - 스택 수열

문제 내용

C에는 스택 라이브러리가 없기 때문에 구현하여 사용해야한다.

그래서 이왕 스택을 구현한 김에 더 깊게 이해하고자 스택 문제를 여러개 풀고 있다.

아마 예시 입출력이 없었다면 아직도 문제를 이해하지 못했을 것이다.

쉽게 설명하자면 1부터 오름차순으로 스택에 push 할 수 있고 pop을 통해 입력된 수열을 만들 수 있는지 체크하고 만들 수 있다면 push와 pop의 과정들을 출력하는 문제이다.

세가지 조건을 나누어서 해결했다.

우선 peek라고도 불리는 stack[top] 값과 temp(입력값)을 비교했다.

1. stack[top]값이 더 큰 경우 "NO" 출력 후 프로그램 종료

2. temp값이 더 큰 경우 stack[top]과 temp가 같아질때까지 push 후 같아지면 pop 진행

3. 두 값이 같은 경우 pop 진행

이 세 가지 경우로 나누어 코드를 짰다.

코드

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STACK_SIZE 100

typedef char element;

typedef struct{
  element data[MAX_STACK_SIZE];
  int top; 
}StackType;

void init_stack(StackType *s){
  s->top = -1;
}

int is_empty(StackType *s){
  return(s->top == -1);
}

int is_full(StackType *s){
  return(s->top == MAX_STACK_SIZE-1);
}

void push(StackType *s, element item){
  if(is_full(s)){
    return;
  }
  s->data[++(s->top)] = item;
}

element pop(StackType *s){
  if(is_empty(s)){
    return 0;
  }
  return s->data[(s->top)--];
}

int priority(char c){
  if(c == '(' || c==')')
    return 0; //'()'은 연산에 참가 안하고 따로 처리하므로 후순위로 둠
  else if(c == '+' || c == '-') 
    return 1;
  else if(c == '*' || c == '/')
    return 2;
}

int main(void){
  char input[100] = {0,};
  scanf("%s", input);
  StackType s;
  char temp;
  init_stack(&s);
  for(int i=0; i<strlen(input); i++){
    int ch = input[i];
    switch(ch){
      case '+': case '-' : case '*' : case '/':
        while(!is_empty(&s) && priority(s.data[s.top])>=priority(ch)){
          printf("%c", pop(&s));
        }
        push(&s, ch);
        break;

      case '(':
        push(&s, ch);
        break;

      case ')':
        temp = pop(&s);
        while(temp !='('){
          printf("%c", temp);
          temp = pop(&s);
        }
        break;

      default : //피연산자인 경우
        printf("%c", ch);
        break;
    }
  }
  while(!is_empty(&s)){
    printf("%c", pop(&s));
  }
}

비즈니스 로직을 JSP에서 분리했더라도, 데이터베이스 연결(JDBC) 코드가 서블릿이나 JSP에 직접 포함되어 있다면 심각한 문제를 야기한다.

// 서블릿이나 JSP 파일 내부 - 좋지 않은 예시
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;

try {
    // 1. 드라이버 로딩
    Class.forName("oracle.jdbc.driver.OracleDriver");
    // 2. 커넥션 생성
    conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "user", "pass");
    // 3. SQL 작성 및 실행
    String sql = "SELECT * FROM member WHERE id = ?";
    pstmt = conn.prepareStatement(sql);
    pstmt.setString(1, request.getParameter("id"));
    rs = pstmt.executeQuery();
    // 4. 결과 처리...
    // 이 모든 코드가 DB 작업이 필요한 모든 파일에 중복되어 삽입된다.
} catch(Exception e) {
    // 예외 처리
} finally {
    // 5. 자원 해제 (매번 반복)
    if(rs != null) rs.close();
    if(pstmt != null) pstmt.close();
    if(conn != null) conn.close();
}

이러한 구조는 코드의 중복이 극심하고, DB 정보(URL, ID, PW)가 변경되면 관련된 모든 파일을 수정해야 하는 유지보수 재앙을 초래한다.

또한, 매 요청마다 DB 커넥션을 생성하고 해제하는 과정은 시스템에 엄청난 부하를 주어 성능 저하의 주범이 된다.

해결책으로 DAO(Data Access Object) 패턴을 도입하여 데이터 로직을 분리하고, 커넥션 풀(Connection Pool)을 함께 사용하여 시스템의 효율을 극대화해야 한다.

DAO 패턴

DAO는 데이터베이스에 접근하고 처리하는 로직(CRUD: Create, Read, Update, Delete)을 별도의 클래스로 완전히 분리하여 캡슐화하는 디자인 패턴이다.

이는 '관심사의 분리(Separation of Concerns)' 원칙을 충실히 따르는 방법이다.

서블릿이나 다른 서비스 클래스들은 복잡한 JDBC 코드나 SQL 문을 전혀 알 필요가 없다.

그저 DAO 객체에게 "회원 정보 저장", "ID가 'user1'인 회원 정보 조회" 와 같이 의미 있는 기능 단위로 요청만 하면 된다.

DTO, VO 그리고 자바빈(JavaBean)

DTO (Data Transfer Object) / VO (Value Object) 계층 간(Controller-Service-DAO) 데이터를 전달하기 위한 목적으로 만들어진 객체이다. 예를 들면 MemberDTO는 회원 한 명의 정보를 온전히 담아 운반하는 '데이터 상자' 역할을 한다.

자바빈 (JavaBean) 앞서 다뤘던 자바빈은 특정 규칙을 따르는 자바 클래스를 지칭하는 기술 규약이다. 1. private 접근 제한자로 필드를 선언한다. 2. public 접근자로 getter/setter 메서드를 가진다. 3. 인자 없는 기본 생성자(default constructor)를 가진다.

하지만 여기서 DTO는 자바빈 규약에 따라 만드는 것이 일반적이다.

즉, MemberDTO는 '데이터 전달'이라는 역할(패턴)을 수행하며, 그 구현은 자바빈(기술 규약)을 따른다.

따라서 "DTO는 자바빈이다"라고 말할 수 있다.

JSP에서 <jsp:useBean> 액션 태그가 DTO 객체를 쉽게 다룰 수 있는 것도 DTO가 자바빈 규약을 따르기 때문이다.

DAO (Data Access Object)

실제 DB 작업을 수행하는 객체이다.

모든 JDBC 코드는 DAO 클래스 내부에만 존재한다.

// MemberDAO.java 의 예시
public class MemberDAO {
    // ... Connection Pool을 통해 Connection을 얻어오는 로직 ...

    public int insertMember(MemberDTO dto) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        String sql = "INSERT INTO member (id, password, name, email) VALUES (?, ?, ?, ?)";
        int result = 0;
        try {
            conn = getConnection(); // 커넥션 풀에서 하나 빌려오기
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, dto.getId());
            pstmt.setString(2, dto.getPassword());
            pstmt.setString(3, dto.getName());
            pstmt.setString(4, dto.getEmail());
            result = pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(pstmt, conn); // 자원 반납
        }
        return result;
    }
    // getMember(id), updateMember(dto), deleteMember(id) 등 다른 메서드들...
}

커넥션 풀(Connection Pool)

데이터베이스 커넥션을 맺고 끊는 작업은 네트워크 통신, 사용자 인증, 세션 설정 등이 포함된, 시스템에 상당한 부하를 주는 고비용 작업이다.

매 요청마다 이 작업을 반복하는 것은 극심한 성능 저하를 유발한다.

커넥션 풀은 이 문제를 해결하기 위해 미리 일정 개수의 DB 커넥션을 생성하여 '풀(Pool)'이라는 저장 공간에 보관해두고, 필요할 때마다 빌려 쓰고 반납하는 기법이다.

동작 원리:

1. WAS 시작 웹 애플리케이션 서버(EX:Tomcat)가 시작될 때, context.xml에 설정된 정보를 읽어 지정된 개수만큼 커넥션을 미리 생성하여 풀에 저장한다.

2. DAO의 요청 MemberDAO가 DB 작업이 필요하면, DriverManager.getConnection()을 직접 호출하는 대신, WAS가 제공하는 JNDI(Java Naming and Directory Interface) 서비스를 통해 커넥션 풀을 찾는다.

3. 대여(Borrow) JNDI를 통해 찾은 커넥션 풀(DataSource 객체)에게 dataSource.getConnection()을 호출하여 커넥션을 요청한다. 풀은 유휴 상태의 커넥션 하나를 빌려준다.

4. 작업 수행 DAO는 빌린 커넥션을 사용하여 SQL 작업을 수행한다.

5. 반납(Return) 작업이 끝나면 connection.close()를 호출한다. 커넥션 풀을 통해 얻은 커넥션은 이 때 실제로 닫히는 것이 아니라, 풀에 반납되어 '대기' 상태로 돌아간다.

6. 재사용 다른 요청이 들어오면, 풀에 대기 중인 커넥션을 다시 빌려주어 커넥션 생성 비용 없이 즉시 DB 작업을 시작할 수 있다.

Tomcat context.xml 설정 예시 META-INF/context.xml 파일에 다음과 같이 DB 정보를 설정한다.

<?xml version="1.0" encoding="UTF-8"?>
<Context>
    <Resource name="jdbc/OracleDB" auth="Container"
              type="javax.sql.DataSource"
              driverClassName="oracle.jdbc.driver.OracleDriver"
              url="jdbc:oracle:thin:@localhost:1521:XE"
              username="myuser"
              password="mypassword"
              maxTotal="20"   <!-- 최대 커넥션 개수 -->
              maxIdle="10"    <!-- 유휴 상태로 유지할 최대 커넥션 개수 -->
              maxWaitMillis="5000" /> <!-- 커넥션을 기다리는 최대 시간(ms) -->
</Context>

커넥션 풀 사용 코드 (DAO 내부)

// DAO에서 커넥션을 얻어오는 메서드
private Connection getConnection() {
    Connection conn = null;
    try {
        Context initContext = new InitialContext();
        // context.xml 에 설정한 "jdbc/OracleDB" 이름을 찾아 DataSource 객체를 얻어온다.
        DataSource ds = (DataSource) initContext.lookup("java:/comp/env/jdbc/OracleDB");
        conn = ds.getConnection(); // DataSource를 통해 풀에서 커넥션을 대여한다.
    } catch (Exception e) {
        e.printStackTrace();
    }
    return conn;
}

DAO 패턴과 커넥션 풀의 조합은 현대적인 웹 애플리케이션 구축의 표준적인 방법이다.

회원가입 및 로그인 기능 구현

JSP/Servlet 기반 MVC 패턴을 사용하여 회원가입 및 로그인 기능을 구현하는 코드이다.

DB 테이블

데이터베이스에 회원 정보를 저장할 member 테이블을 생성한다.

-- member 테이블 생성 SQL
CREATE TABLE member (
    id VARCHAR2(20) PRIMARY KEY,
    password VARCHAR2(20) NOT NULL,
    name VARCHAR2(30) NOT NULL,
    email VARCHAR2(50),
    regdate DATE DEFAULT SYSDATE
);

Model (데이터 및 로직 처리)

Member.java (DTO)

회원 정보를 담아 계층 간에 전달하는 객체. 자바빈 규약에 따라 작성한다.

// Member.java
package com.example.model;

import java.io.Serializable;
import java.sql.Date;

public class Member implements Serializable {
    private static final long serialVersionUID = 1L;

    // 필드 (DB 컬럼과 일치)
    private String id;
    private String password;
    private String name;
    private String email;
    private Date regdate;

    // 기본 생성자
    public Member() {
    }

    // Getter and Setter
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public Date getRegdate() { return regdate; }
    public void setRegdate(Date regdate) { this.regdate = regdate; }
}

MemberDAO.java (DAO)

실제 데이터베이스에 접근하여 CRUD 작업을 수행하는 객체.

커넥션 풀을 사용한다.

// MemberDAO.java
package com.example.model;

import java.sql.*;
import javax.naming.*;
import javax.sql.*;

public class MemberDAO {

    private DataSource dataSource;

    // 생성자에서 커넥션 풀(DataSource)을 찾아 초기화
    public MemberDAO() {
        try {
            Context context = new InitialContext();
            dataSource = (DataSource) context.lookup("java:comp/env/jdbc/OracleDB");
        } catch (NamingException e) {
            e.printStackTrace();
        }
    }

    // 회원가입 (Create)
    public int join(Member member) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        int result = 0;
        String sql = "INSERT INTO member (id, password, name, email) VALUES (?, ?, ?, ?)";

        try {
            conn = dataSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, member.getId());
            pstmt.setString(2, member.getPassword());
            pstmt.setString(3, member.getName());
            pstmt.setString(4, member.getEmail());
            result = pstmt.executeUpdate(); // 성공 시 1 반환
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (pstmt != null) pstmt.close();
                if (conn != null) conn.close(); // 커넥션을 풀에 반납
            } catch (SQLException e) {}
        }
        return result;
    }

    // 로그인 인증 (Read)
    public int loginCheck(String id, String password) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        int result = -1; // -1: 에러, 0: 비밀번호 불일치, 1: 성공
        String sql = "SELECT password FROM member WHERE id = ?";

        try {
            conn = dataSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, id);
            rs = pstmt.executeQuery();

            if (rs.next()) { // 아이디가 존재할 경우
                if (rs.getString("password").equals(password)) {
                    result = 1; // 로그인 성공
                } else {
                    result = 0; // 비밀번호 불일치
                }
            } else {
                result = -1; // 아이디 존재 안함
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (rs != null) rs.close();
                if (pstmt != null) pstmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {}
        }
        return result;
    }
}

View (사용자 인터페이스)

join.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>회원가입</title>
</head>
<body>
    <h2>회원가입</h2>
    <form action="join.do" method="post">
        <label for="id">아이디:</label><br>
        <input type="text" id="id" name="id" required><br><br>
        <label for="password">비밀번호:</label><br>
        <input type="password" id="password" name="password" required><br><br>
        <label for="name">이름:</label><br>
        <input type="text" id="name" name="name" required><br><br>
        <label for="email">이메일:</label><br>
        <input type="email" id="email" name="email"><br><br>
        <input type="submit" value="가입하기">
    </form>
</body>
</html>

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>로그인</title>
</head>
<body>
    <h2>로그인</h2>
    <form action="login.do" method="post">
        <label for="id">아이디:</label><br>
        <input type="text" id="id" name="id" required><br><br>
        <label for="password">비밀번호:</label><br>
        <input type="password" id="password" name="password" required><br><br>
        <input type="submit" value="로그인">
    </form>
    <br>
    <%-- 로그인 실패 시 에러 메시지 출력 --%>
    <%
        String error = (String) request.getAttribute("error");
        if (error != null) {
    %>
        <p style="color: red;"><%= error %></p>
    <%
        }
    %>
    <a href="join.jsp">회원가입</a>
</body>
</html>

main.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    // 페이지 상단에서 세션 검사
    String userId = (String) session.getAttribute("userId");
    if (userId == null) { // 세션에 로그인 정보가 없으면
        response.sendRedirect("login.jsp"); // 로그인 페이지로 강제 이동
        return; // 현재 페이지의 나머지 코드 실행 중단
    }
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>메인 페이지</title>
</head>
<body>
    <h1><%= userId %>님, 환영합니다!</h1>
    <p>성공적으로 로그인되었습니다.</p>
    <a href="logout.do">로그아웃</a>
</body>
</html>

Controller (요청 처리 및 흐름 제어)

JoinServlet.java

// JoinServlet.java
package com.example.controller;

import java.io.IOException;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;

import com.example.model.Member;
import com.example.model.MemberDAO;

@WebServlet("/join.do")
public class JoinServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 파라미터 인코딩 설정
        request.setCharacterEncoding("UTF-8");

        // 2. 파라미터 추출 및 Member 객체 생성
        Member member = new Member();
        member.setId(request.getParameter("id"));
        member.setPassword(request.getParameter("password"));
        member.setName(request.getParameter("name"));
        member.setEmail(request.getParameter("email"));

        // 3. DAO를 통해 DB에 회원 정보 저장
        MemberDAO dao = new MemberDAO();
        int result = dao.join(member);

        // 4. 결과에 따른 페이지 이동
        if (result == 1) { // 회원가입 성공
            response.sendRedirect("login.jsp");
        } else { // 회원가입 실패
            // 실제로는 에러 페이지로 보내거나 알림을 띄우는 것이 좋음
            response.sendRedirect("join.jsp");
        }
    }
}

LoginServlet.java

// LoginServlet.java
package com.example.controller;

import java.io.IOException;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;

import com.example.model.MemberDAO;

@WebServlet("/login.do")
public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 파라미터 추출
        String id = request.getParameter("id");
        String password = request.getParameter("password");

        // 2. DAO를 통해 인증 시도
        MemberDAO dao = new MemberDAO();
        int result = dao.loginCheck(id, password);

        // 3. 결과에 따른 처리
        if (result == 1) { // 로그인 성공
            // 세션 생성 및 사용자 정보 저장
            HttpSession session = request.getSession();
            session.setAttribute("userId", id);
            response.sendRedirect("main.jsp");
        } else { // 로그인 실패
            // 에러 메시지를 request에 저장
            request.setAttribute("error", "아이디 또는 비밀번호가 올바르지 않습니다.");
            // 포워드를 통해 login.jsp로 이동하여 에러 메시지 출력
            RequestDispatcher dispatcher = request.getRequestDispatcher("login.jsp");
            dispatcher.forward(request, response);
        }
    }
}

LogoutServlet.java

// LogoutServlet.java
package com.example.controller;

import java.io.IOException;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;

@WebServlet("/logout.do")
public class LogoutServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 세션 가져오기 (없으면 null 반환)
        HttpSession session = request.getSession(false);

        // 2. 세션이 존재하면 무효화
        if (session != null) {
            session.invalidate();
        }

        // 3. 로그인 페이지로 리다이렉트
        response.sendRedirect("login.jsp");
    }
}

이처럼 JSP/Servlet 기반 MVC 웹 애플리케이션에서는 각 구성 요소가 명확한 역할을 수행한다.

요청은 컨트롤러(서블릿)가 받아서 흐름을 제어한다. 데이터 처리와 비즈니스 로직은 모델(DAO, DTO)이 담당한다. 화면 표시는 뷰(JSP)가 담당한다.

이러한 역할 분담은 코드의 재사용성을 높이고 유지보수를 용이하게 만든다.

특히** HTML나 JSP 폼(form)**에서 넘어온 많은 파라미터를 처리하는 코드는 순식간에 지저분해지고 관리가 어렵다.

<%
    // 스크립틀릿을 사용한 지저분한 코드의 예
    request.setCharacterEncoding("UTF-8");
    String id = request.getParameter("id");
    String password = request.getParameter("password");
    String name = request.getParameter("name");
    String email = request.getParameter("email");

    // 넘어온 파라미터마다 객체를 생성하고 setter를 호출해야 한다.
    Person p = new Person(); 
    p.setId(id);
    p.setPassword(password);
    p.setName(name);
    p.setEmail(email);
%>

JSP의 본래 목적인 '화면 표현(View)'에 집중하기 위해, 이러한 자바 로직 코드를 분리할 필요가 있다.

이때 JSP 액션 태그(Action Tag) 중 하나인 <jsp:useBean>이 강력한 해결책이 되어준다.

자바빈(JavaBean)이란 ?

<jsp:useBean>을 사용하려면, 데이터를 담을 자바 객체가 특정 규칙을 따라야 한다.

이러한 객체를 자바빈(JavaBean)이라고 부른다.

자바빈의 규칙

1. 클래스는 public으로 선언되어야 한다.
2. 멤버 변수(프로퍼티)는 private으로 선언하여 외부 접근을 막는다.
3. 각 멤버 변수에 접근할 수 있는 public 접근자인 getter/setter 메서드가 있어야 한다.
4. 인자(매개변수)가 없는 기본 생성자가 반드시 있어야 한다.

EX: Person.java

package com.example.bean; // 패키지 경로

// 1. public 클래스
public class Person {

    // 2. private 멤버 변수
    private String id;
    private String name;

    // 4. 기본 생성자
    public Person() {
    }

    // 3. public Getter/Setter 메서드
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

ECLIPSE에서 Getter Setter 쉽게 설정하는 법

<jsp:useBean>이란?

<jsp:useBean>은 JSP 페이지에서 사용할 자바빈(JavaBean) 객체를 선언, 생성, 관리해주는 액션 태그이다.

스크립틀릿의 복잡한 코드를 아래와 같이 간결한 태그 몇 줄로 완벽하게 대체할 수 있다.

<jsp:useBean> 자바빈 객체를 생성하거나, 지정된 scope에 이미 객체가 존재하면 그 객체를 가져온다.

<jsp:setProperty> useBean으로 준비된 객체의 필드(프로퍼티)에 값을 자동으로 설정한다.

<jsp:getProperty> 객체 필드의 값을 가져와 화면에 출력한다.

useBean 사용 예 (Before & After)

personAction.jsp

Before: 스크립틀릿 사용

<%@ page import="com.example.bean.Person" %>
<%
    request.setCharacterEncoding("UTF-8");

    Person p = new Person(); // 직접 객체 생성
    p.setId(request.getParameter("id")); // 파라미터 하나하나 직접 설정
    p.setName(request.getParameter("name"));
%>
아이디: <%= p.getId() %> <br>
이름: <%= p.getName() %>

After: <jsp:useBean> 액션 태그 사용

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<% request.setCharacterEncoding("UTF-8"); %>

<%-- 1. Person 객체를 request 영역에서 찾거나, 없으면 새로 생성하여 'p'라는 이름으로 사용 --%>
<jsp:useBean id="p" class="com.example.bean.Person" scope="request" />

<%-- 2. p 객체의 프로퍼티(id, name)에 요청 파라미터 값을 자동으로 설정 --%>
<jsp:setProperty name="p" property="*" />

아이디: <jsp:getProperty name="p" property="id" /> <br>
이름: <jsp:getProperty name="p" property="name" />

액션 태그 자세히 보기

<jsp:useBean id="p" class="com.example.bean.Person" scope="request" />

id: JSP 페이지 내에서 사용할 객체의 변수 이름(p)을 지정한다.

class: 사용할 자바빈의 전체 클래스 경로(패키지 포함)를 지정한다.

scope: 객체가 저장되고 유지될 메모리 영역을 지정한다. (page, request, session, application 중 선택)
<jsp:setProperty name="p" property="*" />

name: 값을 설정할 자바빈 객체의 id를 지정한다. (useBean의 id와 일치)

property="*"** 요청 파라미터의 이름과 자바빈의 프로퍼티(멤버 변수) 이름이 일치하는 모든 항목에 대해, 해당 setter 메서드(setId(), setName() 등)를 자동으로 호출하여 값을 설정해준다.

왜 <jsp:useBean>을 사용해야 할까?

<jsp:useBean> 액션 태그를 사용하면 JSP 페이지에서 데이터 처리 로직(Java 코드)을 거의 완벽하게 제거할 수 있다.

이를 통해 몇가지 이점을 얻는다.

1. 가독성 및 유지보수성 향상: HTML과 유사한 태그로 로직을 처리하므로 코드가 훨씬 깔끔하고 이해하기 쉬워집니다.
2. 역할 분리: JSP는 화면을 그리는 역할에, 자바빈은 데이터를 담는 역할에 집중할 수 있어 웹 애플리케이션의 구조가 명확해집니다.
3. 생산성 증가: property="*" 속성 하나로 수많은 request.getParameter()와 setter 호출 코드를 대체하여 개발 시간을 단축시킵니다.

이때 <jsp:getProperty>보다 훨씬 직관적이고 간결하게 객체의 값을 출력하는 방법이 있다.

바로 표현 언어(Expression Language, EL)를 사용하는 것이다.

{p.id}와 같은 형태로 값을 가져오는 방법이 바로 EL의 기본 문법이다.

표현 언어(EL)란?

EL은 JSP 2.0부터 기본으로 포함된 기능으로, JSP 페이지에서 데이터에 더 쉽게 접근하기 위해 만들어진 언어이다.

$ 기호와 중괄호 {}를 사용하여 표현한다. (예: ${표현식})

EL을 사용하면 <jsp:getProperty>나 스크립틀릿 표현식(<%= ... %>) 없이도 자바빈의 프로퍼티, 컬렉션, 배열 등의 값에 간단하게 접근할 수 있다.

EL을 사용한 개선 방법

Before: <jsp:getProperty> 사용

아이디: <jsp:getProperty name="p" property="id" /> <br>
이름: <jsp:getProperty name="p" property="name" />

After: 표현 언어(EL) 사용

아이디: ${p.id} <br>
이름: ${p.name}

코드가 훨씬 간결하고 직관적으로 변한 것을 바로 확인할 수 있다.

또 자바스크립트에서 객체 속성에 접근하는 것과 유사하여 JS를 접해봤다면 이해하기도 쉽다.

EL의 동작원리

1. 객체 저장 <jsp:useBean id="p" ... scope="request" /> 태그는 Person 객체를 생성하여 request라는 메모리 영역(scope)에 p라는 이름으로 저장한다.

2. 객체 검색 EL 표현식 ${p.id}가 실행되면, JSP 컨테이너는 다음 순서로 p라는 이름의 객체(Attribute)를 자동으로 찾는다. page 영역 -> request 영역 -> session 영역 ->application 영역

3. Getter 호출 request 영역에서 p 객체를 찾으면, EL은 p.id 부분을 해석하여 p.getId() 메서드를 자동으로 호출하고 그 반환값을 해당 위치에 출력한다.

최종 완성 코드 (useBean + setProperty + EL)

이 세 가지를 조합하면 가장 이상적이고 현대적인 JSP 코드가 완성된다.

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<% request.setCharacterEncoding("UTF-8"); %>

<%-- 1. useBean으로 Person 객체를 request 영역에 준비 --%>
<jsp:useBean id="p" class="com.example.bean.Person" scope="request" />

<%-- 2. setProperty로 폼 파라미터 값을 객체에 자동으로 채우기 --%>
<jsp:setProperty name="p" property="*" />

<h3>회원 정보 (EL 사용으로 깔끔해진 코드)</h3>
<ul>
    <li>아이디: ${p.id}</li>
    <li>이름: ${p.name}</li>
</ul>

쿠키(Cookie)

HTTP 프로토콜은 '상태가 없는(Stateless)' 특징을 가진다.

이는 서버가 각 요청을 독립적인 것으로 취급하여 이전 요청을 기억하지 못함을 의미한다.

"방금 로그인한 사용자가 누구인지" 알 수 없는 것이다.

이 문제를 해결하기 위해, 서버는 브라우저에 작은 정보를 남겨두는데 이것이 바로 쿠키(Cookie)다.

쿠키는 서버가 사용자의 브라우저(클라이언트)에 저장하는 작은 텍스트 조각이다.

브라우저는 서버에 요청을 보낼 때마다 이 쿠키를 함께 전송하여, 서버가 사용자를 식별할 수 있도록 돕는다.

쿠키의 주요 역할

상태 관리 사용자의 로그인 상태를 유지(자동로그인)한다. 비로그인 상태의 장바구니를 관리한다.

사용자 추적 사용자의 방문 기록이나 행동 패턴을 분석하는 데 사용된다.

개인화 "오늘 하루 이 창을 열지 않음" 팝업, 언어 설정 등 사용자 맞춤형 경험을 제공한다.

JSP 쿠키 객체(Cookie) 활용법

JSP에서 쿠키를 다루는 방법은 매우 간단하다.

1. 쿠키 생성 및 전송 response 내장 객체를 사용한다.

<%
    // 1. "userId"라는 이름에 "guest"라는 값을 가진 쿠키 객체 생성
    Cookie cookie = new Cookie("userId", "guest");

    // 2. 쿠키 유효기간 설정 (초 단위, 여기서는 24시간)
    cookie.setMaxAge(60 * 60 * 24);

    // 3. response 객체에 쿠키를 추가하여 클라이언트로 전송
    response.addCookie(cookie);
%>

2. 쿠키 읽기 request 내장 객체를 사용한다. 브라우저는 여러 쿠키를 가질 수 있으므로 배열 형태로 받아온다.

<%
    // 1. request로부터 모든 쿠키를 배열로 가져온다.
    Cookie[] cookies = request.getCookies();
    String userId = "";

    if (cookies != null) {
        // 2. 쿠키 배열을 순회하며 원하는 이름의 쿠키를 찾는다.
        for (Cookie c : cookies) {
            if (c.getName().equals("userId")) {
                userId = c.getValue();
                break; // 찾았으면 반복 종료
            }
        }
    }
%>
<p>현재 사용자 ID는 <%= userId %> 입니다.</p>

3. 쿠키 삭제 쿠키를 직접 삭제하는 메서드는 없다. 대신, 유효기간을 0으로 설정하여 브라우저가 즉시 삭제하도록 유도할 수 있다.

<%
    Cookie cookie = new Cookie("userId", ""); // 값은 비워도 무방하다.
    cookie.setMaxAge(0); // 유효기간을 0으로 설정
    response.addCookie(cookie);
%>

쿠키는 클라이언트 측에 데이터를 저장하는 간단하고 유용한 방법이다.

하지만 보안에 민감한 정보나 큰 데이터를 저장하기에는 적합하지 않다.

이러한 단점을 보완하기 위해 서버 측 저장 방식인 세션을 사용한다.

세션(Session)

쿠키는 브라우저에 저장되어 보안에 취약하고 저장 데이터의 양도 제한적이다.

로그인 정보나 장바구니처럼 중요하고 복잡한 정보는 세션(Session)을 이용해 처리해야 한다.

세션은 쿠키와 달리 데이터를 서버 쪽에 저장하는 방식이다.

서버는 각 클라이언트를 위한 고유한 저장 공간(세션)을 만들고, 클라이언트에게는 그 공간에 접근할 수 있는 '열쇠(ID)'만 쿠키 형태로 전달한다.

클라이언트는 요청 시마다 이 열쇠를 함께 보내고, 서버는 열쇠를 보고 맞는 세션 저장소의 데이터를 사용한다.

세션의 동작 원리

1. 최초 접속 클라이언트가 서버에 처음 접속하면, 서버는 고유한 세션 ID를 생성한다.

2. 세션 저장소 생성 서버 메모리에 해당 세션 ID와 연결되는 저장 공간을 만든다.

3. 세션 ID 전송 서버는 생성한 세션 ID를 클라이언트 브라우저에 쿠키(보통 JSESSIONID 이름) 형태로 저장시킨다.

4. 재접속 클라이언트가 다시 요청하면, 브라우저는 자동으로 세션 ID 쿠키를 함께 보낸다.

5. 세션 데이터 활용 서버는 전달받은 세션 ID를 통해 서버에 저장된 해당 클라이언트의 데이터를 찾아 사용한다.

JSP 세션(session) 내장 객체 활용법

JSP는 세션을 편리하게 다루도록 session이라는 내장 객체를 기본으로 제공한다.

1. 세션에 값 저장하기 setAttribute("이름", 값) 메서드를 사용한다. 값으로는 모든 종류의 객체(Object)를 저장할 수 있다.

<%
    String userId = "testuser";
    // "loginId" 라는 이름으로 userId 변수의 값을 세션에 저장
    session.setAttribute("loginId", userId);
%>

2. 세션에서 값 불러오기 getAttribute("이름") 메서드를 사용한다. 반환 타입이 Object이므로, 원래 타입으로 형 변환(Casting)이 필요하다.

<%
    // "loginId" 라는 이름의 세션 값을 가져온다.
    Object value = session.getAttribute("loginId");
    String loginId = "";
    if (value != null) {
        loginId = (String) value;
    }
%>
<p>현재 로그인한 아이디: <%= loginId %></p>

3. 세션에서 특정 값 삭제하기 removeAttribute("이름") 메서드를 사용한다.

<%
    // "loginId" 세션만 삭제
    session.removeAttribute("loginId");
%>

4. 세션 전체 무효화 (로그아웃) invalidate() 메서드를 사용한다. 해당 클라이언트의 세션 저장소 전체가 서버에서 삭제된다.

<%
    // 세션을 완전히 종료시킨다 (로그아웃 시 사용).
    session.invalidate();
%>

Java로 웹 개발을 시작하면 가장 먼저 JSP(JavaServer Pages)와 서블릿(Servlet)을 만나게 된다.

서블릿 (Servlet) 서블릿은 순수 자바(Java) 코드이다. 서블릿은 사용자의 요청을 처리하고, 비즈니스 로직을 실행하며, 데이터를 제어하는 역할을 수행한다.

JSP (JavaServer Pages) JSP는 HTML 코드 안에 자바 코드를 삽입하여 사용한다. JSP는 사용자에게 최종적으로 보여질 화면의 구조와 내용을 담는다.

서블릿의 한계

초기 웹 개발에서는 서블릿만으로 모든 것을 처리했다.

out.println("<html><body><h1>안녕하세요</h1></body></html>");

위의 코드처럼 자바만을 이용해 한 줄 한 줄 HTML을 문자열로 출력하는 것은 비효율적이었다.

디자인을 조금만 변경해도 자바 코드를 다시 컴파일해야 하는 번거로움도 있었다.

이처럼 서블릿은 로직 처리에는 강력하지만, 화면을 구성하는 표현(Presentation)에는 매우 취약한 구조를 가졌다.

JSP : HTML 문서에 자바를 심다

이러한 불편을 해결하기 위해 JSP가 등장했다.

JSP는 반대로 HTML을 기본 구조로 삼고, 필요한 부분에만 자바 코드를 넣어 동적으로 데이터를 처리할 수 있도록 했다.

이로써 디자이너는 자바를 몰라도 HTML 구조를 쉽게 수정하고, 개발자는 필요한 부분에만 로직을 추가하는 역할 분담이 가능해졌다.

MVC 패턴

MVC 패턴 및 JSP 프로젝트 구조

결론적으로 현대 웹 개발은 이 둘을 함께 사용하는 MVC(Model-View-Controller) 패턴으로 정착되었다.

Controller(컨트롤러) : 서블릿 사용자의 모든 요청을 가장 먼저 받는다. 필요한 비즈니스 로직을 처리하고 데이터를 가공한다. 그 결과를 어떤 JSP에게 보여줄지 결정하여 전달한다.

View(뷰) : JSP 컨트롤러(서블릿)로부터 전달받은 데이터를 화면에 그리는 역할에만 집중한다.

Model(모델) 데이터 그 자체나 데이터를 처리하는 자바 클래스(JavaBean, DTO, DAO 등)를 의미한다.

흐름 사용자 요청 → 서블릿이 받아서 처리 → 결과를 JSP에 전달 → JSP가 화면을 그려서 사용자에게 응답

JSP 핵심 문법 요약

나도 그랬듯이 초보자들은 프로젝트를 시작할 때, 모든 코드를 파일 하나에 다 넣으려고 한다.

하지만 JSP를 예로 들었을때 HTML, CSS, JavaScript, 자바 로직, 데이터베이스 연결 코드까지 한 파일에 뒤섞이면 처음에는 빠르게 결과물이 나오는 것처럼 보인다.

하지만 프로젝트가 조금만 커져도, 그 코드는 누구도 손대고 싶지 않은 '스파게티 코드'가 되어버린다.

잘못된 프로젝트 구조는 유지보수를 악몽으로 만들고, 팀원과의 협업을 불가능하게 한다.

프로젝트에서 왜 구조가 중요한지, 그리고 가장 표준적으로 사용되는 MVC 패턴을 기반으로 어떻게 깔끔한 구조를 만들 수 있는지 설명하겠다.

왜 프로젝트 구조가 중요한가?

역할 분담 디자이너는 화면(View)에, 개발자는 로직(Controller, Model)에 집중할 수 있게 한다.

유지보수성 "로그인 로직을 수정해야지" 라고 생각했을 때, LoginServlet.java와 MemberDAO.java만 보면 되도록 만들어준다. 수많은 JSP 파일을 뒤질 필요가 없다.

재사용성 잘 만들어진 데이터베이스 처리 로직(MemberDAO)은 회원 정보가 필요한 어떤 페이지에서든 재사용할 수 있다.

협업 효율성 모든 팀원이 파일이 어디에 위치하고 어떤 역할을 하는지 예측할 수 있어, 코드 충돌을 줄이고 개발 속도를 높인다.

JSP 프로젝트의 표준 구조: MVC 패턴

JSP/Servlet 웹 애플리케이션의 구조를 잡는 가장 표준적인 방법은 MVC 패턴이다. 이 패턴은 프로젝트를 세 가지 역할로 명확하게 나눈다.

Model 데이터 그 자체(DTO/VO)와 데이터를 처리하는 비즈니스 로직(Service, DAO). 순수 자바 클래스로 구성된다.

View 사용자에게 보여지는 화면. JSP 파일이 이 역할을 전담한다.

Controller 사용자의 요청을 받고, 모델과 뷰를 연결하는 중재자. 서블릿(Servlet)이 이 역할을 맡는다.

예시: 기본적인 MVC 프로젝트 폴더 구조

이클립스의 'Dynamic Web Project' 기준으로, 다음과 같은 구조를 따르는 것이 일반적이다.

my-web-project/
├── src/main/java/          # 순수 자바 코드가 위치하는 곳 (Model, Controller)
│   └── com/example/
│       ├── controller/     # 1. Controller (서블릿)
│       │   ├── LoginServlet.java
│       │   └── JoinServlet.java
│       ├── model/          # 2. Model (데이터 관련 클래스)
│       │   ├── dao/        #    - DAO (Data Access Object)
│       │   │   └── MemberDAO.java
│       │   └── dto/        #    - DTO (Data Transfer Object)
│       │       └── MemberDTO.java
│       └── util/           # 3. 유틸리티 클래스
│           └── DBManager.java  (DB 커넥션 풀 관리 등)
│
├── src/main/webapp/        # 웹 콘텐츠가 위치하는 곳 (View)
│   ├── WEB-INF/
│   │   ├── web.xml         #    - 서블릿 매핑 등 웹 애플리케이션 설정 파일
│   │   └── lib/            #    - 외부 라이브러리 (ex: ojdbc.jar)
│   ├── member/             # 기능별로 폴더를 나누면 좋음
│   │   ├── login.jsp
│   │   └── join.jsp
│   ├── main.jsp
│   ├── index.jsp
│   └── css/
│       └── style.css
│
└── pom.xml                 # (Maven 프로젝트인 경우) 의존성 관리 파일

각 폴더의 역할

1. src/main/java 백엔드 로직의 핵심 controller 패키지 사용자의 모든 HTTP 요청(GET, POST)을 가장 먼저 받는 서블릿들이 위치한다. 서블릿은 요청을 분석해서 어떤 모델을 사용할지, 어떤 뷰를 보여줄지 결정하는 '교통경찰' 역할을 한다.

   model.dao 패키지 MemberDAO처럼 데이터베이스에 직접 접근하여 INSERT, SELECT, UPDATE, DELETE (CRUD) 로직을 전담하는 클래스들이 모여있다.

   model.dto 패키지 MemberDTO처럼 데이터베이스 테이블의 정보를 행(Row) 단위로 담기 위한 객체(JavaBean)들이 위치한다. 계층 간 데이터 전송을 위한 '데이터 그릇'이다.

2. src/main/webapp

사용자의 눈에 보이는 모든 것 내가 앞으로 공유할 코드들과 나의 Github에 있는 코드들은 교수님께 배운대로 모두 경로를 WebContents 바꿔놨다.

이클립스 기준으로 프로젝트 생성시에 경로를 바꿀 수 있다.

이 폴더 아래의 파일들은 URL을 통해 직접 접근이 가능하다. (단, WEB-INF 폴더 제외)

.jsp 파일 (View) 컨트롤러(서블릿)로부터 전달받은 데이터를 화면에 동적으로 그리는 역할을 한다. 자바 로직은 최소화하고, 화면 표시에만 집중해야 한다.

css, js, images 폴더 정적인 리소스 파일들을 위치시킨다.

3. WEB-INF

보안이 필요한 핵심 설정 공간 이 폴더 안의 파일들은 클라이언트가 URL로 직접 요청할 수 없어 보안에 유리하다.

web.xml 배포 서술자(Deployment Descriptor)라고 부른다. 어떤 URL 요청을 어떤 서블릿으로 연결할지(서블릿 매핑), 필터, 리스너 등 웹 애플리케이션의 핵심 설정을 정의한다.

lib jdbc.jar 같은 외부 라이브러리(JAR 파일)를 위치시키는 곳이다.

파일이 함께 동작하는 방식 (로그인 과정 예시)

1. 사용자 요청 사용자는 login.jsp에서 아이디와 비밀번호를 입력하고 '로그인' 버튼을 누른다. 폼의 action은 /login을 가리킨다.

2. Controller (서블릿) 처리 web.xml에 /login 요청을 처리하도록 매핑된 LoginServlet이 요청을 가로챈다.

   LoginServlet은 request.getParameter()로 사용자가 입력한 아이디와 비밀번호를 받는다.

   MemberDAO 객체를 생성하고, dao.loginCheck(id, pw) 메서드를 호출하여 DB에 해당 사용자가 있는지 확인한다.

3. Model (DAO, DTO) 작업: MemberDAO는 커넥션 풀에서 DB 커넥션을 얻어와 SELECT 쿼리를 실행한다.

   결과가 있다면 로그인 성공, 없으면 실패로 판단하고 그 결과를 LoginServlet에 반환한다.

4. View (JSP)로 전달 및 표시:

   로그인 성공 시: LoginServlet은 session.setAttribute("userId", id)로 세션에 로그인 정보를 기록한 뒤, response.sendRedirect("main.jsp")를 통해 메인 페이지로 사용자를 보낸다.

   로그인 실패 시: 에러 메시지를 request에 담아 RequestDispatcher를 이용해 다시 login.jsp로 포워딩한다. login.jsp는 전달받은 에러 메시지를 화면에 표시한다.

이처럼 역할에 따라 프로젝트 구조를 명확히 나누는 것은 선택이 아닌 필수이다.

MVC 패턴은 복잡한 웹 애플리케이션을 여러 개발자가 협업하여 만들고, 오랫동안 안정적으로 유지보수할 수 있게 하는 가장 검증되고 안정적인 방법이다.

실무에서 쓰이는 개념들을 하나하나 익힐수록 개인 프로젝트도 관리가 편해지고 뭔가 효율적이고 깔끔한 코딩을 하게되는 것 같다.

최종_보고서.hwp 진짜최종_보고서.hwp 진짜진짜최종_수정본_보고서.hwp 교수님께_보낼파일_최종.hwp

우리는 모두 파일의 버전을 관리하느라 고통받아 본 경험이 있다.

개발 프로젝트는 수십, 수백, 수만 개의 파일로 이루어져 있고, 수많은 사람이 동시에 작업한다.

위와 같은 방식으로 파일 버전을 관리하며 이메일로 파일을 주고받기엔 한계가 있다.

이때 사용하는 도구가 바로 Git과 GitHub이다.

Git & GitHub, 무엇이 다른가?

가장 먼저 이 둘의 관계를 명확히 해야 한다.

Git은 '도구'이고, GitHub는 그 도구를 활용하는 '서비스'이다.

Git (소프트웨어): 버전 관리 '소프트웨어(도구)'

내 컴퓨터에 설치하여 코드의 변경 이력을 사진 찍듯이 저장하고, 언제든 과거로 돌아갈 수 있는 타임머신 역할을 한다.

인터넷 없이도 내 컴퓨터에서 모든 버전 관리가 가능하다.

GitHub (웹 서비스): Git으로 관리하는 프로젝트를 올려두는 '웹 호스팅 서비스'

Git이라는 도구만으로는 힘든 백업, 공유, 협업을 가능하게 해준다.

왜 반드시 함께 사용해야 하는가?

1. 완벽한 버전 관리 (Git) + 안전한 클라우드 백업 (GitHub) Git으로 내 코드의 모든 변경사항을 기록하고, GitHub에 올려두면 내 컴퓨터가 고장 나도 코드는 안전하다.
2. 체계적인 개인 프로젝트 관리 (Git) + 훌륭한 공개 포트폴리오 (GitHub) Git으로 내 프로젝트를 관리하고 GitHub에 꾸준히 올리는 것은, "나는 이렇게 코딩하고 성장해왔다"를 보여주는 가장 확실한 이력서가 된다.
3. 강력한 독립 작업 (Git Branch) + 체계적인 팀 협업 (GitHub Pull Request) Git의 브랜치 기능으로 내 작업을 독립적으로 수행하고, GitHub의 Pull Request 기능으로 팀원들에게 코드 리뷰를 요청하며 안전하게 코드를 병합할 수 있다.

기초 사용법

1. 최초 설정 (컴퓨터에 딱 한 번만)

Git을 설치한 후, 커밋에 기록될 내 정보를 설정한다.

Git Bash를 설치하고 다음을 입력한다.

이때 복사와 붙여넣기는 ctrl + c ctrl + v 대신 ctrl + insert shift + insert로 사용한다.

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

2. 로컬 프로젝트 생성 및 GitHub에 올리기

1단계: 내 컴퓨터에서 Git 관리 시작

# 프로젝트 폴더를 만들고 이동
mkdir my-project
cd my-project

# 이 폴더를 Git으로 관리 시작!
git init

아니면 vscode에서 터미널 창에서 bash를 선택하거나 프로젝트 폴터에서 우클릭 후 이 경로에서 bash 실행하기를 통해 생략할 수 있다.

2단계: 코드 수정 및 로컬에 버전 저장 (add & commit)

# 변경된 모든 파일을 스테이징(장바구니에 담기)
git add .

# 장바구니에 담긴 내용을 하나의 버전으로 저장(커밋)
git commit -m "Initial commit: Add README.md"

3단계: GitHub 원격 저장소 생성 및 연결

1. GitHub에 로그인하여 New repository 버튼으로 새로운 저장소를 만든다.

2. 생성된 저장소의 URL(예: https://github.com/YourName/my-project.git)을 복사한다.

3. 내 컴퓨터 터미널에서 아래 명령어로 로컬 저장소와 원격 저장소를 연결한다.

# 원격 저장소 주소를 'origin'이라는 이름으로 추가
git remote add origin https://github.com/YourName/my-project.git

# 로컬의 main 브랜치를 원격 저장소(origin)로 업로드(push)
git push -u origin main

이제 my-project는 내 컴퓨터와 GitHub 양쪽에 모두 존재하며 서로 연결되었다.

3. 협업의 기본 사이클: Pull → Branch → Commit → Push → Pull Request

팀 프로젝트에 참여할 때의 일반적인 작업 흐름이다.

1단계: 작업 시작 전, 항상 최신 코드로 동기화

다른 팀원이 수정했을지 모르는 최신 코드를 원격 저장소에서 내 컴퓨터로 가져온다.

git pull origin main

2단계: 나만의 작업 공간(브랜치) 만들기

main 브랜치를 직접 건드리지 않고, 새로운 기능을 개발하기 위한 독립된 브랜치를 만든다.

# 'feature/login' 이라는 브랜치를 만들고 그곳으로 이동
git checkout -b feature/login

3단계: 기능 개발 및 커밋

이제 feature/login 브랜치에서 마음껏 코드를 수정하고, add와 commit으로 작업 단위를 저장한다.

# (열심히 코딩...)
git add .
git commit -m "Feat: Implement user login logic"

4단계: 내 브랜치를 원격 저장소에 업로드

내가 만든 feature/login 브랜치를 팀원들이 볼 수 있도록 GitHub에 올린다.

git push origin feature/login

5단계: Pull Request(PR) 생성

가장 중요한 협업 과정이다.

1. GitHub 사이트로 이동하면 "feature/login 브랜치에 변경사항이 있으니 Pull Request를 생성할래요?" 라는 초록색 버튼이 보인다.
2. 버튼을 눌러 내가 작업한 내용과 리뷰를 요청하는 메시지를 작성하고 PR을 생성한다.
3. 이제 팀원들은 내 코드를 보고 의견을 남길 수 있다. 리뷰가 끝나고 승인이 나면, 관리자가 Merge 버튼을 눌러 내 코드를 main 브랜치에 안전하게 합친다.

Git과 GitHub는 더 이상 선택이 아닌 필수라고 한다.

협업할때 뿐만 아니라 개인 프로젝트를 할때도 버전을 효율적으로 관리하고 포트폴리오로도 활용하기 위해 Git이 중요한 것 같다.

이전에 진행하였던 나의 프로젝트도 GitHub에 업로드해서 수정사항들을 더 체계적으로 관리하고 새로운 업데이트가 생겼을때 bash를 이용해 더욱 편하게 관리할 수 있을 것이다.

앞으론 터미널의 claude code와 Mcp를 활용해보며 교수님이 학기중에 수도 없이 말씀하신 바이브 코딩 능력을 길러봐야겠다.

데이터 무결성은 데이터베이스 내의 데이터에 대해 정확성(Accuracy), 일관성(Consistency), 유효성(Validity)을 유지하는 것을 의미한다.

즉, 데이터베이스에 저장된 값은 항상 의도된 형식과 규칙에 맞게 저장되어야 하며, 데이터 간의 관계 또한 모순이 없어야 한다.

데이터베이스 시스템(DBMS)은 이러한 무결성을 강제하기 위해 다양한 제약조건(Constraint) 기능을 제공한다.

데이터 무결성을 지키는 4가지 제약조건

1. 개체 무결성 (Entity Integrity)

기본 키(Primary Key)는 절대 NULL 값을 가질 수 없다.

개체 무결성은 테이블 내의 모든 행(Row)이 고유하게 식별될 수 있도록 보장하는 규칙이다.

이를 위해 사용되는 것이 바로 기본 키(Primary Key)이다.

2. 기본키 무결성 (Primary Key Integrity)

기본 키의 값은 중복될 수 없다.

만약 학생 테이블의 '학생 ID'가 없거나(NULL) 여러 학생이 동일한 ID를 가진다면 특정 학생을 정확하게 찾아내거나 구분할 수 없다.

PRIMARY KEY 활용

CREATE TABLE Student (
    StudentID INT PRIMARY KEY, -- StudentID는 NULL이거나 중복될 수 없다.
    StudentName VARCHAR(50) NOT NULL,
    Major VARCHAR(50)
);

3. 참조 무결성 (Referential Integrity)

외래 키(Foreign Key)는 부모 테이블의 기본 키에 존재하는 값이거나 NULL이어야 한다.

참조 무결성은 두 개의 테이블이 관계를 맺고 있을 때, 그 관계가 항상 유효하도록 보장하는 규칙이다. 이는 외래 키(Foreign Key)를 통해 지켜진다.

'수강' 테이블에 존재하지도 않는 '학생 ID'나 개설되지도 않은 '과목 코드'가 입력된다면 데이터는 의미를 잃는다.

참조 무결성은 이처럼 "없는 학생이 수강 신청을 하는" 등의 논리적 오류를 막아준다.

자식 테이블(수강)의 컬럼에 FOREIGN KEY 제약조건을 설정

-- 부모 테이블
CREATE TABLE Student (
    StudentID INT PRIMARY KEY,
    StudentName VARCHAR(50)
);

-- 자식 테이블
CREATE TABLE Enrollment (
    EnrollmentID INT PRIMARY KEY,
    StudentID INT, -- 이 컬럼이 외래 키가 된다.
    CourseCode VARCHAR(10),
    FOREIGN KEY (StudentID) REFERENCES Student(StudentID) -- Student 테이블의 StudentID를 참조한다.
);

이렇게 설정하면, Student 테이블에 존재하지 않는 StudentID는 Enrollment 테이블에 삽입될 수 없다.

4. 도메인 무결성 (Domain Integrity)

컬럼에 저장되는 데이터는 정해진 규칙(타입, 제약조건)을 반드시 따라야 한다.

도메인 무결성은 테이블의 특정 컬럼에 입력될 데이터의 '범위(Domain)'를 사용자가 정한 규칙에 맞도록 강제하는 것이다.

'성별' 컬럼에 '남', '여' 외에 '99999' 같은 엉뚱한 값이 들어가거나, '나이' 컬럼에 음수 값이 들어가는 것을 막아야 데이터의 유효성이 보장된다.

데이터 타입(Data Type): INT, VARCHAR(10), DATE 등으로 타입을 지정한다.

NOT NULL: NULL 값 입력을 허용하지 않는다.

UNIQUE: 중복된 값을 허용하지 않는다.

CHECK: 특정 조건에 맞는 값만 허용한다. (예: 나이는 0보다 커야 한다)

DEFAULT: 값이 입력되지 않았을 때 기본으로 설정될 값을 지정한다.

CREATE TABLE Member (
    MemberID INT PRIMARY KEY,
    Gender CHAR(1) NOT NULL CHECK (Gender IN ('M', 'F')), -- 성별은 'M' 또는 'F'만 가능
    Age INT CHECK (Age > 0), -- 나이는 양수만 가능
    Email VARCHAR(100) UNIQUE, -- 이메일은 중복될 수 없다.
    JoinDate DATE DEFAULT NOW() -- 가입일은 기본으로 현재 날짜가 입력된다.
);

정규화와 무결성의 관계

정규화(Normalization) 데이터의 중복을 제거하고 테이블 구조를 효율적으로 만드는 설계 과정이다. 정규화를 잘하면 데이터 이상 현상이 줄어들어 무결성을 지키기 쉬워진다.

즉, 무결성을 위한 기반 공사이다.

무결성(Integrity) 설계된 구조 위에서 데이터의 정확성과 일관성을 보장하는 규칙이다.

데이터베이스 정규화는 관계형 데이터베이스에서 데이터의 중복을 최소화하고, 데이터의 일관성과 무결성을 확보하기 위해 테이블을 구조화하는 과정이다.

잘못 설계된 테이블에서는 데이터를 추가, 수정, 삭제할 때 예기치 않은 문제가 발생할 수 있다.

정규화는 이러한 '이상 현상'을 방지하는 핵심적인 역할을 한다.

정규화는 왜 필요한가? (데이터 이상 현상)

만약 정규화를 제대로 하지 않으면 다음과 같은 데이터 이상 현상이 발생할 수 있다.

아래와 같은 '수강 신청 테이블'이 있다고 가정해보자.

1. 삽입 이상 (Insertion Anomaly) 아직 수강 신청을 하지 않은 새로운 학생 '홍길동'을 추가하고 싶어도, 신청한 '과목 코드'가 없으면 데이터를 추가할 수 없다.

   즉, 불필요한 데이터(과목 정보)가 있어야만 학생 정보를 추가할 수 있는 모순이 발생한다.

2. 갱신 이상 (Update Anomaly) '이영희' 교수가 '최영희'로 개명했다면, '컴퓨터 개론'을 수강하는 모든 학생의 데이터에서 교수 이름을 일일이 바꿔야 한다.

   만약 하나라도 빠뜨리면 데이터의 일관성이 깨진다.

3. 삭제 이상 (Deletion Anomaly) '박민지' 학생이 '컴퓨터 개론' 수강을 취소하면 해당 행이 삭제된다.

   이때 '컴퓨터 개론' 과목을 수강하는 학생이 아무도 없다면, '컴퓨터 개론' 과목 정보 자체가 데이터베이스에서 사라져 버린다.

정규화는 바로 이러한 문제들을 해결하기 위해 테이블을 논리적으로 분해하는 과정이다.

정규화 과정 (1NF, 2NF, 3NF)

제1정규화 (1NF, First Normal Form)

규칙: 테이블의 모든 컬럼은 반드시 원자값을 가져야 한다.

원자값이라는 것은 컬럼의 값이 더 이상 쪼개질 수 없다는 의미이다.

[정규화 전]

위 테이블에서 '수강 과목' 컬럼은 두 개의 값을 가지고 있으므로 제1정규형을 위반한다.

[제1정규화 후]

이렇게 각 행이 하나의 의미를 갖도록 값을 분리하면 제1정규화가 완료된다.

제2정규화 (2NF, Second Normal Form)

규칙: 제1정규화를 만족해야 하고, 부분 함수 종속성(Partial Functional Dependency)을 제거해야 한다.

쉽게 말해, 기본 키(Primary Key)가 여러 컬럼으로 구성된 복합 키일 경우, 테이블의 다른 모든 컬럼은 기본 키 전체에 종속되어야 한다. 기본 키의 일부에만 종속된 컬럼이 있다면 테이블을 분리해야 한다.

[정규화 전]

기본 키가 (학생 ID, 과목 코드)인 테이블이 있다.

학생 이름, 학과는 기본 키의 일부인 학생 ID에만 종속된다. (학생 ID만 알면 학생 이름을 알 수 있다)

성적은 학생 ID와 과목 코드 모두에 종속된다. (누가 어떤 과목을 들었는지 알아야 성적을 알 수 있다)

이처럼 기본 키의 일부에만 종속되는 '부분 함수 종속성'이 존재하므로 제2정규형을 위반한다.

[제2정규화 후]

부분 함수 종속성을 제거하기 위해 테이블을 다음과 같이 분리한다.

학생 테이블

수강 테이블

이제 모든 컬럼이 각 테이블의 기본 키 전체에 종속되므로 제2정규화가 완료된다.

제3정규화 (3NF, Third Normal Form)

규칙: 제2정규화를 만족해야 하고, 이행적 함수 종속성(Transitive Functional Dependency)을 제거해야 한다.

이행적 함수 종속성이란, A → B이고 B → C일 때 A → C가 성립하는 관계를 말한다.

즉, 기본 키가 아닌 일반 컬럼이 다른 일반 컬럼을 결정해서는 안 된다.

[정규화 전]

이 테이블에서 과목 코드는 기본 키이다.

과목 코드 → 담당 교수 (과목 코드를 알면 담당 교수를 알 수 있다)

담당 교수 → 교수 연락처 (담당 교수를 알면 그의 연락처를 알 수 있다)

기본 키가 아닌 '담당 교수' 컬럼이 '교수 연락처' 컬럼을 결정하고 있으므로 이행적 종속 관계가 존재한다. 이는 제3정규형을 위반한다. (교수 연락처가 바뀌면 여러 행을 수정해야 하는 갱신 이상 발생)

[제3정규화 후]

이행적 종속성을 제거하기 위해 테이블을 분리한다.

과목 테이블

교수 테이블

이렇게 분리하면 더 이상 일반 컬럼끼리 종속되는 관계가 사라지므로 제3정규화가 완료된다.

결론

• 1NF: 값은 원자적이어야 한다.
• 2NF: 부분 종속성을 제거해야 한다. (복합 키일 때)
• 3NF: 이행 종속성을 제거해야 한다. (일반 컬럼끼리의 종속)

실무에서는 보통 제3정규화까지 마치는 것을 목표로 한다.

더 높은 단계의 정규화도 있지만, 3NF까지 진행하면 대부분의 데이터 이상 현상을 해결할 수 있다.

정규화는 데이터의 중복을 막고 무결성을 지키기 위한 필수적인 과정이다.

정규화된 데이터베이스는 장기적으로 훨씬 안정적이고 확장성 있는 시스템의 기반이 된다.

강의에서 교수님께서 항상 하시던 말씀이 있다.

정규화를 배우는 이유는 데이터베이스를 정규화 하기 위함이라기 보다는 설계시에 정규화가 필요없는 좋은 데이터베이스를 설계하기 위함이라고 하셨다.

정규화를 이해하고 애초부터 정규화가 필요없는 데이터베이스를 설계해야겠다.

다음 글에서는 무결성에 대해 다뤄보겠다.

*BAEKJOON *: 14626 - ISBN

#include <stdio.h>

int main() {
  char check;
  int num[13] = {0,}, sum = 0, flag, result;

  for (int i = 0; i < 13; i++) {
    scanf("%c", &check);
    if (check == '*')
      flag = i;
    else
      num[i] = check-48;
  }
  for (int i = 0; i < 13; i++) {
    if(i!=flag){
      if (i % 2 == 1)
        sum += num[i] * 3;
      else
        sum += num[i];
    } 
  }
  if (flag % 2 == 0) { // 1을 곱하는 경우
    for(int i=0; i<10; i++){ 
      if((sum+i)%10==0){
        printf("%d", i);
      }
    }
  } else { // 3을 곱하는 경우
    for(int i=0; i<10; i++){ 
      if((sum+3*i)%10==0){
        printf("%d", i);
      }
    }
  }
  return 0;
}

오랜만에 알고리즘 문제를 풀어봤더니 내가 생각한대로 동작을 안했다.

디버깅 과정에서 배운 내용을 복습겸 정리해보려고 한다.

형변환(Type Casting)

형변환은 데이터의 자료형을 다른 자료형으로 바꾸는 것이다.

예를 들어 정수 int를 문자 char로 바꾸는 식이다.

1. 자동 형변환 (Implicit Type Conversion)

컴파일러가 "알아서" 해주는 형변환을 자동 형변환이라고 한다.

주로 데이터 손실이 없는 방향으로, 즉 더 작은 자료형이 더 큰 자료형으로 바뀔 때 일어난다.

규칙 char → int → long → float → double (더 표현 범위가 넓고 정밀한 쪽으로 자동 변환)

언제 일어나는가? 서로 다른 자료형을 가진 변수끼리 연산할 때 발생한다.

    #include <stdio.h>

    int main() {
        int a = 10;
        double b = 3.0;

        // a(int)가 b(double)와 계산되기 위해 
        //컴파일러에 의해 임시로 double형으로 자동 형변환된다
        // 10 -> 10.0 으로 바뀐 뒤에 3.0과 더해진다
        printf("결과: %f\n", a + b); // 결과: 13.000000

        return 0;
    }

이때 큰 자료형을 작은 자료형에 대입하면 데이터 손실이 발생할 수 있다.

    int c = 3.141592; // double형 실수를 int형에 넣으려고 함
    printf("%d\n", c); // 소수점 이하가 모두 잘리고 '3'만 저장된다

2. 명시적 형변환 (Explicit Type Casting)

개발자가 강제로 자료형을 바꾸는 것이다.

데이터 손실을 감수하고서라도 형변환이 필요할 때 사용한다.

사용법 (바꿀_자료형)변수_또는_값

언제 사용하는가? 가장 대표적인 예시는 정수 나눗셈의 결과를 실수로 얻고 싶을 때 사용한다.

    #include <stdio.h>

    int main() {
        int a = 10;
        int b = 3;

        // (1) 잘못된 경우
        // 정수와 정수의 나눗셈 결과는 무조건 정수(몫)이다.
        printf("잘못된 계산: %f\n", a / b); // 3.000000 같은 이상한 값이 나옴

        // (2) 올바른 경우 (명시적 형변환 사용)
        // 변수 a를 연산 순간에만 잠시 double형으로 강제 변환한다.
        // (double)a / b  ->  10.0 / 3  ->  double과 int의 연산이 됨
        // b는 자동으로 double형으로 '자동 형변환'되어 계산된다.
        printf("올바른 계산: %f\n", (double)a / b); // 결과: 3.333333

        return 0;
    }

Int형과 Char형 변수 사이의 형변환

위의 형변환에 대해서는 잘 알고 있었지만 Int와 Char 사이의 형변환을 잘 이해하지 못해서 문제를 틀렸다.

(int)'5'= 53

(int)char 형변환이 잘 안되길래 더 공부해봤다.

알고보니 형변환은 아주 잘 되고 있는 게 맞지만, 우리가 기대하는 방식이 아니었다.

왜 (int)'5'는 5가 아닐까 ?

컴퓨터는 '문자'를 그대로 저장하지 못하기 때문에 숫자를 사용한다.

이때 어떤 숫자가 어떤 문자를 뜻할지 약속한것이 *아스키(ASCII) *코드이다.

C언어에서 char 자료형은 사실 문자가 아니라 '문자에 해당하는 아스키 코드'를 저장하는 8비트 정수형이다.

우리가 char c = '5'; 라고 쓰면,

컴퓨터는 변수 c에 '문자 5'에 해당하는 아스키 코드 값인 53을 저장한다.

'0' 48 '1' 49 '2' 50 '3' 51 '4' 52 '5' 53 ... ... '9' 57

따라서 (int)c 라고 형변환을 하면, c에 저장된 값 53을 그냥 더 큰 정수 자료형인 int로 옮겨 담는 것이다.

이러한 원리 때문에 값이 바뀌지 않고 53이 그대로 유지되는 것이다.

올바른 형변환 방법

1. 한 글자 숫자('0' ~ '9')를 바꿀 때: 아스키 코드 값 빼기

가장 기본적이고 빠른 방법으로 위의 알고리즘 문제에서도 사용되었다.

'5' - '0' → 53 - 48 → 5

'8' - '0' → 56 - 48 → 8

#include <stdio.h>

int main() {
    char c1 = '7';

    // 방법 1: '0' 문자를 빼기 (가장 추천하는 방식, 직관적이다)
    int num1 = c1 - '0';

    // 방법 2: 48 숫자를 빼기 (결과는 같지만, 48이 뭔지 모르면 헷갈림)
    int num2 = c1 - 48;

    printf("문자 '7'은 숫자 %d 입니다.\n", num1); // 결과: 문자 '7'은 숫자 7 입니다.
    printf("문자 '7'은 숫자 %d 입니다.\n", num2); // 결과: 문자 '7'은 숫자 7 입니다.

    return 0;
}

2. 문자열("123")을 숫자로 바꿀 때: atoi() 함수

여러 글자로 이루어진 숫자 문자열을 한 번에 정수로 바꿀 때 사용한다.

atoi는 ASCII to Integer 의 줄임말이다.

stdlib.h 헤더 파일에 포함된 함수로, 숫자 문자열의 시작 주소를 받아서 정수(int)로 변환해 돌려준다.

#include <stdio.h>
#include <stdlib.h> // atoi 함수를 쓰려면 꼭 포함해야 함!

int main() {
    char str[] = "14626"; // 큰따옴표로 묶인 문자열 (내부적으로는 char 배열)

    int num = atoi(str);

    printf("문자열 \"%s\"는 숫자 %d 입니다.\n", str, num); // 결과: 문자열 "14626"는 숫자 14626 입니다.
    printf("계산도 가능: %d * 2 = %d\n", num, num * 2); // 결과: 계산도 가능: 14626 * 2 = 29252

    return 0;
}

atoi는 char c = '5' 같은 단일 문자 변수에는 직접 쓸 수 없다.

항상 char 배열, 즉 문자열을 인자로 넣어줘야 한다.

C언어 연산자 우선순위 (Operator Precedence)

연산자 우선순위를 기존에도 알고 있었지만 연산이 많아지니까 헷갈려서 정리해보겠다.

C언어도 연산자마다 정해진 계산 순서가 있다.

아래 표는 위에서 아래로 갈수록 우선순위가 낮아진다.

같은 줄에 있는 연산자들은 우선순위가 같다.

조금이라도 헷갈리면 무조건 괄호 ( )를 사용하는것이 좋다.

괄호를 사용하면 우선순위가 가장 높기에 먼저 실행되고 가독성도 좋아진다.

이때 데이터베이스 삽입, 삭제, 수정, 검색 그리고 쿠키나 세션을 활용한 로그인과 회원가입 로직을 구현해보며 1학기를 마무리했다.

GET 방식과 POST 방식의 차이점

GET과 POST는 HTTP 프로토콜을 이용해 서버에 무언가를 요청할 때 사용하는 방식이다. 둘 다 요청을 보내는 역할을 하지만, 사용하는 목적과 방식에 큰 차이가 있다.

엽서(GET)와 편지 봉투(POST)에 비유할 수 있다.

GET 방식은 엽서를 보내는 것과 비슷하다. 주소(URL)에 전달할 내용(데이터)이 전부 드러나 있어 누구나 쉽게 볼 수 있다.

POST 방식은 편지 봉투에 편지를 넣어 보내는 것과 같다. 내용(데이터)을 봉투(Body) 안에 숨겨서 보내기 때문에, 겉에서는 내용을 알 수 없다.

주요 차이점 비교

언제 사용할까?

GET을 사용하는 경우

서버에서 데이터를 조회(Read)할 때 주로 사용하다.

검색 엔진에서 검색어를 전달하는 것처럼, 데이터가 노출되어도 괜찮은 경우에 사용하다.

캐싱이 필요한 경우에 유리하다. (예: 이미지나 CSS 파일 요청)

POST를 사용하는 경우

서버에 데이터를 생성(Create)하거나 수정(Update)할 때 주로 사용하다.

로그인 정보나 회원가입 정보처럼 민감한 데이터를 전송할 때 사용하다.

파일 업로드처럼 데이터의 크기가 클 때 사용하다.

JSP에서 POST 방식을 사용하여 입력하기

input.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="process.jsp" method="post">
이름입력:<input type="text" name="name" size="10">
점수입력:<input type="text" name="score" size="10">
<input type="submit" value="입력">
</form>
</body>
</html>

JSP에서 GET 방식으로 출력하기

output.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
입력한 사용자 아이디 :<%=request.getParameter("userId") %><br>
입력한 사용자 패스워드 :<%=request.getParameter("password") %><br>
</body>
</html>

주소창에 GET 방식으로 userId와 password를 전달하여서 결과가 잘 출력되었다.

컴퓨터 공학과 복수전공을 준비하며 타 학교 컴퓨터 공학과에서는 전공 필수 과목일 정도로 중요한 논리회로라는 강의를 수강하였다.

한 학기에 전부 공부하기엔 양이 많아 가볍게 보고 넘어간 부분들도 많다.

나중에 보면 내용이 떠오를 정도로 기억에 남는 핵심 내용들만 복습겸 정리해보겠다.

1. ADC와 양자화 잡음(Quantization Noise)

ADC(Analog to Digital Converter)는 아날로그 신호(연속적인 전압, 전류 등)를 디지털 신호(0과 1의 조합)로 변환하는 장치다.
센서, 마이크, 온도계, 조이스틱 등에서 나오는 아날로그 데이터를 컴퓨터나 마이크로컨트롤러가 처리할 수 있도록 해주는 필수 인터페이스다.

ADC의 변환 과정

ADC는 아날로그 신호를 디지털로 바꾸기 위해 다음의 3단계 과정을 거친다.

1. 샘플링(Sampling)

   • 연속적인 아날로그 신호를 일정 시간 간격(샘플링 주기)마다 잘라서 이산적인 값(샘플)으로 만든다.
   • 예: 온도센서에서 1초에 100번씩 온도를 측정
   • 샘플링 주파수는 신호의 최대 주파수의 2배 이상(샤논의 표본화 정리)이어야 원 신호를 복원할 수 있다.

2. 양자화(Quantization)

   • 샘플링된 각 값을 미리 정해진 여러 단계(양자화 레벨) 중 가장 가까운 값으로 반올림한다.
   • 예: 8비트 ADC라면 0~255까지 256단계로 나눔
   • 이 과정에서 실제 값과 양자화된 값 사이에 오차(양자화 잡음)가 생긴다.

3. 부호화(Encoding)

   • 양자화된 값을 컴퓨터가 이해할 수 있는 2진수(비트열)로 변환한다.
   • 예: 150단계 → 10010110(2진수)

아날로그 신호와 디지털 신호

쉽게 얘기해서 왼쪽과 같은 아날로그 신호를 일정 간격으로 자르는게 샘플링이고, 자른 값을 정해놓은 방식대로 반올림 하는게 양자화 이걸 2진수로 바꾸는것이 부호화이다. 그리고 이 양자화 과정의 반올림에서 생기는 오차가 바로 양자화 잡음이다.

양자화 잡음은 신호 품질을 떨어뜨리는 주요 원인 중 하나다.
양자화 스텝이 작을수록 잡음은 줄지만, 필요한 비트 수가 늘어나서 저장 공간이나 전송 대역폭이 커진다.

양자화 잡음 줄이는 법 비선형 압신(Companding) 사용: 작은 신호에 더 촘촘한 스텝을 할당한다. 오버샘플링: 샘플링 주파수를 높여 잡음을 분산시킨다.

2. 그레이 코드(Gray Code)

그레이 코드는 연속된 값끼리 1비트만 다르게 만드는 이진 코드다.
이 코드를 쓰면 값이 바뀔 때 여러 비트가 동시에 바뀌는 걸 막을 수 있어서, 하드웨어에서 신호 오류를 줄일 수 있다.

XOR을 활용해 2진수를 그레이코드로 변환할 수 있다.

*XOR을 활용한 2진수 - 그레이코드 변환 * https://computersource.tistory.com/60

특징 인접 값끼리 1비트만 다르다. 회로에서 에러 검출, 엔코더, 디지털-아날로그 변환 등에 많이 쓴다.

파이썬에서의 이진수 그레이 코드 변환

  # 이진수 → 그레이 코드
  gray = binary ^ (binary >> 1)
  # 그레이 코드 → 이진수
  b = gray
  while gray > 0:
      gray = gray >> 1
      b = b ^ gray

예시 표

3. 에러 검출 코드

디지털 신호에서 에러를 검출하기 위해 여러 가지 코드가 쓰인다.

2-out-of-5 코드는 각 코드에 1이 2개만 들어가도록 해서, 1의 개수가 다르면 에러라고 판단한다.

4. 논리 게이트(Logic Gates)

디지털 회로의 기본 단위는 논리 게이트다.
각 게이트는 입력 신호를 받아 정해진 논리 연산을 수행한다.

논리게이트 논리식 및 회로기호

*이미지 출처 *: 위키백과

버퍼(Buffer) 게이트는 입력 신호를 그대로 출력해서 신호를 안정화시키는 역할을 한다.

5. 불대수(Boolean Algebra)와 최소항식

불대수는 0과 1 두 값으로 논리 연산을 다루는 대수 체계다.
논리회로를 간소화할 때 꼭 필요한 도구다.

주요 법칙 교환법칙: A+B = B+A, A·B = B·A 결합법칙: (A+B)+C = A+(B+C) 분배법칙: A·(B+C) = A·B + A·C 드모르간 법칙: (A+B)' = A'·B', (A·B)' = A'+B' 흡수법칙: A + A·B = A

최소항(minterm)의 정의

n개의 변수로 이루어진 논리식에서, 각 변수마다 한 번씩 등장하는 n개의 논리곱(AND) 항을 최소항이라고 한다.

각 최소항은 진리표의 한 행(입력 조합)에 정확히 하나씩 대응한다.

입력 조합이 1(참)이 되는 경우의 항만을 모아 OR(+) 연산으로 합친 것이 최소항식이다.

예시

변수 x, y, z가 있을 때: x=0, y=1, z=0에 해당하는 최소항:
→ x' y z'
x=1, y=0, z=1에 해당하는 최소항:
→ x y' z

진리표에서 함수 f가 1이 되는 행의 입력 조합에 해당하는 최소항만을 OR로 연결한다.

최소항식의 표기와 의미

기호 표기: m0, m1, m2, ...로 표기한다.
예: x'y'z = m1 (x=0, y=0, z=1)

함수 표현: F(x, y, z) = Σ(1, 3, 6, 7)
→ m1, m3, m6, m7에 해당하는 최소항의 합

예시

f = x'y'z + x'yz + xy'z' + xyz 이 식은 각 항이 세 변수(x, y, z)를 모두 한 번씩 포함하므로 최소항식이다.

최소항식 전개의 방법

1. 진리표 작성
   입력 변수의 모든 조합에 대해 함수 값(f)이 1인 행을 찾는다.
2. 각 조합에 해당하는 최소항 도출
   0인 변수는 보수(NOT), 1인 변수는 그대로 사용하여 AND로 묶는다.
3. 모든 최소항을 OR로 연결
   f가 1인 모든 행의 최소항을 + 연산(OR)으로 합친다.

예시

변수 3개(x, y, z), f가 1인 경우:
(x, y, z) = (0, 1, 1) → x' y z
(x, y, z) = (1, 0, 0) → x y' z'
(x, y, z) = (1, 1, 0) → x y z'
최소항식: f = x'y z + x y' z' + x y z'

최소항식의 특징과 활용

논리회로 설계의 표준: 논리함수를 AND, OR 게이트만으로 간단하게 구현할 수 있다. 카르노맵, 퀸-맥클러스키 등 논리식 간소화의 출발점이 된다. 모든 최소항을 조합하면 2ⁿ개가 만들어진다(n: 변수 개수)

최소항과 최대항의 관계

최소항(Minterm)
함수가 1이 되는 입력 조합의 논리곱(AND) 최대항(Maxterm)
함수가 0이 되는 입력 조합의 논리합(OR) 보수 관계 최소항식의 보수는 최대항식, 최대항식의 보수는 최소항식이 된다.

6. 카르노맵(Karnaugh Map)

카르노맵은 불 함수를 시각적으로 간소화하는 도구다.
입력 변수가 3~4개일 때 효과적으로 최소 논리식을 찾을 수 있다.

3변수 예시

1이 인접한 칸끼리 묶어서 최소항을 만든다.

묶음 예시 X=0, YZ=00/01 → $\overline{X}\overline{Y}$ X=0, YZ=01/11 → $\overline{X}Z$

최종식 $\overline{X}\overline{Y} + \overline{X}Z$

카르노맵 간소화 방법 https://homubee.tistory.com/42

7. 퀸-맥클러스키(Quine-McCluskey) 방법

변수 4개 이상의 논리식 간소화를 위한 체계적 알고리즘이다. 카르노맵보다 확장성이 높아 디지털 컴퓨터 구현에 적합하다.

동작 원리

1. 최소항 그룹화: 최소항을 2진수로 변환 후 1의 개수로 그룹 분류
   EX: 최소항 [0(000), 1(001), 2(010), 5(101), 6(110), 7(111)]
   그룹 0: 000
   그룹 1: 001, 010
   그룹 2: 101, 110
   그룹 3: 111

2. 주항(PI) 추출: 인접 그룹끼리 1비트 차이 항 병합
   000-001 → 00-
010-110 → -10
101-111 → 1-1
   더 이상 병합 불가능한 항을 주항으로 선택

3. 주항 차트로 최소 커버링: 필수 주항(Essential PI) 선정 후 나머지 항 커버링.

퀸 맥클러스키 간소화 방법 https://blog.naver.com/leeyunghuk1/220959424842

8. 가산기(Adder)

조합논리회로는 AND, OR, NOT 세가지 기본 논리회로의 조합으로 만들어지고 가산기에 대해 정리하겠다.

반가산기(Half Adder)

반가산기는 한 자리 2진수 2개를 입력해서 합과 캐리를 계산하는 회로이다.

입력: A, B 출력: 합(S), C

전가산기(Full Adder)

반 가산기는 2진수 한 자리 덧셈을 하기때문에 아랫자리에서 발생한 올림은 고려하지 않아 2비트 이상의 2진수 덧셈은 할 수 없다.

그러하여 이전 자리올림을 입력으로 넣어 덧셈을 할 수 있도록 한 회로가 전가산기이다.

• 입력: A, B, 이전 자리올림(Cin)
• 출력: 합(S), Cout

9. 디코더(Decoder)

디코더는 n비트의 입력 → 2^n개의 정보로 출력시켜주는 회로이다.

주소 지정과 명령어 해석에 사용한다.

2x4 디코더의 경우에는 아래와 같은 진리표, 논리식, 회로도를 가진다.

아래와 같이 표와 논리식을 보기 좋게 정리할 수 있다.

입력과 출력 진리표

각 출력의 논리식

$$Y_0 = \overline{B} \overline{A}$$ $$Y_1 = \overline{B} A$$ $$Y_2 = B \overline{A}$$ $$Y_3 = B A$$

10. 멀티플렉서(Multiplexer, MUX)

멀티플렉서는 2^n개의입력 중 1개 선택해서 출력하는 조합논리회로.

데이터 선택기로 CPU 내부에서 활용한다.

4X1 MUX

4X1 MUX를 이용해 3개의 입력에 따른 출력 설계하기

$$F(A, B, C) = \Sigma m(0, 1, 5, 7)$$

이 내용은 처음에 접했을때 어려웠지만 반복해서 연습하다보니 쉽게 느껴졌다.

C를 0,1과 같은 패턴으로 두고 패턴을 찾아 입력으로 사용하여 설계하면 된다.

11. 래치(Latch)와 플립플롭(Flip-Flop)

순서논리회로는 기억 능력이 있는 논리회로인데, 이때 기억 능력을 위해 기억 소자가 필요하고 이때 사용되는 핵심 부품이 래치와 플립플롭이다.

플립플롭은 1비트의 정보를 저장할 수 있는 메모리 소자로, 저장 기능이 있다.

래치(Latch)와 플립플롭(Flip-Flop)의 비교

1. SR 플립플롭 (Set-Reset Flip-Flop)

가장 기본적인 플립플롭으로, SR 래치에 클럭 입력을 추가한 구조이다.

특성표 (Characteristic Table) 클럭이 인가되었을 때의 동작을 나타낸다.

특성식 (Characteristic Equation) $$Q_{t+1} = S + R'Q$$ (단, SR=0 조건)

특성(방정)식은 특성표를 바탕으로 만든 카르노맵을 통해 구할 수 있다.

여기표 (Excitation Table) 현재 상태 Q(t)에서 다음 상태 Q(t+1)로 변하기 위해 필요한 입력 S와 R을 나타낸다. (X는 Don't Care)

2. D 플립플롭 (Data Flip-Flop)

SR 플립플롭의 S=R=1 문제를 해결하기 위해 입력을 하나로 통합한 플립플롭이다.

구조 SR 플립플롭의 S 입력에 D를, R 입력에 D의 NOT 게이트를 연결합니다. 이로써 S와 R은 항상 반대 값을 갖게 되어 S=R=1 조건이 원천적으로 차단된다.

동작 클럭의 엣지에서 입력 D의 값이 그대로 출력 Q에 저장된다. 그래서 '데이터' 또는 '지연(Delay)' 플립플롭이라고도 한다.

특성표

특성식 $$Q_{t+1} = D$$

여기표

3. JK 플립플롭 (Jack-Kilby Flip-Flop)

SR 플립플롭의 S=R=1 문제를 해결하면서, 그 상태를 유용한 토글(Toggle) 기능으로 활용한 범용 플립플롭이다.

진화 S=J, R=K로 대응되며, J=K=1일 때 출력이 현재 상태의 반대(Q')가 된다.

특성표

특성식 $$Q_{t+1} = JQ' + K'Q$$

여기표

4. T 플립플롭 (Toggle Flip-Flop)

JK 플립플롭의 J와 K 입력을 하나로 묶어 만든 특수 형태의 플립플롭이다.

구조 J=K=T로 연결한다.

동작 T=0이면 현재 상태를 유지하고, T=1이면 클럭 엣지마다 출력을 반전(토글)시킨다. 주파수를 1/2로 분주하는 효과가 있어 카운터 설계의 핵심 소자이다.

특성표

특성식 $$Q_{t+1} = T \oplus Q = TQ' + T'Q$$

여기표

12. 동기 순서논리회로 설계: 3비트 동기식 카운터 (JK 플립플롭 사용)

설계 5단계 상세 과정

목표 000 → 001 → 010 → 011 → 100 → 101 → 110 → 111 → 000... 순서로 카운트하는 3비트 동기식 카운터 설계

1단계: 상태도 (State Diagram)

3비트이므로 총 $2^3 = 8$개의 상태(000 ~ 111)를 가진다.

각 상태는 클럭이 한 번 인가될 때마다 다음 숫자로 변경된다. (예: 010에서 클럭 인가 시 011로)

마지막 상태인 111에서는 다음 클럭에 000으로 돌아간다.

(000) -> (001) -> (010) -> (011) -> (100) -> (101) -> (110) -> (111) -> (000)

2단계: 상태표 (State Table)

3단계: 상태 여기표 (Excitation Table)

2단계 상태표와 JK 플립플롭의 여기표를 결합

‘×’는 무관(상관없음) 조건을 의미한다.

4단계: 카르노맵을 이용한 입력 논리식 간소화

3단계 표를 바탕으로 각 J, K 입력(J2, K2, J1, K1, J0, K0)에 대한 논리식을 카르노맵을 이용해 구한다.

JA = BC KA = BC JB = C KB = C JC = 1 KC = 1

5단계: 회로도 구현 (Circuit Implementation)

4단계에서 구한 논리식을 바탕으로 회로를 구성한다.

이 프로젝트는 대학교 '데이터베이스설계' 강의에서 진행하였다.

한 학기동안 개념 학습, 시험 공부, 매주 진행하는 팀 활동으로 많은 노력을 쏟았다.

그 결과 약 70명중 1-2등으로 A+라는 성적을 받았다.

프로젝트의 주제는 "데이터베이스를 활용한 시흥시의 불편함 개선"이었고 이때 사용자가 현업에서 실제로 사용할 수 있는 데이터베이스를 설계해야했다.

이 강의와 프로젝트를 통해 효율적인 ERD 설계를 중심으로 정규화나 각종 데이터베이스에 대한 지식을 배웠다. 또한 SQL을 배우고 구축한 데이터베이스에 샘플데이터를 삽입해 SQL문을 통한 시연까지 해보았다.

프로젝트는 다음과 같은 과정으로 진행되었다.

1. 인터뷰 요청

2. 인터뷰를 통한 업무 및 요구사항 분석

3. ERD 설계(논리적 설계) 및 보완

4. 용어사전 및 도메인 기술서 작성

5. 물리적 설계

6. 발표 및 보고서 작성 물리적 설계를 통한 테이블에 샘플 데이터 삽입 및 SQL문 시연

프로젝트 개요

학교 주변의 주점과 음식점은 우리 학교 학생들이 대부분의 손님을 차지한다.

이 점으로 학교 행사, 시험기간, 동아리 활동과 같은 교내의 요인들로 인해 사람들이 몰리는 시간대와 요일이 급격하게 변화한다.

이러한 점으로 사람이 없을 줄 알고 사장님 혼자서 홀과 주방을 모두 담당하시다가 손님이 몰려와서 안주가 나오는데 1시간 가까이 걸렸던 적도, 주변 학생들 중에서도 알바를 하다가 손님이 없어 어쩔 수 없이 조기 퇴근하는 경우도 보았다.

또한 사장님께서 여러 인력을 여러 시간대에 매일 카카오톡 단톡방으로 배치하는데, 어려움을 느끼신다고 하셨다.

이런 배경속에서 학교 행사나 여러 요소들을 동시에 관리해서 필요한 인력을 예측할 수 있는 인력 배치 시스템이 있다면 아래의 3가지 주체에게 각각 좋은 영향을 미칠 수 있을 것이라고 생각했다.

1. 자영업자 인건비 절감 효율적인 식자재 관리 인력을 쉽게 관리

2. 직원(알바생) 근로 시간 예측 가능 급여 안정성 증가

3. 시흥시 주민(시설 이용자) 빠른 서비스(EX : 서빙 시간) 질 좋은 서비스(EX: 음식의 신선도)

주제의 구체화

나는 학교 앞 번화가의 가장 큰 주점을 주제로 선정했다.

처음에는 시흥시 자영업자의 효율적인 인력배치 시스템을 주제로 선정하려했지만 좁은 주제로 시작해 나중에 확장하는것이 더욱 효과적일 것이라고 생각했다.

예를 들면 어떤 자영업이든 필요인력의 정도를 알 수 있는 인력배치 시스템을 막연하게 주제로 시작하기보다는 학교라는 변수에 가장 민감하게 변화하는 학교 앞 번화가를 대상으로 시작해서 점차 데이터베이스를 확장해나가는게 효율적이라고 생각했다.

실제로 우리 학교 앞 번화가가 시흥에서 가장 큰 상권 중 하나였고, 주변 자영업들의 매출변동은 비슷한 구조를 띤다.

이때 매출이 가장 민감하게 변화하는 대형 주점을 주제로 삼는다면 인근 자영업으로도 시흥시로도 주제를 확장하기 유리하다고 생각했다.

인터뷰 진행

주제를 구체화 시킨 뒤 목표했던 대형 주점에 대한 인터뷰 내용을 설계하고 사장님께 인터뷰를 요청드렸고, 감사하게도 인터뷰에 응해주시기로 하였다.

인터뷰를 진행하며 우리가 생각했던 학생들에 의한 수요 변동에 대한 부분이 맞음을 확인할 수 있었다.

또한 현재 업무가 어떤식으로 진행되고 있는지, 시스템에 어떤 기능이 있으면 좋을지 등을 분석하는 시간을 가졌다.

DFD Level 0(Data Flow Diagram) 설계

인터뷰를 바탕으로 ERD 작성을 위한 업무 기능도를 작성하였다.

또한 업무 기술서와 업무 기능도를 작성하여 ERD 작성을 위한 기반을 마련하였다.

ERD 설계(논리적 설계)

처음에는 위와 같이 도메인 없이 피터 첸(Peter-Chen) 표기법을 통해 ERD를 작성하여 중간 발표를 하였다.

이때 교수님께 피드백을 받았고 또한 개체, 관계, 속성의 검토에 대해서 배우고, 불필요함에도 불구하고 있으면 더 좋은 요소인 비정규화 등 많은 개념을 배웠다.

이러한 배움을 통해 처음엔 막연하게 그리던 ERD가 이젠 왜 필요한지를 이해하게 되면서 개체, 관계, 속성 하나하나 정말 많은 고민을 하면서 수정과 수정을 거듭하였다.

그러하여 용어사전과 도메인을 설계하고 최종발표때는 Toad Data Modeler 툴을 활용해 아래와 같은 최종 ERD를 설계할 수 있었다.

용어사전과 도메인 설계

협업을 피해갈 수 없는 실무에서 용어의 통일은 정말 중요하다고 교수님께서 말씀해주셨다.

논리적 설계를 바탕으로 물리적 설계를 하기 위해서 용어사전과 도메인 설계를 가장 먼저 진행하였다.

용어사전은 정해진 규칙에 따라 더 분리할 수 없는 최소단위의 단수명사를 가능한 사용하려고 노력하였고 약어를 활용했다.

위의 사진은 용어사전의 일부이다.

위의 사진은 도메인 기술서의 일부이고 좀 단순하지만 새로 알게된 점이 있었다.

계좌번호나 전화번호같은 경우에 연산이 불필요하며 -와 같은 기호도 포함될 수 있고, 데이터의 손실 등의 오류를 초래할 수 있기에 Int 보단 문자열로 관리하는게 맞다는 점이었다.

이런 점 외에도 여러 점들을 고려해서 도메인을 설계할 수 있었다.

물리적 설계

ERD에 용어사전과 도메인 기술서를 바탕으로 물리적 설계를 진행하였다.

DDL 구축 및 샘플 데이터 삽입

Toad Data Modeler을 통해 DDL을 구축하고 MYSQL WorkBench를 활용해 테이블을 생성하고 러프한 샘플 데이터를 삽입했다.

샘플 데이터를 바탕으로 SQL 시연

각종 SQL 문을 실행하며 교수님과 학우들 앞에서 최종 보고서와 함께 시연했다.

대동제와 시험기간 두가지의 사례를 보여주기 위해 극단적인 샘플 데이터를 삽입한체로 시연했다.

학교 축제기간 필요 인력 예측

작년 학교 축제때의 매출 변화 추이를 보며 올해에는 어떻게 인력배치를 해야할지 고민하는 예시이다.

올해 행사정보에서 대학축제가 있음을 확인하고

작년 대동제와 평소일의 데이터를 비교해봐야겠다라고 생각을 한다.

축제때 매출이 많이 나왔음을 확인했지만 더 알아보고자 시간대별 매출을 알아본다.

축제때가 평소보다 매출은 많지만 학생들이 축제가 끝나고 2차로 많이 오는건지 22시 이전에는 오히려 평소보다 손님이 없다.

올해 대동제에는 22시 전엔 인원 1명만 배치해도 되겠다는 결론을 내린다.

기말고사 시험기간 필요 인력 예측

시험 기간과 평소일의 매출을 비교해보니 여러가지 정보를 알 수 있었다.

1. 시험기간엔 손님이 많이 안오구나
2. 시험기간 직후에는 손님이 많이 오는구나
3. 시험기간이어도 금요일이면 장사가 잘되는구나

시험기간의 손님 유형을 보려고한다.

시험기간엔 학생보단 일반인이 더 많다는 특징을 찾아내어서 방문 시간대까지 한번 보려고한다.

일반인들은 학생들보다 일찍오는 편이어서 시험기간엔 이른시간엔 많이 배치하고 늦은 시간에는 최소인력만 투입시켜도 되겠다는 결론을 내린다.

앞선 정보를 고려한 인력 배치

Insert문을 통해 기존의 직원 정보를 활용해 배치한다.

이와 같이 잘 배치되었음을 알 수 있다.

결론 및 느낀점

이처럼 인력 필요량을 예측할 수 있도록 여러 데이터를 수집 저장 분석할 수 있는 테이블과 테이블간의 관계를 설계하고 실제로 데이터들의 상관관계를 통해 인력 필요량을 정해 배치까지 해볼 수 있었다.

데이터베이스의 여러 개념들을 익히고 논리적 설계와 물리적 설계를 거쳐 SQL까지 다뤄볼 수 있는 좋은 경험이었다.

1학년을 보내면서 대학이라는 곳이 단순히 강의를 듣는 곳인줄 알았는데 이렇게 직접 인터뷰도 해보고 실무에서 사용할 수 있는 데이터베이스를 설계해보니 신기했고 4.41이라는 좋은 학점으로 학기를 마무리해 뿌듯하다.

프로젝트를 진행하며 필요한 부분들을 스스로 더 공부해본 경험, 그리고 정말 많은 시간을 할애하며 최종 보고서를 작성하고 발표 시연하고, 팀장으로써 팀원들을 이끌고 리드해본 값진 경험은 당시엔 힘들었지만 나를 더 성장시킨 것 같다.

또 앞으로 어떤식으로 학습해야할지도 감 잡을 수 있었던 것 같다.

이외에도 CS 지식을 다루는 다른 과목들도 벨로그에 작성하며 복습하고 되돌아보는 시간을 가지려고 한다.