정적 팩터리 메서드란? 객체의 생성을 역할을 하는 클레스 메서드

클래스는 클라이언트에 public 생성자 대신 정적 팩터리 메서드를 제공할 수 있다.

정적 팩토리 메서드가 가지는 장점

1. 이름을 가질 수 있다

   • 생성자에 넘기는 매개변수와 생성자 자체만으로는 반환될 객체의 특성을 제대로 설명하지 못한다.
   • 반면 정적 팩터리는 반환될 객체의 특성을 쉽게 묘사할 수 있다.
   • 하나의 시그니처로는 하나의 생성자만을 만들 수 있다. 한 클래스에 시그니처가 같은 여러 생성자가 필요할 것 같으면, 생성자를 정적 팩터리 메서드로 바꾸고 각각의 차이를 잘 드러내는 이름을 지어주자.

2. 호출될 때마다 인스턴스를 새로 생성하지 않아도 된다.

   • 이 덕분에 불변 클래스는 인스턴스를 미리 만들어 놓거나, 새로 생성한 인스턴스를 캐싱하여 재활용하는 식으로 불필요한 객체 생성을 피할 수 있다. ex) Boolean.valueOf(boolean) 의 경우 객체를 아예 생성하지 않는다.

3. 반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다.

   • 이 장점은 엄청난 유연성을 가지게 되는데, API를 만들 때 이 유연성을 응용하면 구현 클래스를 공개하지 않고도 그 객체를 반환할 수 있어 API를 작게 유지할 수 있다.

4. 입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다.

   • 반환 타입이 하위 타입이기만 하면 어떤 클래스의 객체를 반환하든 상관없다.

5. 정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.

   • 이렁 유연함은 서비스 제공자 프레임워크를 만드는 근간이 된다. 이 구현체들을 클라이언트에 제공하는 역할을 프레임워크가 통제하여, 클라이언트를 구현체로부터 분리해준다.

이제 단점을 알아보자.

1. 상속을 사용하려면 public이나 protected 생성자가 필요하니 정적 팩터리 메서드만 제공하면 하위 클래스를 만들 수 없다.
2. 정적 팩터리 메서드는 프로그래머가 찾기 어렵다.
   • 정적 팩터리 메서드에 흔히 사용되는 명명 방식들
     • from, of, valueOf, getInstance, newInstance, create, getType, newType, type

출처

이펙티브 자바 - 조슈아 블로크 지음

(그림 출처 - (인프런) 스프링 MVC 1편 - 김영한)

요청 흐름

1. 핸들러 조회
2. 핸들러를 처리할 수 있는 핸들러 어댑터 조회
3. handle(handler)
4. 핸들러어댑터에서 handler 호출
5. 핸들러(컨트롤러)가 ModelAndView 반환
6. ViewResolver 호출
7. ViewResolver가 View 반환
8. render(model) 호출

DispatcherServlet 등록하는 법

• Spring : web.xml을 통해 등록

<servlet>
    <servlet-name>appServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/classes/servlet-context.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

• Spring Boot
  • Spring Boot에서는 DispatcherServlet을 자동으로 등록해주기 때문에 수동으로 등록해주지 않아도 됨

- `DispatcherServletConfiguration` 에서 `DispatcherServlet`을 bean으로 등록

    → dependency에서 해당 configuration을 갖고 있는 것으로 확인

코드를 통해 알아보는 DispatcherServlet 요청 Flow

1. 핸들러 조회 (1036 Line) → 요청을 처리할 Controller 조회

2. 핸들러 어댑터 조회 (1043 Line)

- HandlerAdapter 리스트를 순회하며 파라미터로 넘어온 handler를 지원하는지 확인
    - RequestMappingHandlerAdapter가 조회됨

3. handle(handler)
4. 핸들러 어댑터를 통해 핸들러 호출
5. 핸들러(컨트롤러)가 ModelAndView 반환

6. viewResolver 호출
7. View 반환

8. render(model) 호출

→ 여기까지 DispatcherServlet의 요청흐름에 대해서 알아보았다.

이제부터 HandlerMapping과 HandlerAdapter에 대해서 더 알아보자.

DispatcherServlet.properties를 확인하면 스프링에서 디폴트로 사용하는 HandlerMapping, HandlerAdapter 종류를 확인할 수 있다.

HandlerMapping

HTTP 요청정보를 이용해서 컨트롤러를 찾아주는 역할

• interface

• 스프링에서 사용하는 default HandlerMapping

• BeanNameUrlHandlerMapping : URL과 일치하는 이름을 갖는 빈과 매핑시켜주는 HandlerMapping 구현체
• RequestMappingHandlerMapping : @RequestMapping 애노테이션을 토대로 - RequestMappingInfo 인스턴스를 만드는 HandlerMapping 구현체
• RouterFunctionMapping : RouterFunction을 지원하는 HandlerMapping 구현체

HandlerAdapter

handler를 실행시켜주는 역할

• HandlerAdapter 인터페이스

- `supports` : 파라미터로 넘어온 Handler를 지원하는 지 여부를 판단하는 메서드
- `handle` : handler 호출하는 메서드

• 스프링에서 사용하는 default HandlerAdapter

• HttpRequestHandlerAdapter : HttpRequestHandler를 구현한 컨트롤러를 처리하는 HandlerAdapter 구현체
• SimpleControllerHandlerAdapter : Controller 인터페이스를 구현하여 만든 컨트롤러에 요청을 보낼 때 사용하는 HandlerAdapter 구현체
• RequestMappingHandlerAdapter : @Controller 클래스 내 @RequestMapping 어노테이션 핸들러 매핑을 처리하는 HandlerAdapter 구현체
• HandlerFunctionAdapter : RouterFunctionMapping를 처리하기 위한 - HandlerFunctions를 지원하는 HandlerAdapter 구현체

먼저 넣은 데이터가 먼저 나오는 FIFO(First in First out) 구조로 저장하는 자료 구조

(이미지 출처 : https://buildgoodhabit.tistory.com/142)

연산

• enQueue : 큐에 요소를 추가한다. rear + 1 을 하고 그 자리에 요소를 추가한다.
• deQueue : 큐에서 맨 앞의 요소를 제거한다. front + 1 을 하고 그 자리에 있던 요소를 출력한다.
• isEmpty : 큐가 비었는지를 확인한다. front == rear이면 큐가 비었다고 판단한다.
• peek : 큐의 맨 앞의 요소를 확인한다.

구현

• Array

public static class ArrayQueue {
        private int front, rear, size;
        private int capacity;
        private int array[];

        public ArrayQueue(int capacity) {
           this.capacity = capacity;
           front = this.size = 0;
           rear = capacity - 1;
           array = new int[this.capacity];
        }

        public boolean isFull(ArrayQueue queue) {
            return queue.size == queue.capacity;
        }

        public boolean isEmpty(ArrayQueue queue) {
            return queue.size == 0;
        }

        public void enqueue(int item) {
            if (isFull(this)) return;

            this.rear = (this.rear + 1) % this.capacity;
            this.array[this.rear] = item;
            this.size++;
            System.out.println(item + " enqueued to queue");
        }

        public int dequeue() {
            if (isEmpty(this)) return Integer.MIN_VALUE;

            int item = this.array[this.front];
            this.front = (this.front + 1) % this.capacity;
            this.size--;
            return item;
        }

        public int getFront() {
            if (isEmpty(this)) {
                return Integer.MIN_VALUE;
            }
            return this.array[this.front];
        }

        public int getRear() {
            if (isEmpty(this)) {
                return Integer.MIN_VALUE;
            }
            return this.array[this.rear];
        }
    }

• 시간복잡도
  • Enqueue(insertion) : O(1)
  • Dequeue(deletion) : O(1)
  • Front(Get front) : O(1)
  • Rear(Get rear) : O(1)
• 공간 복잡도
  • O(N)
• 배열 구현의 장점
  • 구현이 간단하다.
• 배열 구현의 단점
  • 사이즈가 고정되어 있다.
    
• Linked List

    public static class QNode {
        int key;
        QNode next;

        public QNode(int key) {
            this.key = key;
            this.next = null;
        }
     }

    public static class LinkedListQueue {
        private QNode front, rear;

        public LinkedListQueue() {
            this.front = this.rear = null;
        }

        public void enqueue(int key) {
            QNode temp = new QNode(key);

            if (this.rear == null) {
                this.front = this.rear = temp;
                return;
            }

            this.rear.next = temp;
            this.rear = temp;
        }

        public void dequeue() {
            if (this.front == null) {
                return;
            }

            QNode temp = this.front;
            this.front = this.front.next;

            if (this.front == null) {
                this.rear = null;
            }
        }
    }

• 시간복잡도
  • enqueue, dequeue : O(1)

Priority Queue

• 특징
  • 모든 항목에는 연관된 우선순위가 있다.
  • 우선 순위가 높은 요소는 우선 순위가 낮은 요소보다 먼저 큐에서 제거한다.
  • 두 요소의 우선 순위가 같으면 대기열의 순서에 따라 제공된다.

Dequeue (Double - ended Queue)

• 특징
  • Dequeue는 양쪽에서 넣고 빼고가 가능한 큐이다.
  • Dequeue는 Stack과 Queue를 합쳐놓은 것과 같다.
    • pushFront + popBack = Stack, pushBack + popFront = Queue

public class MyDequeue {
    private MyNode front, rear;

    public void pushFront(int data) {
        if (front == null) {
            this.front = this.rear = new MyNode(data);
        } else {
            MyNode temp = new MyNode(data);
            temp.next = this.front;
            this.front.prev = temp;
            this.front = temp;
        }

        System.out.println(data + " front pushed to dequeue");
    }

    public void pushBack(int data) {
        if (rear == null) {
            this.front = this.rear = new MyNode(data);
        } else {
            MyNode temp = new MyNode(data);
            temp.prev = this.rear;
            this.rear.next = temp;
            this.rear = temp;
        }

        System.out.println(data + " back pushed to dequeue");
    }

    public int popFront() {
        if (this.front == null) {
            System.out.println("Empty Dequeue");
            return -1;
        }
        MyNode temp = this.front;
        this.front = this.front.next;
        this.front.prev = null;
        return temp.data;
    }

    public int popBack() {
        if (this.rear == null) {
            System.out.println("Empty Dequeue");
            return -1;
        }
        MyNode temp = this.rear;
        this.rear = this.rear.prev;
        this.rear.next = null;
        return temp.data;
    }

    public class MyNode {
        MyNode prev;
        MyNode next;
        int data;

        MyNode(int data) {
            this.data = data;
        }
    }
}

참고

• https://www.geeksforgeeks.org/queue-set-1introduction-and-array-implementation
• https://www.geeksforgeeks.org/queue-linked-list-implementation/?ref=lbp
• https://www.geeksforgeeks.org/priority-queue-set-1-introduction/?ref=lbp

후입선출(Last In First Out - LIFO) 특성을 가지는 자료구조

(이미지 출처 : https://velog.io/@tiiranocode/자료-구조-스택stack-큐queue)

연산

• push : 스택에 item을 추가
• pop : 스택에서 item을 제거. 이때 제거되는 item은 넣은 순서의 역순으로 가장 위의 요소가 제거됨
• peek : stack의 top 요소 반환
• isEmpty: stack이 비어있으면 true, 그렇지 않으면 false를 반환

구현

스택은 후입선출(LIFO)의 개념으로, 배열과 연결리스트로 구현할 수 있다.

배열 예제

public class StackAsArray {
    static final int MAX = 1000;
    int top;
    int arrStack[] = new int[MAX];

    StackAsArray() {
        top = -1;
    }

    boolean isEmpty() {
        return (top < 0);
    }

    boolean push(int data) {
        System.out.println(data + " pushed to stack");

        if (top > MAX - 1) {
            System.out.println("Stack Overflow");
            return false;
        } else {
            arrStack[++top] = data;
            return true;
        }
    }

    int pop() {
        if (top < 0) {
            System.out.println("Stack is empty");
            return -1;
        } else {
            int x = arrStack[top--];
            return x;
        }
    }

    int peek() {
        return arrStack[top];
      }
}

연결 리스트 예제

public class StackAsLinkedList {

    StackNode root;

    static class StackNode {
        int data;
        StackNode next;

        StackNode(int data) { this.data = data; }
    }

    public boolean isEmpty() {
        if (root == null) {
            return true;
        }
        return false;
    }

    public void push(int data) {
        StackNode newNode = new StackNode(data);
        newNode.next = root;
        root = newNode;
        System.out.println(data + " pushed to stack");
    }

    public int pop() {
        if (root == null) {
            System.out.println("Stack is empty");
        }

        int popped = Integer.MIN_VALUE;
        popped = root.data;
        root = root.next;
        return popped;
    }

    public int peek() {
        if (root == null) {
            System.out.println("Stack is empty");
        }

        return root.data;
    }

    public static void main(String[] args) {
        StackAsLinkedList sll = new StackAsLinkedList();

        sll.push(10);
        sll.push(20);
        sll.push(30);

        System.out.println(sll.pop() + " popped from stack");

        System.out.println("Top element is " + sll.peek());
    }
}

참고

• https://namu.wiki/w/스택(자료구조)
• https://www.geeksforgeeks.org/stack-data-structure-introduction-program/

왜 안될까................... 이유를 찾아보니 vuejs 공식문서 예외적인상황들

$refs 는 컴포넌트가 렌더링 된 후에 접근할 수 있으며, 반응형이 아닙니다. 즉, 직접적인 자식 요소 제어에만 유효합니다 - $refs를 template나 computed 속성 안에 포함시키지 않는 것이 좋습니다.

<b-tr v-if="조건">
     <b-th>판매자</b-th>
         <b-td colspan="3">
             <child-component :render="{ label: false }"
                              v-model="merchant"
                              ref="childComponent">
            </child-component>
         </b-td>
</b-tr>

ref로 사용하는 컴포넌트가 렌더링 되지 않아 생긴 문제였다. v-if를 사용하는 것이 문제가 될 수 있었던 것이다....

해결 방법

v-if 대신 v-show를 사용해 조건에 상관없이 페이지에 렌더링 시켜주는 방법으로 해결할 수 있었다.

v-if를 사용할 경우 제약사항이 생길 수 있다는 것을 몰랐던게 좀 아쉽다.

_처음부터 공식문서를 정독하는 방법으로 공부를 했다면 이런 실수를 하지 않았을 텐데, 틈틈히 공식문서를 읽어야겠다. _

1.1 자바란?

자바의 가장 중요한 특징은 운영체제에 독집적이라는 것이다.

• 자바로 작성된 프로그램은 운영체제의 종류에 관계없이 실행이 가능하기 때문에, 운영체제에 따라 프로그램을 전혀 변경하지 않고도 실행이 가능하다.

1.3 자바 언어의 특징

1. 운영체제에 독립적이다.

• 이는 자바가상머신(JVM)을 통해서 가능한 것인데, 자바 응용 프로그램으로부터 전달받은 명령을 해당 운영체제가 이해할 수 있도록 변환하여 전달한다. 자바로 작성된 프로그램은 운영체제에 독립적이지만, JVM은 운영체제에 종속적이다.

2. 객체지향언어이다.
3. 비교적 배우기 쉽다.
4. 자동 메모리 관리(Garbage Collection)

• 자바로 작성된 프로그램이 실행되며, Garbage Collector가 자동적으로 메모리를 관리해주기 때문에 프로그래머는 메모리를 따로 관리 하지 않아도 된다.

5. 네트워크와 분산처리를 지원한다.
6. 멀티쓰레드를 지원한다.

• 자바에서 개발되는 멀티쓰레드 프로그램은 시스템과는 관게없이 구현가능하며, 관련된 라이브러리가 제공되므로 구현이 쉽다. 그리고 여러 쓰레드에 대한 스케줄링을 자바 인터프리터가 담당하게 된다.

7. 동적 로딩(Dynamic Loading)을 지원한다.

• 보통 자바로 작성된 애플리케이션은 여러 개의 클래스로 구성되어 있다. 자바는 동적 로딩을 지원하기 때문에 실행 시에 모든 클래스가 로딩되지 않고 필요한 시점에 클래스를 로딩하여 사용할 수 있다는 장점이 있다.

참고 : 자바의 단점으로는 속도문제가 가장 대표적이지만 바이트 코드를 하드웨어의 기계어로 바로 변환해주는 JIT 컴파일러와 Hotspot과 같은 신기술의 도입으로 JVM의 기능이 향상됨으로서 속도 문제가 상당히 개선되었다.

1.4 JVM(Java Vertual Merchine)

JVM은 '자바를 실행하기 위한 가상 기계'라고 할 수 있으며, '가상 기계'는 소프트웨어로 구현된 하드웨어를 뜻하는 넓은 의미의 용어이다. 자바로 작성된 애플리케이션은 모두 JVM에서만 실행된다.

일반 애플리케이션의 코드는 OS만 거치고 하드웨어로 전달되는데 비해 Java 애플리케이션은 JVM을 한 번 더 거치기 때문에, 그리고 하드웨어에 맞게 완전히 컴파일된 상태가 아니고 실행 시에 해석(interpret)되기 때문에 속도가 느리다는 단점을 가지고 있다. 그러나 요즘엔 바이트코드를 하드웨어 기계어로 바로 변환해주는 JIT 컴파일러와 향상된 최적화 기술이 적용되어서 속도의 격차를 많이 줄였다.

자바 애플리케이션은 JVM하고만 상호작용을 하기 때문에 OS와 하드웨어에 독립적이라 다른 OS에서도 프로그램의 변경없이 실행이 가능하다. 단, OS에 종속적이기 때문에 해당 OS에서 실행가능한 JVM이 필요하다.

원문

Java의 정석 3rd Edition 남궁성 지음

$ git rebase -i `수정하고자 하는 log의 hash값`

2. 변경 원하는 log를 edit으로 변경 후 나가기
![](https://images.velog.io/images/soso_ok9/post/ad90b43c-5634-40ea-83d1-878e3ff668f7/image.png)
pick -> edit으로 수정 후 esc -> :wq 입력

3. git amend로 author 수정

$ git commit --amend --author="사용자명 <이메일>"

4. git rebase 종료


****** 참고 ******
https://jojoldu.tistory.com/120

| : 또는 () : 그룹 [] : 문자셋, 괄호안에 어떤 문자든 [^] : 부정 문자셋, 괄호안에 어떤 문자가 아닐때 (?:) : 찾지만 기억하지는 않음

Quantifiers

? : 있거나 없거나 * : 없거나 있거나 많거나 + : 하나 또는 많이 {n} : n번 반복 {min,} : 최소 {min,max} : 최소, 그리고 최대

Boundary-type

\b : 단어 경계 \B : 단어 경계가 아님 ^ : 문장의 시작 $ : 문장의 끝

Character classes

. : 어떤 글자(줄바꿈 문자 제외) \d : digit 숫자 \D : digit 숫자 아님 \w : word 문자 \W : word 문자 아님 \s : space 공백 \S : space 공백 아님

** < 참고 > ** https://github.com/dream-ellie/regex

객체지향 설계 원칙(SOLID)는 아래 5가지 원칙의 첫 글자를 따서 만든 단어다.

1. SRP(The Single Responsibility Principle) : 단일 책임 원칙 모든 클래스는 각각 하나의 책임만 가져야한다. 클래스는 그 책임을 완전히 캡슐화해야 함을 말한다.

2. OCP(The Open Closed Principle) : 개방 폐쇄 원칙 확장에는 열려 있고 수정에는 닫혀있는, 기존의 코드를 변경하지 않으면서(Closed), 기능을 추가할 수 있도록(Open) 설계가 되어야 한다는 원칙을 말한다.

3. LSP(The Liskov Subsititution Principle) : 리스코프 치환 원칙 자식 클래스는 언제나 자신의 부모 클래스를 대체할 수 있다는 원칙이다. 즉 부모 클래스가 들어갈 자리에 자식 클래스를 넣어도 계획대로 잘 작동해야한다. 자식클래스는 부모 클래스의 책임을 무시하거나 재정의하지 않고 확장만 수행하도록 해야 LSP를 만족한다.

4. ISP(The Interface Segregation Principle) : 인터페이스 분리 원칙 한 클래스는 자신이 사용하지 않는 인터페이스는 구현하지 말아야 한다. 하나의 일반적인 인터페이스보다 여러개의 구체적인 인터페이스가 낫다. 즉 어떤 클래스가 다른 클래스에 종속될 때에는 가능한 최소한의 인터페이스만을 사용해야 한다.

5. DIP(The Dependency Inversion Principle) : 의존관계 역전 원칙 의존 관계를 맺을 때 변화하기 쉬운 것 또는 자주 변화하는 것보다 변화하기 어려운 것, 거의 변화가 없는 것에 의존하라는 것이다. 한 마디로 구체적인 클래스보다 인터페이스나 추상 클래스와 관계를 맺으라는 것이다.

높은 응집도와 낮은 결합도

개방 폐쇄 원칙은 높은 응집도와 낮은 결합도라는 소프트웨어 개발의 고전적인 원리로도 설명이 가능하다. 응집도가 높다는 건 하나의 모듈, 클래스가 하나의 책임 또는 관심사에만 집중되어 있다는 뜻이다. 불필요하거나 직접 관련이 없는 외부의 관심과 책임이 얽혀있지 않으며, 하나의 공통 관심사는 한 클래스에 모여있다.

• 높은 응집도 응집도가 높다는 것은 변화가 일어날 때 해당 모듈에서 변하는 부분이 크다는 것으로 설명할 수도 있다.

• 낮은 결합도 낮은 결합도는 높은 응집도보다 더 민감한 원칙이다. 책임과 관심사가 다른 오브젝트 또는 모듈과는 낮은 결합도, 즉 느슨하게 연결된 형태를 유지하는 것이 바람직하다. 느슨한 연결은 관계를 유지하는 데 꼭 필요한 최소한의 방법만 간접적인 형태로 제공하고, 나머지는 서로 독립적이고 알 필요도 없게 만들어주는 것이다. 결합도가 낮아지면 변화에 대응하는 속도가 높아지고, 구성이 깔끔해진다. 또한 확장하기도 매우 편리하다.

• 참고 https://medium.com/@hckcksrl/solid-%EC%9B%90%EC%B9%99-182f04d0d2b 토비의 스프링 3.1 Vol1 | 스프링의 이해와 원리 이일민 지음

mac에서 Java를 설치하는 방법

[1] 아래 링크에서 jdk 설치 파일을 다운 받고 실행하기 https://www.oracle.com/kr/java/technologies/javase-jdk11-downloads.html

[2] Terminal 열기

$ cd /Library/Java/JavaVirtualMachines 
$ ls 

[3] 환경변수 편집

$ vi ~/.bash_profile

[4] java -version 확인

[5] Test

# Test.java
public class Test{
        public static void main(String [] args){
                System.out.println("Hello World!");
        }
}

Java 8 설치 참고 링크

https://mkyong.com/java/how-to-install-java-on-mac-osx/