김영한님의 모든 개발자를 위한 HTTP웹 기본지식 강의를 듣고 요약했습니다.

지금은 HTTP 시대

HTML 문서를 연결하는 프로토콜로 시작했다.
HTML, IMAGE, 음성, 영상, 파일, JSON ... 모두 HTTP 를 쓴다.
서버간에 데이터를 주고 받을 때도 대부분 HTTP를 사용한다.

HTTP 역사

HTTP 1.1 에 대해 공부하는 것이 중요하다.
대부분의 기능과 내용이 1.1에 있기 때문이다. 2와 3은 성능 개선 관련이고 상대적으로 내용이 적다.

HTTP 1.1 - 가장 많이 사용, 우리에게 가장 중요한 버전
HTTP 2 - 2015 성능 개선
HTTP 3 - 성능 개선을 위해 TCP 대신에 UDP 사용

HTTP의 기반 프로토콜

TCP기반으로 동작: HTTP/1.1, HTTP/2
UDP기반으로 동작: HTTP/3

현재 HTTP 1.1 을 주로 사용하고 있지만, HTTP2, 3도 점점 늘어나고 있다.

HTTP 특징

4가지 특징에 대해 이해해보자.

• 클라이언트 서버 구조

• 무상태 프로토콜(stateless)
• 비연결성
• HTTP 메시지로 요청/응답

클라이언트 서버 구조

클라이언트와 서버를 분리하는 것이 매우 중요하다. (예전에는 안그랬다)

• Request Response 구조
• 클라이언트는 서버에 요청을 보내고, 응답을 기다린다.
• 서버는 요청에 대한 응답 메시지를 만들어서 보내준다.

클라이언트와 서버를 분리하는 것의 장점?

비즈니스 로직과 데이터를 전부 서버가 관리한다.
클라이언트는 UI와 사용성에 집중할 수 있다.
클라이언트가 PC만 서비스 하다가 Phone 이 필요해지면, application에 필요한 UI를 새로 만드는 것에 집중하면 된다. 클라이언트가 비즈니스 로직을 고민할 필요 없다.

클라이언트/서버가 분리된 구조를 통해 각각 독립적으로 진화할 수 있다는 것이 장점이다.

무상태 :stateless

서버가 클라이언트의 상태를 보존하지 않는다.
컨텍스트(context)를 모른다.

상태유지 무상태 이해를 위한 예시

고객이 물건을 구매할 때 점원과 대화하는 상황을 상상해보자.
고객은 클라이언트이고, 점원은 HTTP 서버 역할과 같다.

상태유지(stateful) 예시

고객 "이 노트북 얼마인가요?"
점원A "100만원 입니다."

고객 "2개 구매할께요."
점원A **"200만원 입니다. 신용카드, 현금 중에 어떤 걸로 결제하시나요?" **

-> 점원이 상황의 문맥(context)를 알고 있다.
따라서 점원은 100만원 x 2개 = "200만원 입니다." 라고 대답해줄 수 있다.

무상태(stateless) 예시

고객 "이 노트북 얼마인가요?"
점원A "100만원 입니다."

고객 "2개 구매할께요."
점원B **" ?? 무엇을 2개 구매하시겠어요? " **

-> 점원이 상황의 문맥(context)을 모른다.
무상태라면, 고객이 요청할 때마다 새로운 점원이 고객을 응대하는 것과 같다.

[중요]stateful과 stateless 차이

상태유지

• 중간에 다른 점원으로 바뀌면 안된다.
• 항상 같은 서버가 유지되어야 한다.
• 클라이언트 A는 계속 서버1과 통신해야 한다.

무상태

• 서버가 장애가 나면? 중간에 다른 점원(서버)으로 바뀌어도 된다.
• 갑자기 고객이 증가해도 점원을 대거 투입할 수 있다.
• 갑자기 클라이언트 요청이 증가해도 서버를 대거 투입할 수 있다.

무상태의 강점은 서버1이 장애 나도 서버2가 대신 응답해줄 수 있다는 것이다.
서버가 클라이언트의 상태를 저장하지 않기 때문이다.
스케일 아웃 즉, 수평 확장에 유리하다.

[중요] stateless의 실무 한계

모든 것을 무상태로 설계 할 수도 있는 경우도 있고 없는 경우도 있다.

• 무상태 : 로그인이 필요 없는 단순한 서비스 소개 화면
• 상태유지: 로그인한 사용자의 경우.

    결제 과정이 필요하는 경우. 
    **브라우저 쿠키와 서버 세션 등을 사용해서 상태를 유지한다. **

무상태와 상태유지는 전송 데이터의 양에 차이가 있다.
상태 유지 시, 데이터의 양이 더 적을 수 있다.

따라서 ‘상태 유지’는 최소한만 사용해서 개발하자.

무상태(stateless)는 데이터 전송량이 좀 더 많다.
애플리케이션 설계 시, 되도록이면 무상태로 설계하는 것이 좋다.

비연결성

HTTP는 기본이 연결을 유지하지 않는 모델이다.
일반적으로 초 단위 이하의 빠른 속도로 응답한다.

연결을 유지하면?

클라이언트가 서버와 연결 유지하면 계속 서버가 자원을 소모하고 있게 된다.

연결을 유지하지 않으면?

요청/응답 만 하고, 연결을 끊어버려서 최소한의 자원만 사용한다.

비 연결성의 한계와 극복

1. 비연결성 이라면, 요청을 보낼 때 마다 TCP/IP 연결을 새로 맺어야 한다.

-> 3 way handshake 시간 추가된다.
사용자 입장에서는 시간이 단점이 된다.

2. 웹브라우저로 사이트를 요청하면 다운로드 받을 것이 많다.

HTML 뿐만 아니라 자바스크립트, css, image 등 많은 자원이 함께 다운로드 된다.

지금은 HTTP 지속 연결로 문제 해결

이전에는 HTML 응답, 이미지 응답, Javascript 응답.. 각각 연결해야 했었다.
하나의 페이지에는 HTML 말고도 이미지도 있고 여러개가 있는데, 하나 받을 때 마다 새로운 연결을 요청해야 했다.

이제는 Persistent connections 라는 지속 연결로 문제를 해결하고 있다.
한 번 연결이 되면, HTML와 이미지 여러개 등의 다운로드를 할 만큼의 시간동안 연결이 유지된다.
http/2, http/3에서 더 많은 최적화되고 있다.

stateless 를 기억하자

서버 개발자들이 가장 어려워하는 업무가 뭘까?

같은 시간에(일제히) 딱 맞추어 발생하는 대용량 트래픽에 대응하는 것이다.
ex) 명절 KTX예약, 수강신청, 선착순 이벤트

이것만 기억하자. "최대한 stateless 로 설계하자"
어떻게든 머리를 쥐어짜서 stateless로 설계해야 대응할 수 있다!

HTTP 메시지

요청 메시지와 응답 메시지 구조의 차이를 이해하자.

Request 요청 메시지

요청, URL, version
body 본문을 가질 수 있다.

HTTP 요청한것
헤더값
공백라인 CRLF
응답메시지

요청메시지에서 시작라인

start-line은 요청이냐 응답이냐에 따라 다르다.

요청메시지에서 시작라인은 request-line
응답메시지에서 시작라인은 status-line

요청메시지는 request-line이라고 한다.
request-line: method SP(공백) request-target SP. HTTP-version

(여기서 SP는 스페이스 라는 뜻이다. )

http 메서드 : 서버가 수행해야 할 동작 지정
종류 : GET, POST, PUT, DELETE…
GET: 리소스 조회
POST: 요청 내역 처리

요청대상 : 절대경로로 시작한다.
요청대상: 절대경로 “/“로 시작하는 경로

응답메시지의 시작라인

응답메시지의 시작라인은 status-line으로 되어 있다.

status-line 구성

HTTP-version SP
status-code SP
reason-phrase CRLF

(여기서 SP는 스페이스 라는 뜻이다. )

HTTP version: HTTP 1.1 / 2/3

HTTP 상태코드 : 요청의 결과를 의미한다.

200 성공
*400 클라이언트 요청 오류
500 서버 내부 오류 *
이유 문구: 사람이 이해할 수 있는 상태코드 설명글

HTTP 헤더

header-field: field-name:OWS
(OWS: 띄어쓰기 허용 )

HTTP 전송에 필요한 모든 부가정보를 포함한다.
HTTP 1.1을 기준으로 학습하자.

읽을 거리 :
MDN HTTP 개요

JPA에서 가장 많이 사용하는 관계가 N:1 이다. 

다대일 엔티티 관계를 2개의 객체를 통해 예시 코드를 정리했다. 

다대일 단방향 관계 시나리오

Member 객체와 Team 객체가 있다.

멤버는 팀에 속할 수 있다. 여러 멤버는 하나의 팀에 속할 수 있다.

하나의 팀에는 여러 멤버들이 속할 수 있다. 

Member 객체

package hellojpa;

import javax.persistence.*;

@Entity @Getter @Setter
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="member_id") // 실제 DB에 매핑할 칼럼명
    private Long id; // 객체에서 다룰 필드명

    @Column(name = "username")  
    private String name;  

    @ManyToOne //Member 객체 입장에서 '다'니까 ManyToOne
    @JoinColumn(name = "team_id") // Team객체에서 참조하는 DB매핑 칼럼명 'team_id'
    private Team team;
}

Team 객체

package hellojpa;

import javax.persistence.*;

@Entity @Getter @Setter
public class Team {

    @Id @GeneratedValue
    @Column(name="team_id")
    private Long id;
    private String name;
}

여러 멤버들이 하나의 팀에 속할 수 있으므로, 다대일 관계다. 

다대일에서, '다'에 외래키가 있어야 한다. 

따라서 Member 객체의 필드에서  Team 객체를 필드로 만들어서 참조하도록 만든다. 

관계형 DB의 ERD로 생각하면,  Member 테이블의 컬럼 하나가 team_id 를 FK로 가지게 된다. 

객체의 연관관계로 표현하려면, FK 가 아니라 객체 참조 필드를 쓰면 된다.

Member.team 참조필드로 다대일 단방향 연관관계를 맺을 수 있다.

이렇게 Member 객체가 Team 객체를 참조할 수 있다. 

다대일 양방향 관계 시나리오

이 팀에 속한 멤버들 목록을 알고 싶다. 

즉, Team 객체에서 List< Member> 를 필드로 가진다. 

단방향과의 차이 

단방향 : Member <- Team

양방향 : Member <- Team,   Team <- Member 단방향 관계 2개를 설정하면 양방향이다. 

단, DB의 ERD 관점에서 설계가 변하지 않는다. 

관계형 데이터베이스 에서는 FK하나를 가지고, 조인하면 두 테이블 모두를 자유롭게 조회할 수 있다. 

관계형 데이터베이스 테이블을 보면 '방향'개념이 없다. 

Member 객체

package hellojpa;

import javax.persistence.*;

@Entity @Getter @Setter
public class Member {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="member_id")
    private Long id;

    @Column(name = "username")
    private String name;  

    @ManyToOne // Member 엔티티 입장 중심으로 적는다.
    @JoinColumn(name = "team_id") // Team 엔티티에서 참조하는 실제컬럼명 (FK이름을) 적는다.
    private Team team;
}

Team 객체

package hellojpa;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
public class Team {

    @Id @GeneratedValue
    @Column(name="team_id")
    private Long id;
    private String name;

    @OneToMany(mappedBy = "team") // 일대다 매핑에서, 상대팀 엔티티의 어느 필드를(칼럼을) 참조하는지 적는다.
    private List<Member> members = new ArrayList<>();

    /** 연관관계 편의 메소드 Team이나 Member 한 쪽에만 구현하기! */
    public void addMember(Member member){
        member.setTeam(member.getTeam());
        members.add(member);
   }
}

연관관계의 주인이란?

연관관계의 주인은 '양방향' 연관관계에서 다루는 개념이다.

외래키를 사용하는 쪽이 연관관계의 주인이다. 

여기서, Member.team이 연관관계의 주인이다.

mappedBy속성에는 자신을 매핑하고 있는 주인엔티티의 칼럼명을 적어준다. (Member의 team)

주인이 아닌 쪽은 읽기만 가능하다. 그리고 mappedBy 속성으로 주인을 지정해줘야 한다.

연관관계 편의 메소드 

Member도 Team을 참조하고, Team도 Member를 참조한다.

그래서 값을 삽입할 때 헷갈리는 부분이 있다. 

양방향 연관관계에서, 한 쪽을 선택하여 연관관계 편의 메소드를 작성하자.

예를 들어, Member가 속한 Team을 세팅 해 줄 때, 반대편 Team에도 member가 속함을 세팅하자.

유지보수 편의를 위함이다.

1. Member 객체에 구현

Member를 추가할 때, 반대편에 Team 객체에도 members List에 새 멤버를 추가한다. 

public void changeTeam(Team team){
	this.team = team;
	team.getMembers().add(this); // 멤버 객체의 members에 '나 자신'을 추가한다.
}

2. Team 객체에 구현

Team 객체를 추가할 때 member 객체를 추가한다. 

    public void addMember(Member member){
        member.setTeam(member.getTeam());
        members.add(member);
   }

둘 중 한 곳에만 연관관계 편의 메소드를 작성하자. 양 쪽에 작성하면 버그 발생할 확률이 높다. 

1. (DB테이블 관점) 다중성 : 다대일, 일대다, 일대일, 다대다 
참고) 다대다는 실무에서 쓰면 안된다. 

2. 단방향? 양방향?

테이블

테이블은 FK 하나로 양 테이블을 조인할 수 있다. 따라서 방향이라는 개념이 없다. 

객체

객체는 참조용 필드가 있는 쪽으로만 참조 가능하다. 단방향 2개를 설정해야 양방향 관계를 만들 수 있다.

3. 연관관계의 주인 
외래키를 사용하는 쪽이 연관관계의 주인이다. 
연관관계의 주인은 양방향 연관관계에서 다루는 개념이다.
주인이 아닌 쪽은 읽기만 가능하다. 그리고 mappedBy 속성으로 주인을 지정해줘야 한다.

문제

구명보트 프로그래머스 level2

리뷰

이 문제의 핵심은 1명 또는 2명의 사람만 태울 수 있다는 것이다.

왜냐하면 제한사항이 구명보트의 무게 제한은 항상 사람들의 몸무게 중 최댓값보다 크게 주어지기 때문이다.

맨 앞을 가리키는 인덱스 변수와 맨 뒤를 가리키는 인덱스 변수를 둔다.

그리고 people 벡터를 정렬 한다.

int front = 0; // 맨 앞 인덱스 
int back = people.size() - 1;  // 맨 뒤 인덱스 

sort(people.begin(), people.end()); // 오름차순 정렬 [50, 50, 70, 80]  

양 끝 인덱스의 사람 무게 합이 무게제한보다 작다면,

양 끝 인덱스를 증가 및 감소시킨다. (front 증가 , back 감소 )

// 인덱스 변화 :  앞에서는 증가, 뒤에서는 감소 
if (people[front] + people[back] <= limit && (back-front >= 1) ) { 
    front++; back--;  
    // 2명을 태워 보낸 셈이니까 인덱스 차이가 (back-front >= 1)  만족해야 함.
}
else { // 뒤에 큰 값만 제거 
    back--;
}

코드

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int solution(vector<int> people, int limit) {

    int answer = 0; 
    int front = 0; // 맨 앞 인덱스 
    int back = people.size() - 1;  // 맨 뒤 인덱스 

    sort(people.begin(), people.end()); // 오름차순 정렬 

    while (front <= back) { //  양 끝 인덱스가 만날 때 까지 

        if (people[front] + people[back] <= limit && (back-front >= 1) ) {
            front++; back--;  // 인덱스 변화 :  앞에서는 증가, 뒤에서는 감소 
        }
        else { // 뒤에 큰 값만 제거 
            back--;
        }
        answer++;
    }

    return answer;
}

문제

징검다리 건너기 프로그래머스 level3

리뷰

완전 탐색으로 푸니까 정확도100점, 효율성0점이 나왔다.

1씩 돌의 숫자를 감소시키다보면, 돌 최대 개수가 20만개니까 시간초과가 날 수 밖에 없다. 어려웠다..

다른 분들 풀이를 보니 이분탐색이라는 힌트가 있었다.

다리 건너는 사람 수를 돌에 써있는 숫자의 최소값과 최대값을 가지고 탐색하는 것이다.

// 다리를 건너는 사람 수를 탐색 
int front = 1;
int back = *max_element(stones.begin(), stones.end()); // 범위 내의 최대값 #include <algorithm> 

// 이분탐색 
while (front <= back) {

    int mid = (front + back) / 2;

    if (limit_check(stones, mid, k)) {
        back = mid - 1;
    }
    else {
        front = mid + 1;
    }
}

limit_check()

모든 돌을 순회하면서 mid 숫자를 빼본다.

limit가 충족된다면, true를 리턴한다.

// 연속적으로 0 이 limit개 만큼 있는지 참/거짓 확인한다. 

bool limit_check(vector<int> s, int mid, int limit) {

    int cnt = 0; // 연속으로 0 이 있는 개수

    for (auto i : s) { // 돌의 숫자에서 mid를 뺀다 

        if (i - mid <= 0) {
            cnt++;
            if (cnt == limit) // mid 명이 건널 수 있다고 판단. 
                return true;
        }
        else {
            cnt = 0;
        }
    }
    return false;
}

정답 뜬 코드

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

// 연속적으로 0 이 limit개 만큼 있는지 참/거짓 확인 
bool limit_check(vector<int> s, int mid, int limit) {
    int cnt = 0; // 연속으로 0 이 있는 개수

    for (auto i : s) { // 돌에서 mid를 뺀다 

        if (i - mid <= 0) {
            cnt++;
            if (cnt == limit)
                return true;
        }
        else {
            cnt = 0;
        }
    }
    return false;
}

int solution(vector<int> stones, int k) {

    // 다리를 건너는 사람 수를 탐색 
    int front = 1;
    int back = *max_element(stones.begin(), stones.end()); // 최대값 

    // 이분탐색 
    while (front <= back) {

        int mid = (front + back) / 2;

        if (limit_check(stones, mid, k)) { // mid 숫자로 limit가 충족된다면, 
            back = mid - 1; // 숫자를 줄여본다. 
        }
        else {
            front = mid + 1;
        }
    }
    return front;
}

코드 [ 효율성 0점 정확도 100점 완전탐색 ]

이렇게 짜지 말아야지 하는 마음으로 기록해둔다.

#include <string>
#include <vector>
using namespace std;

int solution(vector<int> stones, int k) {

    int answer = 0; // 사람 수 
    bool flag = true;

    while (flag) {

        int limit_cnt = 0;
        // 0 이 연속되는지 확인 
        for (auto it = stones.begin(); it != stones.end(); ++it)
        {
            if (*it == 0) {
                limit_cnt++;
                if (limit_cnt >= k) return answer; // 제한 숫자 초과 시 종료 
            }
            else {
                limit_cnt = 0;
            }
        }

        // 1 감소 
        for (auto it = stones.begin(); it != stones.end(); ++it)
        {
            if(*it > 0) *it = *it - 1;
        }

        if (limit_cnt >= k) flag = false;
        else {
            answer++;
        }
    }

    return answer;
}

문제

실패율 프로그래머스 level1

2019 KAKAO BLIND RECRUITMENT

리뷰

answer에 담아야 하는 건 실패율 높은 순의 '인덱스'이다.

그래서 pair 에 인덱스와 실패율을 담았다. 자료형에 주의하자.

vector<pair<int, double>> per; // <인덱스, 실패율>

// 실패율  =  N스테이지에 위치한 사람 수  / N스테이지 이상에 위치한 사람 수 
double a = count(stages.begin(), stages.end(), i);  // N에 위치한 사람 
double b = count_if(stages.begin(), stages.end(), [i](int elem) { return elem >= i; });  // N 이상인 사람

제한 사항을 주의해야 한다.

• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
• bool compare(pair<int, double> a, pair<int, double> b) { if (a.second == b.second) return (a.first < b.first); return (a.second > b.second) ; }

• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.

if (b == 0) { // 스테이지에 도달한 사람이 없으면, 실패율 0 
    per.push_back({i , 0 });
    continue;
}

코드

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

// 만약 실패율이 같은 스테이지가 있다면,  작은 번호의 스테이지가 먼저 온다 

bool compare(pair<int, double> a, pair<int, double> b) {
    if (a.second == b.second) return (a.first < b.first); 
    return (a.second > b.second) ;
}

vector<int> solution(int N, vector<int> stages) {

    vector<int> answer;
    vector<pair<int, double>> per; // <인덱스, 실패율>

    for (int i = 1; i <= N; i++) { // 스테이지 : 1부터 N까지 

        double a = count(stages.begin(), stages.end(), i);  // i에 위치한 사람 
        double b = count_if(stages.begin(), stages.end(), [i](int elem) { return elem >= i; });  // i 이상인 사람

        if (b == 0) { // 스테이지에 도달한 사람이 없으면, 실패율 0 
            per.push_back({i , 0 });
            continue;
        }

        double fail = a / b; 
        per.push_back({i, fail});
    }

    sort(per.begin(), per.end(), compare); 

    for (int i = 0; i < N; i++) { // 인덱스를 answer에 옮긴다 
        answer.push_back(per[i].first);
    }

    return answer;
}

문제

체육복 프로그래머스 level1

리뷰

문제에서 주의할 점은 이 문장이다.

• 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다.
• 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.

이 점 때문에 헷갈릴 것 같아서. 여벌 가진 학생과 도난당한 학생을 따로 처리했다.

 //  answer 초기화.  모든 학생이 자신의 체육복을 가지고 있다고 가정한다.
int answer = n ;

// 1.  모든 학생이 1개의 체육복을 가지고 있다고 가정한다.
vector<int> student(n+1, 1); 

// 2.  여벌 있는 학생만  + 1 
for (auto i : reserve) { 
    student[i]++;
}

// 3.  도난 당했다면 -1
for (auto i : lost) { 
    student[i]--;
    if (student[i] == 0) answer--; // 0 이라면 정답에서 빼준다. 
}

자신의 앞이나 뒤의 학생에게만 체육복을 빌려줄 수 있다.

따라서 [ 2, 0 ] 인 경우, 내 뒤에 학생에게 빌려주면 [ 1 , 1] 이 된다.

[ 0, 2 ] 인 경우에도, 똑같이 [ 1, 1] 이 된다.

이 두 가지 경우에만 answer를 증가시킬 수 있다.

학생 두 명을 동시에 확인하니까 반복문 인덱스를 주의해야 한다.

    for (int i = 1; i < n; i++) { // 빌려줄 수 있는 경우는 (2, 0) 그리고 (0, 2) 인 경우 뿐이다. 

        if (student[i] == 2 && student[i+1] == 0) {
            student[i] = student[i + 1] = 1;
            answer++;

        }else if(student[i] == 0 && student[i + 1] == 2) {
            student[i] = student[i + 1] = 1;
            answer++;
        }
    }

코드

#include <string>
#include <vector>
using namespace std;

int solution(int n, vector<int> lost, vector<int> reserve) {

    int answer = n;

    vector<int> student(n+1, 1); // 1로 초기화 

    for (auto i : reserve) { // 여벌 있으면 + 1 
        student[i]++;
    }

    for (auto i : lost) { // 도난 당했다면 -1
        student[i]--;
        if (student[i] == 0) answer--;
    }

    for (int i = 1; i < n; i++) { // 빌려줄 수 있는 경우는 (2, 0) 그리고 (0, 2) 인 경우 뿐이다. 

        if (student[i] == 2 && student[i+1] == 0) {
            student[i] = student[i + 1] = 1;
            answer++;

        }else if(student[i] == 0 && student[i + 1] == 2) {
            student[i] = student[i + 1] = 1;
            answer++;
        }
    }

    return answer;
}