가전제품 이것저것 이야기

1. spring boot

: 스프링 프레임워크와 3rd party library들에 대한 복잡하고 반복적인(boiler-plate) 설정 코드를 최소화하고 비즈니스 로직 구현에 집중하게 함

- 내장된 Servlet container(Tomcat)를 이용하여 독립적으로 실행 가능한 Spring 애플리케이션 개발 가능 (JAR)

- 'starter' dependency를 이용한 build 의존성 설정 간소화

- 스프링 프레임워크와 3rd party library들에 대한 자동 설정(auto-config)

2. 스타터 의존성(starter)

spring-boot-starter 가 포함하는 의존성

1) spring-boot

2) spring-boot-autoconfigure

3) spring-boot-starter-logging

4) javax-annotation-api

5) spring-core

6) snakeyaml

spring-boot-starter-web이 포함하는 의존성

1) spring-boot-starter

2) spring-boot-starter-json

3) spring-boot-starter-tomcat

4) spring-web

5) spring-webmvc

+ spring-boot-starter-jdbc

3. 자동설정(auto-configuration)

: 어플리케이션 실행 시, classpath에 Spring module 또는 3rd party library가 존재할 경우,

관련된 bean들의 설정을 자동으로 실행한다.

예) 특정 database가 classpath에 있으면 그 database를 사용하는 Datasource bean들을 자동으로 실행한다.

예) spring-jdbc 모듈이 classpath에 있고, datasource bean이 설정되어 있으면 jdbcTemplate bean을 자동으로 설정해준다.

예) Spring-webmvc 모듈이 classpath에 있으면 DispatcherServlet, HandlerMapping 등 Spring MVC의 기본 bean들을 자동 설정

예) Thymeleaf library가 classpath에 있으면  template resolver, view resolver, template engine 등을 자동으로 설정(view로 이용 가능)

예) Spring Security 모듈이 classpath에 있으면 Spring Security 기반의 웹 보안을 위해 필요한 bean들을 자동 설정

예) Embedded Tomcat이 classpath에 있으면 Tomcat servlet container를 시작함 (8080 port 사용)

아래와 같은 명시적인 설정을 하지 않아도 Spring boot가 필요한 bean들을 자동으로 생성 및 설정해준다.

4. Spring boot Actuator

: 실행중인 애플리케이션의 내부 상태를 조회하고 모니터링하는 기능

다양한 application metrics

1) 실행중인 process, thread의 상태

2) HTTP 요청

3) 메모리 사용량

4) data source 사용량(connection 개수)

5) GC 횟수 및 개수

- Web endpoint(Rest URL)이나 원격 shell을 통해 이용 가능하다.

5. @SpringBootApplication

어노테이션은 다음과 같은 세 가지 어노테이션을 포함한다.

1) @SpringBootConfiguration : @Configuration 기능 포함

2) @EnableAutoConfiguration : classpath 기반으로 자동 bean scan 실행

4) @ComponentScan : 현재의 package를 base로 자동 bean scan 실행

- sub package들도 모두 실행

6. shell/cmd에서 build 실행 방법

1) mvnw가 포함된 폴더로 이동

2) mvnw package

-> build 후 JAR 파일 생성

3) java -jar target/demo-0.0.1-SNAPSHOT.jar

-> 생성된 JAR 파일 실행

4) mvnw spring-boot:run

-> build 후 바로 실행

7. 추가적인 MVC 설정, 인터셉터 설정

1. 벨만 포드 알고리즘

victorydntmd.tistory.com/104

def bellman_ford(graph, start):
    distance, predecessor = dict(), dict()  # 거리 값, 각 정점의 이전 정점을 저장할 딕셔너리
    # 거리 값을 모두 무한대로 초기화 / 이전 정점은 None으로 초기화
    for node in graph:  
        distance[node], predecessor[node] = float('inf'), None
    distance[start] = 0  # 시작 정점 거리는 0

    # 간선 개수(V-1)만큼 반복
    for _ in range(len(graph) - 1):
        for node in graph:
            for neighbour in graph[node]:  # 각 정점마다 모든 인접 정점들을 탐색
                # (기존 인접 정점까지의 거리 > 기존 현재 정점까지 거리 + 현재 정점부터 인접 정점까지 거리)인 경우 갱신
                if distance[neighbour] > distance[node] + graph[node][neighbour]:
                    distance[neighbour] = distance[node] + graph[node][neighbour]
                    predecessor[neighbour] = node

    # 음수 사이클 존재 여부 검사 : V-1번 반복 이후에도 갱신할 거리 값이 존재한다면 음수 사이클 존재
    for node in graph:
        for neighbour in graph[node]:
            if distance[neighbour] > distance[node] + graph[node][neighbour]:
                return -1, "그래프에 음수 사이클이 존재합니다."

    return distance, predecessor
    
    
# 음수 사이클이 존재하지 않는 그래프
graph = {
    'A': {'B': -1, 'C':  4},
    'B': {'C':  3, 'D':  2, 'E':  2},
    'C': {},
    'D': {'B':  1, 'C':  5},
    'E': {'D': -3}
}

# 그래프 정보와 시작 정점을 넘김
distance, predecessor = bellman_ford(graph, start='A')

print(distance)
print(predecessor)


# 음수 사이클이 존재하는 그래프
graph = {
    'A': {'B': -1, 'C':  4},
    'B': {'C':  3, 'D':  2, 'E':  2},
    'C': {'A': -5},
    'D': {'B':  1, 'C':  5},
    'E': {'D': -3}
}


distance, predecessor = bellman_ford(graph, start='A')

print(distance)
print(predecessor)

2. 플로이드 와샬 알고리즘

blog.naver.com/ndb796/221234427842

from sys import stdin
from math import inf

n = int(stdin.readline())
m = int(stdin.readline())

# 이동 최소비용을 저장할 2차원 배열
cost = [[inf] * n for _ in range(n)]
for _ in range(m):
    a, b, c = map(int, stdin.readline().split())
    cost[a-1][b-1] = min(cost[a-1][b-1], c)

# 플로이드 와샬 알고리즘 적용
k in range(n):
    cost[k][k] = 0
    for i in range(n):
        for j in range(n):
            cost[i][j] = min(cost[i][j], cost[i][k]+cost[k][j])

# 결과 출력
for row in cost:
    for i in range(n):
        # 갈 수 없는 경로인 경우, 0 출력
        if row[i] == inf:
            row[i] = 0
        print(row[i], end=" ")
    print()

1. 비용을 정렬한다.

2. 비용이 작은 노드부터 방문한다.

3. 시작점으로부터의 비용을 갱신한다.

C언어 코드

#include <stdio.h>
#include <limits.h>

#define TRUE    1
#define FALSE   0
#define MAX_VERTICES    100     /* 노드의 수 */
#define INF     9999        /* 무한 값(연결이 없는 경우) */

int distance[MAX_VERTICES]; /* 시작노드로부터의 최단경로 거리 */
int previous[MAX_VERTICES]; /* 경유 노드  :  이 배열의 값을 어떻게 설정할 것인가?가 이 숙제의 문제*/
int found[MAX_VERTICES];    /* 방문한 노드 표시 */

typedef struct GraphType {
    int n;                  // 정점의 개수
    int adj_mat[MAX_VERTICES][MAX_VERTICES];
} GraphType;

// 그래프 초기화
void graph_init(GraphType *g)
{
    int r,c;
    g->n = 0;
    for (r = 0; r < MAX_VERTICES; r++)
    for (c = 0; c < MAX_VERTICES; c++)
    g->adj_mat[r][c] = INF;
    
    for (r = 0; r < MAX_VERTICES; r++) // pak 추가
    g->adj_mat[r][r] = 0;
}

int choose(int distance[], int n, int found[])
{
    int i, min, minpos;
    min = INT_MAX;
    minpos = -1;
    for (i=0; i < n; i++)
    if (distance[i] < min && ! found[i]) {
        min = distance[i];
        minpos=i;
    }
    return minpos;
}


void read_graph_to_adj_mat(GraphType *g)
{
    int n, u, v;
    scanf("%d", &n);
    g->n = n;
    scanf("%d", &u);
    while (u != -1)
    {
        scanf("%d", &v);
        scanf("%d", &g->adj_mat[u][v]);
        g->adj_mat[v][u] = g->adj_mat[u][v];
        
        scanf("%d", &u);
    }
}
void print_path(int start, int end)
{
    int u = end ;
    if(start == end) {
        printf("%d", start);
        return;
    }
    else {
        print_path(start, previous[u]);
        printf("->%d", u);
    }
}
void shortest_path(GraphType *g, int start, int e, int except) /* 시작노드 */
{
    int i, u, w;
    for(i=0; i<g->n; i++)   /* 초기화 */
    {
        distance[i] = g->adj_mat[start][i];
        found[i] = FALSE;
        previous[i] =start;
    }
    
    found[start] = TRUE;    /* 시작노드 방문 표시 */
    distance[start] = 0;
    
    for(i = 0; i < (g->n)-1; i++) {
        u = choose(distance, g->n, found);
        found[u] = TRUE;
        if(u == except) continue;
        if(u == e) {
            print_path(start, u);
            printf("(%d)\n", distance[u]);
        }
        for(w=0; w<g->n; w++) { // distance[] 재조정
            if(!found[w])
                if( distance[u] + g->adj_mat[u][w] < distance[w] ) {
                    distance[w] = distance[u] + g->adj_mat[u][w];
                    previous[w] = u;
                }
        }
    }
}

int main()
{
    GraphType g;        // 입력 그래프
    int sIndex, dIndex, eIndex;
    graph_init(&g);;
    
    read_graph_to_adj_mat(&g);
    
    //printf("시작점:");
    scanf("%d", &sIndex);
    //printf("도착점:");
    scanf("%d", &dIndex);
    
    //printf("제외점:");
    scanf("%d", &eIndex);
    //shortest_path(&g, sIndex, dIndex);
    shortest_path(&g, sIndex, dIndex, eIndex);
}

파이썬의 우선순위 큐를 사용해보면 좋을 것 같다.

www.daleseo.com/python-priority-queue/

www.daleseo.com/python-heapq/

메모이제이션 강좌를 보셨나요? 재귀 호출 시, 반복적으로 계산되는 것들의 계산 횟수를 줄이기 위해 이전에 계산했던 값을 저장해두었다가 나중에 재사용하는 방법입니다. 메모이제이션이 동적 프로그래밍 중 하나입니다.

알고리즘을 짤 때 분할정복 기법을 사용하는 경우가 많습니다. 큰 문제를 한 번에 해결하기 힘들 때 작은 여러 개의 문제로 나누어서 푸는 기법인데요. 작은 문제들을 풀다보면 같은 문제들을 반복해서 푸는 경우가 생깁니다. 그 문제들을 매번 재계산하지 않고 값을 저장해두었다가 재사용하는 기법이 동적 프로그래밍입니다.

dfs(깊이우선탐색)

한 루트로 탐색하다가 특정 상황에서 최대한 깊숙히 들어가서 확인한 뒤 다시 돌아가 다른 루트로 탐색하는 방식이다. 

- 재귀로 구현한다.

- 한번 방문한 곳은 다시 가지 않기 위해 check 배열 사용

BFS(너비우선탐색)

인접 노드부터 탐색

- 큐를 사용한다.

- 한번 방문한 곳은 다시 가지 않기 위해 check 배열 사용

1. MVC Pattern

Model : 결과 데이터

View : UI

Controller : Request 처리, Request/Response 데이터 전달

2. Spring MVC 

: MVC Framework(spring-webmvc)

-> Spring DI, AOP 이용가능

🔑 MVC 모델

1. MVC 모델 1과 MVC 모델 2의 차이점에 대해 설명하시오.

👉🏻 MVC 모델 정리 포스팅

👉🏻 MVC란 Model, View, Controller의 줄임말로써, MVC는 사용자와 상호작용하는 S/W를 디자인함에 있어 세가지 요소로 쪼개어 하는 것을 의미합니다. MVC 모델 1은 웹 브라우저의 요청을 JSP 페이지가 받아서 처리 하는 구조입니다. JSP 페이지 안에서 모든 정보를 표현(view)하고 저장(model)하고 처리(control)되므로 재사용이 힘들고, 읽기도 힘들어 가독성이 떨어집니다. 주로 중소형 프로젝트에 적합한 모델입니다. MVC 모델 2는 모델 1과 달리 웹 브라우저의 요청을 하나의 서블릿이 받게 됩니다. 서블릿은 웹 브라우저의 요청을 알맞게 처리한 뒤, 그 결과를 JSP로 포워딩 합니다. 처리 작업의 모듈화로 유지보수가 쉬워지는 반면 개발 시간이 늘어난다는 단점을 가지고 있습니다. 

(+) Spring MVC 모델 2

👉🏻 스프링 MVC 프레임워크는 스프링이 제공하는 트랜잭션 처리, DI, AOP를 손쉽게 사용할 수 있습니다.
다른 MVC 프레임워크와 마찬가지로 컨트롤러를 사용하여 요청을 처리합니다. 스프링에서는 DispatcherServlet이 MVC에서의 컨트롤러(Controller)부분을 처리합니다. 

💡 구성 요소

3. 개발 과정

step 1) DispatcherServlet 설정

: Client로부터 request를 전달받는 servlet 객체(front controller)

: web.xml 설정 

step 2) HandlerMapping 설정

: Request를 처리할 handler(controller and method) 선택

[디폴트] /WEB-INF/[name]-servlet.xml

Step 3) Controller 구현 및 설정

- Annotation 기반 controller

: @Controller (자동 bean scan 대상)

: @RequestMapping (사용자 정의 메소드를 특정 request URL에 대한 handler method로 지정)

step 4) ViewResolver 

: 논리적인 view 이름에 대해 물리적인 view 객체 생성

step 5) View 구현

: JSP 등을 사용하여 View page 작성

4.  Javacode 기반 설정

5. ContextLoaderListener

- Root container

6. HandleMapping

: Request를 처리할 handler(controller) 객체 선택

- RequestMappingHandler : @Controller and @RequestMapping 어노테이션 이용하여 handler 객체 선택

- URL matching pattern

* Ant pattern

? (한 개의 문자), * (0개 이상의 문자와 매칭), ** (0개 이상의 디렉토리와 매칭)

7. Controller 구현 : HTTP 전송 방식 지정

1) method 속성

2) @GetMapping, @PostMapping 이용

8. Request Param 추출 

1) HttpServletRequest 이용

2) @RequestParam

3) @PathVariable

3) @RequestHeader

4) @CookieValue

5) Servlet API

9. Command 객체를 통한 Form 입력 처리

: HTML Form 에 입력된 데이터를 자바빈 객체를 통해 입력 받음

- View 에서 command 객체 접근

- @ModelAttribute로 객체 이름 지정

- 여러 개