[스프링 핵심 원리와 활용] #3. 웹 서버와 서블릿 컨테이너(2)

[YONGHYNG]

서블릿 컨테이너 초기화1

• WAS를 실행하는 시점에 필요한 초기화 작업들이 있다. 서비스에 필요한 필터와 서블릿을 등록하고, 여기에
  스프링을 사용한다면 스프링 컨테이너를 만들고, 서블릿과 스프링을 연결하는 디스페처 서블릿도 등록해야 한다.
• WAS가 제공하는 초기화 기능을 사용하면, WAS 실행 시점에 이러한 초기화 과정을 진행할 수 있다.
• 과거에는 web.xml을 사용해서 초기화했지만, 지금은 서블릿 스펙에서 자바 코드를 사용한 초기화도 지원한다.

서블릿 컨테이너와 스프링 컨테이너

서블릿 컨테이너 초기화 개발

• 서블릿은 ServletContainerInitializer라는 초기화 인터페이스를 제공한다. 이름 그대로 서블릿 컨테이너를 초기화 하는 기능을 제공한다.
• 서블릿 컨테이너는 실행 시점에 초기화 메서드인 onStartup() 을 호출해준다. 여기서 애플리케이션에 필요한 기능들을 초기화 하거나 등록할 수 있다.

ServletContainerInitializer

public interface ServletContainerInitializer {
           public void onStartUp(Set<Class<?>> c, ServletContext ctx) throws ServletException;
}

• Set<Class<?>> c : 조금 더 유연한 초기화를 기능을 제공한다. @HandlesTypes 애노테이션과 함께 사용한다.
• ServletContext ctx : 서블릿 컨테이너 자체의 기능을 제공한다. 이 객체를 통해 필터나 서블릿을 등록할 수 있다.

hello/container/MyContainerInitV1

package hello.container;

import jakarta.servlet.ServletContainerInitializer;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;

import java.util.Set;

public class MyContainerInitV1 implements ServletContainerInitializer {

    @Override
    public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {
        System.out.println("MyContainerInitV1.onStartup");
        System.out.println("MyContainerInitV1 c = " + c);
        System.out.println("MyContainerInitV1 ctx = " + ctx);
    }
}

• 이것이 끝이 아니다. 추가로 WAS에게 실행할 초기화 클래스를 알려줘야 한다.
• resources/METAINF/services/jakarta.servlet.ServletContainerInitializer
• hello.container.MyContainerInitV1 이 파일에 방금 만든 MyContainerInitV1 클래스를 패키지 경로를 포함해서 지정해주었다.
  이렇게 하면 WAS를 실행할 때 해당 클래스를 초기화 클래스로 인식하고 로딩 시점에 실행한다.

서블릿 컨테이너 초기화2

• 여기서는 HelloServlet이라는 서블릿을 서블릿 컨테이너 초기화 시점에 프로그래밍 방식으로 직접 등록해줄 것이다.

서블릿을 등록하는 2가지 방법

• @WebServlet 애노테이션
• 프로그래밍 방식

HelloServlet

package hello.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class HelloServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet.service");
        resp.getWriter().println("hello Servlet!");
    }
}

• 로그: HelloServlet.service
• Http 응답: hello.servlet!

애플리케이션 초기화

• 서블릿 컨테이너는 조금 더 유연한 초기화 기능을 지원한다. 여기서는 이것을 애플리케이션 초기화라 하겠다.

AppInit

package hello.servlet.ServletContext;

import jakarta.servlet.ServletContext;

public interface AppInit {

    void onStartup(ServletContext servletContext);
}

• 애플리케이션 초기화를 진행하려면 먼저 인터페이스를 만들어야 한다. 내용과 형식은 상관없고, 인터페이스는 꼭 필요하다.
• AppInit 인터페이스를 만들자

package hello.container;

import hello.servlet.HelloServlet;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletRegistration;

/**
 * http://localhost:8080/hello-servlet
 */
public class AppInitVlServlet implements AppInit {

    @Override
    public void onStartup(ServletContext servletContext) {
        System.out.println("AppInitV1Servlet.onStartup");

        //순수 서블릿 코드 등록
        ServletRegistration.Dynamic helloServlet =
                servletContext.addServlet("helloServlet", new HelloServlet());
        helloServlet.addMapping("/hello-servlet");
    }
}

• 여기서는 프로그래밍 방식으로 HelloServlet 서블릿을 서블릿 컨테이너에 직접 등록한다.
• Http로 /hello-servlet을 호출하면 HelloServlet 서블릿이 실행된다.

서블릿을 등록하는 2가지 방법

• @WebServlet 애노테이션
• 프로그래밍 방식

참고 - 프로그래밍 방식을 사용하는 이유

• @WebServlet 을 사용하면 애노테이션 하나로 서블릿을 편리하게 등록할 수 있다. 하지만 애노테이션 방식을 사용하
  면 유연하게 변경하는 것이 어렵다. 마치 하드코딩 된 것 처럼 동작한다. 아래 참고 예시를 보면 /test 경로를 변경하고 싶으면 코드를 직접 변경해야 바꿀 수 있다.
• 반면에 프로그래밍 방식은 코딩을 더 많이 해야하고 불편하지만 무한한 유연성을 제공한다.
• 예를 들어서
  • /hello-servlet 경로를 상황에 따라서 바꾸어 외부 설정을 읽어서 등록할 수 있다.
  • 서블릿 자체도 특정 조건에 따라서 if문으로 분기해서 등록하거나 뺄 수 있다.
  • 서블릿을 내가 직접 생성하기 때문에 생성자에 필요한 정보를 넘길 수 있다.

참고 예시

@WebServlet(urlPatterns = "/test")
public class TestServlet extends HttpServlet {}

MyContainerInitV2

package hello.container;

import jakarta.servlet.ServletContainerInitializer;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.HandlesTypes;

import java.util.Set;

@HandlesTypes(AppInit.class)
public class MyContainerInitV2 implements ServletContainerInitializer {

    @Override
    public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {

        System.out.println("MyContainerInitV2.onStartup");
        System.out.println("MyContainerInitV2 c = " + c);
        System.out.println("MyContainerInitV2 container = " + ctx);

        for (Class<?> appInitClass : c) {
            try {
                AppInit appInit = (AppInit)
                        appInitClass.getDeclaredConstructor().newInstance();
                appInit.onStartup(ctx);
            } catch (Exception e) {
                throw new ServletException(e);
            }
        }
    }
}

• 1. @HandlesTypes 애노테이션에 애플리케이션 초기화 인터페이스를 지정한다.
  • 여기서는 앞서 만든 AppInit.class 인터페이스를 지정했다.
• 2. 서블릿 컨테이너 초기화( ServletContainerInitializer )는 파라미터로 넘어오는 Set<Class<?>> c 에 애플리케이션 초기화 인터페이스의 구현체들을 모두 찾아서 클래스 정보로 전달한다.
  • 여기서는 @HandlesTypes(AppInit.class) 를 지정했으므로 AppInit.class 의 구현체인 AppInitV1Servlet.class 정보가 전달된다.
  • 참고로 객체 인스턴스가 아니라 클래스 정보를 전달하기 때문에 실행하려면 객체를 생성해서 사용해야 한다.
• 3. appInitClass.getDeclaredConstructor().newInstance()
  • 리플렉션을 사용해서 객체를 생성한다. 참고로 이 코드는 new AppInitV1Servlet() 과 같다 생각하면 된다.
• 4. appInit.onStartup(ctx)
  • 애플리케이션 초기화 코드를 직접 실행하면서 서블릿 컨테이너 정보가 담긴 ctx 도 함께 전달한다.

초기화는 다음 순서로 진행된다.

• 1. 서블릿 컨테이너 초기화 실행
  • resources/META-INF/services/jakarta.servlet.ServletContainerInitializer
• 2. 애플리케이션 초기화 실행
  • @HandlesTypes(AppInit.class)

참고
서블릿 컨테이너 초기화만 있어도 될 것 같은데, 왜 이렇게 복잡하게 애플리케이션 초기화라는 개념을 만들었을까?

• 편리함
  • 서블릿 컨테이너를 초기화 하려면 ServletContainerInitializer 인터페이스를 구현한 코드를 만들어야 한다. 여기에 추가로 META-INF/services/jakarta.servlet.ServletContainerInitializer 파일에 해당 코드를 직접 지정해주어야 한다.
  • 애플리케이션 초기화는 특정 인터페이스만 구현하면 된다.
• 의존성
  • 애플리케이션 초기화는 서블릿 컨테이너에 상관없이 원하는 모양으로 인터페이스를 만들 수 있다. 이를 통해 애플리케이션 초기화 코드가 서블릿 컨테이너에 대한 의존을 줄일 수 있다. 특히 ServletContext ctx 가 필요없는 애플리케이션 초기화 코드라면 의존을 완전히 제거할 수도 있다

스프링 컨테이너 등록

• 이번에는 WAS와 스프링을 통합 진행
• 앞서 배운 서블릿 컨테이너 초기화와 애플리케이션 초기화를 활용하면 된다.

다음 과정 진행

• 스프링 컨테이너 만들기
• 스프링 MVC 컨트롤러를 스프링 컨테이너에 빈으로 등록하기
• 스프링 MVC를 사용하는데 필요한 디스패처 서블릿을 서블릿 컨테이너 등록하기

build.gradle - spring-webmvc 추가

implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'

implementation 'org.springframework:spring-webmvc:6.0.4'

• spring-webmvc 라이브러리를 추가하면 스프링 MVC 뿐 아니라 spring-core를 포함한 스프링 핵심 라이브러리들도 함께 포함된다.

HelloController

package hello.spring;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello-spring")
    public String hello(){
        System.out.println("HelloController.hello");
        return "hello spring!";
    }
}

• 간단한 스프링 컨트롤러이다.
• 실행 시 hello spring! 출력한다.

HelloConfig

package hello.spring;

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

@Configuration
public class HelloConfig {

    @Bean
    public HelloController helloController(){
        return new HelloController();
    }
}

• 컨트롤러를 스프링 빈으로 직접 등록한다. 참고로 여기서는 컴포넌트 스캔을 사용하지 않고 빈을 직접 등록했다.
• 이제 애플리케이션 초기화를 사용해서 서블릿 컨테이너에 스프링 컨테이너를 생성하고 등록하자

AppInitV2Spring

package hello.container;

import hello.spring.HelloConfig;
import hello.spring.HelloController;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletRegistration;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

public class AppInitV2Spring implements AppInit {

    @Override
    public void onStartup(ServletContext servletContext){
        System.out.println("AppInitV2Spring.onStartup");

        //스프링 컨테이너 생성
        AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
        appContext.register(HelloConfig.class);

        //스프링이 MVC 디스패처 서블릿 생성, 스프링 컨테이너 연결
        DispatcherServlet dispatcher = new DispatcherServlet(appContext);

        //디스패처 서블릿을 컨테이너에 등록
        ServletRegistration.Dynamic servlet = servletContext.addServlet("dispatcherV2", dispatcher);

        servlet.addMapping("/spring/*");
    }
}

• AppInitV2Spring 는 AppInit 을 구현했다. AppInit 을 구현하면 애플리케이션 초기화 코드가 자동으로 실행된다. 앞서 MyContainerInitV2 에 관련 작업을 이미 해두었다.

스프링 컨테이너 생성

• AnnotationConfigWebApplicationContext 가 바로 스프링 컨테이너이다.
  • AnnotationConfigWebApplicationContext 부모를 따라가 보면 ApplicationContext 인터페이스를 확인할 수 있다.
  • 이 구현체는 이름 그대로 애노테이션 기반 설정과 웹 기능을 지원하는 스프링 컨테이너로 이해하면 된다.
• appContext.register(HelloConfig.class)
  • 컨테이너에 스프링 설정을 추가한다.

스프링 MVC 디스패처 서블릿 생성, 컨테이너 연결

• new DispatcherServlet(appContext)
• 코드를 보면 스프링 MVC가 제공하는 디스패처 서블릿을 생성하고, 생성자에 앞서 만든 스프링 컨테이너를 전달하는 것을 확인할 수 있다. 이렇게 하면 디스패처 서블릿에 스프링 컨테이너가 연결된다.
• 이 디스패처 서블릿에 HTTP 요청이 오면 디스패처 서블릿은 해당 스프링 컨테이너에 들어있는 컨트롤러 빈들을 호출한다.

디스패처 서블릿을 서블릿 컨테이너에 등록

• servletContext.addServlet("dispatcherV2", dispatcher)
  • 디스패처 서블릿을 서블릿 컨테이너에 등록한다.
• /spring/* 요청이 디스패처 서블릿을 통하도록 설정
  • /spring/* 이렇게 경로를 지정하면 /spring 과 그 하위 요청은 모두 해당 서블릿을 통하게 된다.
  • /spring/hello-spring
  • /spring/hello/go

주의! 서블릿을 등록할 때 이름은 원하는 이름을 등록하면 되지만 같은 이름으로 중복 등록하면 오류가 발생한다. 여기
서는 dispatcherV2 이름을 사용했는데, 이후에 하나 더 등록할 예정이기 때문에 이름에 유의하자

실행 과정 정리
/spring/hello-spring

• 실행을 /spring/* 패턴으로 호출했기 때문에 다음과 같이 동작한다.
  • dispatcherV2 디스패처 서블릿이 실행된다. ( /spring )
• dispatcherV2 디스패처 서블릿은 스프링 컨트롤러를 찾아서 실행한다. ( /hello-spring )
  • 이때 서블릿을 찾아서 호출하는데 사용된 /spring 을 제외한 /hello-spring 가 매핑된 컨트롤러 HelloController )의 메서드를 찾아서 실행한다. (쉽게 이야기해서 뒤에 * 부분으로 스프링 컨트롤러를 찾는다.)

스프링 MVC 서블릿 컨테이너 초기화 지원

• 지금까지의 과정을 생각해보면 서블릿 컨테이너를 초기화 하기 위해 다음과 같은 복잡한 과정을 진행했다.
  • ServletContainerInitializer 인터페이스를 구현해서 서블릿 컨테이너 초기화 코드를 만들었다.
  • 여기에 애플리케이션 초기화를 만들기 위해 @HandlesTypes 애노테이션을 적용했다.
  • /META-INF/services/jakarta.servlet.ServletContainerInitializer 파일에 서블릿 컨테이너 초기화 클래스 경로를 등록했다.

서블릿 컨테이너 초기화 과정은 상당히 번거롭고 반복되는 작업이다. 스프링 MVC는 이러한 서블릿 컨테이너 초기화 작업을 이미 만들어두었다. 덕분에 개발자는 서블릿 컨테이너 초기화 과정은 생략하고, 애플리케이션 초기화 코드만 작성하면 된다.

스프링이 지원하는 애플리케이션 초기화를 사용하려면 다음 인터페이스를 구현하면 된다.

WebApplicationInitializer

package org.springframework.web;

public interface WebApplicationInitalizer {
       void onStartup(ServletContext servletContext) throws ServletException;
}

AppInitV3SpringMvc

package hello.container;

import hello.spring.HelloConfig;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRegistration;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;


/**
 * http://localhost:8080/hello-spring
 *
 * 스프링 MVC 제공 WebApplicationInitializer 활용
 * spring-web
 * META-INF/services/jakarta.servlet.ServletContainerInitializer
 * org.springframework.web.SpringServletContainerInitializer
 */
public class AppInitV3SpringMvc implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        System.out.println("AppInitV3SpringMvc.onStartup");

        //스프링 컨테이너 생성
        AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext();
        appContext.register(HelloConfig.class);

        //스프링 MVC 디스패처 서블릿 생성, 스프링 컨테이너 연결
        DispatcherServlet dispatcher = new DispatcherServlet(appContext);

        //디스패처 서블릿을 서블릿 컨테이너에 등록 (이름 주의! dispatcherV3)
        ServletRegistration.Dynamic servlet = servletContext.addServlet("dispatcherV3", dispatcher);

        //모든 요청이 디스패처 서블릿을 통하도록 설정
        servlet.addMapping("/");
    }
}

• WebApplicationInitializer 인터페이스를 구현한 부분을 제외하고는 이전의 AppInitV2Spring 과 거의 같은 코드이다.
  • WebApplicationInitializer 는 스프링이 이미 만들어둔 애플리케이션 초기화 인터페이스이다.
• 여기서도 디스패처 서블릿을 새로 만들어서 등록하는데, 이전 코드에서는 dispatcherV2 라고 했고, 여기서는 dispatcherV3 라고 해주었다. 참고로 이름이 같은 서블릿을 등록하면 오류가 발생한다.
• servlet.addMapping("/") 코드를 통해 모든 요청이 해당 서블릿을 타도록 했다.
  • 따라서 다음과 같이 요청하면 해당 디스패처 서블릿을 통해 /hello-spring 이 매핑된 컨트롤러 메서드가 호출된다.

참고

• 여기서는 이해를 돕기 위해 디스패처 서블릿도 2개 만들고, 스프링 컨테이너도 2개 만들었다.
• 일반적으로는 스프링 컨테이너를 하나 만들고, 디스패처 서블릿도 하나만 만든다. 그리고 디스패처 서블릿의 경로 매핑도 / 로 해서 하나의 디스패처 서블릿을 통해서 모든 것을 처리하도록 한다.

스프링 MVC가 제공하는 서블릿 컨테이너 초기화 분석

• 스프링은 어떻게 WebApplicationInitializer 인터페이스 하나로 애플리케이션 초기화가 가능하게 할까? 스프링도 결국 서블릿 컨테이너에서 요구하는 부분을 모두 구현해야 한다.
• spring-web 라이브러리를 열어보면 서블릿 컨테이너 초기화를 위한 등록 파일을 확인할 수 있다. 그리고 이곳에 서블릿 컨테이너 초기화 클래스가 등록되어 있다.

/META-INF/services/jakarta.servlet.ServletContainerInitializer
org.springframework.web.SpringServletContainerInitializer

SpringServletContainerInitializer

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {}

• 코드를 보면 우리가 앞서 만든 서블릿 컨테이너 초기화 코드와 비슷한 것을 확인할 수 있다.
• @HandlesTypes 의 대상이 WebApplicationInitializer 이다. 그리고 이 인터페이스의 구현체를 생성하고 실행하는 것을 확인할 수 있다. 우리는 앞서 이 인터페이스를 구현했다.

그림 정리

• 스프링MVC도 우리가 지금까지 한 것 처럼 서블릿 컨테이너 초기화 파일에 초기화 클래스를 등록해두었다. WebApplicationInitializer 인터페이스를 애플리케이션 초기화 인터페이스로 지정해두고, 이것을 생성해서 실행한다.
• 따라서 스프링 MVC를 사용한다면 WebApplicationInitializer 인터페이스만 구현하면 AppInitV3SpringMvc 에서 본 것 처럼 편리하게 애플리케이션 초기화를 사용할 수 있다.

정리

• 지금까지 서블릿 컨테이너 초기화를 사용해서 필요한 서블릿도 등록하고, 스프링 컨테이너도 생성해서 등록하고 또 스프링 MVC가 동작하도록 디스패처 서블릿도 중간에 연결해보았다. 그리고 스프링이 제공하는 좀 더 편리한 초기화 방법도 알아보았다.
• 지금까지 알아본 내용은 모두 서블릿 컨테이너 위에서 동작하는 방법이다. 따라서 항상 톰캣 같은 서블릿 컨테이너에 배포를 해야만 동작하는 방식이다.
• 과거에는 서블릿 컨테이너 위에서 모든 것이 동작했지만, 스프링 부트와 내장 톰캣을 사용하면서 이런 부분이 바뀌기 시작했다.