문자 개수 세기(count)

a = "hobby"
print(a.count('b'))

<출력 결과>

2

위치 알려주기(find)

a = "hobby"
print(a.find('b'))

<출력 결과>

2 

-> b가 처음으로 나온 위치를 알려준다.

문자열 삽입(join)

print(",".join('abcd'))

<출력 결과>

a,b,c,d

-> 문자열 각 사이에 ','를 삽입한다. join함수는 문자열뿐만 아니라 리스트나 튜플에도 사용될 수 있다.

소문자 <-> 대문자 변환(upper, lower)

a = "HOBby"
print(a.upper())
print(a.lower())

<출력 결과>

HOBBY
hobby

문자열 바꾸기(replace)

a = "Hello, World!"
print(a.replace("World!", "Python!"))
print(a) # 원본은 바뀌지 않는다

<출력 결과>

Hello, Python!
Hello, World!

기준을 가지고 문자열 나누기(split)

a = "Hello, World!"
print(a.split()) # 공백을 기준으로 나누기
b  = "apple:banana:grape"
print(b.split(':')) # 쉼표를 기준으로 나누기

<출력 결과>

['Hello,', 'World!']
['apple', 'banana', 'grape']

참고로, 문자열을 나눌땐 split()말고도 인덱싱과 슬라이싱이 있다.

• 인덱싱: a[0]
• 슬라이싱: a[2:5]

import heapq

def solution(jobs): # [요청 시각, 소요 시간]
    # 요청 시각 기준 정렬
    jobs.sort()

    curr_time = 0           # 현재 시간
    total = 0               # 총 반환시간
    idx = 0                 # jobs 인덱스
    complete_count = 0      # 처리 완료 개수
    heap = []               # 대기 큐

    while complete_count < len(jobs): # 모든 작업 끝날 때까지
        # 현재 시간까지 요청된 작업 모두 힙에 저장
        while idx < len(jobs) and jobs[idx][0] <= curr_time:
            request, duration = jobs[idx] 
            heapq.heappush(heap, (duration, request)) # 튜플 형태로 heap에 저장(1순위: 소요시간, 2순위: 요청 시각)
                                                      # 작업 번호는 고려x -> 소요시간, 요청시각 같으면 평균 반환시간 동일
            idx += 1 # 다음 작업 번호

        # 힙에서 꺼내서 작업 실행
        if heap: 
            duration, request = heapq.heappop(heap)
            curr_time += duration
            total += curr_time - request # 반환 시간 = 종료 시각 - 요청 시각
            complete_count += 1
        else: # 처리할 작업이 아직 안들어왔으면 현재 시간을 다음 요청 시각으로 점프
            curr_time = jobs[idx][0] # 그 다음 작업 번호의 요청 시각

    return total // len(jobs)

핵심 1

jobs 리스트는 요청 시각 기준으로 정렬한 후, heap에 '소요 시간'과 '요청 시각'을 따로 넣어줘야한다. 이때 heap 자료구조를 사용하는 이유는, 소요시간이 최소인 아이템을 가장 먼저 뽑아야하기 때문이다.

우선순위: 소요시간 > 요청 시각 > 아이템 번호

heapq.heappush(heap, (duration, request)) 튜플에 작업 번호 idx를 넣지 않았다. 그 이유는 소요시간과 요청시각이 같은 작업이면 완전히 동일한 작업이기 때문에 그것들 중에서 어떤 것을 먼저 수행해도 반환 시간(종료 시각 - 요청 시각)의 평균은 같기 때문이다.

핵심 2

curr_time을 기준으로 작업을 수행하고, curr_time을 점점 이동시킨다.

1) heap에 저장 2) heap에서 꺼내서 작업 수행(duration이 최소인 아이템부터 꺼내진다)

요청 시각 <= 현재 시각 인 아이템들을 대상으로 1번 작업을 먼저 수행한 후, 2번을 수행한다.

cf) 요청 시각: jobs[idx][0] 여기서 idx는 jobs의 작업 번호이다.

만약 해당 조건에 해당하는 아이템이 없어서 heap 비었으면 curr_time을 다음 작업 번호의 요청 시각으로 갱신해준다. (curr_time = jobs[idx][0])

핵심 3

하나의 작업을 완료하면 curr_time에 duration만큼 더해서 갱신해주고 반환 시간(total)을 계산해서 갱신해준다.

접근하기 어려웠던 점

jobs 리스트를 가지고 어떻게 우선순위 큐를 구현해야하는지가 어려웠다. 일단 2차원 배열 정렬 개념이 머릿속에 잡혀있지 않았고, 요청 시각 순으로 정렬된 jobs를 작업 목록으로 활용하고 heap은 대기 큐로 활용할 생각을 못했다.

또한 jobs는 [요청 시각, 소요 시간] 인데 이 상태로 힙에 저장하면 소요 시간이 가장 우선순위가 높다는 문제 조건을 충족할 수 없다. 따라서 heap에는 (소요 시간, 요청 시각) 처럼 순서를 바꾼 튜플을 한 아이템으로 저장해야 했다.

집합이란?

중복을 허용하지 않고, 순서가 없는 원소들의 모임입니다. 파이썬의 set 타입이 해당됩니다.

Set 역시 내부적으로 해시 테이블을 기반으로 동작하기 때문에 데이터 조회 속도가 매우 빠릅니다.

장점 원소의 존재 여부를 매우 빠르게 확인할 수 있습니다. (평균 시간 복잡도: O(1))

데이터를 추가하는 순간 자동으로 중복이 제거됩니다.

교집합, 합집합 등 유용한 집합 연산을 기본으로 지원합니다.

단점

• 순서가 없기 때문에 인덱스([0], [1])로 접근할 수 없습니다.
• Key-Value 형태가 아닌, 값 자체만 저장합니다.

언제 사용할까?

• 목록에서 중복된 값을 간단히 제거하고 싶을 때

• 데이터의 존재 여부만 빠르게 확인하고 싶을 때 (백준 1920번 문제)

• 데이터 그룹 간의 공통점이나 차이점을 찾아야 할 때 (교집합, 차집합 등)

  # 리스트의 중복 제거하기
  my_list = [1, 2, 2, 3, 4, 4, 4, 5]
  unique_set = set(my_list)
  print(unique_set) 
  # 출력: {1, 2, 3, 4, 5}

• • 주요 함수 및 사용법 (Python Set 기준)**

• add(value): 원소 추가

• remove(value): 원소 삭제 (삭제할 원소가 없으면 에러 발생)

• discard(value): 원소 삭제 (삭제할 원소가 없어도 에러 발생 안 함)

• in: 존재 여부 확인

my_set = {1, 2, 3}
my_set.add(4)      # {1, 2, 3, 4}
my_set.remove(2)   # {1, 3, 4}

# 존재 여부 확인
if 3 in my_set:
    print("3은 집합에 포함되어 있습니다.")

집합 연산

• & 또는 intersection(): 교집합 (둘 다에 있는 원소)

• | 또는 union(): 합집합 (모든 원소)

• • 또는 difference(): 차집합 (한쪽에만 있는 원소)

    set_a = {1, 2, 3, 4}
    set_b = {3, 4, 5, 6}
    

print(set_a & set_b) # 교집합: {3, 4} print(set_a | set_b) # 합집합: {1, 2, 3, 4, 5, 6} print(set_a - set_b) # 차집합: {1, 2}

from collections import deque

def solution(bridge_length, weight, truck_weights):
    # 다리에 올라갈 수 있는 트럭 수 bridge_length
    # 다리가 견딜 수 있는 무게 weight
    # 트럭 별 무게 truck_weights

    trucks = deque(truck_weights) # 대기 트럭 큐
    bridge = deque([0] * bridge_length) # 다리 큐
    time = 0
    current_weight = 0

    while trucks or current_weight > 0: # 대기 트럭이 남아있거나 다리 위에 트럭이 남아있으면 반복
        time += 1
        out_truck = bridge.popleft() # 다리를 지난 버스
        current_weight -= out_truck

        if(trucks and current_weight + trucks[0] <= weight):
            in_truck = trucks.popleft() # 다리를 건널 버스
            bridge.append(in_truck) # 다리에 버스 추가
            current_weight += in_truck # 버스 무게 추가
        else:
            bridge.append(0) # 다리에서 pop한 자리 채워주기
    return time

1. 문제 유형

시뮬레이션 + 큐 2개 사용

시뮬레이션 문제 특징

• “매 초마다”
• “각 단계에서”
• “상태가 변한다”
• “그대로 구현하시오”

2. 처음에 잘못 생각한 접근

• 한 번에 여러 트럭의 weight를 계산하려고 했다.
• 슬라이싱과 sum으로 한 번에 처리하려 했다.
• 이 문제는 한 번에 계산하는 문제가 아니라, 시간 흐름에 따라 상태가 변하는 문제였다.

3. 핵심 깨달음

• 시간 단위(1초)로 상태가 변하는 문제는 시뮬레이션을 먼저 떠올린다.
• 순서대로 처리되는 구조는 deque를 사용하면 자연스럽게 구현할 수 있다.
• 다리처럼 길이가 고정된 구조는 deque([0] * bridge_length)로 초기화한다.
• 대기열이 비어도, 시스템(다리 위)에 남은 요소가 있으면 반복을 계속해야 한다.

4. 구현 실수 정리

• current_weight <= weight가 아니라

  current_weight + trucks[0] <= weight로 검사해야 한다.

• 트럭을 올리지 못한 경우 bridge.append(0)을 해줘야 한다.

• while trucks가 아니라 while trucks or current_weight > 0이어야 한다.

• & 대신 and를 사용해야 한다.

myapp컨테이너와 myapp-dev컨테이너와 연결된 Caddy(로드밸런서)가 myapp-dev 컨테이너를 찾지 못해 myapp-dev 컨테이너로 연결되는 url 접속시 503에러가 발생했다.

원인

두 컨테이너가 서로 다른 디렉토리에서 실행되어, Docker가 각각 별개의 네트워크(_webnet)를 생성했다. 그로인해 이미 Caddy와 연결된 myapp 컨테이너는 접속이 잘 되지만 추가로 연결하려는 myapp-dev는 인식을 못한 것이다.

해결

워크플로우 스크립트deploy-main.yml과 deploy-dev.yml의 docker compose 명령어에 -p 옵션을 추가했다.

deploy-dev.yml

- name: Deploy Docker services
  run: | 
   ssh prod 'cd /opt/app-backup && sudo docker compose -p promptplace -f docker-compose.yml up -d --build app caddy'

deploy-main.yml

- name: Deploy Docker services (Dev)
  run: |
   ssh prod 'cd /opt/app-dev && sudo docker compose -p promptplace -f docker-compose.yml up -d --build app-dev'

이를 통해 실행 경로가 다르더라도 두 환경이 promptplace라는** 하나의 네트워크**를 공유하도록 설정을 변경했다. (참고로 여기서 promptplace는 내 프로젝트 이름이다.) 이제 Caddy가 동일한 네트워크 상에 있는 Dev 컨테이너를 정상적으로 인식하고 트래픽을 라우팅한다.

트랜잭션이 필요한 이유

회원가입 로직에서

1. 회원정보 member를 DB에 저장
2. 회원 선호 preferences를 DB에 저장

-> 2번에서 실패했을 때 1번이 이미 저장돼버리면 데이터가 불완전하게 남는다. 이를 막기 위해 1번과 2번 모두가 성공한 후, 실제로 적용되게 해야한다. 바로 그걸 트랜잭션이 해준다.

트랜잭션의 4가지 핵심 원칙(ACID)

Atomicity(원자성): 모두 성공하거나, 모두 실패 Consistency(일관성): 데이터는 항상 유효한 상태를 유지 Isolation(고립성): 동시에 실행되어도 서로 간섭하지 않음 Durability(지속성): 트랜잭션이 완료되면 DB에 영구 반영됨

import math

def solution(progresses, speeds):
    answer = []
    days = [] # 작업 일 수 

    for i in range(len(progresses)):
        d = math.ceil((100 - progresses[i])/speeds[i])
        days.append(d)

    count = 0
    max_day = days[0]

    for day in days:
        if day <= max_day:
            # 묻어가기
            count += 1
        else:
            answer.append(count)
            max_day = day
            count = 1 # 현재 day추가

    answer.append(count) # 마지막 배포
    return answer

📌 1. 유형

앞에 있는 기능이 배포되어야 뒤에 있는 기능도 배포 가능. -> FIFO(큐)

📌2. 헷갈린 부분

첫번째 기능이 완료되면 두번째 기능이 완료되지 않아도 세번째 기능을 배포 가능하다고 생각했다. 그러나 이 문제는 앞에 기능이 완료되어야 뒤에 기능도 배포 가능하기 때문에 불가능하다. 따라서 O(N)으로 탐색이 가능하다.

📌3. 핵심

이중 for문 쓰지 말고, max_day (기준값) 변수 하나만 갱신하면 된다.

VPC = 아파트 단지 → AZ = 동 (A동, B동 등) → Subnet = 각 동 안의 층 → EC2, RDS = 층에 사는 사람들

서울 리전 (ap-northeast-2)
└── VPC (10.0.0.0/16)
    ├── Subnet-A (10.0.1.0/24, ap-northeast-2a)
    │   └── EC2 인스턴스 A
    └── Subnet-B (10.0.2.0/24, ap-northeast-2b)
        └── RDS 인스턴스 B

VPC 서브넷 IP 주소 대역에서는 5개의 주소를 host에 할당할 수 없다.

1. 첫 주소 : 서브넷의 네트워크 대역
2. 두번째 : VPC 라우터에 할당
3. 세번째 : Amazon이 제공하는 DNS에 할당
4. 미래를 위해 예약
5. 브로드 캐스트 주소

🌟 VPC 내부적으로 라우터가 있고, 그렇다면 VPC 내부 서브넷끼리 통신이 되겠네? [매우 중요]

포트포워딩

하나의 공용 아이피 주소를 가진 공유기가 자신의 포트를 통해 올바른 사설 아이피 주소를 가진 디바이스에게 데이터를 주는 것

포트 포워딩의 포트와 소켓에서 포트는 서로 연관이 없음!

pubic subnet

VPC 서브넷 중 외부와 통신이 원활하게 되는 서브넷 대역

private subnet

외부와 통신이 되지 않는 서브넷 대역

npm add swagger-autogen swagger-ui-express

swagger 세팅

import swaggerAutogen from "swagger-autogen" 
import swaggerUiExpress from "swagger-ui-express"

app.use(
  "/docs",
  swaggerUiExpress.serve,
  swaggerUiExpress.setup({}, {
    swaggerOptions: {
      url: "/openapi.json",
    },
  })
);

app.get("/openapi.json", async (req, res, next) => {
  // #swagger.ignore = true
  const options = {
    openapi: "3.0.0",
    disableLogs: true,
    writeOutputFile: false,
  };
  const outputFile = "/dev/null"; // 파일 출력은 사용하지 않습니다.
  const routes = ["./src/index.js"];
  const doc = {
    info: {
      title: "UMC 7th",
      description: "UMC 7th Node.js 테스트 프로젝트입니다.",
    },
    host: "localhost:3000",
  };

  const result = await swaggerAutogen(options)(outputFile, routes, doc);
  res.json(result ? result.data : null);
});

아래는 경로가 없는 미들웨어 함수이기 때문에 이 함수는 모든 경로, 모든 HTTP 메서드 요청에 대해서 실행된다

const myLogger = (req, res, next) => {
    console.log("LOGGED");
    next(); // 다음 미들웨어 또는 라우트 핸들러로 제어를 넘김
}

**app.use**(myLogger); 

/* ----> 위에 두 개의 코드를 하나로 합친 것이다. 
app.use((req, res, next) => {
    console.log("LOGGED");
    next();         
});
*/

'/' 경로로 들어오는 모든 HTTP 요청에 대해 실행되는 미들웨어 함수는 app.use()와 '/'를 이용한다.

**app.use('/'**, (req, res, next) => {
  console.log('Request Type:', req.method)
  next();
});

'/' 경로로 들어오는 GET 요청에 대해 실행되는 미들웨어 함수는 app.get() 과 '/' 를 이용한다.

app.get('/', (req, res) => {
    console.log("/");
    res.send("Hello UMC!");
}

Express 미들웨어 (next())

next() 는 다음 미들웨어 함수 or 해당 라우트 핸들러로 제어를 넘기는 함수이다. 따라서 next()를 호출하지 않으면 요청이 다음 단계로 진행되지 않는다.

const myLogger = (req, res, next) => {
  console.log("LOGGED");
  // next();
}

app.use(myLogger);

app.get('/', (req, res) => {
  console.log("/");
  res.send("Hello UMC!");
});

app.get('/hello', (req, res) => {
  console.log('/hello');
  res.send('Hello world!');
});

next() 를 주석처리 했더니 '/' 경로로 요청을 해도 LOGGED만 출력되고 '/hello' 경로로 요청을 해도 LOGGED만 출력되는 것을 확인했다.

즉, app.use(myLogger)미들웨어만 실행되고 이후에 실행되어야 할 라우트 핸들러는 실행되지 않는 것이다. 이렇게 되면 res.send() 코드가 실행되지 않아 응답이 전송되지 않고 이로 인해 무한 로딩 상태 or 타임 아웃으로 끝난다.

Error 처리

export const handleMemberSignUp = async (req, res, next) => {
  console.log("회원가입을 요청했습니다!");
  console.log("[MemberController] request body:", req.body); // 값이 잘 들어오나 확인하기 위한 테스트용

  const member = await memberSignUp(bodyToMember(req.body)); 
  // res.status(StatusCodes.OK).json({ 
  //   resultType: "SUCCESS",
  //   error: null,
  //   success: member,
  // });

  res.status(StatusCodes.OK).success(member);
};

member.service.js

member 저장 + preference 저장 두 db 작업을 트랜잭션을 사용하여 하나로 묶었다. 해당 트랜잭션 함수를 repository 계층으로 분리하는 작업은 이후에 리팩토링 할 예정이다.

export const memberSignUp = async (data) => {
  try{
    const result = await prisma.$transaction(async (tx) => {
      // 1. 이메일 중복 검사
      const existing = await tx.member.findFirst({where:{email:data.email}});
      if(existing)
        throw new error("이미 존재하는 이메일입니다.");
      // 2. member 생성
      const created = await tx.member.create({
        data:{
          email: data.email,
          name: data.name,
          gender: data.gender,
          age: data.age,
          address: data.address,
          specAddress: data.specAddress,
          phoneNumber: data.phoneNumber,
        }
      });

      const memberId = created.id;

      // 3. member_prefer 생성 
      for (const categoryId of data.preferences) {
        await tx.memberPrefer.create({
          data: {
            memberId: memberId,
            categoryId: categoryId,
            createdAt: new Date(),
            updatedAt: new Date(),
          },
        });
      }
      // 4. member + member_prefer 정보 조회 
      const member = await tx.member.findUnique({ where: { id: memberId } });
      const preferences = await tx.memberPrefer.findMany({
        where: { memberId },
        orderBy: { categoryId: 'asc' },
        select: { categoryId: true }
      });

      return responseFromMember({ member, preferences });
    });

    return result;

  } catch(error) {
    // rollback
    console.error("회원가입 실패: ", error.message);
    throw error;
  }

GET /api/member

• prisma 라이브러리 설치

  npm install @prisma/client prisma

• prisma 설정 파일 만들기

  npm exec prisma init

  

  // .env
  // 나의 mysql정보를 넣으면 됨 
  DATABASE_URL="mysql://<DB_USER>:<DB_PASSWORD>@<DB_HOST>:<DB_PORT>/<DB_NAME>"

• schema.prisma 수정

  //prisma/schema.prisma
  generator client {
      provider = "prisma-client-js"
  }
  
  datasource db {
      provider = "mysql"
      url = env("DATABASE_URL")
  }

• Member 모델 추가

  // prisma/schema.prisma
  
  model Member {
    id            Int       @id @default(autoincrement())
    name          String?   @db.VarChar(20)
    gender        String?   @db.VarChar(10)
    age           Int?
    address       String?   @db.VarChar(40)
    specAddress   String?   @map("spec_address") @db.VarChar(40)
    phoneNum      String?   @map("phone_num")    @db.VarChar(13)
    status        String?   @db.VarChar(15)
    inactiveDate  DateTime? @map("inactive_date") @db.DateTime(6)
    socialType    String?   @map("social_type")   @db.VarChar(10)
    createdAt     DateTime? @map("created_at")    @db.DateTime(6)
    updatedAt     DateTime? @map("updated_at")    @db.DateTime(6)
    email         String?   @db.VarChar(50)
    point         Int?
  
    @@map("member")
  }
  

• prisma의 schema 파일 수정시 자동으로 서버 재시작하도록 설정

  // package.json
  // nodemon 수정
  "dev": "nodemon -e js,json,prisma --exec \"prisma generate && node src/index.js\"" 

• 다른 코드 전체에서 공유하도록 설정

  // src/dbConfig.js
  import { PrismaClient } from "@prisma/client";
  
  export const prisma = new PrismaClient();

• 데이터 하나 찾기

  await prisma.member.findFirst({ 
    where: { id: 1 } 
  });

• 데이터 생성하기

  await prisma.user.create({
    data: {
        name: "엘빈",
        email: "test@example.com",
        ...,
      }
  });
  

• addUser 함수를 ORM을 사용하도록 수정

  // src/member.repository.js
  
  **import { prisma } from "../db.config.js"; // prisma 임포트** 
  
  export const addUser = async (data) => {
    const user = await prisma.user.findFirst({ where: { email: data.email } });
    if (user) {
      return null;
    }
  
    const created = await prisma.user.create({ data: data });
    return created.id;
  };
  

• addMember를 ORM으로 바꾼 후 첫 API Test

1. github 라벨 생성

2. github 이슈 생성

3. 생성한 이슈에 branch 생성

   git fetch origin
   git checkout feature/create-article-api

4. .gitignore 설정

5. .env 설정

   // .env
   PORT=3030

   // src/index.js
   import dotenv from "dotenv"
   dotenv.config(); // .env파일을 읽어와서 process.env에 저장
   const port = process.env.PORT;
   
   console.log("현재 포트:", process.env.PORT);

6. db 연결

   // .env
   DB_HOST=localhost
   DB_PORT=3306
   DB_USER=root
   DB_PASSWORD=mysql3143
   DB_NAME=mission_db

   // src/db.config.js
   import mysql from "mysql2/promise";
   import dotenv from "dotenv";
   
   dotenv.config();
   
   export const pool = mysql.createPool({
    host: process.env.DB_HOST || "localhost", // mysql의 hostname
    user: process.env.DB_USER || "root", // user 이름
    port: process.env.DB_PORT || 3306, // 포트 번호
    database: process.env.DB_NAME || "mission_db", // 데이터베이스 이름
    password: process.env.DB_PASSWORD || "mysql3143", // 비밀번호
    waitForConnections: true,
    // Pool에 획득할 수 있는 connection이 없을 때,
    // true면 요청을 queue에 넣고 connection을 사용할 수 있게 되면 요청을 실행하며, false이면 즉시 오류를 내보내고 다시 요청
    connectionLimit: 10, // 몇 개의 커넥션을 가지게끔 할 것인지
    queueLimit: 0, // getConnection에서 오류가 발생하기 전에 Pool에 대기할 요청의 개수 한도
   });
   

7. /api/user요청 데이터

   {
      "name": "이름",
      "gender": "여성/남성",
      "age": "23",
      "birth": "20030315",
      "address": "주소",
      "specAddress": "세부주소",
      "email": "이메일",
      "categories": ["도시락", "고기"]
   }

8. DTO 구현 (responseFromUser )

   export const responseFromUser = ({ member, preferences }) => {
    return {
      id: member.id,
      email: member.email,
      name: member.name,
      gender: member.gender,
      age: member.age,
      address: member.address,
      specAddress: member.spec_address,
      phoneNumber: member.phone_num,
      preferences: preferences.map(p => p.category_id)
    };
   };

9. API test(/api/user)

미션 인증

Issue: 5주차 mission branch: feature/chapter-05

1. 특정 지역에 가게 추가하기 API

• post 요청
• store 테이블, region테이블
• 이미 저장되어있는 지역에 해당하는 가게를 추가
• 프론트가 regionId를 넘겨주면 백이 해당 id에 해당하는 지역에 가게 추가

  // request body 
  {
     "regionId": 1,
     "name": "마포곱창",
     "address": "서울시 마포구 합정동 123",
     "score": 4.5
  }

• 검증 사항
  • 요청된 regionId가 region 테이블의 id에 포함되어있는 숫자인지
  • 검증사항을 통과했으면
  • store테이블에 요청 데이터 저장
  • store테이블에 저장된 데이터들을 사용자에게 반환

2. 가게에 리뷰 추가하기 API

• post 요청
• review 테이블, review_image테이블

3. 가게의 미션을 도전 중인 미션에 추가(미션 도전하기) API

• post 요청
• member_mission 테이블 <이미 도전 중인 미션> <이미 완료된 미션> <새로 도전하는 미션>

1. Service-Oriented Architecture(Service Layer Pattern)

Controller - Service Layer - Data Access Layer (Repository Layer)

• Controller: 단순히 요청과 응답 역할만 한다(라우팅 역할)
• Service Layer: Controller로 부터 전달된 요청에 대한 로직을 적용하는 계층
• Data Access Layer(Repository Layer): Service계층에서 데이터베이스 접근이 필요한 경우 데이터에 대한 코드가 작성되는 계층

2. MVC 패턴

Controller - Model - View

• Controller: 요청과 응답 역할과 필요한 로직을 수행한다.
• Model: 데이터, 비즈니스 로직 담당
• View: 사용자가 보게 될 화면 담당(HTML 또는 템플릿 파일에 데이터를 삽입하여 컨트롤러에게 넘긴다)

MVC와 SOA의 차이점

3. 그 외 다른 프로젝트 구조

1. Clean Architecture
2. Microservices Architecture
3. RESTful Architecture
4. Service Layer Pattern
5. Event-Driven Architecture

비즈니스 로직

비즈니스 로직은 지켜야 할 도메인 규칙을 코드로 옮긴 부분이다.

규칙이란, 사용자가 무언가를 요청했을 때 허용할지 말지, 어떻게 처리할지를 정하는 조건과 계산이다.

ex)

• 주문은 얼마 이상이어야 한다
• 재고 없으면 주문 불가
• 관리자만 삭제할 수 있다
• 무료배송은 3만원 이상부터

SOA 아키텍처에서 비즈니스 로직은 대부분 Service계층에서 작성된다

DTO

DTO(Data Transfer Object)는 계층 간 또는 외부로 데이터를 전달할 때, 필요한 정보만 안전하게 담는 전용 객체이다.

• DTO를 사용하는 이유

  1. 필요한 데이터만 보내기 위해(DB 모델은 너무 많은 정보가 있기 때문에 다 보낼 필요가 없음)

  2. 보안(민감한 정보 숨기기)

  3. 계층 간 역할 분리 (도메인 모델vs전송 모델)

  4. API 응답 형식 통일

     ex) 유저 정보 응답

  User 모델 (전체 정보)

    // models/User.js
    const User = {
      id: 1,
      name: "홍길동",
      password: "secret123",
      email: "gildong@example.com",
      role: "admin",
      createdAt: "...",
      updatedAt: "..."
    };

  프론트에 필요한 정보만 주기 위해 DTO 객체를 사용한 예시

    // dtos/UserDTO.js
    class UserDTO {
      constructor(user) {
        this.id = user.id;
        this.name = user.name;
        this.email = user.email;
      }
    }
  
    module.exports = UserDTO;
  

ES (Ecma Script) : ECMA international에서 정한 자바스크립트의 표준, 규격

ES는 버전이 계속 업데이트되어 ES5, ES6 등등의 버전이 있다.

ES6이후로도 업데이트가 되고있지만, ES6가 가장 큰 변화를 가져온 버전이기 때문에 중요하게 다뤄진다.

ES6

ES6의 주요 변화 및 특징

1. let과 const도입

   var의 단점을 보완하기 위해 let과 const를 도입했다.

   • var (문제점 3가지)

     • 스코프 범위가 function

         if(true){
             var a =10;
         }
         console.log(a); // 10 (블록 밖에서도 접근이 가능하여 문제 발생 가능) 

     • 중복 선언 가능

         var name = "cindy";
         var name = "chill"; // 중복 선언 가능하여 문제 발생 가능 

     • Hoisting이 가능

       Hoisting이란, 인터프리터가 코드를 실행하기 전에 함수, 변수, 클래스 또는 임포트(import)의 선언문을 해당 범위의 맨 위로 끌어올리는 것처럼 보이는 현상이다.

       그래서 아래 코드처럼 아직 선언되지도 않은 변수를 사용할 수 있는 현상이 발생한다.

         console.log(name); // undefined(->원래 오류가 나야 정상인데, 변수를 인식하고있음) 
         var name = "cindy"
         console.log(name); // cindy

   • let

     • 스코프 범위가 중괄호이다(for, if, function)

         if (true) {
           let b = 20;
         }
         console.log(b); // 오류 발생 (b는 블록 안에서만 유효)

     • 재할당 가능

     • 중복 선언 불가능

   • const

     • 스코프 범위가 중괄호이다(for, if, function)
     • 재할당 불가능
     • 중복 선언 불가능

2. 화살표 함수 (Arrow Functions)가 추가됨 표기: ⇒

   화살표 함수는 동적으로 this가 바인딩 되지 않고 고정되어서 버그가 줄어든다.

   참고) this의 동적 vs 정적

   • 동적인 this

     예시 ) 일반함수

     const person = {
       name: "Alice",
       greet: function() {
         function innerFunc() {
           console.log(this.name); // this == window
         }
         innerFunc(); // 일반함수로 호출됨 
       }
     };
     
     person.greet(); // undefined 또는 에러(window.name이 없음)

   • 정적인 this

     예시) 화살표 함수

       const person = {
         name: "Bob",
         greet: function() {
           const arrowFunc = () => {
             console.log(this.name); // this == person객체
           };
           arrowFunc(); // 화살표함수로 호출됨
         }
       };
     
       person.greet(); // Bob

3. 클래스 문법 제공 이전에는 prototype 기반이었지만 이젠 클래스 기반으로 더 직관적인 객체 생성 가능 !

    class Animal {
      constructor(name) {
        this.name = name;
      }
   
      speak() {
        console.log(`${this.name}이(가) 소리를 낸다.`);
      }
    }
   
    const dog = new Animal('강아지');
    dog.speak(); // 강아지가 소리를 낸다.

4. 템플릿 리터럴 (백틱)

   이전에는 문자열을 이어붙일 때 +를 썼지만 이젠 백틱(````)과 ${} 문법 사용 가능

    const name = '철수';
    const age = 20;
   
    const message = `안녕하세요, 제 이름은 ${name}이고 나이는 ${age}살입니다.`;
    console.log(message);

5. 구조 분해 할당 (Destructuring) 배열이나 객체에서 필요한 값을 변수로 꺼내기 쉽게 해준다.

    // 배열
    const [x,y] = [1,2];
    console.log(x); // 1
   
    // 객체
    const person = {name: "아린", age: 25};
    const { name, age } = person;
    console.log(name); // 아린

6. 스프레드 연산자 … 배열/객체를 복사하거나 병합할 때 사용한다.

   함수 인자처럼 펼쳐 쓸 수도 있다.

     const arr1 = [1,2];
      const arr2 = [...arr1, 3, 4];
      console.log(arr2); // [1,2,3,4]
   
      const user = {name:"아린"};
      const newUser = {...user, age:25};
      console.log(newUser); // { name: '아린', age: 25 }

7. *기본 매개변수 * 함수에 인자를 안 넣으면 사용되는 기본 값 설정 가능

   function greet(name = "손님") {
      console.log(`안녕하세요, ${name}님!`);
   }
   
   greet(); // 안녕하세요, **손님**님!
   greet("아린"); // 안녕하세요, 아린님!

8. Promise (비동기 처리) then, catch로 콜백 지옥을 피하게 도와주는 기능이다.

   const fetchData = new Promise((resolve, reject) => {
    const success = true;
    if (success) {
      resolve("데이터 성공!");
    } else {
      reject("에러 발생!");
    }
   });
   
   fetchData.then(data => console.log(data)).catch(err => console.error(err));

9. 모듈(import, export) 파일을 분리해서 코드를 재사용하기 쉽게 만들었다

    // math.js
    export const add = (a, b) => a + b;
   
    // app.js
    import { add } from './math.js';
    console.log(add(3, 4)); // 7

10. Symbol 고유한 값을 만들기 위한 유일한 키

    → 다른 키와 절대 충돌 안나게 할 때 사용

    const id = Symbol('id');
    const user = {[id]:123};
    
    console.log(user[id]); // 123

11. Set / Map

    • set: 중복없는 값들의 모음
    • Map: 키-값 쌍을 저장하는 자료구조

      const set = new Set([1, 2, 2, 3]);
      console.log(set); // Set { 1, 2, 3 }
      

    const map = new Map(); map.set('name', '아린'); map.set('age', 25); console.log(map.get('name')); // 아린

    ### ES6를 중요시 하는 이유
    ES6는 JavaScript 코드의 효율성, 가독성, 유지보수성을 높여주는 핵심적인 변화를 가져왔기 때문에 현대 JavaScript 개발의 표준이라고 할 수 있다.  
    

ES Module

ES Module이란 import와 export를 통해 모듈을 관리할 수 있게 해주는 시스템이다.

<사용법>

1. package.json에 "type":"module" 설정

{
    "type": "module"
}

2. .mjs 확장자 , import 구문 사용

   a. 내보내기

    // math.js
    export const add = (a, b) => a + b;
    export const subtract = (a, b) => a - b;

   b. 가져오기

    // app.js
    import { add, subtract } from './math.js';
   
    console.log(add(2, 3)); // 5
    console.log(subtract(5, 3)); // 2

내가 작성한 API 명세서에 대한 피드백

1. API URL에 user id로 사용자 정보에 접근하는 방식으로 했는데, 이는 보안상 좋지 않은 방법이므로 JWT 토큰에서 user id를 추출하는 방식 활용하기

2. RESTful API 원칙에 따라 단수형이 아닌 복수형으로 사용하고, 명사 중심으로 설계하기

3. 미션 성공 누르기 API

   • 현재 파라미터로 PATCH 요청을 구현했는데, RESTful API 원칙, 일관성 등등 여러 측면에서 Request Body로 구현하는 게 더 적합

     • 주로 GET은 파라미터로
     • POST, PUT, PATCH는 Request Body로 전달

• join의 종류
  • Inner Join
  • Outer Join
    • Left Join
    • Right Join
    • Full Join

Inner Join

두 테이블의 공통된 부분만 가져올 때 사용

아래는 해시태그가 UMC인 책의 이름을 가져오는 쿼리문

select b.* 
from book as b
inner join book_hash_tag as bht on b.id = bht.book_id
inner join hash_tag as ht on bht.hash_tag_id = ht.id
where ht.name = "UMC";

Outer Join

교집합 외부에 존재하는 데이터를 가져올 때 사용 Left 조인이 일반적으로 가장 많이 사용됨

아래는 left join을 그림으로 표현한 이미지.

이처럼 모든 좌측 테이블을 가져오되, 조인 불가능한 것은 NULL로 채운다.

pagination (limit, offset)

아래는 offset을 이용해 최신순 정렬을 구현한 쿼리문

select * from book 
order by created_at desc
limit 15 offset 0;

• limit: 가져올 데이터의 양
• offset: 가져올 데이터의 초기 위치 값
• 즉, limit 15 offset 0 은 0에서부터 15개의 데이터를 가져오라는 뜻이다.

pagination (cursor)

cursor: 마지막으로 조회한 컨텐츠를 의미

아래는 cursor를 이용해 최신순 정렬을 구현한 쿼리문

Ex) 마지막으로 본 book_id가 3일 때 , 해당 아이디의 책이 생성된 날짜 이전(created_at < )의 책들을 내림차순으로 정렬하여 최근에 생성된 책부터 15권을 출력하라

select * from book 
where created_at < (select created_at from book where id = 3)
order by created_at desc;

🎯미션 기록

1. 내가 진행중, 진행 완료한 미션 모아서 보는 쿼리(페이징 포함)

   select * from user_mission um
   where status = "progress" or status = "complete"
   limit ? offset (?-1)*?; 

2. 리뷰 작성하는 쿼리,

• 사진의 경우는 일단 배제

  insert into review (user_id, restaurant_id, rating, body, created_at, updated_at) 
  values(?, ?, ?, ?, now(), now());

3. 홈 화면 쿼리 (현재 선택 된 지역에서 도전이 가능한 미션 목록, 페이징 포함)

   select *
   from mission as m 
   join user_mission as um on m.id = um.mission_id
   join restaurant on um.restaurant_id = restaurant .id
   join region on region.id = restaurant.region_id
   where region.name = ?
   limit ? offset(?-1)*?;

4. 마이 페이지 화면 쿼리

   select * from user;

1. 카카오 소셜 로그인을 구현 할 예정이다.
2. 회원 탈퇴 기능이 필요하다.
3. 이름, 닉네임, 전화번호, 성별이 필요하다.

책 관련 요구 사항

1. 사용자가 책 여러 권을 대여할 수 있다.
2. 책은 하나의 카테고리가 있다.
3. 책은 제목, 설명에 대한 정보가 필요하다.
4. 책 소개 페이지에 해시태그가 붙을 수 있고,

책 한 권에 해시태그 여러 개가, 해시태그 하나가 여러 책에 붙을 수 있다. 5. 사용자가 책 설명 페이지에서 책에 좋아요를 누를 수 있다. 6. 책 카테고리 별로 현재 몇 개의 책이 있는지 집계가 필요하다.

알림 관련 요구 사항

1. 알림은 공지 관련 알림, 책 반납 시간 임박 알림, 마케팅 알림이 있을 수 있다.

아래는 요구사항에 대한 나의 테이블 설계도이다.

<소셜로그인 테이블>
소셜아이디
사용자아이디(pk)


<사용자 테이블>
사용자아이디(pk)
닉네임
전화번호
성별
활성화 여부

<책 테이블>
책 아이디(pk)
카테고리
제목
설명

<해시태그>
태그아이디(pk)
태그이름


<책-태그 테이블>
책아이디(fk)
태그아이디(fk)

<사용자-책 좋아요 테이블>
사용자아이디(fk)
책아이디(fk)

<알림 테이블>
알림아이디(pk)
알림 카테고리(종류: 공지, 반납 시간 임박, 마케팅)
알림 내용

user 테이블

agree 테이블 (이용약관)

user_agree 테이블

food_category 테이블

favorite_food 테이블

restaurant 테이블

mission 테이블

user_mission 테이블

review 테이블

review_image 테이블

user_point 테이블

인터넷 통신은 end system 간 패킷을 주고받는 방식으로 이루어진다.
클라이언트(end system)는 요청을 보낼 때 패킷에 최종 목적지의 IP 주소를 담아 네트워크로 전송한다.

패킷을 받은 라우터는 패킷 안에 있는 목적지 IP 주소를 확인한 후,
라우팅 테이블을 참조하여 다음 홉(next hop)으로 패킷을 전달한다.

패킷이 최종 목적지 호스트(end system)에 도달하면
Network Layer에서 Transport Layer로 전달되고,
최종적으로 애플리케이션이 데이터를 처리한다.

OSI 7 Layer 참고

같은 IP 내에서 여러 프로세스를 구분하기 위해
Transport Layer는 포트 번호(port number)를 사용한다.

같은 IP 주소를 사용하더라도

• port 80
• port 443
• port 3306

과 같이 포트 번호에 따라 서로 다른 애플리케이션 동작을 수행한다.

인터넷 통신 과정에서는 여러 문제가 발생할 수 있다.

1. 만약 상대의 컴퓨터가 꺼져 있다면?
2. 만약 중간에 패킷이 소실된다면?
3. 뒤에 보낸 패킷이 먼저 도착한다면?

이러한 문제들은 TCP를 통해 해결할 수 있다.

TCP

1. 상대의 컴퓨터가 꺼져 있다면?

최종 목적지의 컴퓨터가 꺼져 있다면 패킷을 받을 수 없다.
따라서 패킷을 보내기 전에 클라이언트는
목적지 IP의 특정 포트에서 TCP 프로세스가
연결을 수락할 수 있는 상태인지 확인한다.

이때 사용되는 과정이 3-way handshake이다.

클라이언트는 서버에 SYN 패킷을 전송하고,
서버의 응답에 대해 ACK 패킷을 전송하면
3-way handshake가 완료된다.

이를 통해 서로 통신을 시작할 준비가 되었음이 확인된다.

2. 중간에 패킷이 소실된다면?

TCP는 ACK를 통해 수신 여부를 확인한다.
일정 시간 동안 ACK가 도착하지 않으면
해당 패킷이 소실되었다고 판단하고 재전송을 수행하여
데이터 전달을 보장한다.

3. 뒤에 보낸 패킷이 먼저 도착한다면?

패킷의 크기가 큰 경우 데이터는 여러 개로 쪼개져 전송되며,
이 과정에서 뒤에 보낸 패킷이 먼저 도착할 수 있다.

TCP는 이 문제를 sequence number로 해결한다.
각 패킷에 순서 번호를 부여하여 전송하고,
수신 측은 이를 기반으로 데이터를 재정렬한다.

만약 중간에 누락된 패킷이 있다면
해당 패킷에 대해 재전송을 요청하여 문제를 해결한다.

UDP

UDP는 신뢰성보다 속도를 우선하는 프로토콜이다.

UDP는 TCP와 달리

• 3-way handshake
• 데이터 전달 보증
• 순서 보장

을 제공하지 않는다.

기존 IP 위에 포트 번호와 체크섬 등
최소한의 헤더만 추가한 프로토콜로,
TCP에 비해 신뢰성은 낮지만 빠르다는 장점이 있다.

정리하면,
IP는 전달을 담당하고
TCP는 신뢰성을 보장하며
UDP는 속도를 우선한다.

Web Server와 WAS

Web Server

Web Server는 html, css, 이미지와 같은 정적 리소스를 처리해주는 서버를 말한다. 대표적으로는 Apache, Nginx 등이 있다.

WAS

WAS는 DB 조회, 로직 처리와 같은 동적 리소스를 처리해주는 서버를 말한다. 대표적으로는 Spring Boot의 내장 서버인 Tomcat이 있다.

WAS는 동적 리소소뿐만 아니라 정적 리소스까지 처리할 수 있다. 그러나 현재 Web Server를 많이 쓰고있다.

왜그럴까?

이는 비용, 보안 측면에서 여러 이유가 있다. 이건 추후에 다뤄보도록 하겠다.

실습 인증

🔗문제 링크 바로가기

이 문제는 질문 이해가 관건인 것같다. 본문만 이해하면 구현하는건 크게 무리가 없는 것같다. 아래에 내가 헷갈렸던 부분을 정리해놨다.

• 로봇이 올라갈 때마다 해당 칸의 내구도가 1씩 감소한다.
• 로봇은 뒤쪽 컨베이어벨트 칸에 올라갈 수 없다. 따라서 로봇은 0~(N-1)번째 칸에만 존재할 수 있다. 따라서 로봇이 (N-1)번째 칸에 올라가면 내려줘야한다. 왜그러냐고 물으면 이유는 없다. 그냥 문제 조건일 뿐이다...

<각 단계> - 1단계: 벨트가 회전하면 로봇도 그에 따라 회전한다. - 2단계: 앞 칸이 비어있으면 로봇은 스스로 이동한다. - 3단계: 0번째 칸에 로봇을 올린다(올릴 수 있으면)

• 각 단계별로 회전을 무한대로 하는 것이 아니라 1단계에서 1칸씩 이동하면 2단계로 넘어가서 이동할 수 있는 로봇들은 1칸씩 이동한다. 그리고 3단계로 넘어가 하나의 로봇을 올리는 것이다.

from collections import deque
import sys
input = sys.stdin.readline

N, K = map(int, input().split())
A = deque(list(map(int, input().split()))) # 내구도
robots = deque([0] * N) # 로봇 위치(앞쪽 N칸만)

step = 0

while True:
    step += 1

    # 1. 벨트 + 로봇 회전
    A.rotate(1) # 벨트 회전
    robots.rotate(1) # 벨트가 회전함에 따라 로봇도 같이 회전
    robots[-1] = 0 # 내리는 위치에서 로봇 제거

    # 2. 로봇 이동(앞 칸이 비어있으면 스스로 이동)
    for i in range(N-2, -1, -1): # 뒤에서부터
        if robots[i] == 1 and robots[i+1] == 0 and A[i+1] > 0:
            robots[i] = 0
            robots[i+1] = 1
            A[i+1] -= 1

    robots[-1] = 0 # 내리는 위치에서 로봇 제거

    # 3. 올리는 칸에 로봇 올리기
    if A[0] > 0 and robots[0] == 0:
        robots[0] = 1
        A[0] -= 1

    # 4. 내구도 0인 칸의 개수 세기
    if A.count(0) >= K:
        break

print(step)

문제

morgan 라이브러리를 추가하고 main에 반영했더니 깃헙 Action에서 컨테이너가 unhealthy해서 배포가 실패했다고 떴다.

ssh 접속하여 docker ps로 확인해보니 컨테이너 상태가 Restarting으로 표시되었다. 원래는 healthy로 표시되어야 한다.

원인

내가 작성한 docker-compose.yml를 보면, 사용자가 수동으로 stop하기 전까지 컨테이너를 재시작하라는 명령어 때문에 계속 restart 상태였던 것같다. 자세한 로그를 살펴보기 위해 sudo docker logs myapp로 로그를 출력해보니 morgan 모듈을 찾지 못했다는 에러가 떴다.

내가 코드에서 morgan을 사용했고, 서버는 해당 모듈을 node_modules에서 찾으려 했는데 devDependencies로만 설치하고 production 환경에서는 설치가 안되어서 서버가 찾지 못한 것이다. 이 에러 때문에 프로세스가 종료되고 컨테이너가 계속 restart 하려고 했던 것이다.

해결

dev용 모듈과 production용 모듈을 구분하여 설치한다.

pnpm install express morgan
pnpm install @types/morgan --save-dev

만약 해당 모듈을 사용하는 코드를 배포 하고싶다면, 첫 번째 명령어로 설치해야한다. 기존에는 두 번째 명령어만 작성해서 인식을 못했던 것이다.