리루

Java8 - Optional

뚱보리루 — Sun, 5 Jul 2020 12:24:46 +0900

- 비어있을 수 있고, 어떤 값을 갖고 있을 수 있는 컨테이너 인스턴스

- null 체크를 하지 않으면 Null Pointer Exception이라는 문제가 발생 할 경우가 잦아질 수 있다.

- 매번 Null check 할 수 없고 Human error가 있을 수 있다.

- Null을 반환할 수 있는 상황 자체도 문제다.

방법 1.

- null이 반환될 수 있는 코드에서 미리 null check를 해서 client 코드에 편의를 제공할 수 있다. 하지만 로직상 자꾸 exception 처리를 넣는건 좋은 습관이 아니다.

방법 2.

- null을 그냥 반환하고 client 코드에서 null check를 한다.

- 리턴 값으로만 Optional로 사용하길 권장된다. (매개변수 등으로 사용가능하지만 호출하는 쪽에서 Optional 타칩이지만 null을 넘겨 줄 수 있으므로 이는 NPE가 발생할 수 있는 위험한 방식이다.)

public void optionalParameter(Optional<Param> param){

}

optionalParameter(null);

- 맵의 키 타입으로 Optional을 사용하면 안된다. Map의 큰 컨셉 중 하나는 key 값이 null이 아닌 것인데 Optional을 키로 사용했을 경우에 키가 있을 수도, 없을 수도 있다는 것 자체가 문제가 될 수 있다.

- 인스턴스 필드타입으로도 사용하지 말자. 어떠한 클래스의 필드가 있을 수도 있고, 없을 수도 있다라는 도메인 클레스 설계는 좋지 못하다.

- 컨테이너 성 데이터 타입 (Collection, Map, Stream, Array,Optional)은 이미 자체적으로 비어있는지 여부에 대해서 확인 할 수 있으니 Optional로 한번 더 작업 할 필요가 없다.

검사 및 값 가져오기

- isPresent()로 있는지 없는지 확인 가능.

- Java11 부터는 isEmpty() 도 제공.

- get() 을 통해서 값을 가져 올 수 있다.( 값이 들어있을 때는 문제가 없지만 값이 안들어 있으면 NoSuchElementException 발생)

- get() 호출 전에 해당 값이 있는지 확인 필요.

- 값이 있을 때의 처리는 ifPresent() 를 사용해 처리하면 추가적인 값 확인 없이 사용할 수 있다.

- 값을 가져올 때는 orElse()를 사용해서 있으면 값을 꺼내오고, 없으면 새로운 클래스를 만드는 메소드 호출 등의 방법을 사용

- orElseGet(Supplier) 를 사용할 수 도 있는데 이 둘의 차이는 orElse의 경우에는 참이든 거짓이든 parameter 속의 내용을 수행하지만 orElseGet의 경우에는 Else인 케이스에만 Supplier를 수행하게 된다. orElse 같은 경우에는 상수같이 이미 만들어진 작업에 대해서는 사용하는 것이 적절하고, 동적으로 무엇을 만들어야 하는 상황에서는 orElseGet이 더 적절할 수 있다.

- 중복 Optional일 경우에는 flatMap을 통해서 한번에 까버릴 수 있다.

// 양파까기
Optional<Optional<Day>> day = optional.map(Date::getDay);
Optional<Day> day2 = day1.orElse(Optional.empty());

// flatMap 사용
Optional<Day> test = optional.flatMap(Date::getDay);

Steam

뚱보리루 — Sun, 5 Jul 2020 11:06:03 +0900

Stream

-https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html

- Sequence of elements supporting sequential and parallel aggregate operations.

- 연속된 데이터를 처리하는 Operation의 모임

- 데이터를 담는 저장소가 아니라 데이터를 소스로 사용해서 어떠한 처리를 하는 것

- Functional in nature : Stream으로 전달받은 데이터 다체를 변경하는게 아니라 또다른 Stream을 반환한다.

- 들어오는 데이터가 무제한일 수 있다.

- 들어오는 데이터가 무제한일 때 Short Circuit 메소드를 사용해 제한할 수 있다.

- Stream 이 제공하는 Operation은 계속해서 이어지는 중계형 Operation(Stream을 반환)과 종료 Operation(Stream이 아닌 다른 형태를 반환)으로 나눌 수 있다. (forEach도 stream 반환이 아니라 종료 Operation이다)

- Stream 데이터 소스는 오직 터미널 오퍼네이션을 실행할 때에만 처리한다. (중계형 Operation들은 Lazy하게 동작한다.)

package com.example.demok;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class RunSomething {

    public static void main(String[] args) {

    }

    public void run(){

        List<String> alphabet = new ArrayList<>();
        alphabet.add("a");
        alphabet.add("b");
        alphabet.add("c");
        alphabet.add("d");
        alphabet.add("e");

        // Do nothing because of no terminate operation
        alphabet.stream().map( s -> {
            System.out.println(s);
            return s.toUpperCase();
        });

        // Return a list
        List<String> upperCases = alphabet.stream().map( s -> {
            System.out.println(s);
            return s.toUpperCase();
        }).collect(Collectors.toList());

    }
}

pallarel stream

- ForkJoinPool 을 이용해 여러개의 Thread를 사용해 병렬로 동작한다.

- 무조건 paralleaStream을 사용한다고 빠른 것은 아니다.(Context Switch에 시간이 더 걸리는 케이스가 있을 것.)

    @Test
    public void streamTest(){
        List<String> alphabet = new ArrayList<>();
        alphabet.add("a");
        alphabet.add("b");
        alphabet.add("c");
        alphabet.add("d");
        alphabet.add("e");

        List<String> list = alphabet.parallelStream().map( s -> {
            System.out.println(s + ", " + Thread.currentThread().getName());
            return s.toUpperCase();
        }).collect(Collectors.toList());

        /*
        c, main
        a, ForkJoinPool.commonPool-worker-3
        e, ForkJoinPool.commonPool-worker-2
        b, ForkJoinPool.commonPool-worker-1
        d, ForkJoinPool.commonPool-worker-4
         */
    }

Java8 함수형 인터페이스

뚱보리루 — Sat, 4 Jul 2020 16:16:17 +0900

Functional Interface : Any interface with a SAM(Single Abstract Method) is a functional interface, and its implementation may be treated as lambda expressions.

- Java8에서는 Interface에 static method / default method가 사용가능하다. 이러한 추가적인 함수들이 있더라도 SAM이 하나만 존재한다면 Functional Interface라고 할 수 있다.

- `void do something();` 앞에는 `abstract`가 생략되어 있다고 볼 수있다.

- Abstract Method가 복수개가 되면 컴파일에러가 발생한다.(`@FunctionalInterface`가 있는 경우)

- `@FunctionalInterface`는 자바 standard library에 포함되어 있기 때문에 따로 import 되지 않는다.

package com.example.demok;

@FunctionalInterface
public interface Something {
    
    void doSomething();
    
    static void doStatic(){
        System.out.println("Static method");
    }
    
    default void doDefault(){
        System.out.println("Default method");
    }
    
}

package com.example.demok;

public class RunSomething {

    public static void main(String[] args) {

        // Anonymous inner class
        Something something = new Something() {
            @Override
            public void doSomething() {
                System.out.println("Something");
            }
        };
        something.doSomething();

        // Lambda expression
        Something newSomething = () -> System.out.println("New Something");
        newSomething.doSomething();

        // Lambda expression 2
        Something multiSomething = () -> {
            System.out.println("New Something 1");
            System.out.println("New Something 2");
        };
        multiSomething.doSomething();

    }
}

특징

1. 함수를 First class object로 사용 할 수 있다.

- Lambda expression 같은 형태를 리턴, 매개변수 등 Objcect 같이 사용할 수 있다.

2. 순수함수(Pure Function)

- Side Effect를 만들 수 없다. 함수 밖 변수 변경할 수 없다.

- 동일한 input이 들어가면 결과는 항상 같아야 한다.

- 상태가 없다.

3. 고차함수(Higher Order Function)

- 함수가 함수를 매개변수로 사용할 수 있고, 함수를 리턴할 수 있다.

자바가 기본으로 제공해주는 함수형 인터페이스들이 있다.

1. Function

/**
 * Represents a function that accepts one argument and produces a result.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #apply(Object)}.
 *
 * @param <T> the type of the input to the function
 * @param <R> the type of the result of the function
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

package com.example.demok;

import java.util.function.Function;

public class AppendQuestionMark implements Function<String, String> {


    @Override
    public String apply(String s) {
        return s.concat("!");
    }
}

package com.example.demok;

import java.util.function.Function;

public class RunSomething {

    public static void main(String[] args) {

        AppendQuestionMark appendQuestionMark = new AppendQuestionMark();
        System.out.println(appendQuestionMark.apply("Let's Go Home"));

        Function<String, String> concatQuestionMark = (s) -> s.concat("!");
        System.out.println(concatQuestionMark.apply("Let's Go Home"));
    }
}

1-1. compose(), andThen()

- 다른 함수들과 조합해서 사용할 수 있는 함수 제공.

- compose 내부의 함수 먼저 수행 후, 외부함수 수행

@FunctionalInterface
public interface Function<T, R> {
    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
}

package com.example.demok;

import java.util.function.Function;

public class RunSomething {

    public static void main(String[] args) {

        Function<String, String> concatQuestionMark = (s) -> s.concat("?");
        Function<String, String> concatStarMakr = (s) -> s.concat("*");
        Function<String, String> multiFunction = concatQuestionMark.compose(concatStarMakr);
        
        // Would you like something to drink*?
        System.out.println(multiFunction.apply("Would you like something to drink"));
        // Would you like something to drink?*
        System.out.println(concatQuestionMark.andThen(concatStarMakr).apply("Would you like something to drink"));
    }
}

2. Consume

- 반환타입은 없고, 입력타입만 존재하는 함수형 인터페이스

/**
 * Represents an operation that accepts a single input argument and returns no
 * result. Unlike most other functional interfaces, {@code Consumer} is expected
 * to operate via side-effects.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #accept(Object)}.
 *
 * @param <T> the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
 }

3. Supplier

- 입력타입은 없고 반환타입만 존재하는 함수형 인터페이스

/**
 * Represents a supplier of results.
 *
 * <p>There is no requirement that a new or distinct result be returned each
 * time the supplier is invoked.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #get()}.
 *
 * @param <T> the type of results supplied by this supplier
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

package com.example.demok;

import java.util.function.Consumer;
import java.util.function.Supplier;

public class RunSomething {

    public static void main(String[] args) {

        // Hello World!
        Consumer<String> consumer = (s) -> System.out.println("Hello" + s);
        consumer.accept("World!");

        // Hello World!
        Supplier<String> supplier = () -> "Hello World!";
        System.out.println(supplier.get());
        
    }
}

4. Predicate

- 인자 하나를 받아서 true / false 를 반환해주는 함수형 인터페이스

/**
 * Represents a predicate (boolean-valued function) of one argument.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #test(Object)}.
 *
 * @param <T> the type of the input to the predicate
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

package com.example.demok;

import java.util.function.Predicate;

public class RunSomething {

    public static void main(String[] args) {

        // True
        Predicate<Integer> predicate = (i) -> i < 10;
        System.out.println(predicate.test(5));
    }
}

5. UnaryOperator

- Function의 입출력 두 값의 형태가 동일 할 때 사용가능

package java.util.function;

/**
 * Represents an operation on a single operand that produces a result of the
 * same type as its operand.  This is a specialization of {@code Function} for
 * the case where the operand and result are of the same type.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #apply(Object)}.
 *
 * @param <T> the type of the operand and result of the operator
 *
 * @see Function
 * @since 1.8
 */
@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

package com.example.demok;

import java.util.function.UnaryOperator;

public class RunSomething {

    public static void main(String[] args) {

        UnaryOperator<String> unaryOperator = (s) -> s + "world!";
        System.out.println(unaryOperator.apply("Hello "));
    }
}

변수 캡쳐

- 로컬 클래스, 익명 클래스, 람다함수 에서는 외부 변수가 `final`인 경우에만 참조가 가능했다.

- Java8부터는 `final`이 명시적으로 붙어 있지 않아도 Effective fianl(`final`이 붙어 있지 않지만 실질적으로 변화가 없어 final처럼 사용되는 변수)는 사용가능하다.

- Effective final 변수가 어디선가 변경된다면 컴파일 에러가 발생한다.

- 로컬 클래스, 익명 클래스, 네스트 클래스는 각 클래스가 생성되면 해당 클래스에 새로은 scope이 생겨서 변수에 대한 쉐도윙이 일어난다.

- 람다는 사용되는 메서드와 scope가 같아서 쉐도윙이 되지 않는다.

package com.example.demok;

import java.util.function.Consumer;

public class RunSomething {

    public static void main(String[] args) {
        
    }
    
    public void run(){
        int localValue = 1;
        
        // Inner Class
        class innerClass {
            int localValue = 2;
            void method(){
                System.out.println(localValue);
            }
        }
        
        // Anonymous class
        Consumer<Integer> consumer = new Consumer<Integer>() {
            @Override
            public void accept(Integer localValue) {
                System.out.println(localValue);
            }
        };
        
        // Lambda
        // Error : Variable 'localValue' is already defined in the scope
        Consumer<Integer> integerConsumer = (localValue) -> System.out.println(localValue);
                
    }
}

1. 쿠버네티스를 알기위한 기본 사항들

뚱보리루 — Mon, 25 May 2020 16:52:29 +0900

1. 쿠버네티스 사용 이유.
- 대규모 서비스를 최대한 자원을 효율적으로 사용하기 위함.
- 기존 VM(VMWare, Open Stack)들은 가상화는 되는데 효율이 안나왔다.(무거운 OS를 사용하게 돼서)
- dot Cloud 라는 회사가 Linux의 cgroup이라는 자원 격리기술을 Container라는 기술로 만드들고 docker라고 회사명을 변경
- 컨테이너 가상화 기술은 서버스간 자원격리를 해서 OS를 따로 띄우지 않아도 됨.
- OS 가동시간이 없기 때문에 자동화시에 엄청 빠르고 자원 효율도 매우 높음.
- 근데 도커 자체는 하나의 서비스를 컨테이너로 가상화시켜서 배포를 하는거지 엄청 많은 서비스들을 운영할 때 그걸 일일이 배포하고 운영하는 역할을 하진 않는다.
- 이런걸 해주는게 컨테이너 오케스트레이션이라는 개념이고, 여러 컨테이너들을 관리해주는 솔루션이라고 보면됨.
- 도커가 오픈소스라 이를 활용해 오케스트레이션 서비스(오케스트레이터)들이 많은 회사에서 나왔는데 이 중 하나가 구글의 쿠버네티스다.
- 쿠버네티스 개발시에는 여러 회사가 참여함(ms, google, ibm 등등)

1.1 쿠버네티스가 해주는 자동화
- Auth Scaling : 트래픽에 따라 자원을 자동으로 구성
- Auto Healing : 한 서버가 장애가 나도 장애가난 서버 위에 있는 서비스들이 다른 서버로 이동시켜주는 기능.
- Deployment : 기능을 통해 RollingUpdate, ReCreate 기능 지원

1.2 VM vs Container
- VM : Host OS 위에 VM 가상화를 위한 hypervisor가 있고 그 위에서 GuestOS 구성
- Container : Host OS위에 Container 가상화를 시켜주는 여러 소프트웨어 들이 있고(도커, rkt, LXC)
- 도커가 컨테이너를 만들어주는데 이 컨테이너는 서버와 이를 위한 라이브러리를 함께 이미지로 만들 수 있다.
- 도커는 여러 컨테이너간에 Host 자원을 분리해서 사용하게 해준다.(namespace, cgroups을 사용해 격리를하게되고, namespace는 커널에 관한 영역을 분리(mnt,pid,net,ipc), cgroups는 자원에 관한 영역을 분리(memory, CPU, I/O, network) )
- 컨테이너 가상화가 깔려있는 OS에서는 개발환경에 대한 걱정 없이 배포가 가능해짐
- 시스템 구조적으로 컨테이너는 한 OS를 공유하는 개념이고, VM은 각각의 OS를띄워야해 컨테이너가 빠를 수 밖에 없다.
- 보안적으로 vm은 게스트 os가 뚫려도 다른 게스트 os나 host os 와 완벽히 분리가 되어있어 영향이 없는데, 컨테이너는 한 컨테이너가 뚫려 os 영역에 접근가능해지면 다른 컨테이너가 위험에 쳐할 수 있다.
- 컨테이너는 시스템을 모듈별로 만들어 개발했을 때 배포 및 확장부분에 있어 효율적이다. VM의 경우에는 새로운 게스트 OS를 띄워야해 불필요하게 모듈을 확장해 자원을 낭비해야 하는 경향이 있다.

2. 쿠버네티스 사용자
  2.1 쿠버네티스 운영자
   - 클러스터를 운영
   - Installation, Architecture, Networking
  2.2 쿠버네티스 사용자
   - 쿠버네티스 기능을 이용해서 서비스를 배포
   - Workloads, Service, Storage / Config, Metadata, Cluster

3. 쿠버네티스 개념
- Master, Node들로 구성된 쿠버네티스 Cluster
- Node들은 자원을 제공, Master는 쿠버테니스 전반적인 기능을 컨트롤
- 클러스터 내 namespace가 쿠버테니스 오브젝트들을 독립된 공간으로 분리해준다.
- Namesapce는 쿠버네티스 최소 배포단위인 Pod들이 있고, Pod들에게 외부로부터 접근이 가능하게 해주는 Service가 있다.
- 서로다른 Namesapce에 있는 pod들에게는 Service에서 연결이 불가.
- Pod 안에는 여러 Container들이 있고, 컨테이너 하나 당 하나의 앱이 돌아가니, pod 하나당 여러 앱들이 돌아갈 수 있다.
- 근데 Pod에 문제가 생겨 재생성이 되면 그 안에 있는 데이터들이 다 날아가서 공용으로 사용할 수 있는 Volume을 만들어 사용 가능.
- Namespace에 ResourceQuota와 LimitRange를 달아서 pod 갯수나 cpu/memory를 제한할 수 있다.
- ConfigMap이나 Secret을 통해서 Pod 생성시 환경변수 값이나 파일 마운팅이 가능하다.
- Controller가 Pod들을 관리해준다.
    - Replication Controller, ReplicaSet이 기본적인 컨트롤러인데, 파드가 죽으면 감지해 살려주거나 파드의 갯수를 scale in-out 해준다.
    - Deployment는 배포 후 새 파드들을 업그래이드 해주고 배포시 문제가 생기면 롤백을 도와준다.
    - DaemonSet은 한 노드에 파드가 하나씩만 유지되게 해준다. (이런 케이스는 추후 설명)
    - Job은 어떤 특정 작업만하고 종료되어야 할때 사용, 이게 주기적인 작업이 되면 Cron Job 사용.

5. Servlet (써블릿) - DispatcherServlet

뚱보리루 — Sun, 2 Feb 2020 22:12:14 +0900

1. 요청이 어떻게 처리되느냐?

- 해당 요청의 정보들을 판단한다.(Multipart, Theme, etc..)

- 요청을 처리할 수 있는 Handler를 찾는다. (DispatcherServlet 이 들고있는 여러 종류의 HandlerMapping 중, 기본적으로는 BeanNameUrlHandlerMapping, RequestMappingHandlerMapping 인터페이스가 있다.)

- RequestMappingHandlerMapping 가 @Controller, @GetMapping, @PostMapping 등을 사용한 Handler를 찾아준다.

- 찾은 Handler를 가져와 어느 HandlerAdapter가 찾아낸 Handler를 실행할 수 있는가를 찾아낸다. 이 경우에는 RequestMappingHandlerAdaptor가 해당 Handler를 지원한다.

- HandlerInternal Method 안에서 Java의 Reflection을 통해서 invokeHandlerMethod를 수행한다.

- 해당 Hander를 수행하고, 결과값을 반환한다.

- 여러 타입(15가지)의 ReturnValueHandler 중 반환되는 값의 타입을 어던 Handler가 처리해줄 수 있는지 선택된다.

- @RestController(@Controller + @ResponseBody)일 경우에는 RequestResponseBodyMethodProcessor 가 처리해줄 수 있다.( 그리고 이 상황에서는 ModelAndView 값은 Null이다.)

- Convertor를 사용해 Return 값을 Http Reponse 본문에 넣어주는 역할을 한다.

4. Servlet (써블릿) - Servlet Application에 Spring MVC 적용

뚱보리루 — Sun, 2 Feb 2020 20:10:18 +0900

1. Servlet Application에 Spring 적용의 의미란?

- 스프링이 제공하는 IoC 컨테이너를 활용하겠다.

- 스프링이 제공하는 서블릿 구현체 DispatcherServlet을 사용하겠다.

1-1. (임의로 만든 Servlet에서) 스프링이 제공하는 IoC 컨테이너를 활용하겠다.

- 의존성 필요

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>

- web.xml 파일 내 Listener 변경(기등록된 리스너를 제거하고, Spring에서 제공하는 ContextLoaderListener 등록)

- ContextLoaderListener는 Spring IoC Container (즉, Application Context)를 Servlet Application 생명 주기에 맞춰서 바인딩해준다.

- Application Context를 Web Application에 등록되어있는 Servlet들이 사용할 수 있도록 Application Context를 만들어서 이 Application Context를 Servlet Context에 ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE라는 이름으로 등록해주고(*Servlet Context : Servlet 들이 사용할 수 있는 공용의 정보들을 모아두는 공간), Servlet Context가 종료될 시점에 제거해준다.

public class ContextLoader {
	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    	
        // ...
        
		servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
        
        // ...
    }
}

- ApplicationContext를 만들어야하기 때문에 Spring 설정파일이 필요하다. (기본으로는 xml 형태의 설정파일을 사용하지만 java 파일로도 설정파일을 만들 수 있다.)

- ContextLoaderListener 가 AnnotationConfigWebApplicationContext를 만들 때, AppConfig를 이용해 만든다.

- 그러면 ApplicationContext 안에는 HelloService가 Bean으로 등록되어있다.

- 만든 Servlet에서 ApplicationContext 통해서 HelloService를 꺼내 쓸 수 있다.

a. web.xml에 AnnotationConfigWebApplicationContext, AppConfigf를 파라미터로 한 ContextLoaderListener를 추가.

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!-- Parameter for ContextLoaderListener -->
  <!-- public static final String CONTEXT_CLASS_PARAM = "contextClass"; -->
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
  </context-param>

  <!-- Parameter for ContextLoaderListener -->
  <!-- public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation"; -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>me.json.AppConfig</param-value>
  </context-param>

  <!-- Register a filter -->
  <filter>
    <filter-name>myFilter</filter-name>
    <filter-class>me.json.MyFilter</filter-class>
  </filter>

  <!-- Mapping filter to servlet-->
  <filter-mapping>
    <filter-name>myFilter</filter-name>
    <servlet-name>hello</servlet-name>
  </filter-mapping>

  <!-- Register Servlet Listener-->
  <!--<listener>-->
    <!--<listener-class>me.json.MyListener</listener-class>-->
  <!--</listener>-->

  <!-- Register ContextLoaderListener that is provided by Spring-->
  <!-- * contextClass(Parameter) : AnnotationConfigWebApplicationContext -->
  <!-- * contextConfigLocation(Parameter) : me.json.AppConfig -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>


  <!-- Register servlet -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>me.json.HelloServlet</servlet-class>
  </servlet>


  <!-- Mapping Servlet with url pattern -->
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

</web-app>

b. AppConfig.java 생성

- ContextLoaderListner의 contextConfigLocation 파라미터로 사용됨

- @ComponentScan을 이용해 bean 등록

- 과거에는 xml 파일로 많이 사용되었지만 요즘은 xml이 사용되지 않는 추세이므로 java 파일로 대체

package me.json;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class AppConfig {
}

c. HelloService.java 생성

package me.json;

import org.springframework.stereotype.Service;

@Service
public class HelloService {

    public String getName(){
        return "json";
    }
}

d. Servlet에서 ApplicationContext 가져오기 및 등록된 Bean(HelloService.class) 활용

package me.json;

import org.springframework.context.ApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

import static org.springframework.web.context.WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;

public class HelloServlet extends HttpServlet {

    @Override
    public void init() throws ServletException {
        System.out.println("init");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        // Get HelloService Bean that is registered in Application Context
        ApplicationContext context = (ApplicationContext) getServletContext().getAttribute(ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        HelloService helloService = context.getBean(HelloService.class);

        System.out.println("doGet");
        resp.getWriter().print("<html>");
        resp.getWriter().print("<head>");
        resp.getWriter().print("<body>");
        resp.getWriter().print("<h1>Hello Servlet</h1>");
        resp.getWriter().print("<h1>Hello" + getName() + "</h1>");
        resp.getWriter().print("<h1>Hello" + helloService.getName() + "</h1>");
        resp.getWriter().print("</body>");
        resp.getWriter().print("</head>");
        resp.getWriter().print("</html>");
    }

    private Object getName() {
        // Get attribute value that is set in the Servlet listener
        return getServletContext().getAttribute("name");
    }

    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

1-2. 스프링이 제공하는 서블릿 구현체 DispatcherServlet을 사용하겠다.

- 서블릿을 만들때마다 web.xml에 설정이 늘어난다.

- 여러 서블릿에서 공통으로 처리하고 싶은 부분이 있는데, (filter로 처리할 수 있긴하지만) Front Controller라는 디자인 패턴이 있다.(모든 요청을 Controller 하나가 받아서 처리한다. 해당 요청을 처리할 핸들러들에게 분배(Dispatch)하는 패턴이다.)

- Spring이 Front Controller 역할을 하는 Servlet을 만들어 놓았는데 그것이 바로 DispatcherServlet이다.

- DispatcherServlet은 Root WebApplicationContext를 상속받아 새로운 Servlet WebApplicationContext를 만든다.

- Root WebApplicationContext : ContextLoaderListener에 의해 ServletContext에 등록된 ApplicationContext로 모든 Servlet에서 사용 가능하다.(Services, Repositories Bean과 같이 다른 DispatcherServlet에서도 공용으로 사용 할 수 있다.)

- Servlet WebApplicationContext : DispatcherServlet에서 Root WebApplicationContext를 상속받아 만든 ApplicationContext로, 해당 DispatcherServlet에서만 사용가능하다. (해당 DispatcherServlet에 한정된 Controller, View 같은 Bean들이 등록된다.)

- DispatcherServlet 은 Front Controller 역할을 한다.

- /app 으로 시작하는 모든 요청은 DispatcherServlet을 통해 들어온다.

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!-- Parameter for ContextLoaderListener -->
  <!-- public static final String CONTEXT_CLASS_PARAM = "contextClass"; -->
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
  </context-param>

  <!-- Parameter for ContextLoaderListener -->
  <!-- public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation"; -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>me.json.AppConfig</param-value>
  </context-param>
  
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextClass</param-name>
      <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </init-param>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>me.json.WebConfig</param-value>
    </init-param>
  </servlet>

  <!-- Request that stars with /app/* will come in through DispatcherServlet-->
  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/app/*</url-pattern>
  </servlet-mapping>

  
</web-app>

package me.json;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;

@Configuration
// An applicationContext has this configuration include only Controller.class as a Bean without using default filters
@ComponentScan(useDefaultFilters = false, includeFilters = @ComponentScan.Filter(Controller.class))
public class WebConfig {
}

- DispatcherServlet 중에 /app/hello에 대해서는 HelloController 내 핸들러가 사용된다.

- HelloController Bean은 DispatcherServlet 내 ApplicationContext에 등록이 되고, 이 ApplicationContext를 만들 때 DispatcherServlet은 현재 ServletContext에 들어있는 ContextLoaderListener가 만들어준 ApplicationContext를 부모로 사용한다. 부모로 사용되는 ApplicationContext는 AppConfig.class를 갖고 만들어지고, 이는 Controller 빼고 모든 Bean을 등록하게 되어있다.

package me.json;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;

@Configuration
// An applicationContext has this configuration has defaultFilters as beans and excludes only Controller.class
@ComponentScan(excludeFilters = @ComponentScan.Filter(Controller.class))
public class AppConfig {
}

- 따라서 HelloService.class Bean이 등록되어 있을 것이고, 사용될 수 있다.

package me.json;

import org.springframework.stereotype.Service;

@Service
public class HelloService {

    public String getName(){
        return "json";
    }
}

1-3. DispatcherServlet에 몰빵형

- 항상 이렇게 ApplicationContext에 다한 상속 구조 / 계층구조를 가져야만 하는 것은 아니고, 필요에따라 사용될 수 있다.(DispatcherServlet이 만드는 ApplicationContext에 모든 Bean을 등록할 수 도 있다.)

- 이렇게 되면 Root WebApplicationContext가 따로 없고, DispatcherServlet이 만든 WebApplicationContext가 그냥 Root 처럼 모든 종류의 Bean 을 등록하게 된다.

package me.json;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan
public class WebConfig {
}

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Web Application</display-name>

  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextClass</param-name>
      <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </init-param>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>me.json.WebConfig</param-value>
    </init-param>
  </servlet>

  <!-- Request that stars with /app/* will come in through DispatcherServlet-->
  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/app/*</url-pattern>
  </servlet-mapping>


</web-app>

1-4. web.xml 없이 만들어보자!!(web.xml 없이 DispatcherServlet을 등록하는 방법)

- web.xml 지우기

- WebApplicationInitializer 구현

package me.json;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

public class WebApplication implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(WebConfig.class);
        context.refresh();

        DispatcherServlet dispatcherServlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic app = servletContext.addServlet("app", dispatcherServlet);
        app.addMapping("/app/*");
    }
}

2. 마치며

- 위의 구조는 SpringBoot와는 완전히 다른 구조이다.

- 위의 구조는 Servlet Container가 먼저 뜨고, ServletContainer 안에 등록되는 Servlet Application에다가 (ContextLoaderListener를 등록한다던가 DispatcherServlet을 등록한다던가 해서)Spring을 연동하는 방식이다.

- SpringBoot의 경우에는 Spring Boot Application 이 Java Application으로 먼저 뜨고, 그 안에 tomcat이 내장 서버로 뜬다. (DispatcherServlet 같은)Servlet을 내장 톰켓 안에다가 코드로 등록한다.

[참고] Inflearn 백기선의 스프링 웹 MVC 기반으로 저같은 초보들이 알기 쉽도록 재구성 해보았습니다., (매우 유용하고 친절한 강의라고 생각합니다. 들으시면 기본적인 구조나 원래를 익히는데 도움이 되실 것 같습니다!! 20% 할인하는 기간도 간간히 있으니 잘 활용하세용~)

3. Servlet (써블릿) - 써블릿 리스터와 필터

뚱보리루 — Sun, 2 Feb 2020 15:49:29 +0900

1. 서블릿 리스너

- 웹 애플리케이션에서 발생하는 주요 이벤트를 감지하고 각 이벤트에 특별한 작업이 필요한 경우에 사용할 수 있다.

- 서블릿 컨테이너에서 발생하는 이벤트(서블릿 라이크사이클의 변화, 애트리뷰트의 변화, 세션의 변화)

- 여러개의 서블릿이 공톡적으로 사용할 객체들을 넣어놓는 등의 목적으로 사용할 수 있다.(DB 연결 등)

2. 서블릿 필터

- 요청이 서블릿의 doGet으로 바로가기 전에 전처리 및 응답에 처리를 하기위해서 사용.

- 들어온 요청을 서블릿으로 보내고 또 서블릿이 작성한 응답을 클라이언트로 보내기 전에 특별한 처리가 필요한 경우에 사용된다.

- 체인 형태의 구조를 갖는다.(순차적으로 적용된다, 반드시 다음 체인으로 넘어가도록 코드를 작성해줘야 한다.)

3. 서블릿 리스너 실습

- Servlet Listener 생성

package me.json;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyListener implements ServletContextListener {

    // Servlet Context 의 Lifecycle 을 감지할 수 있는 interface 구현
    // Override interfaces those can detect lifecycle of Servlet Context
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Context Listener Initialized");
        sce.getServletContext().setAttribute("name", "json");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Context Destroyed");
    }
}

- web.xml에 Servlet listener 등록

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!-- Register Servlet Listener-->
  <listener>
    <listener-class>me.json.MyListener</listener-class>
  </listener>


  <!-- Register servlet -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>me.json.HelloServlet</servlet-class>
  </servlet>


  <!-- Mapping Servlet with url pattern -->
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

</web-app>

- Servlet에서 listener 활용

package me.json;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {

    @Override
    public void init() throws ServletException {
        System.out.println("init");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doGet");
        resp.getWriter().print("<html>");
        resp.getWriter().print("<head>");
        resp.getWriter().print("<body>");
        resp.getWriter().print("<h1>Hello Servlet</h1>");
        resp.getWriter().print("<h1>Hello" + getName() + "</h1>");
        resp.getWriter().print("</body>");
        resp.getWriter().print("</head>");
        resp.getWriter().print("</html>");
    }
    
    private Object getName() {
        // Get attribute value that is set in the Servlet listener
        return getServletContext().getAttribute("name");
    }

    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

4. 서블릿 필터 실습

- 서블릿 필터 생성

package me.json;

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter Initialized");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("doFilter : MyFilter");

        // Have to connect to next filter(if this is last filter this will be connected to servlet) : Chaining
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("Filter Destroyed");
    }
}

- web.xml에 서블릿 필터 등록

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!-- Register a filter -->
  <filter>
    <filter-name>myFilter</filter-name>
    <filter-class>me.json.MyFilter</filter-class>
  </filter>


  <!-- Mapping filter to servlet-->
  <filter-mapping>
    <filter-name>myFilter</filter-name>
    <servlet-name>hello</servlet-name>
  </filter-mapping>

  <!-- Register Servlet Listener-->
  <listener>
    <listener-class>me.json.MyListener</listener-class>
  </listener>


  <!-- Register servlet -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>me.json.HelloServlet</servlet-class>
  </servlet>


  <!-- Mapping Servlet with url pattern -->
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

</web-app>

5. 결과

- 아래와 같이 , Context Listener Init과 Filter Init은 호출이 없어도 먼저 호출된다. 해당 이유는 Init 할때 오래 걸릴 수 있는 시간을 미리 1회 호출해 둠으로써 Init 과정을 완료시켜버린다. 이를 '웜업' 이라고 한다.

[참고] Infrean 백기선의 스프링 웹 MVC 기반으로 저같은 초보들이 알기 쉽도록 재구성 해보았습니다., (매우 유용하고 친절한 강의라고 생각합니다. 들으시면 기본적인 구조나 원래를 익히는데 도움이 되실 것 같습니다!! 20% 할인하는 기간도 간간히 있으니 잘 활용하세용~)

2. Servlet (써블릿) - 원시적인 코드로 확인

뚱보리루 — Sun, 2 Feb 2020 15:10:24 +0900

1. 준비

- Maven : maven-archetype-webapp

- 톰켓

- Servlet dependency

https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api/4.0.1

Maven Repository: javax.servlet » javax.servlet-api » 4.0.1

Professional Java Data: RDBMS, JDBC, SQLJ, OODBMS, JNDI, LDAP, Servlets, JSP, WAP, XML, EJBs, CMP2.0, JDO, Transactions, Performance, Scalability, Object and Data Modeling (2001)by Carl Calvert Bettis, Michael Bogovich, Sean Rhody, Mark Wilcox, Kelly Lin P

mvnrepository.com

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

* privided scope : 코딩하는 시점에는 사용할 수 있지만 프로젝트 패키징 할때는 프로젝트에서 빠짐(해당 의존성은 어디선가에서 제공됨---> 톰켓 컨테이너에서 제공됨)

2. 서블릿 생성

- Servelt 생성

package me.json;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {

    @Override
    public void init() throws ServletException {
        System.out.println("init");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doGet");
        resp.getWriter().print("<html>");
        resp.getWriter().print("<head>");
        resp.getWriter().print("<body>");
        resp.getWriter().print("<h1>Hello Servlet</h1>");
        resp.getWriter().print("</body>");
        resp.getWriter().print("</head>");
        resp.getWriter().print("</html>");
    }

    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

- webapp/WEB-INF/web.xml 설정

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>


  <!-- Register servlet -->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>me.json.HelloServlet</servlet-class>
  </servlet>


  <!-- Mapping Servlet with url pattern -->
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

</web-app>

3. 서블릿 실행

- 서블릿 독자적으로 실행할 수 있는 방법은 없다.

- 서블릿 컨테이너(톰켓)에 배포하는 식으로 실행을 해야한다.

- 우측 상단 Add confituration... -> Tomcet Server -> Local 선택

- Tomcat 설치 및 설치 폴더 내 *.sh 파일에 실행권한 부여(chmod +x ./bin/*.sh)

- Tomcat Delpoyment 설정에 war:exploded 추가

: 배포를 하는데 톰켓을 띄울 때 해당 애플리케이션을 war로 묶어서 배포하는 방법(:war)이 있고, war를 압축을 풀어버린 상태로 톰켓에 배포(:war:exploded)하는 방식이 있다.

- 해당 설정을 하면 application context가 설정이 되고, Server 탭에 앱이 떴을때의 기본 url로 설정된다.

- url 이 굉장히 길어서, Deployment/Application Context를 root(/)로 설정하기도 한다.

4. 마치며..

- Spring MVC가 이 httpServlet 기반으로 만들어 졌는데,

- 어떻게 애노테이션(@Controller, @RequestMapping)을 사용해서 요청을 처리 할 수 있나?

- 어떻게 뷰를 println으로 찍는게 아니라 thymeleaf 사용할 수 있나?

- 어떻게 web.xml 없이 Servlet Application을 띄울 수 있었나?

1. Servlet (써블릿) - 기본 설명

뚱보리루 — Sun, 2 Feb 2020 14:14:44 +0900

스프링 웹 엠브씨는 서블릿 기반의 웹 애플리케이션을 쉽게 만들게 도와주는 프레임워크이다.

그렇담 서블릿은?

- 자바 엔터프라이즈 에디션은 웹 애플리케이션 개발용 스펙과 API를 제공한다.(ex, HttpServlet)

- 하나의 요청을 받을 때마다 쌔로운 쓰레드를 만들어서(혹은 풀에서 가져다가) 요청을 처리(CGI같은 기술에 비해 훨씬 빠르고, OS에 플랫폼 독립적인 JAVA 본연의 기능을 지원받을 수 있다.).

그렇담 서블릿 컨테이너(서블릿 엔진)은?

- 톰켓, 제티, 언더토우

- 서블릿 스펙을 준수, 구현하는 컨테이너들

- 서블릿을 어떻게 초기화하고, 실행하고, 사용하는지의 서블릿의 라이프사이클을 관리.

- 세션, 네트워크 관리

- 서블릿 애플리케이션은 우리가 직접 실행할 수 없고, 서블릿 컨테이너가 실행할 수 있기 때문에 반드시 서블릿 컨테이너를 사용해야한다.

서블릿 생명주기

- 서블릿 컨테이너가 최초 요청을 받고,

- 해당 요청을 처리 할 서블릿을 찾아 서블릿 인스턴스를 만든다.

- 최초로 서블릿을 호출(init, 추후 동일한 요청에서 부터는 호출이 안된다.(웜업))

- doGet, doPost 등이 호출

- 서블릿 컨테이너가 종료할 때 destroy() 호출

서블릿 애플리케이션을 만들어서 톰켓에 띄워보자

Dispatcher Servlet의 동작원리

뚱보리루 — Sun, 2 Feb 2020 13:38:59 +0900

- 용어

- HandlerMapper : Handler를 찾아주는 인터페이스

- HandlerAdaptor : Handler를 수행해주는 인터페이스

- View Resolver : View 이름(String 값)을 갖고 실제 매핑되는 View 파일(리소스)을 찾아 변환하는 인터페이스.

- 구성

1. MultipartResolver interface

: 파일 업로드 요청 처리에 필요한 인터페이스(http 요청에서 content-type : multipart 은 경우, 바이너리로 쪼개져서 날아오는 파일들을 받기위한 처리 작업을 한 것으로 예상, HttpServletRequest -> MultipartHttpServletRequest로 변환)

: DispatcherServlet에는 DefaultStratage로 등록된 Bean은 없고, SpringBoot에서는 StandardServletMultipartResolver가 기본으로 등록된다.

2. LocaleResolver

: Client 위치 정보, 지역정보를 확인하는데 사용됨. --> 지역에 따라 적절한 지역언어의 메시지로 화면을 전달하기 위함

: DispatcherServlet 기준으로 기본등록되는 구현체는 AcceptHeaderLocaleResolver이다(요청에 들어있는 accept-language header 값으로 파악).

: MultipartResolver, LocaleResolver는 요청이 Dispatcher servlet에 들어왔을때, 요청을 분석하는데 사용됨.

3. ThemeResolver

: 애플리케이션에서 설정 테마를 파악하고 변경할 수 있는 인터페이스

: Theme이라는 키값을 view에 전달하고, view에서 key 값에 맞는 css 등을 불러와서 적용시키는 기능.

4. HandlerMapping

: 어떤 요청이 들어왔을 때, 그 요청을 처리할 Handler를 찾는 인터페이스.

: 기본 구현체 1) RequestMappingHandlerMapping은 애노테이션 기반으로 핸들러를 찾아준다. 이 경우에는 method 자체가 핸들러가 된다.(* @Controller 같은 애노테이션을 이용해 핸들러를 만들 수 있는 이유는 기본적으로 해당 HandlerMapping이 등록되어 있기 때문이다.)

: 기본 구현체 2) BeanNameUrlHandlerMapping은 빈 이름 기반으로 이 요청에 해당하는 Bean이 있는가를 찾는다. 이 경우에는 Class가 핸들러가 된다.

5. HandlerAdaptor

: HandlerMaaping이 찾아낸 (마음대로, 제멋대로 생긴) 핸들러를 처리하는 인터페이스

: Spring MVC 확장력의 핵심 : 핸들러를 원하는대로 커스텀 해서 만들 수 있다.

: 기본 구현체 1) RequestMappingHandlerAdaptor 가 등록됨(RequestMappingHandlerMapping 와 세트를 이루면 작동)

: 2) HttpRequestHandlerAdaptor, 3) SimpleControllerHandlerAdaptor

6. HandlerExceptionResolver

: DispatcherServlet 실행 중에 전반적으로 일어나는 예외들에 대해서 해당 예외에 따라 맞는 예외처리를 해준다.

: 기본으로 ExceptionHandlerExceptionResolver를 주로 사용할 것 : @ExceptionHandler 애노테이션에 따른 동작을 한다.

* HandlerMapping, HandlerAdaptor, HandlerExceptionResolver 는 Collection으로 복수개의 구현체를 갖고 있으며 이를 순회하며 작동한다. 또한 @Order 를 사용한 순회 순서도 정해질 수 있다.

7. RequestToViewNameTranslator

: 핸들러에서 뷰 이름을 명시적으로 리턴하지 않는 경우(핸들러 매서드 반환타입이 void인 경우 등), 요청 기반으로 뷰 이름을 판단하는 인터페이스

: 기본 구현체는 DefualtRequestToViewNameTranslator 하나이고, url과 동일하게 view 네임으로 사용하는 것으로 예상.

8. ViewResolver

: 명시적으로 view 이름을 가져오든, RequestToViewNameTranslator를 통해서 view 이름을 추측하든 View 이름을 가져온 후, 이름을 갖고 실제 View를 찾아내는 인터페이스.

: DispatcherServlet 기준으로 기본적으로 InternalResourceViewResolver가 등록되어있다.

: SpringBoot에는 더 많은 구현체가 기본적으로 등록되어 있다.

9. FlashMapResolver

: 어떤 데이터를 받고, 저장한 후 그 다음에 보통 리다이렉트를 하는데,

: 왜? 화면에서 refresh 했을 때 같은 요청을 반복하면 동일한 데이터가 반복해서 넘어온다. 이를 방지하기 위한 패턴

: 사실 뭔지 잘 모르겠다. 중복 from submission을 방지하기 위한 패턴.

- 응용

- Spring MVC가 기본적으로 갖고있는 Handler Mapping에는 1. BeanNameUrlHandlerMapping(요청한 url과 빈의 이름이 일치하는 빈을 찾아준다.), 2. RequestMappingHandlerMapping(@RequestMapping이라는 애노테이션을 컨트롤러 클래스나 메서드에 선언하여 사용)가 있다.

- View Resolver 동작 원리

: org.springframework.web.servlet.DispatcherServlet Class 에 servlet을 초기화하는 protected void initStrategies(ApplicationContext context) 내 initViewResolver(context); 수행.(이는 매 요청마다 수행되는 것이 아니라 최초 dispatcher servlet을 초기화 하기위해 한번만 호출된다.)

: 등록된 Bean에서 ViewResolver.class 타입의 Bean을 모두 찾아와서 veiwResolvers List에 넣어둔다.

: 만약 개발자가 등록한 ViewResolver.class 타입의 Bean이 없다면, getDefaultStrategies(context, ViewResolver.class) 수행을 통해서 기본 전략을 가져온다. 이 기본 전략에 internalResourceViewResolver가 들어있다.

: 이는 DispatcherServlet.properties 라는 파일에서 기본전략으로 가져올 내용들을 관리한다. HandlerMapper의 경우에도 이와 마찬가지로 해당 파일에 BeanNameUrlHandlerMapping과 RequestMappingHandlerMapping 값을 갖고 있다.

- DispatcherServlet.properties

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter


org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

[참고] Infrean 백기선의 스프링 웹 MVC, (매우 유용하고 친절한 강의라고 생각합니다. 들으시면 기본적인 구조나 원래를 익히는데 도움이 되실 것 같습니다!! 20% 할인하는 기간도 간간히 있으니 잘 활용하세용~)