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

[YuDeokRin]

섹션 3. 웹 서버와 서블릿 컨테이너

1️⃣ 웹 서버와 스프링 부트 소개

• 외장 서버(전통적인 방식)
  • 외장서버(전통적인 방식) 같은 경우 WAS에 동작하도록 서블릿 스펙에 맞추어 코드를 작성하고 WAR 형식으로 빌드해서 war 파일을 만들었음.
  • 이와 같은 방식은 WAS 기반 위에서 개발하고 실행해야 한다.
• 내장 서버(최근 방식)
  • 내장 톰캣을 가지고 있다. 애플리케이션 코드 안에 톰캣 같은 WAS가 라이브러리로 내장되어 있다는 뜻.
  • 개발자는 코드를 작성하고 JAR로 빌드한 다음에 해당 JAR를 원하는 위치에서 실행하기만 하면 WAS도 함께 실행된다.

2️⃣ 톰캣 설치

• 톰켓 설치

![image.png](%E1%84%89%E1%85%A6%E1%86%A8%E1%84%89%E1%85%A7%E1%86%AB%203%20%E1%84%8B%E1%85%B0%E1%86%B8%20%E1%84%89%E1%85%A5%E1%84%87%E1%85%A5%E1%84%8B%E1%85%AA%20%E1%84%89%E1%85%A5%E1%84%87%E1%85%B3%E1%86%AF%E1%84%85%E1%85%B5%E1%86%BA%20%E1%84%8F%E1%85%A5%E1%86%AB%E1%84%90%E1%85%A6%E1%84%8B%E1%85%B5%E1%84%82%E1%85%A5%2022d24cb399b280309609cb6ec728838f/image%202.png

• 서버를 띠웠다.

• 톰켓 이력보는방법

• :8080 포트를 사용하는지 조회해보는 명령어 - 프로세스 ID(PID) 조회

• 프로세스 종료하는 명령어

sudo kill -9 PID  : 프로세스 종료 

• 톰켓 디폴트 8080포트를 사용하는데 바꿔주려면
  • 톰켓폴더 → conf → server.xml 파일 안에서 코드 수정

☸ k3d-rancher-cluster (default) in spring-boot-v20240120/tool/apache-tomcat-10.1.43
❯ cd conf

☸ k3d-rancher-cluster (default) in tool/apache-tomcat-10.1.43/conf
❯ ls
Catalina             catalina.properties  jaspic-providers.xml logging.properties   tomcat-users.xml     web.xml
catalina.policy      context.xml          jaspic-providers.xsd server.xml           tomcat-users.xsd

☸ k3d-rancher-cluster (default) in tool/apache-tomcat-10.1.43/conf
❯ cat server.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" at this level.
     Documentation at /docs/config/server.html
 -->
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />
  <!-- Security listener. Documentation at /docs/config/listeners.html
  <Listener className="org.apache.catalina.security.SecurityListener" />
  -->
  <!-- OpenSSL support using Tomcat Native -->
  <Listener className="org.apache.catalina.core.AprLifecycleListener" />
  <!-- OpenSSL support using FFM API from Java 22 -->
  <!-- <Listener className="org.apache.catalina.core.OpenSSLLifecycleListener" /> -->
  <!-- Prevent memory leaks due to use of particular java/javax APIs-->
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

  <!-- Global JNDI resources
       Documentation at /docs/jndi-resources-howto.html
  -->
  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>

  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" Note:  A "Service" is not itself a "Container",
       so you may not define subcomponents such as "Valves" at this level.
       Documentation at /docs/config/service.html
   -->
  <Service name="Catalina">

    <!--The connectors can use a shared executor, you can define one or more named thread pools-->
    <!--
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    -->

    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned. Documentation at :
         HTTP Connector: /docs/config/http.html
         AJP  Connector: /docs/config/ajp.html
         Define a non-SSL/TLS HTTP/1.1 Connector on port 8080
    -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />
    <!-- A "Connector" using the shared thread pool-->
    <!--
    <Connector executor="tomcatThreadPool"
               port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />
    -->
    <!-- Define an SSL/TLS HTTP/1.1 Connector on port 8443 with HTTP/2
         This connector uses the NIO implementation. The default
         SSLImplementation will depend on the presence of the APR/native
         library and the useOpenSSL attribute of the AprLifecycleListener.
         Either JSSE or OpenSSL style configuration may be used regardless of
         the SSLImplementation selected. JSSE style configuration is used below.
    -->
    <!--
    <Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="150" SSLEnabled="true"
               maxParameterCount="1000"
               >
        <UpgradeProtocol className="org.apache.coyote.http2.Http2Protocol" />
        <SSLHostConfig>
            <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
                         certificateKeystorePassword="changeit" type="RSA" />
        </SSLHostConfig>
    </Connector>
    -->

    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <!--
    <Connector protocol="AJP/1.3"
               address="::1"
               port="8009"
               redirectPort="8443"
               maxParameterCount="1000"
               />
    -->

    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host).
         Documentation at /docs/config/engine.html -->

    <!-- You should set jvmRoute to support load-balancing via AJP ie :
    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
    -->
    <Engine name="Catalina" defaultHost="localhost">

      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->
      <!--
      <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
      -->

      <!-- Use the LockOutRealm to prevent attempts to guess user passwords
           via a brute-force attack -->
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <!-- This Realm uses the UserDatabase configured in the global JNDI
             resources under the key "UserDatabase".  Any edits
             that are performed against this UserDatabase are immediately
             available for use by the Realm.  -->
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

        <!-- SingleSignOn valve, share authentication between web applications
             Documentation at: /docs/config/valve.html -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->

        <!-- Access log processes all example.
             Documentation at: /docs/config/valve.html
             Note: The pattern used is equivalent to using pattern="common" -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />

      </Host>
    </Engine>
  </Service>
</Server>

• 이 부분에서 port를 변경

<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               maxParameterCount="1000"
               />

plugins {
    id 'java'
    id 'war'
}

group = 'hello'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    //서블릿
    implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'
}

tasks.named('test') {
    useJUnitPlatform()
}

• 서블릿 등록
  • /test로 요청이 들어오면 서블릿이 실행된다.
  • TestServlet.service를 로그에 출력

/**
 * http://localhost:8080/test
 */
@WebServlet(urlPatterns = "/test")
public class TestServlet extends HttpServlet {

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

3️⃣ 프로젝트 설정

• 프로젝트 설정은 간단한 것으로 생각되어 그대로 따라가기만 된다.

4️⃣ WAR 빌드와 배포

• 프로젝트 빌드

• 빌드 후 libs에는 war파일이 생긴다.

• 참고
  • build.gradle에 보면 war 플러그인이 사용된 것을 확인할 수 있다.
  • 플러그인이 war 파일을 만들어준다.

plugins {
    id 'java'
    id 'war'
}

✅ WAR 압축 풀기

• 우리가 빌드한 war 파일의 압축을 풀어서 내용물을 확인
• build/libs 폴더로 이동
• 다음 명령어를 사용해서 압축을 풀자
  • jar -xvf server-0.0.1-SNAPSHOT.war

✅WAR를 푼 결과

• WEB-INF
  • classes
    • hello/servlet/TestServlet.class
  • lib
    • jakarta.servlet-api-6.0.0.jar
• index.html WAR를 푼 결과를 보면 WEB-INF , classes , lib 같은 특별한 폴더들이 보인다. 이 부분을 알아보자.

✅ JAR, WAR 간단 소개

• JAR소개

  • 자바는 여러 클래스와 리소스를 묶어서 JAR(Java Archive)라고 하는 압축 파일을 만들 수 있다.
  • 이 파일은 JVM 위에서 직접 실행되거나 또는 다른 곳에서 사용하는 라이브러리로 제공한다.
  • 직접 실행하는 경우 main() 메서드가 필요 그리고 MAINFEST.MF 파일에 실행할 메인 메서드가 있는 클래스를 지정해두어야함

• WAR 소개

  • WAR(Web Application Archive)라고 한다.
  • WAR 파일은 웹 어플리케이션(WAS)에 배포할 때 사용하는 파일이다.
  • JAR 파일이 JVM위에서 실행된다면, WAR는 웹 애플리케이션 서버 위에서 실행된다.

• 웹 애플리케이션 서버 위에서 실행되고, HTML 같은 정적 리소스와 클래스 파일을 모두 함께 포함하기 때문에 JAR와비교해서 구조가 더 복잡함.

• 주의사항 - WAR 구조를 지켜야 한다.

✅WAR 구조

• WEB-INF

  • classes : 실행 클래스 모음
  • lib : 라이브러리 모음
  • web.xml : 웹 서버 배치 설정 파일(생략 가능)

• index.html : 정적 리소스

• WEB-INF 폴더 하위는 자바 클래스와 라이브러리, 그리고 설정 정보가 들어가는 곳이다.

• WEB-INF 를 제외한 나머지 영역은 HTML, CSS 같은 정적 리소스가 사용되는 영역이다.

➡️ WAR 배포

생성된 WAR파일을 톰캣 서버에 실제 배포해보자.

1. 톰캣 서버를 종료한다. ./shutdown.sh
2. 톰캣폴더/webapps 하위를 모두 삭제한다.
3. 빌드된 server-0.0.1-SNAPSHOT.war 를 복사한다.
4. 톰캣폴더/webapps 하위에 붙여넣는다.
   톰캣폴더/webapps/server-0.0.1-SNAPSHOT.war
5. 이름을 변경한다.
   톰캣폴더/webapps/ROOT.war
6. 톰캣 서버를 실행한다. ./startup.sh

5️⃣ 톰캣 설정 - 인텔리제이 J 유료 버전

• Run에서 설정 해주기

6️⃣ 서블릿 컨테이너 초기화 1

• 지금부터 서블릿 컨테이너의 초기화 기능을 알아보고 이어서 이 초기화 기능을 스프링 만들고 연결해보자.

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("MyContainnerInitV1.onStartup");
        System.out.println("MyContainnerInitV1 c = " + c);
        System.out.println("MyContainnerInitV1 ctx= " + ctx);
    }
}

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

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

7️⃣ 서블릿 컨테이너 초기화 2

• 서블릿 컨테이너 초기화를 자세히 알아보자.

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

• @WebServlet 애노테이션 → 앞서 했던 방법

• 프로그래밍 방식 → 이번에 할 것

• HelloServlet.java

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.interface

package hello.controller.container;

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

public interface AppInit {
    void onStartup(ServletContext servletContext);
}

• AppInitV1Servlet.java

package hello.controller.container;

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

import java.util.Set;

public class AppInitV1Servlet implements AppInit {

    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        System.out.println("AppInitV1Servlet.onStartup");

        //순수 서블릿 코드 등록(프로그래밍 방식)
        ServletRegistration.Dynamic helloServlet = servletContext.addServlet("helloServlet", new HelloServlet());
        helloServlet.addMapping("/hello-servlet");

    }
}

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

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

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

➡️ AppInit는 어떻게 실행되는 것일까?

package hello.controller.container;

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

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 {
                //new AppInitV1Servlet()과 같은 코드
                AppInit appInit = (AppInit) appInitClass.getDeclaredConstructor().newInstance();
                appInit.onStartup(ctx);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

✅ 애플리케이션 초기화 과정

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

➡️MyContainerInitV2 등록

• MyContainerInitV2를 실행하려면 서블릿 컨테이너에게 알려줘야하는 설정이 필요하다.

resources/META-INF/services/jakarta.servlet.ServletContainerInitializer

hello.container.MyContainerInitV1
hello.container.MyContainerInitV2

• 실행 로그

MyContainerInitV1.onStartup
MyContainerInitV1 c = null
MyContainerInitV1 ctx =
org.apache.catalina.core.ApplicationContextFacade@38dd0980
MyContainerInitV2.onStartup
MyContainerInitV2 c = [class hello.container.AppInitV1Servlet]
MyContainerInitV2 container =
org.apache.catalina.core.ApplicationContextFacade@38dd0980
AppInitV1Servlet.onStartup

✅ 그림으로 정리

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

✅ 참고

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

8️⃣ 스프링 컨테이너 등록

• 이번에는 WAS와 스프링을 통합해보자.

• 다음과 같은 과정이 필요

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

dependencies {
    //서블릿
    implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'

    //스프링 MVC 추가
    implementation 'org.springframework:spring-webmvc:6.0.4'
}

• 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!";
    }
}

• 심플한 스프링 컨트롤러

• 실행하면 HTTP 응답으로 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.servlet.HelloServlet;
import hello.spring.HelloConfig;
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);

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

        // /spring/* 요청이 디스패처 서블릿을 통하도록 설정
        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 이름을 사용했는데, 이후에 하나 더 등록할 예정이기 때문에 이름에 유의하자

• 결과

hello spring!

✅ 실행 과정 정리

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

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

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

 

서블릿 컨테이너 초기화는 정말 귀찮다. 반복되는 작업이면서 번거롭다.

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

• 스프링이 지원히는 애플리케이션 초기화 코드를 사용

package org.springframework.web;

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

package hello.container;

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

public class AppInitV3SpringMvc implements WebApplicationInitializer {

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

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

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

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

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

• WebApplicationInitializer 인터페이스를 구현한 부분을 제외하고는 이전의AppInitV2Spring 과 거의 같은 코드이다.

  • WebApplicationInitializer 는 스프링이 이미 만들어둔 애플리케이션 초기화 인터페이스이다.

• 여기서도 디스패처 서블릿을 새로 만들어서 등록하는데, 이전 코드에서는 dispatcherV2 라고 했고, 여
  기서는 dispatcherV3 라고 해주었다.

• 참고로 이름이 같은 서블릿을 등록하면 오류가 발생한다.
  servlet.addMapping("/") 코드를 통해 모든 요청이 해당 서블릿을 타도록 했다.
  따라서 다음과 같이 요청하면 해당 디스패처 서블릿을 통해 /hello-spring 이 매핑된 컨트롤러 메
  서드가 호출된다

• 현재 등록된 서블릿 다음과 같다.
  • / = dispatcherV3
  • /spring/* = dispatcherV2
  • /hello-servlet = helloServlet
  • /test =TestServlet
  • 이런 경우 우선순위는 더 구체적인 것이 먼저 실행된다.

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

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

✅ SpringServletContainerInitializer

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

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

✅ 정리

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