주제

회원 정보 관리 API 생성

• 회원 목록 조회
• 회원 조회
• 회원 등록
• 회원 수정
• 회원 삭제

 API URI 설계

• 회원 목록 조회 / read-member-list
• 회원 조회 / read-member-by-id
• 회원 등록 / create-member
• 회원 수정 / update-member
• 회원 삭제 / delete-member

이렇게 설계하는 것은 좋은 URI 설계인가?

URI 설계를 할 때 가장 중요한 것은 리로스 식별 입니다.

API URI 고민

• 리소스의 의미는 뭘까?

- 회원 등록/수정/조회 하는게 리소스가 아니다.

- 회원이라는 개념 자체가 바로 리소스이다.

• 리소스를 어떻게 식별하는게 좋을까?

- 회원을 등록, 수정, 조회하는 것을 모두 배제

- 회원이라는 리소스만 식별하면 됨 => 회원 리소스를 URI 에 매핑

리소스와 행위를 분리

가장 중요한 것은 리소스를 식별하는 것

• URI 는 리소스만 식별
• 리소스와 해당 리소스를 대상으로 하는 행위를 분리 ( 리소스 : 회원 / 행위 : 조회,등록,삭제,수정 )
• 리소스는 명사, 행위는 동사 ( 미네랄을 캐라 )
• 행위 ( 메서드 ) 는 어떻게 구분? ( HTTP 메서드 - GET,POST )

HTTP 메서드

클라이언트가 서버에 무언가를 요청을 할 때 기대하는 행동입니다.

[ 주요 메서드 ]

1. GET : 리소스 조회
2. POST : 요청 데이터 처리, 주로 등록에 사용
3. PUT : 리소스를 대체, 해당 리소스가 없으면 생성
4. PATCH : 리소스 부분 변경
5. DELETE : 리소스 삭제

[ 기타 메서드 ]

1. HEAD : GET 과 동일하지만 메시지 부분을 제외하고, 상태 줄과 헤더만 반환
2. OPTIONS : 대상 리소스에 대한 통신 가능 옵션(메서드) 를 설명 ( 주로 CORS 에서 사용 )
3. CONNECT : 대상 자원으로 식별되는 서버에 대한 터널을 설정
4. TRACE : 대상 리소스에 대한 경로를 따라 메시지 루프백 테스트를 수행

GET

• 리소스 조회
• 서버에 전달하고 싶은 데이터는 query 를 통해서 전달
• 메시지 바디를 사용해서 데이터 전달 가능하지만, 지원하지 않는 곳이 많아서 권장하지 않음

[ 과정 ]

1. 클라이언트가 GET 메서드로 리소스 요청

2. 서버는 데이터를 JSON 형태로 응답데이터를 전송해줌

POST

• 요청 데이터 처리
• 메시지 바디를 통해 서버로 요청 데이터 전달
• 서버는 요청 데이터를 처리 -> 메시지 바디를 통해 들어온 데이터를 처리하는 모든 기능 수행
• 주로 전달된 데이터로 신규 리소스 등록, 프로세스 처리에 사용 

[ 부가 설명 ]

서버한테 위와 같이 데이터를 줄 것이라고 알려주고,

데이터를 처리해달라고 클라이언트에서 서버로 요청을 하는 것

즉, 핵심은 [ 메시지 바디를 통해 서버로 요청 데이터를 전달 ] 하는 것입니다.

그러면 서버는 이 요청데이터를 받아서 처리하는데, 보통 메시지 바디를 통해 들어온 데이터를 처리하는 모든 기능을

다 수행합니다.

* 신규 등록시, 리소스 등록3 에서 Location 에 자원의 신규 생성된 URI 경로를 적어줍니다.

POST

요청 데이터를 어떻게 처리한다는 뜻일까?

• 스펙 : POST 메서드는 대상 리소스가 리소스의 고유 한 의미 체계에 따라 요청에 포함 된 표현을 처리하도록 요청합니다.
• 예시

- HTML 양식에 입력 된 필드와 같은 데이터 블록을 데이터 처리 프로세스에 제공
 ex.  HTML 폼에 입력한 정보로 회원가입,주문 등에서 사용

- 게시판, 뉴스, 그룹, 메일링, 리스트, 블로그 또는 유사한 기사 그룹에 메시지 게시
 ex. 게시판 글쓰기, 댓글 달기

- 서버가 아직 식별하지 않은 새 리소스 생성
 ex. 신규 주문 생성

- 기존 자원에 데이터 추가
 ex. 한 문서 끝에 내용 추가하기

• 정리 : 이 리소스 URI 에 POST 요청이 오면 요청 데이터를 어떻게 처리할지 리소스마다 따로 정해야함 ( 정해진게 없음 )

POST 정리

• 새 리소스 생성 ( 등록 ) - 서버가 아직 식별하지 않은 새 리소스 생성
• 요청 데이터 처리

- 단순히 데이터를 생성/변경하는 것을 넘어서 프로세스를 처리하는 경우
ex. 주문의 결제완료 -> 배달시작 -> 배달 완료처럼 단순히 값 변경을 넘어 프로세스의 상태가 변경되는 경우
   ( 배달 시작을 누르게되면 그 후에 굉장히 큰 프로세스가 실행됨 )

- POST 의 결과로 새로운 리소스가 생성되지 않을 수 있음
ex. POST /orders/{ordered}/start-delivery ( 컨트롤 URI )

• 다른 메서드로 처리하기 애매한 경우 ( JSON 으로 조회 데이터 넘겨야하는데, GET 사용 어려운 경우 )

PUT

• 리소스 수정이 아니라 리소스를 완전히 갈아치움
• 리소스가 있으면 대체 ( 쉽게 말해 덮어 쓰기 )
• 리소스가 없으면 생성
• 클라이언트가 리소스 위치를 알고 URI 지정 ( POST 와의 차이점 )
• 즉, 클라이언트가 리소스 위치를 알고 있어야함.

위의 예제에서 만약 member/100 리소스가 없으면, 신규로 생성이 됩니다.

그런데 만약 있으면 [ 기존것은 없어지고 새로 들어감 ]

[ age 만 50으로 수정 ] 을 하고 싶어도 username 이 없어지고 age 50이 들어와버립니다.

그래서 이러한 수정을 위해서 PATCH 를 사용합니다.

PATCH

- 리소스 부분 변경

- PATCH 를 못쓰는 버젼이 있어서 그런 경우 POST 를 사용해야함

DELETE

리소스 제거

HTTP

모든 데이터를 전송 가능

• HTML,TXT
• IMAGE, 음성, 영상, 파일
• JSON, XML
• 서버간에 데이터를 주고 받을 때도 대부분 HTTP 사용

HTTP 메시지 구조

* 공백은 무조건 필요함

HTTP 요청 메시지

HTTP 응답 메시지

시작 라인

요청 메시지

• start-line = request-line / status-line

start-line 을 request-line 과 status-line 이 있는데

요청 메시지는 request-line 이라고 부릅니다.

• request-line = method SP(공백) request-target SP HTTP-version CRLF (엔터) 

method : GET/POST 등

request-target : 요청하는 대상

HTTP method

• 종류 : GET,POST,PUT,DELETE...
• 서버가 수행해야 할 동작 지정

- GET : 리소스를 달라고 요청하고, 리소스 조회

- POST : 리소스를 줄테니까 작업을 요청, 요청 내역 정리

Request-target

• absolute-path [?query] ( 절대경로 [?쿼리] )
• 절대경로= "/" 로 시작하는 경로
• 참고 : * , http://...?x=y 와 같이 다른 유형의 경로 지정 방법도 있음

[ 예제 ]
GET / search?q=hello&hl=ko HTTP/1.1
Host : www.google.com 

응답 메시지

• start-line = request-line / status-line

status-line 에 해당합니다.

• status-line = HTTP-version SP(공백) status-code SP reason-phrase CRLF

• HTTP version
• HTTP status code : 요청 성공, 실패를 나타냄

200 - 성공
400 - 클라이언트 요청 오류
500 - 서버 내부 오류

[ 예제 ]

HTTP 헤더

• header-field = field-name ":" OWS field-value OWS ( OWS : 띄어쓰기를 써도 되고,안해된다. 즉 허용해준다는 뜻 )
• field-name : 대소문자 구분 없음

* 단,  [Host SP :] 의 형태는 안됩니다. 즉, 공백을 주의깊게 보고 사용해야합니다.

HTTP 헤더의 용도

• HTTP 전송에 필요한 모든 부가정보 ( 메시지 바디 내용, 메시지 바디 크기, 압축, 인증, 캐시 관리 정보,,, 등등 )
• 표준 헤더가 너무 많음
• 필요시 임의의 헤더 추가 가능

HTTP 메시지 바디의 용도

• 실제 전송할 데이터
• HTML 문서, 이미지, 영상, JSON 등 byte로 표현할 수 있는 모든 데이터 전송 가능

HTTP 정리

• HTTP 메시지에 모든 것을 전송
• HTTP/1.1 을 기준으로 학습
• 클라이언트 서버 구조
• 무상태 프로토콜 ( 스테이스리스 )
• HTTP 메시지
• 단순함, 확장 가능

Bean definition

빈이 존재할 수 있는 범위를 의미합니다.

• Spring Framework 는 6개의 범위를 지원하며, 그 중 4개는 ApplicationContext 를 사용하는 경우에만 사용할 수 있습니다.
• bean 은 여려가지 범위 중에서 하나에 배치될 수 있도록 정의할 수 있습니다.
• 사용자 정의 범위를 생성할 수 있습니다.

싱글톤 스코프

클래스 인스턴스가 딱 1개만 생성되는 것을 보장하는 디자인 패턴

• 스프링 컨테이너의 시작과 함께 생성되어서 스프링 컨테이너가 종료될때까지 유지됩니다.
• 싱글톤 빈의 하나의 공유 인스턴스만 관리하게 됩니다.
• [해당 bean Definition 과 일치하는 ID] or [ID 를 가진 빈] 에 대한 모든 요청은 스프링 컨테이너에서 해당 특정 빈 인스턴스를 반환
• 스프링 컨테이너 종료시 소멸 메서드도 자동으로 실행됨

싱글톤 특징

• 해당 빈의 인스턴스를 오직 하나만 생성해서 사용
• 인스턴스는 싱글톤 빈의 캐시에 저장됨
• 정해진 빈에 대한 모든 요청과 참조는 캐시된 개체를 반환 ( 즉, 여러번 호출해도 모두 같은 인스턴스 참조 주소값 가짐 )

싱글톤 패턴의 문제점

1) 구현하는 코드 자체가 많아짐

2) 의존관계상 클라이언트 구체 클래스에 의존

3) 지정해서 가져오기 때문에 테스트가 어려움

4) private 생성자를 사용해 자식 클래스를 만들기 때문에 유연성이 떨어짐

5) 싱글톤 빈은 기본적으로 애플리케이션 구동 시 생성되므로 빈이 많을수록 구동 시간이 증가됨

싱글톤 패턴 문제와 싱글톤 컨테이너

위의 싱글톤 패턴의 문제점은 싱글톤 컨테이너를 사용함으로써 해결이 가능합니다.

• 스프링 컨테이너는 싱글톤 컨테이너 역할을 합니다.
• 싱글톤 객체로 생성하고 관리하는 기능을 싱글톤 레지스트리라고 합니다.
• 스프링 컨테이너의 위 기능 덕분에 싱글턴 패턴의 모든 단점을 해결하며 객체를 싱글톤으로 유지할 수 있습니다.

스프링 컨테이너

• 스프링 프레임워크의 핵심 컴포넌트로, 내부에 존재하는 빈의 생명주기를 관리합니다.
• 의존성 주입을 통해 애플리케이션의 컴포넌트를 관리합니다.
• 서로 다른 빈을 연결해 애플리케이션의 빈을 연결하는 역할을 해줍니다.
• 이로 인해, 개발자는 모듈 간의 의존/결합으로 인해 발생하는 문제로부터 자유로워집니다.

형태

ApplicationContext 를 스프링 컨테이너라고 하며, 인터페이스로 구현되어 있습니다.

생성 방법

XML, Annotation 기반 자바 설정 클래스로 만들수 있습니다.

예전에는 xml 을 통해 모두 설정해줬지만, 이러한 복잡한 부분들을 스프링부트를 사용하면서 거의 사용하지 않게 되었습니다.

스프링 컨테이너를 왜 사용할까?

• 기존에는 객체를 사용하기 위해 무수히 많은 [ new 생성자 ] 를 써야했습니다.
• 이러한 객체의 의존성을 낮추기 위해 스프링 컨테이너를 사용합니다.

스프링 컨테이너만으로 이 문제를 어떻게 해결할 수 있을까?

• 기존의 방식은 새로운 수정사항이 있을 때 변경사항을 전부 수작업으로 수정해줬어야 했습니다.
• 이러한 방식은 대규모 프로젝트가 될 수록 문제가 되었습니다.
• 스프링 컨테이너를 통해 구현 클래스에 의존성을 제고하고, 인터페이스에만 의존하도록 설계하였습니다.

스프링 컨테이너 설정 과정

• 스프링 컨테이너는 Configuration Metadata 를 사용합니다.
• 스프링 컨테이너는 피라미터로 넘어온 설정 클래스 정보를 사용해서 스프링 빈을 등록합니다.
• new AnnotationConfigurationContext( 구성정보.class ) 로 스프링에 있는 @Bean 메서드를 등록 해줍니다.
• 즉, 애너테이션 기반의 자바 설정 클래스로  Spring 을 만듭니다.

ApplicationContext

스프링 컨테이너를 만드는 다양한 방법들은 ApplicationContext 의 구현체입니다.

ApplicationContext Interface 구현체 확인 방법

Mac :
1) cmd + O
2) Class 에서 ApplicationContext 검색

Window :
1) ctrl + N
2) Class 에서 ApplicationContext 검색

Spring Container 의 종류

• BeanFactory

1) 스프링 컨테이너의 최상위 인터페이스

2) 빈을 등록, 생성, 조회, 돌려주는 등 빈의 관리를 하는 역할

3) getBean() 메소드를 통해 빈을 인스턴스화 할 수 있음

4) @Bean 이 붙은 메서드의 명을 스프링 빈의 이름으로 사용해 빈 등록 할 수 있음

• ApplicationContext

1) BeanFactory 기능을 상속받아 제공

2) BeanFactory 의 모든 기능을 다 사용 가능하며, 그 외 부가기능도 제공

* 부가기능

- MessageSource : 메세지 다국화 인터페이스

- EnvironmentCapable : 개발서버, 운영서버 등 환경변수 등으로 나눠처리하는 애플리케이션 구동 정보를 관리하는 인터페이스

- ApplicationEventPublisher : 이벤트 관련 기능을 제공하는 인터페이스

- ResourceLoader : 파일, 클래스 패스, 외부 등 리소스를 편리하게 조회

Bean 이란?

스프링 컨테이너에 의해 관리되는 재사용 소프트웨어 컴포넌트입니다.

• 빈은 인스턴스 객체를 의미합니다.
• 스프링 컨테이너에 등록된 객체를 스프링 빈이라고 합니다.
• @Bean 이 적힌 메서드를 모두 호출해서 반환된 객체를 스프링 컨테이너에 등록합니다.
• 빈은 클래스의 등록정보, 게터/세터 메서드를 포함합니다.

Bean 접근방법

ApplicationContext 사용하여 bean 정의를 읽고 액세스 할 수 있습니다.\

ApplicationContext ac = new ApplicationContext("appConfig.class");
MemberServcie ms = ac.getBean("memberService",MemberService.class); // 빈을 불러옴

putIfAbsent

- Key 값이 존재하는 경우 : Map의 value 값 반환

- Key 값이 존재하지 않는 경우 : Key와 value 를 Map 에 저장하고 Null 을 반환

매개변수

- key : 지정된 값이 연관될 키

- value : 지정된 키와 연결될 값

기본 예제

import java.util.HashMap;

public class putIfAbsentTest {

	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<String, Integer>();
		map.put("A", 1);
		map.put("B", 1);
		map.put("C", 1);
		map.put("D", null);
		
		System.out.println("result : " + map.toString());
		//result : {A=1, B=1, C=1, D=null}
		
		map.putIfAbsent("E", 1);
		System.out.println("result1 : " + map);
		//result1 : {A=1, B=1, C=1, D=null, E=1}
		
		map.putIfAbsent("E", 2);
		System.out.println("result2 : " + map);
		//result2 : {A=1, B=1, C=1, D=null, E=1}
		
		map.putIfAbsent("D", 1);
		System.out.println("result3 : " + map);
		//result3 : {A=1, B=1, C=1, D=1, E=1}
	}
}

이중 중괄호 사용

단일 표현식에서 Java 객체를 생성하고 초기화하기 위해 이중 중괄호를 사용할 수 있습니다.

이렇게하면 인스턴스 이니셜라이저만 포함된 익명의 내부 클래스가 생성됩니다.

예제

[ 자바 객체 초기화 ]

import java.util.Arrays;
 
class Employee
{
    private String name;
    private int id;
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setAge(int id) {
        this.id = id;
    }
 
    // 게터
 
    @Override
    public String toString() {
        return Arrays.asList(name, String.valueOf(id)).toString();
    }
}
 
// Java에서 객체 초기화
class Main
{
    public static void main(String[] args)
    {
        // 익명 클래스
        Employee person = new Employee() {{
            // 초기화 블록
            setName("Aditya");
            setAge(27);
        }};
 
        System.out.println(person);
    }
}

[ Java 에서 세트 초기화 ]

Set<Integer> set = new HashSet<Integer>() {{
    add(1);
    add(2);
    add(3);
}};

이외에 List, Map 초기화에도 세트 초기화와 같은 형식으로 사용됩니다.

하지만 이중 중괄호는 사용할 때마다 추가 클래스가 필요하므로 이 기술은 피하는 것이 좋습니다.

또한 인스턴스 및 개체에 대한 숨겨진 참조를 보유하므로, 메모리 누수 문제를 일으킬 수 있습니다.

HashSet

• Set 인터페이스에서 지원하는 구현 클래스
• 순서대로 입력되지 않고, 일정하게 유지되지 않습니다.
• null 요소 허용
• 중복을 허용하지 않음

중복을 걸러내는 과정

• hashCode() 메서드를 호출해 코드를 얻음
• 저장되어 있는 객체들의 해시 코드와 비교해 같은 해시 코드가 있는지 확인
• 있다면 다시 equlas() 메서도르 두 객체를 비교
• true 가 나오면 동일한 객체로 판단하고 중복 저장하지 않습니다.

* String 형에 대해서 중복을 걸러내는 과정의 특징

: 앞의 과정과 같은데, 다른 점은 String 클래스가 hashCode(), equals() 메소드를 재정의해서 같은 문자열일 경우,

  리턴값을 true 로 나오게 했기 때문입니다.

변수 선언 방법

• hashSet<데이터 타입> 변수명 = new HashSet<데이터타입>();

   해당 데이터 타입형의 HashMap 데이터가 들어갑니다.

다양한 메서드들

1. add
2. remove
3. clear
4. size
5. contains(찾고자 하는 값 )

예제

프로그래머스 [ 신고 결과 받기 ] 문제에서 사용될 수 있습니다.

https://tjdwns4537.tistory.com/97

프로그래머스

문제: 신고 결과 받기

[ 오답 풀이 ]

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class 신고결과받기 {
    /*
    - 문제 : 불량 이용자 신고 후 처리 결과를 메일로 발송하는 시스템 개발
    - 시스템 :
    1) 각 유저는 한 번에 한명의 유저 신고 가능
     + 신고 횟수 제한 없음
     + 서로 다른 유저 계속 신고 가능
     + 한 유저를 여러본 신고할 수 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됨

    2) k번 이상 신고된 유저는 게시판 이용 금지되며,
    그 유저에 대해 모든 유저에게 정지 사실 메일로 발송됨
     + 유저가 신고한 모든 내용을 취합해서 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송

    - 입력 값 :
    id_list : 유저 목록
    report : 신고 한 사람과 신고 당한 사람
    k : 정지되는 횟수

    - 신고 메일 양식 :
    "muzi"가 "frodo"를 신고했습니다.

    - 유저 목록 :
    "muzi", "frodo", "apeach", "neo"

    - 결과 :
    각 유저별 메일을 받은 횟수를 배열에 담은 것을 리턴

        // report 에 (띄어쓰기) 를 기준으로 split 해서 배열에 담음
        // 0번부터 짝수는 신고인, 홀수는 신고 당한사람
        // 신고인과 신고 당한사람 비교 문법 필요
        // k번 이상된 사람 있으면 cnt 의 해당하는 인덱스에 카운터가 증가됨

    */
    public static void main(String[] args) {
        String[] id_list = {"muzi", "frodo", "apeach", "neo"};
        String[] report = {"muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"};
        String[] report2 = {"ryan con", "ryan con", "ryan con", "ryan con"};
        int k = 2;
        int[] solution = solution(id_list, report2, k);
        for (int i = 0; i < solution.length; i++) {
            System.out.println(solution[i] + " ");
        }

    }
    public static int[] solution(String[] id_list, String[] report, int k) {
        int[] answer = new int[id_list.length];

        HashMap<String, String> map = new HashMap<>();
        String[][] SplitString = new String[report.length][2];

        int[] cnt = new int[id_list.length];
        
        for (int i = 0; i < cnt.length; i++) {
            cnt[i] = 0;
        }
        for (int i = 0; i < report.length; i++) {
            SplitString[i] = report[i].split(" ");
        }

        for (int i = 0; i < SplitString.length; i++) {
            for (int w = 0; w < id_list.length; w++) {
                // > 신고한사람, 당한사람이 한번이라도 있으면 map 에 담기기 때문에 map 을 다시 조회해서 해당하는 인원이 나오면 신고 카운트가 증가되지 않음
                Iterator<Map.Entry<String, String>> entries = map.entrySet().iterator();
                while (entries.hasNext()) {
                    Map.Entry<String, String> entry = entries.next();
                    if (entry.getKey().equals(SplitString[i][0]) && entry.getValue().equals(SplitString[i][1])) {
                        System.out.println(entry.getKey() + "  " + entry.getValue());
                        continue;
                    }
                    if(entry.getKey().equals(SplitString[i][0])){
                        answer[w] = answer[w] + 1;
                    }
                }
                // <
                if(SplitString[i][1].equals(id_list[w])){
                    map.put(SplitString[i][0],SplitString[i][1]);
                    cnt[w] = cnt[w]+1;
                }
            }
        }

        return cnt;
    }
}

해결 방식의 문제점

문제를 잘못 이해한게 가장 큰 실수였습니다.

id_list 별 신고 당한 횟수로 이해를 하고 다음과 같이 코드를 작성하였습니다.

저렇게 작성하게 될 경우, 신고한 사람의 기준에서 카운트를 세는 과정을 구할 수가 없습니다.

그래서 저 방식을 그대로 유지한 채 코드를 수정해보려 했지만 해결 방법을 찾지 못했습니다.

다른 사람들의 코드를 보니 HashSet 을 이용하는 것으로 보입니다.

그래서 다시 풀이를 작성해보겠습니다.

public static int[] solution(String[] id_list, String[] report, int k){
        int[] answer = new int[id_list.length];

        /*
        HashMap<String,HashSet<String>> DeclaratedMap
        -> 중복 체크

        HashMap<String,Integer> DeclarateMap
        -> 키값 : 신고당한사람, value값 : 카운트 횟수

        HashSet<String> repSet
        -> report 를 리스트로 변환한 후 hashSet 의 요소로 넣어줌
         */

        HashMap<String, HashSet<String>> DeclaratedMap = new HashMap<>();
        HashMap<String, Integer> DeclarateCountMap = new HashMap<>();
        HashSet<String> DeclarateSet = new HashSet<>(Arrays.asList(report));

        for (String DeclareInfo : DeclarateSet) {
            String Declarater = DeclareInfo.split(" ")[0];
            String Declarated = DeclareInfo.split(" ")[1];

            // HashSet 에 신고 당한 대상을 담아준다.
            HashSet<String> temp = new HashSet<>();
            temp.add(Declarated);

            // 만약 신고 당한 대상의 map에 신고 한 사람 이름의 키 값이 존재 하지 않으면 추가해준다.
            DeclaratedMap.putIfAbsent(Declarater, temp);

            // 신고 당한 대상의 map 에 신고한 사람의 키에 대한 HashSet에 신고당한 대상의 이름을 넣어준다.
            DeclaratedMap.get(Declarater).add(Declarated);

            DeclarateCountMap.put(Declarated, DeclarateCountMap.getOrDefault(Declarated, 0) + 1);
        }

        //
        for (String Declared : DeclarateCountMap.keySet()) {
            int DeclaredCount = DeclarateCountMap.get(Declared);
            if (DeclaredCount >= k) {
                for (int i = 0; i < id_list.length; i++) {
                    if (DeclaratedMap.containsKey(id_list[i]) && DeclaratedMap.get(id_list[i]).contains(Declared)) {
                        answer[i]++;
                    }
                }
            }
        }

        return answer;
    }

코드참조 : https://velog.io/@ckr3453/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%8B%A0%EA%B3%A0-%EA%B2%B0%EA%B3%BC-%EB%B0%9B%EA%B8%B0-java

UML

클래스 다이어그램을 의미합니다.

이는 시스템을 구성하는 클래스들 사이의 관계를 표현하기 위해 사용됩니다.

UML 클래스의 표현

1. 가장 윗 부분 : 클래스 이름
2. 중간 부분 : 속성 ( 클래스의 특징 )
3. 마지막 부분 : 연산 ( 클래스가 수행하는 책임 )
4. UML 의 접근제어자 표시는 따로 존재합니다.

* 경우에 따라 속성, 연산 부분은 생략 가능합니다.

* 분석 단계와 설계 단계에서의 클래스 다이어그램은 다릅니다.

UML 에서 제공하는 클래스들 사이의 관계

• 연관 관계

• 다중성 표시

• 일반화 관계

한 클래스가 다른 클래스를 포함하는 상위 개념일 때의 관계로, 상속 개념과 같다고 보면 됩니다.

• 집합 관계

UML 연관 관계의 특별 경우로 [ 전체와 부분의 관계를 명확히 명시 ] 하고자 할 때 사용됩니다.

1) 집약 관계 : 한 객체가 다른 객체를 포함하는 것 ( 생성자에서 참조값을 인자로 받아 필드를 세팅하는 경우 )

2) 합성 관계 : 부분 객체가 전체 객체에 속하는 관계 ( 생성자에서 필드에 대한 객체를 생성하는 경우입니다.

• 의존 관계

일반적으로 한 클래스가 다른 클래스를 사용하는 경우 입니다.

• 인터페이스와 실체화 관계

- 인터페이스 : << interface >> 로 표시

- 관계 : 빈 삼각형 + 점선으로 표시

Stream 이 왜 사용되는가 ?

자바8 에서 추가됬으며 람다를 활용할 수 있는 기술 중 하나입니다.

자바8 이전에는 배열 또는 컬렉션을 다룰려면 for/foreach 문을 사용하는 방법이 었습니다.

이 방법은 단점이 있습니다.

1) 복잡해질 수록 로직이 섞입니다.

2) 코드의 양이 많아집니다.

3) 루프가 여러번 도는 현상이 발생할 수 있습니다.

그래서 이를 보완하고자 등장한 것이 스트림입니다.

Stream

• 스트림은 '데이터의 흐름' 입니다.

1) 배열 또는 인스턴스에 함수 여러 개를 조합

2) 원하는 결과에 대해 필터링, 매핑해 가공된 결과를 얻음

전체 -> 매핑 -> 필터링1 -> 필터링2 -> 결과 생성 -> 결과물

• 스트림은 람다를 이용할 수 있습니다.

1) 코드의 양을 줄일 수 있음

2) 배열과 컬렉션을 함수형으로 처리 가능

• 병럴처리 가능

1) 하나의 작업을 둘 이상 잘게 나눠 동시에 진행 가능

2) 즉, 쓰레드를 활용해 많은 요소를 빠르게 처리 가능

Stream 의 생성

스트림은 배열과 컬렉션 인스턴스를 이용해서 생성할 수 있습니다.

// 1. 배열로 스트림 생성
String[] arr = new Stringp[]{"a","b","c"};
Arrays.stream(arr); 

// 2. 컬렉션으로 스트림 생성
List<String> list = Arrays.asList("a","b","c");
Stream<String> stream = list.stream(); 

// 3. StreamBuilder 로 생성
Stream<String> streamBuilder = Stream.<String>builder().add("sungjun").add("jun").build(); //[ sungjun, jun ]

// 4. Stream.generate() 로 생성
Stream<String> generatedStream = Stream.generate(()->"gen").limit(5) // [ "gen","gen","gen","gen","gen" ]

• Stream.generate()

제너레이트 메서드를 사용하면 람다로 값을 넣을 수 있습니다.

Stream.iterate()

iterate 메서드를 이용하면 초기값과 해당 값을 다루는 람다를 이용해 스트림에 들어갈 요소를 만듭니다.

예제에서는 30 이라는 초기값을 기준으로 2씩 증가하는 값들이 들어갑니다.

Stream<Integer> iteratedStream = Stream.iterate(30,n->n+2).limit(5);
[ 30,32,34,36,38 ]

기본 타입형 스트림

제네릭 ( Stream<String> ) 을 사용하지 않고 기본 (int, double, long) 스트림을 생성할 수 있습니다.

IntStream intStream = IntStream.range(1,5) [1,2,3,4] 
// 두번째 인자는 종료지점에 포함 안됩니다.

이를 활용한 랜덤 난수 생성

DoubleStream doubles = new Random().doubles(3); // 랜덤 난수 3개 생성

Stream 의 다양한 예제

• 문자열 스트링을 숫자로 변환

IntStream charStream = "Stream".chars(); // [ 83,116,114,101,97,109 ]

• 파일 스트림

Files 클래스의 lines 메소드는 해당 파일의 각 라인을 스트링 타입의 스트림으로 만들어줍니다.

Stream<String> lineStream = Files.lines(Paths.get("file.txt"), Charset.forName("UTF-8"));

• Stream 연결하기

Stream<String> stream1 = Stream.of("a","b","c");
Stream<String> stream2 = Stream.of("d","e","f");

stream<String> concat = Stream.concat(stream1,stream2);

가공하기 ( 중간 작업 )

전체 요소 중에서 API 를 활용해 내가 원하는 것만 뽑아내는 과정입니다.

가공 단계를 중간 작업이라고 하는데, 이러한 작업은 스트림을 리턴하기 때문에 여러 작업을 이어 붙여서 작성할 수 있습니다.

List<String> names = Arrays.asList("sun","mon","jun");

//Filtering
Stream<String> FilteringName = names.stream().filter(name->name.contains("s"); // [sun]

//Mapping
String<String> MappingName = names.strea().map(String::toUpperCase);

• Filtering

스트림 내에 요소들을 하나씩 평가해서 걸러내는 작업

• Mapping

스트림 내에 요소들을 특정 값으로 변환해줍니다. 이때 값을 변환하기 위한 람다를 인자로 받습니다.

IntStream.of(10,20,50,40,30).sorted().collect(Collectors.toList());
// [10,20,30,40,50]

IntStream.of(10,20,50,40,30).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
// [50,40,30,20,10]

List<String> lan = Arrays.asList("seoulpower","geoje","busanwon","bew")
lan.stream().sorted(Comparator.comparingInt(String::length)).collect(Collectors.toList());
// [ bew, geoje,busanwon ... ]
lan.stream().sorted(s1,s2->s2.length()-s1.length()).collect(Collectors.toList());
// [ seoulpower, busanwon, ... ]

• sorted : 스트림 내에 요소를 오름차순으로 정렬
• collect(Collectors.변환될 타입) : 스트림으로 반환하는 요소를 해당 컬렉션으로 바꿔서 리턴해줍니다.
• sorted(Comparator.reverseOrder()) : 스트림 내에 요소를 내림차순으로 정렬
• sorted(Comparator.comparingInt(String::length)) : 스트림 내에 요소를 문자열 길이 기준으로 정렬

결과 만들기

가공한 스트림을 가지고 내가 사용할 결과 값을 만들어내는 단계입니다. 따라서 최종 작업입니다.

long count = IntStream.of(1,2,3,4,5).count();
long count = IntStream.of(1,2,3,4,5).sum();
long count = IntStream.of(1,2,3,4,5).min();
long count = IntStream.of(1,2,3,4,5).max();

최소, 최대, 합, 평균 등 기본형 타입으로 결과를 만들어 낼 수 있습니다.

 * 이때, [ 평균/최소/최대 ] 의 경우에는 스트림이 비어있는 경우를 표현할 수 없기때문에 Optional 을 이용해 리턴합니다.

이 외에, 

Reduction, Collecting, Matching, foreach

에 대한 개념이 있지만 현재 쓸 일이 없어서 기억을 못할 것 같으므로 다음에 사용할 일 있을 때

다시 따로 블로깅 하도록 하겠습니다.

조건검사

• findAny, findFirst()

filter() 연산과 함께 사용됩니다. 조건식에 맞는 요소가 있는지 확인할 때 사용됩니다.

반환 타입이 Optional<T> 이며, 스트림의 요소가 없을 때는 비어 있는 Optional 객체를 반환합니다.

• allMatch() : 조건식에 모든 요소가 일치하면 true
• anyMath() : 어떤 요소 하나라도 조건에 일치하면 true
• noneMatch() : 조건식에 모든 요소들이 일치하지많으면 true

[ 소스코드 예제 ]

현재 제가 진행중인 프로젝트에서 사용된 스트림에 대해서 알아보겠습니다.

private static Map<Long, Member> store = new HashMap<>();
public Optional<Member> findByname(String name) {
        return store.values().stream()
                .filter(member -> member.getName().equals(name))
                .findAny();
    }

1. store.values () 의 반환 타입

: Collection<Member> 

 즉, values 는 값을 컬렉션 타입으로 반환 해줍니다. 

2. .stream()

: 컬렉션으로 반환된 values 를 stream 으로 만들어줍니다.

3. .filter( member -> member.getName().equals(name)) 

: store 내부의 member 인자에서 getName() 을 통해서 name 값을 받아옵니다.

 받아온 name 과 findByname 의 인자로 주어진 name 을 비교해줍니다.

4. .findAny()

: filter 한 조건식에 맞는 요소가 있으면 해당 요소를 모두 반환해줍니다. ( 첫번째 하나만 하려면 findFirst )

만약 findAny() 를 붙치지 않는다면 Stream() 을 그대로 반환하는 모습을 볼 수 있습니다.

Map

key,value 로 구성된 Entry 객체를 저장하는 구조

특징

1. 키와 값은 모두 객체

2. 키는 중복될 수 없음

3. 만약 동일한 키를 가지고 있는 Entry객체를 Map 컬렉션에 저장하면, 기존의 값은 없어지고 새로운 값으로 대치됨

컬렉션이란?

객체의 모음, 그룹이라고 할 수 있습니다.

Collection 인터페이스 : [ List, Set, Queue ] 인데,

Map 은 컬렉션이 사실 아니지만, 그냥 컬렉션으로 분류해줍니다.

컬렉션을 왜 사용할까?

1. 일관된 API

컬렉션 하위에 있는 모든 클래스 컬렉션에서 상속 받아 통일된 메서드가 사용 가능해집니다.

2. 프로그래밍 효율성

객체 지향 프로그램의 추상화 개념이 성공적으로 구현되어 있음

3. 프로그램 속도 및 품질 향상

유용한 데이터 구조 및 알고리즘을 지니고 있어 성능이 향상됩니다.

그러면 다시 돌아가 Map 에 대해 알아보도록 하겠습니다.

Map 컬렉션 기능 및 종류

• 종류 : HashMap, HashTable, LinkedHashMap, Properties, TreeMap 등

Map Interface 의 메서드들은 특징에서 알아 봤듯이 키로 객체를 관리합니다.

그래서 키를 매개변수 값으로 사용하는 경우가 많습니다.

그러면 이제 HashMap 에 대해 알아보겠습니다.

HashMap

Map Interface 에서 대표적으로 많이 사용되는 Map Collection 입니다.

[ HashMap 의 키로 사용될 객체는 hashCode(),equals() 메서드를 오버라이딩해서 동등 객체 조건을 정의해야함 ]

• 동등 객체가 될 조건

1) hashCode() : 같은 키 반환

2) equals() : true 반환

Iterator

컬렉션 구현 방법을 노출시키지 않으면서도 원소를 순차적으로 접근 가능하게 해줍니다.

[ Iterator 을 사용해 key, value 모두 반복하며 호출 ]

HashMap<Integer,Interger> map = new HashMap<>();
Iterator<map.Entry<Integer,Integer>> entries = map.entrySet().iterator();
while(entries.hasNext()){
	HashMap.Entry<Integer,Integer> entry = entries.next();
    sout(entry.getKey() + entry.getValue());

[ for loop 로 key값으로 value 찾기 ]

HashMap<Integer,Integer> map = new HashMap<>();
for(Integer Key : map.keySet()){
	Integer value = map.get(key);
    sout ( key + value );
}

getOrDefault

찾는 키가 존재한다면 찾는 키의 값을 반환하고 없다면 기본 값을 반환하는 메서드

기본 형태

getOrDefault(Object Key, V DefaultValue)

- Key : 값을 가져와야 하는 요소

- defaultValue : 지정된 키로 매핑된 값이 없는 경우 반환되어야 하는 기본 값입니다.

기본 사용법

public class MapGetOrDefaultEx {
	public static void main(String arg[]) {
		String [] alphabet = { "A", "B", "C" ,"A"};
		HashMap<String, Integer> hm = new HashMap<>();
		for(String key : alphabet) hm.put(key, hm.getOrDefault(key, 0) + 1);
		System.out.println("결과 : " + hm);
        	// 결과 : {A=2, B=1, C=1}
	}
}

- 동일한 키 값을 추가할 경우 Value 의 값이 덮어쓰기 됩니다.

- 따라서 기존 key값의 value를 계속 사용하고 싶을 경우 getOrDefault 메서드를 사용해서 위의 예와 같이 사용할 수 있습니다.

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.

다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.

• 1478 → "one4seveneight"
• 234567 → "23four5six7"
• 10203 → "1zerotwozero3"

이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다.

숫자영단어

제한사항

• 1 ≤ s의 길이 ≤ 50
• s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다.
• return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만 s로 주어집니다.

[ 나의 풀이 ]

import java.util.HashMap;
import java.util.Map;

public class NumberAndWord {
    public static void main(String[] args) {
        /*
        - 숫자놀이
        : 네오 -> 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면
        프로도는 원래 숫자를 찾는 게임

        //when
        네오가 프로도에게 일부 자릿수를 영단어로 바꾼 카드를 건네줌

        //then
        프로도는 원래 숫자를 찾음

        // how
        1. hashMap 에 0 ~ 9 까지 저장
        2. 입력받은 문자열을 char 형으로 변환
        3. 변환된 char 형이 문자일 경우 하나씩 합치면서 hash value 값과 동일한지 비교
         ( 숫자일 경우 결과 값에 바로 합쳐줌 )
        4. 비교 후 같으면 해당 값을 hashMap 가 비교해서 같은 값을 가지는 key 값을
           결과 값에 합쳐줌
        */
        int res = solution("one4seveneight");
        System.out.println(res);
    }

    public static int solution(String s){
        int answer = 0;
        String temp = "";


        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(0, "zero");
        hashMap.put(1, "one");
        hashMap.put(2, "two");
        hashMap.put(3, "three");
        hashMap.put(4, "four");
        hashMap.put(5, "five");
        hashMap.put(6, "six");
        hashMap.put(7, "seven");
        hashMap.put(8, "eight");
        hashMap.put(9, "nine");

        //when
        char[] ch = s.toCharArray();

        for (int i = 0; i < ch.length; i++) {
            int k = Character.getNumericValue(ch[i]);
            if(0 <= k && k <= 9){
                if(answer == 0){
                    answer += k;
                }
                else{
                    answer = (answer * 10) + k;
                }
            }
            else {
                temp += ch[i];
                for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
                    if (entry.getValue().equals(temp)) {
                        if (answer == 0) {
                            answer += entry.getKey();
                        } else {
                            answer = (answer * 10) + entry.getKey();
                        }
                        temp = "";
                    }
                }
            }
        }

        return answer;
    }
}

다른 사람의 코드를 보니 너무 깔끔하고 짧게 구현해놔서 제 코드를 다시 보니 부끄럽네요..

import java.util.*;

class Solution {
    public int solution(String s) {
        int answer = 0;
        StringBuilder sb = new StringBuilder("");
        int len = s.length();
        String[] digits = {"0","1","2","3","4","5","6","7","8","9"};
        String[] alphabets = {"zero","one","two","three","four","five","six","seven","eight","nine"};

        for(int i=0; i<10; i++){
            s = s.replaceAll(alphabets[i],digits[i]);
        }

        return Integer.parseInt(s);
    }
}

모르겠는 메소드와 타입이 있어서 분석 먼저 해보겠습니다.

StringBuilder

변경 가능한 문자열을 만들어줍니다.

아래와 같이 String 형을 그냥 더하게 된다면 메모리 할당과 해제를 시키는 면에서 비효율적인 코드가 완성됩니다.

String a = "aa";
String b = "bb";
String c = a+b;

자바에서 String 형은 변경이 불가능합니다.

[ 문자열이 더해지는 과정 ]

1) 하나의 문자열을 다른 문자열과 연결하면 새 문자열이 생성

2) 이전 문자열은 가비지 컬렉터로 들어갑니다.

만약, 이러한 행위를 100만번을 하게 된다면 많은 메모리를 잡아 먹게 됩니다.

이 경우 사용하는게 StringBuilder 입니다.

[ 사용 방법 ]

1) StringBuilder 객체 생성

2) append 로 더해줌

3) toString() 으로 할당

StringBuilder sb = new StringBuilder();
sb.append("aa").append("bb");
String c = sb.toString();

replaceAll

• replace ( 변환하고자 하는 대상 문자열 , 변환할 문자 )

String str = "aaaa";
System.out.prinln(str.replace("aa","bbb");

// 결과값 : bbbbbb

• replaceAll ( 변환하고자 하는 대상 문자열, 변환할 문자 )

String str = "jajavava";
System.out.println("java","cool");

// jacoolva 출력

이렇게 보면 차이가 없어 보이지만 중요한 차이점은 지금부터 입니다.

String random = "AbCdGgZz";
System.out.println(random.replaceAll("[bdz]",Y);

// AYCYGgZY 출력

b,d,z 라는 값을 모두 Y로 바꿔주겠다는 의미입니다.

그러면 위의 코드가 이해가 됩니다.

[ 동작과정 ]

1. 알파벳 배열의 값들이 옴

2. 해당 알파벳 배열 값을 찾은 인덱스와 동일한 위치의 digit 배열로 대체

AOP ( Aspect Oriented Programming )

AOP 는 애플리케이션의 핵심 업무 로직에서 [ 로깅, 보안, 트랜잭션 ] 과 같은 공통 기능 로직들을 분리하는 것입니다.

공통 관심 사항, 핵심 관심 사항

애플리케이션의 주 목적을 달성하기 위한 핵심 로직에 대한 관심사는 핵심 관심 사항이라고 합니다.

이를 우리는 흔히 비지니스 로직이라고 부릅니다.

• 핵심 관심 사항

1) 주인이 고객에게 제공하는 커피 메뉴를 구성하기 위해 커피 종류를 등록하는 기능

2) 고객이 마시고 싶은 커피를 주문하는 기능

• 공통 관심 사항

1) 커피 주문 애플리케이션에 아무나 접속하지 못하도록 제한하는 보안적인 부분

2) 주문에 대한 모든 것을 기록하는 부분

3) 등록, 선택 등의 명령을 내리는 부분

위의 그림은 이 두가지 관심 사항을 나타낸 것입니다.

이렇게 핵심 업무 로직과 공통 업무 로직들을 분리하는 것을 AOP 라고 부릅니다.

그렇다면 이런 AOP 가 왜 필요한 것일까요 ??

AOP 가 필요한 이유

1) 코드의 간결성 유지

2) 객체 지향 설계원칙에 맞는 코드 구현

3) 코드의 재사용

위의 세가지 덕분에 유지보수를 보다 쉽게 할 수 있습니다.

Aspect ( 관심 )

AOP 는 애스펙트를 사용하여 다양한 기능을 분리합니다.

애스펙트는 부가 기능과 해당 부가 기능을 어디에 적용할지 정의한 것입니다.

또는 애스펙트는 관점이라는 뜻을 의미하여, 애플리케이션을 바라보는 관점을 하나 하나의 기능 -> 횡단 관심사 관점으로 보는 것입니다.

그래서 AOP 는 기존에 사용하던 OOP 를 대체하기 위한 것이 아닌 횡단 관심사를 깔끔하게 처리하기 위해 OOP 의 부족한 부분을

보조하는 목적으로 개발되었습니다.

• 여러 객체에 공통으로 적용되는 기능
• 애플리케이션에 포함되는 횡단 기능

* 용어 정리

 1) Advice : 부가기능을 정의한 코드 ( 조인 포인트에서 수행되는 코드 )

                 - 기본적으로 순서를 보장하지 않음 ( 보장하고 싶다면 @Order 필요 )

Advice 종류
1) Before
 - 조인 포인트 이전에 실행됨
 - 타겟 메서드가 실행되기 전에 처리해야할 필요가 있는 부가 기능을 호출 전에 공통 기능을 실행
 - 리턴타입이 void
 - 예외 발생시 메서드가 호출되지 않음

2) After returning
 - 조인 포인트가 정상 완료 후 실행됨

3) After throwing
 - 메서드가 예외를 던지는 경우 실행됨
 - 예외가 발생한 경우 공통 기능 실행

4) After
 - 조인 포인트 동작과는 상관없이 실행됨 ( 예외 동작의 finally 와 같음 )
 - 메서드 실행 후 공통 기능 실행
 - 일반적으로 메서드 해제하는데에 사용됨

5) Around
 - 메서드 호출 전후에 수행하며 가장 강력한 어드바이스
 - 어라운드만 있어도 모든 기능 수행 가능

 2) PointCut : Advice를 어디에 적용할지 결정하는 것

포인트컷 지시자 종류

 3) join point : 클래스 초기화, 메소드 호출, 예외 발생, 객체 인스턴스화 등과 같은 애플리케이션 실행 흐름에서의 특정 포인트

                         즉, AOP 적용 위치를 의미합니다.

단, 스프링 AOP 는 프록시 방식을 사용하므로 조인 포인트는 항상 메서드 실행 지점으로 제한됩니다.

 4) 위빙 : 포인트컷으로 결정한타겟의 조인 포인트에 어드바이스를 적용하는 것 ( 어드바이스를 핵심 코드에 적용하는 것 )

 5) AOP 프록시 : AOP 기능을 구현하기 위해 만든 프록시 객체

 6) 타겟 : 핵심 기능을 담고 있는 모듈로 타겟은 부가기능을 부여할 대상이 됨

 7) 어드바이저 : 하나의 어드바이스와 하나의 포인트 컷으로 구성 ( 스프링 AOP 에서만 사용되는 용어 )

OOP

• 공통된 목적을 띈 데이터와 동작을 묶어 하나의 객체로 정의하는 것
• 객체를 활용함으로써 기능을 재사용할 수 있음
• 객체를 잘 활용하기 위해선 관심사 분리 (SoC) 디자인 원칙을 준수해야함

기능 분리

AOP 에서의 관심사 분리는 핵심 기능 , 부가 기능 으로 분리됩니다.

이러한 기능을 나누는데에 AOP 를 사용하는 이유는 다음과 같습니다.

1.  부가기능이 불특정 다수의 여러곳에 작성되야 하는 경우를 방지
2. 부가기능 수정시 사용된 모든 클래스에 수정하지 않게 하나로 관리할 수 있게 해줌

Spring MVC 구조는 @Controller, @Service, @Repository 와 같이 관심사 별로 계층을 나눠 객체를 관리합니다.

이러한 관심사의 분리는 모듈화의 핵심입니다.

• 핵심 기능

- 객체가 제공하는 고유의 기능

• 부가 기능

- 핵심 기능을 보조하기 위해 제공하는 기능

- 로그 추적, 보안, 트랜잭션 등의 기능

- 단독으로 사용하지 않고 핵심 기능과 함께 사용됨

소스 코드

public class Example2_11 {
    private Connection connection;

    public void registerMember(Member member, Point point) throws SQLException {
        connection.setAutoCommit(false); // (1)
        try {
            saveMember(member); // (2)
            savePoint(point);   // (2)
            
            connection.commit(); // (3)
        } catch (SQLException e) {
            connection.rollback(); // (4)
        }
    }

    private void saveMember(Member member) throws SQLException {
        PreparedStatement psMember =
                connection.prepareStatement("INSERT INTO member (email, password) VALUES (?, ?)");
        psMember.setString(1, member.getEmail());
        psMember.setString(2, member.getPassword());
        psMember.executeUpdate();
    }

    private void savePoint(Point point) throws SQLException {
        PreparedStatement psPoint =
                connection.prepareStatement("INSERT INTO point (email, point) VALUES (?, ?)");
        psPoint.setString(1, point.getEmail());
        psPoint.setInt(2, point.getPoint());
        psPoint.executeUpdate();
    }
}

위의 코드에서 아래의 기능들이 보여집니다.

• member.save() 부분의 서비스 작업
• em.persist(), tx.commit(), em.close() 와 같은 트랜잭션 작업

이렇게 AOP 없이 구현하게 되면 애플리케이션 전반적으로 트랜잭션과 관련된 중복된 코드가 수도 없이 나오게 됩니다.

스프링에서는 @Transactional 이라는 어노테이션을 통해서 AOP 기능을 적용할 수 있습니다.

@Component
@Transactional // (1)
public class Example2_12 {
    private Connection connection;

    public void registerMember(Member member, Point point) throws SQLException {
        saveMember(member);
        savePoint(point);
    }

    private void saveMember(Member member) throws SQLException {
        // Spring JDBC를 이용한 회원 정보 저장
    }

    private void savePoint(Point point) throws SQLException {
        // Spring JDBC를 이용한 포인트 정보 저장
    }
}

@Transactional

해당 클래스에 트랜잭션 기능이 적용된 프록시 객체가 생성됩니다.

프록시 객체는 @Transactional 이 포함된 메소드가 호출될 경우, 트랜잭션을 시작하고 정상 여부에 따라 커밋 또는 롤백됩니다.

* 단, 테스트 코드에서의 @Transactional 은 다른 기능을 하므로 주의해야합니다.

Java 웹 애플리케이션에서 IoC 가 적용되는 예

Java Console Application 의 경우 main() 과 같은 엔트리 포인트가 종료되면 애플리케이션의 실행이 종료됩니다.

하지만 웹에서 동작하는 웹 애플리케이션의 경우 클라이언트가 외부에서 접속해서 사용하는 서비스이기 때문에

main() 메서드가 종료되면 안됩니다.

그런데 서블릿 컨테이너에는 서블릿 클래스만 존재하지 main() 메서드가 존재하지 않습니다.

서블릿 컨테이너의 동작원리

1. 서블릿 컨테이너는 클라이언트의 요청이 들어옴

2. 그때마다 서블릿 컨테이너 내의 컨테이너 로직 ( service() 메서드 ) 이 서블릿을 직접 실행

이러한 과정을 거치므로 main () 메서드가 필요 없습니다.

이 경우 서블릿 컨테이너가 서블릿을 제어하고 있기 때문에 애플리케이션 주도권은 서블릿 컨테이너에 있습니다.

그래서 이를 서블릿와 웹 애플리케이션 간에 IoC (제어의 역전) 가 적용되어 있다고 할 수 있습니다.

그렇다면 Spring 에는 IoC 개념이 어떻게 적용되어 있을까요??

DI 의존성 주입

IoC 는 서버 컨테이너 기술, 디자인 패턴, 객체 지향 설계 등에 적용하게 되는 일반적인 개념에 반해

DI ( Dependency Injection ) 는 IoC 개념을 조금 구체화 시킨것이라고 볼 수 있습니다.

• 의존성

객체 지향 프로그래밍에서 의존성이라고 하면 대부분 객체간의 의존성을 의미합니다.

예를 들어서,

A,B 두 개의 클래스 파일이 존재합니다.
A 클래스에서 B 클래스의 메서드 기능을 사용할 것입니다.
이렇게 A 클래스가 B 클래스의 기능을 사용 할 때, "A 클래스는 B 클래스에 의존한다" 라고 합니다.

[ 의존 관계 ]

public class MemberController{
	public void static main(String[] args){
    	MenuService ms = new MenuSerivce();
        List<Menu> menuList = ms.getMenuList(); // 의존 관계 성립
    }
}

public class MenuService{
	public List<Menu> getMenuList(){
    	return null
    }
}

위와 같이 의존 관계가 성립됩니다.

위의 과정에서는 아직 의존성 주입이 일어나지 않았습니다.

[ 의존성 주입 ]

public class Client{
	public static void main(String[] args){
    	MemberService ms = new MemberService();
    	MemberConroller mc = new MemberConroller(ms);
        
        List<Menu> menuList = mc.getMenu();
    }
}

public class MemberConroller{
	private MemberService memberService;
    
    public MemberConroller(MemberService memberService){
    	this.memberService = memberService;
    }
    
    public List<Menu> getMenu(){
    	return memberService.getMenuList();
    }
}

public class MenuService{
	public List<Menu> getMenuList(){
    	return null;
    }
}

MemberService 기능을 사용하기 위해 MemberController 생성자의 객체를 전달받고 있습니다.

이처럼 생성자를 통해서 어떤 클래스의 객체를 전달 받는 것을 의존성 주입이라고 합니다.

생성자의 피라미터로 객체를 전달하는 것을 "외부에서 객체를 주입한다" 라고 표현을 합니다.

• 그렇다면 여기서 의미하는 외부는 무엇일까요??

[ Client 객체 ] 에서 [ MemberController 의 생성자 피라미터 ] 로 menuService 를 전달하고 있습니다.

이렇게 객체를 MemberController 외부에서 전달하고 있기 때문에 Client 가 외부가 됩니다.

의존성 주입의 실무예제

위는 실무에서의 대화 장면입니다.

 - Stub : 메서드가 호출되면 미리 준비된 데이터를 응답하는 과정으로, 고정된 데이터이므로 동일한 데이터를 리턴합니다.

• 해야할 것

- 메뉴 데이터 조회 API 를 위해 MenuServiceStub 클래스를 추가로 작성해서 코드를 구성

- MenuService -> MenuServiceStub 으로 클래스명 변경

- Client , MenuController 는 MenuService 에 의존하기 때문에 클래스명을 변경해야됨

이렇게 업무의 변경사항이 생겼다고 수정된 클래스를 사용하는 수많은 클래스들을 바꿔야 한다면 상당히 비효율적입니다.

그래서 강한 결합이 아닌 느슨한 결합이 필요합니다.

느슨한 결합으로 만들기 위한 대표적인 방법이 [ 인터페이스 사용 ] 입니다.

즉, 클래스를 직접적으로 의존하는게 아니라 인터페이스에 의존하도록 해주는 것입니다.

MenuConroller 가 MenuService 를 의존하지만,

MenuService 의 구현체가 MenuServiceImp, MenuServiceStub 둘 중에 뭔지는 알 필요가 없는 것입니다.

그저 메뉴 목록 데이터를 조회만 할 수 있으면 되는 것입니다.

[ 느슨한 결합 ]

public interface MenuService {
	List<Menu> getList();
}

public class MenuServiceImp implements MenuService {
	@Override
    List<Menu> getList(){
    	return List.Of (
        	new Menu(1,"Americano",2400),
            new Menu(2,"Latte",3000)
        );
    }
}

public class MenuController(){
	private MenuService ms;
    
    public MenuController(MenuService ms){
    	this.ms = ms;
    }
    
    public List<Menu> getMenu(){
    	return ms.getList();
    }
}

public class client{
	public static void main(String[] args){
    	MenuService ms = new MenuServiceImp(); // 업캐스팅
        MenuController mc = new MenuController(ms);
        
        List<Menu> menu = mc.getMenu();
    }   
}

- 업캐스팅 : [ client 객체 ] 의 (  인터페이스 타입 변수  =  new 인터페이스 구현체 ) 와 같은 할당 방법

하지만 위와 같은 방법에도 문제가 있습니다.

Service 구현체에서  new 키워드로 직접 객체를 생성해주고 있습니다.

이는 스프링을 통해서 해결이 가능합니다.

public inteface MemberService{
	void save();
	List<Menu> getList();
}

public class MemberServiceImp implements MemberService{
    ArrayList<Menu> list = new ArrayList<>();
    
    @Override
    void save(Menu menu){
    	list.add(menu);
    }
    
	@Override
    List<Menu> getList(){
    	return list;
    }
}

public class client{
	ApplicationContext ac = new AnnotationApplicationContext(SpringConfig.class);
    MenuController mc = ac.getBean(MenuController.class);
    
    List<Menu> list = mc.getMenu();
}

public class MemberController(){
    public MemberService ms;
    
    @Autowired
    public MemberController(MemberService ms){
    	this.ms = ms;
    }
    
    List<Menu> getMenu(){
    	return ms.getList();
    }
}

@Configuration
@ComponentScan(basePackageClasses = Client.class)
public class SpringConfig(){
	
    @Bean
    public MemberService getMemberService(){
    	return new MemberServiceImp();
    }
    
    @Bean
    public MemberController getMemberController(){
    	return MemberController(getMemberService());
    }
}

• [ 동작과정 ]
• 테스트 코드에서 위의 코드를 호출한다고 가정하겠습니다.
• Menu 객체를 생성해 MemberService 메서드로 리스트를 저장
• MemberController 를 호출하면 SpringConfig 라는 IoC 컨테이너로 가서 빈 조회
• 빈이 존재한다면 해당 되는 빈을 mc 에 할당
• mc 의 getMenu 로 Menu를 조회

위와 같은 동작과정을 거친다면 Spring Framework 영역에서 빈등록, 의존성 주입으로 의존 객체들을 관리 해줍니다.

그래서 MenuService 의 구현체만 변경해줌으로써 한번만 코드를 수정하면 수정 부분에 대해 의존하고 있는 부분까지도

다 같이 적용이 되는 마법같은 일이 일어납니다.

역할과 구현의 분리의 중요성을 알 수 있는 예제였습니다.

프레임워크와 라이브러리의 차이점

• 둘의 결정적인 차이점은 애플리케이션에 대한 제어권입니다.

라이브러리

개발자가 짜놓은 코드 내에서 필요한 기능이 있으면 해당 라이브러리를 호출해서 사용하는 것이 라이브러리입니다.

@SpringBootApplication
@RestController
@RequestMapping(path = "/v1/message")
public class SampleApplication {
    @GetMapping
    public String getMessage() { 
        String message = "hello world";
        return StringUtils.upperCase(message); // 라이브러리 호출
    }

    public static void main(String[] args) {
        SpringApplication.run(SampleApplication.class, args);
    }
}

위의 코드에서 StringUtil 이라는 라이브러리를 호출 해서 사용하고 있습니다.

이렇게 사용하게 되면 애플리케이션 흐름의 주도권이 개발자에게 있습니다.

프레임워크

@SpringBootApplication
@RestController
@RequestMapping(path = "/v1/message")
public class SampleApplication {
    @GetMapping
    public String getMessage() { 
        String message = "hello world";
        return StringUtils.upperCase(message); // 라이브러리 호출
    }

    public static void main(String[] args) {
        SpringApplication.run(SampleApplication.class, args);
    }
}

위의 코드에서 getMessage() 메서드 내부의 코드처럼 개발자가 코드를 작성해두면

SpringFramework 에서 개발자가 작성한 코드를 사용해 애플리케이션의 흐름을 만들어냅니다.

즉, 애플리케이션의 흐름의 주도권이 개발자가 아닌 Framework 에 있습니다.

decryptCaesarCipher

문제

암호화된 문자열과 암호화 키를 입력받아 복호화된 문자열을 리턴해야 합니다.
카이사르 암호(Caesar cipher)는 평문(plaintext)을 암호키 secret개만큼 (오른쪽으로) 평행이동시켜 암호화 합니다. 복호화는 암호화된 문자열을 원래의 평문으로 복원하는 것을 말합니다.

'hello'를 secret 3으로 암호화한 경우: 'khoor'
'codestates'를 secret 11로 암호화한 경우: 'nzopdelepd'

입력

인자 1 : str

• String 타입의 알파벳 소문자 문자열

인자 2 : secret

• int 타입의 암호화 키

출력

• String 타입을 리턴해야 합니다.

주의 사항

• 빈 문자열을 입력받은 경우, 빈 문자열을 리턴해야 합니다.
• 공백은 그대로 두어야 합니다.
• 입력된 문자열은 모두 소문자만 입력됩니다.

입출력 예시

String output = decryptCaesarCipher("khoor", 3);
System.out.println(output); // --> hello

output = decryptCaesarCipher("zruog", 3);
System.out.println(output); // --> world

해결방법

1. 입력받은 str 을 char[] 형으로 변환하여 인덱스로 다룰 수 있게 만듬

2. 아스키 코드를 참조하여 [ 해당 자리 문자 - secret ] 을 해줌으로써 복호화

3. 소문자만 가능하므로 97 ~ 122 에서 순환하게 만들어줌

소스코드

public class decryptCaesarCipher {
    public static void main(String[] args) {
        String res = decryptCaesarCipher("nzop delepd dfaazced jzf", 11);
        System.out.println(res);
    }

    public static String decryptCaesarCipher(String str, int secret) {
        // TODO:
        /*
        - when : 암호화된 문자열과 암호화된 키를 입력받음
        - then : 복호화된 문자열을 리턴
        - how : 카이사르 암호는 평문을 암호키개만큼 오른쪽으로 평행이동시켜 암호화한다.
         */
        String result = "";
        int temp = 0;
        int overNum = 0;
        //when
        char[] ch = str.toCharArray();

        //how
        for (int i = 0; i < ch.length; i++) {
            if(ch[i] == ' '){
                result += ch[i];
            }
            else{
                if(ch[i]-secret >= 97) temp = ch[i]-secret;
                else{
                    overNum = 96 - (ch[i] - secret);
                    temp = 122 - overNum;
                }
                System.out.println("i: "+i+" "+ "temp: "+temp);
                result += Character.toString((char)temp);
            }
        }

        //then
        return result;
    }
}

임베디드 타입

• 새로운 값 타입을 직접 정의할 수 있음
• JPA 는 임베디드 타입이라 함
• 기본 값 타입을 모아 만들어서 복합 값 타입이라 부름
• int,String 과 같은 값 타입

임베디드 타입 장점

• 재사용성
• 높은 응집도
• 해당 값 타입만 사용하는 의미 있는 메소드 생성 가능
• 임베디드 타입을 포함한 모든 값 타입은 값 타입을 소유한 엔티티에 생명주기를 의존

임베디드 타입 사용 방법

• @Embeddable : 값 타입 정의하는 곳에 표시
• @Embedded : 값 타입 사용하는 곳에 표시
• 기본 생성자 필수

임베디드 타입과 테이블 매핑

: 임베디드 타입을 쓴것과 안 쓴것의 회원 테이블은 이전과 똑같음을 알 수 있습니다.

 - 테이블은 데이터를 다루는 개념이기에 변경되지 않도록 설계하는 것이 좋습니다.

 - 엔티티의 경우 메소드까지 신경을 써야하므로 공통 기능은 묶어서 사용하는게 사용성이 더 좋습니다.

임베디드 타입과 테이블 매핑

• 임베디드 타입은 엔티티의 값일 뿐입니다.
• 임베디드 타입을 사용하기 전과 후에 매핑하는 테이블은 같습니다.
• 객체와 테이블을 아주 세밀하게 매핑하는 것이 가능합니다. ( 프로젝트가 커질 수록 세밀한게 좋다 )
• 잘 설계한 ORM 애플리케이션은 매핑한 테이블의 수보다 클래스의 수가 더 많습니다.

임베디드 타입과 엔티티

• 임베디드 타입 멤버 안에 엔티티 객체도 들어 올 수 있습니다

- PhoneNumber 라는 임베디드 객체는 PhoneEntity 라는 엔티티를 가질 수 있음

사용 예시

• 회원 테이블의 [ Address ( city, street, zipcode ) ] , [ WorkPeriod ( Order, Send, ArriveDateTIme ) ] 임베디드 타입을 정의

발생오류

1. EntityManagerFactory 빈을 등록 안한 오류 <해결완료>

[ 기존 코드 ]

    @Bean
    public EntityManager getEm() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory();
        return emf.createEntityManager();
    }

[ 수정 코드 ]

    @Bean
    public EntityManagerFactory getEmf() {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("5xik");
        return emf;
    }
    
    @Bean
    public EntityManager getEm() {
        EntityManagerFactory emf = getEmf();
        EntityManager em = emf.createEntityManager();
        return em;
    }

2. 테이블이 업데이트 되지 않는 오류 < 해결완료 >

<property name="hibernate.hbm2ddl.auto" value="update" />

3. 커밋 시기를 save 함수 내에서 작동하도록 변경 < 해결완료 >

 [ 기존 코드 ]

테스트 코드에서 의존성 주입받은 EntityManager 를 통해 커밋을 해주는 방식을 사용하기 위해 시도

  -> 트랜잭션호출 생성 함수에서 NPE 발생

[ 수정 코드 ]

public Member save(Member member) {
    tx.begin();
    try {
        em.persist(member);
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
    } finally {
        //em.close();
    }
    //mf.close();
    return member;
}

    @Test
    @Commit
    void insertData() {
        Member member = new Member();
        member.setName("test");
        member.setPhonenumber("01011");
        member.setAddress(new Address("city","street","10000"));
        member.setWorkPeriod(new WorkPeriod());
        Member save = repository.save(member);
    }

- member 객체를 테스트 코드에서 만듬

- save 함수 내부에서 begin ~ persist ~ commit 과정을 거침으로써 테스트코드에서는 이에 대한 코드를 작성할 일이 없음

임베디드 타입으로 선언한 값들이 정상적으로 들어오는 것을 알 수 있음

값 타입 공유 참조

임베디드 타입 같은 값 타입을 여러 엔티티에서 공유하면 위험함

[ 예시 ]

    @Test
    @Commit
    void insertData() {
        Address address = new Address("city","str","10000");
        //공유 객체

        Member member = new Member();
        member.setName("test");
        member.setPhonenumber("01011");
//        member.setAddress(new Address("city","street","10000"));
        member.setAddress(address);
        member.setWorkPeriod(new WorkPeriod());

        Member member2 = new Member();
        member2.setName("test");
        member2.setPhonenumber("01011");
        member2.setAddress(address);

        member2.getAddress().setCity("geoje"); // 수정

        Member save = repository.save(member);
        Member save2 = repository.save(member2);
    }

- address 라는 객체를 공유해서 사용

- member2 에 address 를 수정

- member1 에 address 도 수정됨을 볼 수 있음

[ 해결 방법 ]

1) 각각의 객체에 new Address 로 생성자를 통해 할당 해줌

member.setAddress(new Address("city","street","10000"));
member2.setAddress(new Address("city2","street2","20000"));

2) 불변 객체로 생성

 - setter 부분을 private 로 선언해서 외부에서 수정할 수 없게 만들어주는 방법

집합 연산

레코드를 조회하고 분류한 뒤, 특정 작업을 하는 연산

1. GROUP BY

데이터를 조회할 때 그룹으로 묶어서 조회합니다.

ex 1. 고객 테이블의 State 에 따라 그룹화해서 조회해라.

SELECT * FROM customers
GROUP BY State;

* 만약 쿼리 결과 데이터의 중간이 비어있다면 ??

데이터베이스에서 데이터를 불러오는 과정에서 State 에 따라 그룹을 지정했지만,

그룹에 대한 작업없이 조회만 했습니다.

그래서 쿼리 결과로 나타나는 데이터는 각 그룹의 첫번째 데이터만 표현됩니다.

HAVING

GROUP BY 로 조회한 결과를 필터링 할 수 있습니다.

SELECT CustomerId, AVG(Total)
FROM invoices
GROUP BY CustomerId
HAVING AVG(Total) > 6.00

모든 고객의 주문서에서 가격의 평균을 구한 뒤에, 그 평균이 6.00을 넘는 결과만 조회합니다.

이렇게 GROUP BY로 그룹을 지은 결과에 필터를 적용할 때 HAVING 을 사용할 수 있습니다.

HAVING 은 WHERE 과는 적용방식이 다릅니다.

HAVING 은 그룹화한 결과에 대한 필터이고, WHERE 은 저장된 레코드를 필터링 합니다.

따라서 그룹화 전에 필터를 해야한다면, WHERE 를 사용하는것이 맞습니다.

COUNT , SUM , AVG , MAX , MIN

레코드의 갯수를 헤아릴 때 사용합니다.

ex. 모든 레코드에 대한 COUNT 함수 사용

SELECT * COUNT(*) FROM customers
GROUP BY State;

- 각 그룹의 첫번째 레코드와 각 그룹의 레코드 갯수를 집계하여 리턴합니다.

ex. 각 State 에 해당하는 레코드 갯수를 확인하는 COUNT 함수 사용

SELECT State, COUNT(*) FROM Customers
GROUP BY State;

- 그룹으로 묶인 결과의 레코드 갯수를 확인할 수 있습니다.

SELECT 실행 순서

- FROM

- WHERE

- GROUP BY

- HAVING

- SELECT

- ORDER BY

문제

1. 현재 있는 데이터베이스에 존재하는 모든 테이블 정보를 보여주기

SHOW TABLES;

2. USER 테이블의 구조를 보기위한 SQL 을 작성

DESCRIBE USER;

3. USER 테이블에 존재하는 모든 컬럼에 대한 데이터를 확인

SELECT * FROM USER;

4. USER 테이블에 name = 'kim', email='kim@gmail.com' 으로 데이터를 추가

INSERT INTO user(name,email) VALUES ('kim','kim@gmail.com')

5. USER 테이블에 name 이 kim 인 데이터를 찾아라

SELECT * FROM user WHERE user.name = 'kim';

6. USER 테이블에 name 이 kim 이 아닌 데이터를 찾아라

SELECT * FROM user WHERE user.name <> 'kim';

7. Content 테이블에 존재하는 모든 테이블에서 title 컬럼만을 찾기 위한 SQL 작성

SELECT Content.title FROM Content;

8. 위의 테이블에서 Content의 title 과 그 컨텐츠를 작성한 User 의 name 을 찾아라 ( 저자가 없어도 찾음 )

SELECT Content.title, User.name FROM Content LEFT JOIN User ON User.id = Content.id;

9. 위의 테이블에서 Content의 title 과 그 컨텐츠를 작성한 User 의 name 을 찾아라. ( 저자가 있는 컨텐츠의 타이틀만 찾음 )

SELECT Content.title, User.name FROM Content JOIN user ON user.id = content.userId;

10. Content 의 데이터를 수정하기 위한 SQL 을 작성해라.

( title이 database sprint인 content 데이터에서 body를 database is very easy로 수정해야합니다. )

UPDATE Content SET Content.body = 'database is very easy' WHERE Content.title = 'database sprint';

문제

주어진 인접행렬에서 한 정점으로부터 다른 정점으로 이어지는 길이 존재하는지 반환해야 합니다.

입력

인자 1: matrix

• Array 타입을 요소로 갖는 인접 행렬이 담긴 2차원 배열

인자 2: from

• int 타입의 시작 정점

인자 3: to

• int 타입의 도착 정점

출력

• boolean 타입을 리턴해야 합니다.

import java.util.LinkedList;
import java.util.Queue;

public class AdjacentFindRoot {
    public static void main(String[] args) {
        /*
        - 인접 행렬에서 한 정점으로 부터 다른 정점으로 이어지는 길이 존재하는지 반환
        - 입력 : 2차원 배열, 시작정점, 도착정점
        - 출력 : 시작정점에서 도착 정점으로 가는 길이 있으면 true 를 반환
         */

        int[][] test = new int[][]{
                {0, 1, 0, 0, 0},
                {0, 0, 0, 1, 0},
                {0, 1, 0, 0, 0},
                {0, 1, 1, 0, 0},
        };
        boolean directions = getDirections(test, 1, 4);
        System.out.println(directions);
    }

    public static boolean getDirections(int[][] matrix, int from, int to) {

        Queue<Integer> queue = new LinkedList<>();
        queue.add(from);

        boolean[] visited = new boolean[matrix.length];
        visited[from] = true;

        while(queue.size() > 0){
            int now = queue.poll();
            if(now == to) return true;

            for (int i = 0; i < matrix[now].length; i++) {
                if (matrix[now][i] == 1 && !visited[i]) {
                    queue.add(i);
                    visited[i] = true;
                }
            }
        }
        return false;
    }
}

문제

방향이 있는 간선과 방향이 없는 간선들의 목록들을 받아 2차원 배열의 인접행렬을 반환하는 함수를 작성하세요.

조건

각 간선은 3가지 정보를 담고 있습니다.

• 0번째: 간선의 시작 정점 (0 이상의 정수)
• 1번째: 간선의 도착 정점 (0 이상의 정수)
• 2번째: 방향성 (1 == 일시 무향, 0 == 일시 방향)

입력

인자 1: edges

• int 타입의 방향/무향인 간선들의 목록이 담긴 배열

출력

• Array 타입을 리턴해야 합니다.
• 2차원 배열의 인접 행렬

주의 사항

• 정점 0에서 정점 4로 이어주는 간선이 존재할 경우 정점 1, 2, 3도 존재합니다.
• 반환하는 인접행렬은 2차원 배열이며, 행(row)는 바깥 배열, 열(column)은 안쪽 배열입니다.
  • int[][] matrix = new int[][]{{0, 0}, {0, 0}}
  • matrix[0] == 0번째 행
  • matrix[0][0] == 0번째 행의 0번째 열
• 두 정점간의 간선의 유무는 0과 1로 표시합니다.
  • 0: 두 정점간에 간선이 존재하지 않을 경우
  • 1: 두 정점간에 간선이 존재할 경우
• 아래의 2차원 배열에서 세로축은 시작 정점, 가로축은 도착 정점입니다.
• 음수는 올 수 없습니다.
• self loop 없습니다.

public class AdjacentMatrix {
    public static void main(String[] args) {
        /*
        - 방향이 있는 간선과 방향이 없는 간선들의 목록들을 받아 2차원 배열의 인접 행렬을 반환하는 함수를 작성
        - 조건
        1) 0번째 : 간선의 시작 정점
        2) 1번째 : 간선의 도착 정점
        3) 2번째 방향성 ( 1==무향, 0==유향 )
        - 출력
        1) Array type
        2) 2차원 배열 인접 행렬
        - 주의사항
        1) 0 ~ 4로 이어주는 간선이 존재할 경우 1,2,3 정점도 존재합니다.
        2) 두 정점간 간선의 유무는 0과 1로 표시
         */

        int result[][] = new int[][]{
                {0, 3, 0},
                {0, 2, 0},
                {1, 3, 0},
                {2, 1, 0},
        };
        int[][] matrix = createMatrix(result);
        for(int i=0; i< matrix.length; i++){
            for(int j=0; j< matrix.length; j++){
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static int[][] createMatrix(int[][] edges){
        // 가장 큰 정점
        int maxLength = 0;

        for(int i=0; i< edges.length; i++){
            for(int j=0; j< 2; j++){
                if(maxLength < edges[i][j]){
                    maxLength = edges[i][j];
                }
            }
        }

        int[][] result = new int[maxLength+1][maxLength+1];

        for(int i=0; i< edges.length; i++){
            if(edges[i][2] == 1){
                result[edges[i][0]][edges[i][1]] = 1;
                result[edges[i][1]][edges[i][0]] = 1;
            } else {
                result[edges[i][0]][edges[i][1]] = 1;
            }
        }

        return result;
    }
}

[ 반드시 알아야하는 키워드 ]

- 데이터 : 각 항목에 저장되는 값

- 테이블 : 사전에 정의된 열의 데이터 타입대로 작성된 데이터가 행으로 축적

- 컬럼 또는 필드 : 테이블의 한 열을 가리킴

- 레코드 : 테이블의 한 행에 저장된 데이터

- 키 : 테이블의 각 레코드를 구분할 수 있는 값입니다. 각 레코드마다 고유한 값을 가지며, 기본키, 외래키 등이 있습니다.

What is a Schema ?

스키마는 데이터베이스에서 데이터가 구성되는 방식과 서로 다른 엔티티 간의 관계에 대한 설명입니다.

즉, 데이터베이스의 청사진과 같습니다.

예제

학교를 위한 데이터베이스를 구축한다고 가정해봅니다.

교사, 수업, 학생과 같은 데이터를 저장할 예정입니다.

이는 그러면 3개의 엔티티가 구성되는 것입니다.

- 필드 : Teacher 의  Name, Department 와 같은 행을 의미합니다.

- 레코드 : Classes 필드 안에 MUSIC, MATH 와 같이 내부 데이터로 테이블에 저장된 항목이라고 볼 수 있습니다.

[ 선생과 반의 관계는 어떻게 정의할 수 있는가 ? ]

이는 " 한 명의 선생이 여러 반을 가르칩니다. " 라는 개념으로 일대다 관계가 될 수 있습니다.

이를 테이블로 표현을 하면 아래 사진과 같습니다.

이렇게 설정하게 될 경우 한가지 문제가 생깁니다.

CS 101 에 대한 데이터를 변경하고 싶을 때, 테이블을 다 뒤져서 CS 101 이라는 데이터를 찾아야합니다.

굉장히 비효율적입니다.

 그래서 사용하는게 ID 를 가지고 데이터를 찾을 수 있도록 합니다.

ID 는 각 테이블의 레코드 하나를 가리키는 숫자로, 자동으로 증가합니다.

이 ID 필드는 해당 테이블의 기본 키 역할을 합니다.

다른 테이블에서 테이블의 기본키를 참조할 때, 해당 값을 외래 키라고 부릅니다.

이 예시에서는 Classes 의 ID 부분이 외래키에 해당합니다.

[ 클래스와 학생의 관계 ]

이는 다대다 관계가 됩니다.

Class, Teacher 의 관계처럼 TeacherID를 Class 테이블에 넣어주게 될 경우 문제가 발생합니다.

만약 Student 에 Class 를 넣었는데 Class 가 여러개일 경우에는 문제가 생깁니다.

그래서 아래 사진과 같이 일대다를 두 개를 만들어주는 방식으로 해결할 수 있습니다.

트랜잭션

여러 개의 작업을 하나로 묶은 실행 유닛입니다.

1. 각 트랜잭션은 하나의 특정 작업으로 시작

2. 묶여 있는 모든 작업들을 다 완료해야 정상적으로 종료

3. 만약 하나의 트랜잭션에 속해있는 여러 작업 중에 단 하나의 작업이라도 실패할 경우, 이 트랜잭션에 속한 모든 작업을 실패로 간주

ACID

데이터베이스 트랜잭션은 ACID 라는 특성을 가지고 있습니다.

ACID 란, 데이터베이스 내에서 일어나는 하나의 트랜잭션의 안전성을 보장하기 위해 필요한 성질입니다.

• Atomicity
• Consistency
• Isolation
• Durability

Atomicity

원자성이란 트랜잭션에 속해 있는 모든 작업이 전부 성공하거나 전부 실패해서 결과를 예측할 수 있어야 합니다.

하나의 단위로 묶여있는 여러 작업이 부분적으로 실행된다면, 업데이트가 일어났지만 누가 업데이트 했는지 알 수가 없습니다.

그리고 업데이트의 정보가 누락되는 등 데이터가 오염될 수 있습니다.

예를 들어, A -> B 로 계좌이체를 하려고 하는데, 만약 B에서 입금이 되지 않았는데 어디서 문제가 발생했는지 알 수 없다면

그거는 사라지는 돈이 됩니다.

이런 상황을 대비해서 작업이 실패한다면 계좌 A에서 출금하는 작업을 포함해 모든 작업이 실패로 돌아가야 한다는 것이

원자성입니다.

Consistency

일관성이란 데이터베이스의 상태가 일관되야 한다는 성질입니다.

하나의 트랜잭션 이전, 이후의 데이터베이스 상태가 같아야 한다는 겁니다.

예를 들어, 모든 고객은 반드시 이름을 가지고 있어야 한다는 데이터베이스 제약이 있다고 가정해보겠습니다.

다음과 같은 트랜잭션은 일관성을 위반합니다.

 - 이름이 없는 새로운 고객을 추가하는 쿼리

 - 기존 고객의 이름을 삭제하는 쿼리

데이터베이스의 유효한 상태는 다를 수 있지만, 데이터의 상태에 대한 일관성은 변하지 않아야 합니다.

Isolation

격리성은 모든 트랜잭션은 다른 트랜잭션으로부터 독립되어야 한다는 뜻입니다.

실제 동시에 여러 트랜잭션들이 수행될 때, 각 트랜잭션은 고립되어 있어 연속으로 실행된것과 동일한 결과를 나타냅니다.

예를 들어, 계좌에 만원이 있다고 가정해보겠습니다.

이 계좌로 부터 계좌 B로 6천원, 계좌 C로 6천원을 동시에 계좌 이체하는 경우, B 송금 후 C에 보내는 결과와 동일해야합니다.

격리성을 지키는 각 트랜잭션은 철저히 독립적이기 때문에, 다른 트랜잭션의 작업 내용을 알 수 없습니다.

그리고 트랜잭션이 동시에 실행될 때와 연속으로 실행될 때의 데이터베이스 상태가 동일해야 합니다.

Durability

하나의 트랜잭션이 성공적으로 수행되었다면, 해당 트랜잭션에 대한 로그가 남아야합니다.

만약 런타임 오류나 시스템 오류가 발생하더라도 해당 기록은 영구적이어야 합니다.

예를 들어, 은행에서 계좌이체를 성공적으로 마친 후 , 해당 은행 데이터베이스에서 오류가 발생되어 종료되어도

계좌이체 내역은 기록으로 남아있어야 합니다.

만약 계좌 이체를 로그로 기록하기도 전에 시스템 오류 등으로 종료 된다면,

해당 이체 내역은 실패로 돌아가 계좌이체 이전 상태들로 돌아가게 됩니다.

데이터베이스가 왜 필요한가?

• In-memory : 끄면 데이터가 없어짐
• File I/O : 원하는 데이터만 가져올 수 없고 항상 모든 데이터를 가져온 뒤 서버에서 필터링 필요
• Database : 필터링 외에도 File I/O 로 구현이 힘든 관리를 위한 여러 기능들을 가지고있는 데이터에 특화된 서버

엑셀을 사용하지 않고 굳이 데이터베이스를 쓰는 이유는 무엇일까?

• In - Memory

자바스크립트에서 데이터를 다룰 때에는 프로그램이 실행될 때에만 존재하는 데이터가 있습니다.

자바스크립트에서 변수를 만들어 저장한 경우, 그 프로그램이 종료될 때 해당 프로그램이 사용하던 데이터도 사라집니다.

이 말인 즉, 변수 등에 저장한 데이터가 프로그램의 실행에 의존한다는 말입니다.

예기치 못한 상황으로부터 데이터를 보호할 수 없고, 프로그램이 종료된 상태라면 원할 때 받아올 수 없으며,

데이터의 수명이 프로그램의 수명에 의존하게 됩니다.

• File I/O

엑셀 시트, CSV 같은 파일 형태는 한계가 존재합니다.

• 데이터가 필요할 때마다 매번 전체 파일을 읽어야 합니다. 그래서 파일이 커질수록 작업은 버거움
• 파일이 손상되거나 여러 파일을 동시에 다뤄야하는 등 복잡한 데이터량이 많을 수록 데이터 불러들이는 작업이 힘들어짐

반면, RDBMS 에서는 하나의 CSV 파일이나 하나의 엑셀 시트를 한 개의 테이블로 저장할 수 있습니다.

한번에 여러 개의 테이블을 가질 수 있기 때문에 SQL 을 활용해 데이터를 불러오기 수월합니다.

SQL

Structured Query Language 의 줄임말로, 주로 관계형 데이터베이스에서 사용합니다.

SQL 을 사용하기 위해선 데이터의 구조가 고정되어 있어야합니다.

MySQL, Oracle, PostgreSQL 등 다양한 데이터베이스에서 SQL 구문 사용 가능합니다.

NoSQL 은 데이터베이스와 달리 데이터의 구조가 고정되어 있지 않은 데이터베이스 입니다.

관계형 데이터베이스와 달리 테이블을 사용하지 않고, 다른 형태로 저장하며, MongoDB 와 같은 문서 지향 데이터베이스입니다.

쿼리란 ?

검색을 할 때 입력하는 검색어가 일종의 쿼리입니다.

기존에 존재하는 데이터를 검색어로 필터링합니다. 따라서 쿼리는 저장되어 있는 데이터를 필터하기 위한 질의문으로 볼 수 있습니다.

주로 사용하는 데이터베이스 언어

1. 데이터베이스 생성

 CREATE DATABASE 데이터베이스 명;

2. 데이터베이스 사용

USE 데이터베이스 명; 

3. 테이블 정보 확인

 DESCRIBE user;

SQL 명령어 간략히 보기

1. SELECT : 데이터 셋에 포함될 특성을 특정

2. FROM : 뒤에 도출해낼 데이터베이스 테이블을 명시

3. WHERE : 필터 역할

4. ORDER BY : 데이터를 어떤 기준으로 정렬하여 출력할지 결정

5. LIMIT : 출력할 데이터의 개수

6. DISTINCT : 유니크한 값을 받고 싶은 경우 사용

7. INNER JOIN : 둘 이상의 테이블의 공통된 부분을 기준으로 연결

Postman

HTTP API 테스트 도구

HTTP API 테스트 도구 ( CLI )

• curl
• wuzz

HTTP API 테스트 도구 ( GUI )

• Postman
• Insomnia

Postman

제가 사용할 테스트 도구는 Postman 입니다.

Postman 사용하기

Postman 화면보기

1. 새로운 탭 오픈
   • 요청/응답을 여러 개 확인할 수 있습니다.
2. HTTP 메서드 선택
   • GET, POST, DELETE 등과 같은 메서드 중 하나를 선택합니다.
     • API 문서 상 GET 메서드를 사용하므로, GET으로 선택합니다.
3. URL 입력 창
   • URL과 Endpoint를 입력합니다.
     • API 문서에 따르면, http://3.36.72.17:3000/kimcoding/messages 와 같이 입력하면 됩니다.
4. HTTP 요청 버튼
   • 요청을 보냅니다.
5. HTTP 요청시 설정할 수 있는 각종 옵션
   • 추가적인 파라미터나, 요청 본문(body)을 추가할 수 있습니다.
     • API 문서에서 확인할 수 있듯이, roomname 이라는 파라미터를 사용할 수 있습니다. 필수는 아니지만, 파라미터를 사용하려면 Params 탭의 KEY, VALUE 에 각각 roomname 과 필요한 값을 입력합니다.
6. HTTP 응답 화면
   • 요청을 보낸 후 응답을 확인하세요.

이미 만들어져 있는 API 서버가 주어지는 경우를 생각해보겠습니다.

HTTP 로 소통하기 위해선 API 서버의 endpoint 가 URL 로 주어져야합니다.

- GET 요청하기 ( Postman 으로 )

- POST 요청하기 ( 브라우저로 )

GET 요청은 브라우저로도 충분히 테스트할 수 있습니다.

POST 요청은 GET 요청과 다르게 본문(body)를 포함하는 경우가 많습니다.

본문을 설정하는 방법은, 위 그림에서 (5)번 - HTTP 요청 설정 화면 에서 본문을 입력하면 됩니다.

POST를 사용하는 API 문서를 먼저 확인해 봅시다.

다음 그림을 참고하여 POST 요청에 본문을 함께 보냅니다.

* 모든 요청 본문 입력이 완료되었다면, 요청을 보냅니다.

  URL과 Endpoint, 그리고 HTTP 메서드를 정확하게 입력했는지 한 번 더 확인해주면 됩니다.

* 요청이 끝나지 않는 경우

일반적으로 서버가 요청에 대한 응답을 하지 않는 경우, 요청이 끝나지 않습니다.

이것은 서버의 문제입니다. 만약 서버를 만드는 중이라면, 응답 처리를 했는지 확인해 봐야합니다.

이 경우에는 timeout이라는 응답을 받게 됩니다.

* 기대했던 응답이 오지 않는 경우

HTTP 응답 코드를 확인해봐야 합니다.

위 그림의 우측 상단에 HTTP 응답 코드가 표시됩니다.

400 Bad Request라고 되어 있다면, 잘못된 요청을 한 경우입니다.

REST API 란?

웹 애플리케이션에선 HTTP 메서드를 이용해 서버와 통신합니다.

GET 을 통해 웹 페이지나 데이터를 요청,

POST 로 새로운 글이나 데이터를 전송,

DELETE 로 저장된 글이나 데이터를 삭제할 수 있습니다.

이처럼 클라이언트와 서버가 HTTP 통신을 할 때는 어떤 요청을 보내고 받느냐에 따라 메서드 사용이 달라집니다.

REST ( Representational State Transfer ) API 는 웹에서 사용되는 데이터나 자원을 HTTP URI 로 표현하고,

HTTP Protocol 을 통해 요청과 응답을 정의하는 방식을 의미합니다.

간단한 비유를 들어보겠습니다.

어떤 식당의 손님이 있고, 식사 혹은 음료를 주문한다고 가정해보겠습니다.
메뉴판의 상태가 내가 알아볼 수 없는 언어이고, 가독성이 떨어지는 메뉴판이라고 한다면 주문하기 어렵습니다.
이럴 때 만약, 메뉴판이 잘 알아볼 수 있게 누군가 규정을 해놓는다면 누구나 쉽게 메뉴판을 읽고 주문할 수 있습니다.
이러한 역할을 해주는 것이 REST API 입니다.

클라이언트 - 서버 사이에도 데이터와 리소스를 요청하고, 요청에 따른 응답을 전달해주기 위한 메뉴판이 필요합니다.
이 메뉴판을 보고 클라이언트는 식당에서 식사를 주문하듯 서버에 요청하고,
이에 대한 응답을 다시 서버에서 클라이언트로 전송하게 됩니다.

따라서 HTTP 프로토콜 기반으로 요청과 응답에 따라 리소스를 주고받기 위해선 알아보기 쉽게 작성된 메뉴판이 필요합니다.
이 역할을 API 가 수행해야 하므로 서로 잘 알아볼 수 있도록 작성하는 것이 중요합니다.

좋은 REST API 디자인 방법

REST 성숙도 모델을 구조화하면 다음과 같습니다.

실제로는 2단계까지만 적용해도 좋은 API 디자인이라고 볼 수 있으며, 이런 경우 HTTP API 라고 부릅니다.

REST 성숙도 모델 0단계

HTTP 프로토콜을 사용하기만 하면 됩니다.

물론 이 경우, REST API 라고 할 수는 없습니다.

REST 성숙도 모델 1단계

개별 리소스와의 통신을 준수해야 합니다.

모든 자원은 개별 리소스에 맞는 엔드포인트를 사용해야 하며, 요청하고 받은 자원에 대한 정보를 응답으로 전달해야 한다는 것입니다.

앞선 0 단계에서는 모든 요청에서 엔드 포인트로 /appointment 를 사용했습니다.

하지만 1 단계에서는 요청하는 리소스가 무엇인지에 따라 각기 다른 엔드포인트로 구분하여 사용해야 합니다.

위의 예시에서 예약 가능한 시간 확인이라는 요청의 응답으로 받게 되는 자원(리소스)은 허준이라는 의사의 예약 가능한 시간대입니다.

그렇기 때문에 요청 시 /doctors/허준이라는 엔드포인트를 사용한 것을 볼 수 있습니다.

그뿐만 아니라, 특정 시간에 예약하게 되면, 실제 slot이라는 리소스의 123이라는 id를 가진 리소스가 변경되기 때문에, 하단의 특정 시간에 예약이라는 요청에서는 /slots/123으로 실제 변경되는 리소스를 엔드포인트로 사용하였습니다.

예시와 같이, 어떤 리소스를 변화시키는지 혹은 어떤 응답이 제공되는지에 따라 각기 다른 엔드포인트를 사용하기 때문에, 적절한 엔드포인트를 작성하는 것이 중요합니다.

엔드포인트 작성 시에는 동사, HTTP 메서드, 혹은 어떤 행위에 대한 단어 사용은 지양하고, 리소스에 집중해 명사 형태의 단어로 작성하는 것이 바람직 방법입니다.

더불어 요청에 따른 응답으로 리소스를 전달할 때에도 사용한 리소스에 대한 정보와 함께 리소스 사용에 대한 성공/실패 여부를 반환해야 합니다. 예를 들어 만약 김코딩 환자가 허준 의사에게 9시에 예약을 진행하였으나, 해당 시간이 마감되어 예약이 불가능하다고 가정할 때, 아래와 같이 리소스 사용에 대한 실패 여부를 포함한 응답을 받아야 합니다.

REST 성숙도 모델 2단계

REST 성숙도 모델 2단계에서는 CRUD에 맞게 적절한 HTTP 메서드를 사용하는 것에 중점을 둡니다. 앞서 0단계와 1단계 예시에서 보았듯, 모든 요청을 CRUD에 상관없이 POST로 하고 있습니다. 그러나 REST 성숙도 모델 2단계에 따르면 이는 CRUD에 따른 적합한 메서드를 사용한 것은 아닙니다.

먼저 예약 가능한 시간을 확인한다는 것은 예약 가능한 시간을 조회(READ)하는 행위를 의미하고, 특정 시간에 예약한다는 것은 해당 특정 시간에 예약을 생성(CREATE)한다는 것과 같습니다. 그렇기 때문에 조회(READ)하기 위해서는 GET 메서드를 사용하여 요청을 보내고, 이때 GET 메서드는 body를 가지지 않기 때문에 query parameter를 사용하여 필요한 리소스를 전달합니다.

또한 예약을 생성(CREATE)하기 위해서는 POST 메서드를 사용하여 요청을 보내는 것이 바람직합니다. 그리고 2단계에서는 POST 요청에 대한 응답이 어떻게 반환되는지도 중요합니다.

이 경우 응답은 새롭게 생성된 리소스를 보내주기 때문에, 응답 코드도 201 Created 로 명확하게 작성해야 하며, 관련 리소스를 클라이언트가 Location 헤더에 작성된 URI를 통해 확인할 수 있도록 해야, 완벽하게 REST 성숙도 모델의 2단계를 충족한 것이라고 볼 수 있습니다.

물론 메서드를 사용할 때도 규칙이 있습니다.

• GET 메서드 같은 경우는 서버의 데이터를 변화시키지 않는 요청에 사용해야 합니다.
• POST 는 요청마다 새로운 리소스를 생성하고 PUT 은 요청마다 같은 리소스를 반환합니다. 이렇게 매 요청마다 같은 리소스를 반환하는 특징을 멱등(idempotent)하다고 합니다. 그렇기 때문에 멱등성을 가지는 메서드 PUT과 그렇지 않은 POST는 구분하여 사용해야 합니다.
• PUT 과 PATCH 도 구분하여 사용해야 합니다. PUT은 교체, PATCH는 수정의 용도로 사용합니다. 

API를 작성할 때, REST 성숙도 모델의 2단계까지 적용을 하면 대체적으로 잘 작성된 API라고 여깁니다.

물론 로이 필딩은 앞서 이야기한 바와 같이 3단계까지 만족하지 못한다면 REST API가 아니기 때문에 HTTP API라고 불러야 한다고 주장하지만, 뒤에 만나게 되는 레퍼런스의 모범적인 API 디자인조차도 REST 성숙도 모델의 3단계까지 적용한 경우는 극히 드뭅니다. 따라서 3단계까지 무조건적으로 모두 적용해야 한다는 것은 아닙니다.

REST 성숙도 모델 3단계

마지막 단계는 HATEOAS(Hypertext As The Engine Of Application State)라는 약어로 표현되는 하이퍼미디어 컨트롤을 적용합니다. 3단계의 요청은 2단계와 동일하지만, 응답에는 리소스의 URI를 포함한 링크 요소를 삽입하여 작성한다는 것이 다릅니다.

이때 응답에 들어가게 되는 링크 요소는 응답을 받은 다음에 할 수 있는 다양한 액션들을 위해 많은 하이퍼미디어 컨트롤을 포함하고 있습니다.

예를 들어 위와 같이 허준이라는 의사의 예약 가능 시간을 확인한 후에는 그 시간대에 예약을 할 수 있는 링크를 삽입하거나, 특정 시간에 예약을 완료하고 나서는 그 예약을 다시 확인할 수 있도록 링크를 작성해 넣을 수도 있습니다.

이렇게 응답 내에 새로운 링크를 넣어 새로운 기능에 접근할 수 있도록 하는 것이 3단계의 중요 포인트입니다.

만약 클라이언트 개발자들이 응답에 담겨 있는 링크들을 눈여겨본다면, 이러한 링크들은 조금 더 쉽고, 효율적으로 리소스와 기능에 접근할 수 있게 하는 트리거가 될 수 있습니다.

HTTP

- HyperText Transfer Protocol 의 줄임말

- HTML가 같은 문서 전송을 위한 Application Layer 프로토콜

- 웹 브라우저와 웹 서버의 소통을 위해 디자인

HTTP messages

클라이언트와 서버 사이에서 데이터가 교환되는 방식

 - 요청

 - 응답

HTTP messages 는 몇 줄의 텍스트 정보로 구성되어 있습니다.

그러나 개발자는 이런 메시지를 직접 작성할 필요가 거의 없습니다.

구성 파일, API, 기타 인터피에스에서 자동 완성해줍니다.

요청과 응답은 다음과 같은 구조를 가집니다.

 1. start line : 요청이나 응답의 상태를 나타냄. 항상 첫 번째 줄에 위치합니다.

 2. HTTP headers : 요청을 지정하거나, 메시지에 포함된 본문을 설명하는 헤더의 집합

 3. empty line : 헤더와 본문을 구분하는 빈 줄이 있습니다.

 4. body : 요청과 관련된 데이터나 응답과 관련된 데이터 또는 문서를 포함 ( 요청,응답 유형에 따라 선택적 사용됨 )

Request

Start Line

HTTP 요청은 클라이언트가 서버에 보내는 메시지입니다.

Start Line 에는 세가지 요소가 있습니다.

 1. 수행할 작업 ( GET, PUT, POST 등 ) 이나 방식 ( HEAD, OPTIONS ) 을 설명하는 HTTP method 를 나타냅니다.

 2. 요청 대상 또는 프로토콜, 포트, 도메인의 절대 경로는 요청 컨텍스트에 작성됩니다. 이 요청 형식은 HTTP method 마다 다릅니다.

     - origin 형식 : ? 와 쿼리 문자열이 붙는 절대 경로입니다. POST, GET, HEAD, OPTIONS 등의 메서드와 함께 사용됩니다.

     - absolute 형식 : 완전한 URL 형식으로, 프록시에 연결하는 경우 대부분 GET method 와 함께 사용됩니다.

     - authority 형식 : 도메인 이름과 포트 번호로 이뤄진 URL 의 authority component 입니다. HTTP 터널을 구축하는 경우,

                                  CONNECT 와 함께 사용할 수 있습니다.

     - asterisk 형식 : OPTIONS 와 함께 별표( ) 하나로 서버 전체를 표현합니다.

Headers

헤더 이름 ( 대소문자 구분이 없는 문자열 ), 콜론 ( : ), 값을 입력합니다.

값은 헤더에 따라 다릅니다. 여러 종류의 헤더가 있고, 다음과 같이 그룹을 나눌 수 있습니다.

 - General headers : 메시지 전체에 적용되는 헤더로, body를 통해 전송되는 데이터와는 관련이 없는 헤더입니다.

 - Request headers : fetch를 통해 가져올 리소스나 클라이언트 자체에 대한 자세한 정보를 포함하는 헤더를 의미합니다.

                                  User-Agent, Accept-Type, Accept-Language 와 같은 헤더는 요청을 보다 구체화합니다.

                                  Referer 처럼 컨텍스트를 제공하거나 If-None 가 같은 조건에 따라 제약을 추가할 수 있습니다.

 - Representation headers : 이전에는 Entity Headers 로 불렀으며, body에 담긴 리소스의 정보를 포함하는 헤더입니다.

Body

요청의 본문은 HTTP messages 구조의 마지막에 위치합니다. 모든 요청에 body가 필요하지는 않습니다. GET, HEAD, DELETE, OPTIONS처럼 서버에 리소스를 요청하는 경우에는 본문이 필요하지 않습니다. POST나 PUT과 같은 일부 요청은 데이터를 업데이트하기 위해 사용합니다. body는 다음과 같이 두 종류로 나눌 수 있습니다.

• Single-resource bodies(단일-리소스 본문) : 헤더 두 개(Content-Type과 Content-Length)로 정의된 단일 파일로 구성됩니다.
• Multiple-resource bodies(다중-리소스 본문) : 여러 파트로 구성된 본문에서는 각 파트마다 다른 정보를 지닙니다. 보통 HTML form과 관련이 있습니다.

응답(Responses)

Status line

응답의 첫 줄은 Status line이라고 부르며, 다음의 정보를 포함합니다.

1. 현재 프로토콜의 버전(HTTP/1.1)
2. 상태 코드 - 요청의 결과를 나타냅니다. (200, 302, 404 등)
3. 상태 텍스트 - 상태 코드에 대한 설명

Status line은 HTTP/1.1 404 Not Found. 처럼 생겼습니다.

Headers

응답에 들어가는 HTTP headers는 요청 헤더와 동일한 구조를 가지고 있습니다. 대소문자 구분 없는 문자열과 콜론(:), 값을 입력합니다. 값은 헤더에 따라 다릅니다. 요청의 헤더와 마찬가지로 몇 그룹으로 나눌 수 있습니다.

• General headers : 메시지 전체에 적용되는 헤더로, body를 통해 전송되는 데이터와는 관련이 없는 헤더입니다.
• Response headers : 위치 또는 서버 자체에 대한 정보(이름, 버전 등)와 같이 응답에 대한 부가적인 정보를 갖는 헤더로, Vary, Accept-Ranges와 같이 상태 줄에 넣기에는 공간이 부족했던 추가 정보를 제공합니다.
• Representation headers : 이전에는 Entity headers로 불렀으며, body에 담긴 리소스의 정보(콘텐츠 길이, MIME 타입 등)를 포함하는 헤더입니다.

Body

응답의 본문은 HTTP messages 구조의 마지막에 위치합니다. 모든 응답에 body가 필요하지는 않습니다. 201, 204와 같은 상태 코드를 가지는 응답에는 본문이 필요하지 않습니다. 응답의 body는 다음과 같이 두 종류로 나눌 수 있습니다.

• Single-resource bodies(단일-리소스 본문) :
  • 길이가 알려진 단일-리소스 본문은 두 개의 헤더(Content-Type, Content-Length)로 정의합니다.
  • 길이를 모르는 단일 파일로 구성된 단일-리소스 본문은 Transfer-Encoding이 chunked 로 설정되어 있으며, 파일은 chunk로 나뉘어 인코딩되어 있습니다.
• Multiple-resource bodies(다중-리소스 본문) : 서로 다른 정보를 담고 있는 body입니다.

Stateless

Stateless는 말 그대로 상태를 가지지 않는다는 뜻입니다. HTTP로 클라이언트와 서버가 통신을 주고받는 과정에서, HTTP가 클라이언트나 서버의 상태를 확인하지 않습니다.

사용자는 쇼핑몰에 로그인하거나 상품을 클릭해서 상세 화면으로 이동하고, 상품을 카트에 담거나 로그아웃을 할 수도 있습니다. 클라이언트에서 발생한 이런 모든 상태를 HTTP 통신이 추적하지 않습니다.

만약 쇼핑몰에서 카트에 담기 버튼을 눌렀을 때, 카트에 담긴 상품 정보(상태)를 저장해둬야 합니다. 그러나 HTTP는 통신 규약일 뿐이므로, 상태를 저장하지 않습니다.

따라서, 필요에 따라 다른 방법(쿠키-세션, API 등)을 통해 상태를 확인할 수 있습니다. 

Stateless(무상태성)이 HTTP의 큰 특징이라고 기억하면 됩니다.

SPA 를 만드는 기술 AJAX

웹 페이지에서 일부분만 바꾸고 싶다면 AJAX 를 사용합니다.

AJAX 란?

JavaScript, DOM, Fetch, XMLHttpRequest, HTML 등 다양한 기술을 사용하는 웹 개발 기법

AJAX 의 특징

웹 페이지에 필요한 부분에 필요한 데이터만 비동기적으로 받아와 화면에 그려낼 수 있음

예제1.

구글 페이지를 보면 알 수 있습니다.

1)  검색창에 한 글자를 입력

2) 입력할 때마다 해당 글자로 시작하는 단어들을 서버로부터 받아옴

3) 그 바로 아래에 추천 검색어로 보여줌

즉, 검색창에 필요한 데이터만 비동기적으로 받아와 렌더링 됩니다.

예제2.

원티드 채용 공고 페이지를 보면 알 수 있습니다.

1) 원티드 채용공고 목록 페이지를 밑으로 스크롤함

2) 맨 끝에 도달하면 새로운 채용 공고를 서버로 부터 가져와 렌더링함

이러한 이벤트를 무한 스크롤이라고 합니다.

무한 스크롤이 발생할 때마다 Fetch 를 통해 데이터를 가져와 업데이트할 수 있습니다.

예제3.

페이스북 메시지, 네이버 포탈사이트의 뉴스 탭 등

AJAX 의 두 가지 핵심 기술

1) 자바스크립트, DOM

2) Fetch

전통적인 웹 애플리케이션에서는 <form> 태그를 이용해 서버에 데이터를 전송했습니다.

그래서 클라이언트에서 요청을 보내면 매번 새로운 페이지로 이동했어야 했습니다.

그러나 Fetch 를 이용하면 페이지를 이동하지 않아도 서버로부터 필요한 데이터를 받아올 수 있습니다.

Fetch 는 사용자가 현재 페이지에서 작업을 하는 동안 서버와 통신할 수 있습니다.

즉 브라우저는 Fetch 가 서버에 요청을 보내고 읍다을 받을 때 까지 멈추는게 아니라, 계속 페이지를 사용할 수 있게

비동기적인 방식을 사용합니다.

또한 자바스크립트에서 DOM 을 사용해 조작할 수 있기 때문에 Fetch 를 통해 전체 페이지가 아닌 필요한 데이터만 가져와

DOM 에 적용시켜 새로운 페이지로 이동하지 않고 기존 페이지에서 필요한 부분만 변경할 수 있습니다.

[ XHR 과 Fetch ]

Fetch 이전에는 XHR ( XMLHttpRequest ) 를 사용했습니다.

Fetch 는 XHR 의 단점을 보안한 새로운 웹 API 이며, XML 보다 가볍고 자바 스크립트와 호환되는 JSON 을 사용합니다.

AJAX 장점

1) 서버에서 완성된 HTML 을 보내지 않아도 필요한 데이터를 비동기적으로 가져와 브라우저에서 화면의 일부만 업데이트하여 렌더링할 수      있습니다.

2) XHR 이 표준화 되면서부터 브라우저에 상관없이 AJAX 를 사용할 수 있게 되었습니다.

3) 완성된 HTML 이 아닌 필요한 데이터를 JSON, XML 등 텍스트 형태로 보내기 때문에 데이터 크기가 작습니다.

AJAX 단점

1) Search Engine Optimization ( SEO ) 에 불리합니다.

    AJAX 방식의 웹 애플리케이션의 HTML 파일은 뼈대만 있고 데이터는 없기 때문에 사이트의 정보를 긁어가기 어렵습니다.

2) AJAX 에서는 이전 상태를 기억하지 않기 때문에 뒤로가기 버튼을 누를 시 사용자가 의도하지 않은 대로 동작할 수 있습니다.

    그래서 뒤로가기 등의 기능을 구현하기 위해선 History API 를 사용해야 합니다.

SSR

Server Side Rendering 의 줄임말 입니다. 

자바스크립트가 웹 페이지를 브라우저에서 렌더링하는 대신에 서버에서 렌더링을 합니다.

예를 들어서, 온라인에서 가구를 주문 했을 때 배송 출발지에서 조립을 완료한 상태로 보내는 것입니다.

브라우저가 서버의 URI로 GET 요청을 보내면, 서버는 정해진 웹 페이지 파일을 브라우저로 전송합니다.

서버의 웹 페이지가 브라우저에 도착하면 완전히 렌더링됩니다.

만약, 페이지의 내용에 데이터베이스의 데이터가 필요한 경우, 서버는 데이터베이스의 데이터를 불러온 다음 웹 페이지를

완전히 렌더링된 페이지로 변환한 후 브라우저에 응답으로 보냅니다.

서버는 사용자의 브라우저가 다른 경로로 이동할 때마다 이 작업을 다시 수행합니다.

CSR

Client Side Rendering 줄임말 입니다. 

클라이언트에서 자바스크립트가 페이지를 렌더링 합니다.

예를 들어서, 모든 부품이 최대한 나뉘어 운송이 쉬운 상태로 배송한 다음 집에서 조립하는 경우입니다.

1) 웹 브라우저의 요청을 서버로 보냄

2) 서버는 웹 페이지를 렌더링하는 대신, 웹 페이지의 골격이 될 단일 페이지를 클라이언트에 보냅니다.

3) 이때 서버는 웹 페이지와 함께 자바스크립트 파일을 보냅니다.

4) 클라이언트가 웹 페이지를 받으면 웹 페이지와 함께 전달된 자바스크립트 파일은 브라우저에서 웹 페이지를

    완전히 렌더링 된 페이지로 바꿉니다.

 * 웹 페이지에 데이터베이스 데이터가 필요한 경우

1) 브라우저는 데이터베이스 저장된 데이터를 가져와 웹 페이지에 렌더링

2) 이때, API 가 사용됨

3) 브라우저가 다른 경로로 이동하면 서버가 웹 페이지를 다시 보내지 않습니다.

4) 브라우저는 브라우저가 요청한 경로에 따라 페이지를 렌더링합니다.

차이점

주요 차이점은 페이지가 렌더링 되는 위치입니다.

SSR 은 서버에서 페이지를 렌더링, CSR 은 브라우저에서 페이지를 렌더링합니다.

SSR 을 사용할 경우

자원이용이 서버에 집중되기에 애플리케이션 유지비용이 높습니다.

일부 서드파티 자바스크립트 라이브러리의 경우 서버 사이드 렌더링이 불가능할 수 있습니다.

CSR 을 사용할 경우

사이트에 풍부한 상호 작용이 있는 경우, CSR 은 빠른 라우팅으로 강력한 사용자 경험을 제공합니다.

웹 애플리케이션을 제작하는 경우, CSR 을 이용해 더 나은 사용자 경험을 제공할 수 있습니다.

예시

SSR 예시

네이버 블로그가 있습니다.

네이버에서 SSR 방식을 도입한 이유는 검색엔진 최적화에 유리한 이점이 있기 때문입니다.

블로그 같은 경우 검색 엔진에 많이 노출되는게 유리하고, 다른 웹사이트에 비해 사용자와 상호작용이 많지 않기 때문에

SSR이 합리적인 선택이 될 수 있습니다.

뉴욕 타임즈 홈페이지가 있습니다.

SSR의 대표적인 단점인 많은 사용자가 클릭할 때마다 전체 웹사이트를 다시 서버에서 받아오기 때문에 발생하는 서버 과부하

이슈가 있음에도 불구하고, CSR에 비해 초기 로딩 속도가 빨라서 구독자가 신문 기사를 빠르게 읽을 수 있다는 장점이 있습니다.

또한 신문사의 기사가 검색 엔진에 노출되는 것이 중요하기 때문에 SSR 을 이용하고 있습니다.

CSR 예시

아고다가 있습니다.

사실 아고다 뿐만 아니라 많은 예약 사이트가 CSR 을 사용하고 있습니다.

SSR 에서는 서버에서 렌더링을 해야 하기 때문에 상호작용이 많아질수록 서버에 부담이 많아집니다.

그래서 CSR 을 통해서 서버가 클라이언트에 필요한 데이터만 넘겨주기 때문에 부담이 적습니다.

그리고 SPA ( Single Page Application ) 를 기반으로 화면의 일부만 받아온 데이터로 변경해주기 때문에 빠른 렌더링으로

UX 에 유리합니다.

Single Page Application

- 유저의 입력와 요청에 의한 콘텐츠나 정보의 최신화가 페이지를 새로 불러오지 않고 현재 페이지에서 이뤄집니다.

- 필수적인 요소만 요청합니다.

- AJAX, Asynchronous JavaScript, XML 이 주로 사용합니다.

- 유저는 페이지 새로 고침 되지 않고, 요청한 응답을 기다리면서 페이지와 상호작용이 가능합니다.

Microservice Architecture

작고 가벼운 특정한 한 가지 기능에 집중한 웹 애플리케이션을 의미합니다.

각 애플리케이션의 기능 요소들은 상호간에 의존적으로 설계되지 않습니다.

따라서 개발 단계에서도 그리고 개발 완성 이후에도 같은 개발 언어를 사용할 필요가 없습니다.

개발자는 원하는 언어를 사용해 기능 개발에 유연성을 갖게 되고, 개발 과정의 전반적인 속도와 생산성이 향상됩니다.

Serverless Architecture

개발자가 웹 애플리케이션의 서버와 기타 기반 기능들에 대해 외부의 제 3자인 클라우드 서비스 제공자에게 의탁하는 방식입니다.

이 방식은 개발자가 서버,기반 기능들에 걱정할 필요 없이 특정 기능의 개발에 집중할 수 있게 합니다.

HTTP

웹 브라우저상에서 클라이언트와 서버간의 통신을 담당하는 프로토콜입니다.

클라이언트에서의 데이터 요청과 서버에서의 요청에 대한 응답을 반복하면서 웹 애플리케이션을 작동시킵니다.

HTTP 요청을 할 때에는 하고 싶은 처리의 종류를 나타내는 메서드 이름, 처리 대상의 이름이 포함됩니다.

HTTP 응답에는 요청에 대한 처리 결과를 상태 코드, 헤더, 실제 처리 결과인 메시지가 포함됩니다.

쿠키와 세션

HTTP 는 데이터를 요청하고 요청에 대한 응답을 전송하는 무상태성의 프로토콜 입니다.

우리가 특정 쇼핑몰에 접속한다고 가정해보겠습니다.

구매를 원하는 상품에 대해 장바구니에 넣음 -> 그 중 일부 물품만 결제 진행 ( 남은 물품은 나중에 구매 )

위와 같은 기능을 실현할 때에는 무상태성의 특징을 가진 HTTP 프로토콜만 가지고는 불가능합니다.

이를 위해 필요한 기능이 쿠키와 세션입니다.

• 쿠키 : 웹 애플리케이션을 사용하는 유저의 정보를 클라이언트에 보관 후 다음 접속 부터는 유저의 정보를 클라이언트가 서버로 보내서 유저를 서버가 식별하게 합니다. 쿠키에 담긴 내용으로 웹 애플리케이션에 유저가 설정했던 항목들에 대해 저장을 해서 다음에 이어서 같은 방식으로 작동하게 도와줍니다.
• 세션 : 서버에 Session-Id 라는 고유 아이디를 할당해서 유저를 식별합니다. 단순하고 유출되면 안되는 정보는 서버에서 관리를 하면서 세션 ID와 매칭해서 저장해 관리합니다. 주로 사용되는 방법은, 세션 정보는 쿠키에서 관리하고 실제 매칭되는 값들은 서버측에서 관리하는게 일반적입니다.

사용자 인증

컴퓨터나 특정 시스템을 사용할 때 유저를 식별할 수 있는 ID 값과 암호를 입력합니다.

웹에서의 인증은 개인정보를 바탕으로 합니다.

단지 사용자 식별용 고유 아이디와 암호 뿐이 아니라, 개인의 신원 또한 파악하는 다요소 인증(MFA) 가 웹에서의 보안의 필수 요소로 되었습니다.

가장 일상적으로 접근하는 방식은 OAuth 방식의 로그인입니다.

이 방식은 서비스 자격증명 메커니즘을 다른 믿을만한 제3자의 서비스에 위임해 인증하는 방식입니다.

URL

브라우저의 주소창에 입력한 URL은 서버가 제공되는 환경에 존재하는 파일 위치를 나타냅니다.

예를 들어, https://park.com:443 사이트 접속을 하게 되면, park.com 주소가 가리키는 서버의 기본 폴더를 의미합니다.

슬래쉬를 이용해 파일을 진입할 수 는 있지만, 보통 보안때문에 외부에서 직접 접근 가능한 경우는 없습니다.

URL 구성

URL은 Uniform Resource Locator 의 줄임말 입니다.

schema, host, url-path 로 구분할 수 있습니다.

- scheme : 통신 방식을 결정 ( 웹 브라우저에선 https 사용 )

- hosts : 웹 서버의 이름이나 도메인, IP를 사용해 주소를 나타냄

- url-path : 웹 서버에서 지정한 루트 디렉터리로부터 시작해 웹 페이지, 이미지, 동영상 등 위치한 경로와 파일명을 나타냄

URI 는 Uniform Resource Identifier 의 줄임말입니다.

URL 의 기본 요소인 schema, hosts, url-path 에 더해 query, bookmark 를 포함합니다.

즉 URL을 포함하는 상위 개념입니다.

- query : 웹 서버에 보내는 추가적인 질문

Domain Name

웹사이트 주소가 IP주소로만 작성해서 이용해야 한다면 기억하기 어렵습니다.

그래서 호스트 이름과 도메인 이름으로 바꿔서 기억하기 쉽게 만드는 것입니다.

각 도메인 정보와 데이터베이스를 Registry 가 관리를 합니다. 즉, Registry 는 중개 등록업체입니다.

각 Registry 의 종류에 따라 도메인의 종류가 바뀝니다.

도메인 종류

1) gTLD - generic Top Level Domain

: 전 세계에서 등록 가능한 .com .net .org .edu .gov 등이 있음

2) ccTLD - country code Top Level Domain

: .kr .us .jp 등 각 네트워크 정보센터에서 위임받아서 관리합니다.

DNS

호스트의 도메인 이름을 IP주소로 변환하거나 반대의 경우를 수행할 수 있도록 개발된 데이터베이스 시스템입니다.

웹 애플리케이션의 요청흐름

1) 브라우저의 url 입력

2) 해당 주소를 찾기 위해 DNS 서버에 요청

3) IP주소를 찾으면 HTTPS 요청 보냄 ( 만약 방문 기록이 캐시 메모리에 있으면 캐시에서 가져옴 )

4) 웹 서버에 요청이 도착

5) 웹 서버는 저장소에 요청을 보내 페이지 관련 데이터를 가져옴

6) 정보를 가져오는 중에 비지니스 로직이 동작

7) 비지니스 로직들은 각 데이터를 어떻게 다룰지 정해져 있음

8) 로직을 통해 요청 받은 데이터들이 처리되고 브라우저에 응답

9) 요청들이 브라우저에 응답으로 돌아올 때, 웹 페이지 화면에 출력

모든 애플리케이션은 client-side , server-side 로 작동합니다.

유저가 요청하게 되는 경우 크게 두 가지 프로그램이 동작합니다.

 - 유저의 입력에 따른 브라우저에서 작동하는 프로그램

 - HTTP 요청에 따라 서버에서 요청 처리하는 프로그램

따라서 웹 애플리케이션을 개발하기 위해 웹 개발자는 [ 브라우저의 기능 개발 ] 과 [ 서버 기능 개발 ] 을 하게 됩니다.