Maven과 XML로 시작하는 Spring 4.3.x 웹 애플리케이션

해당 블로그글은 레거시 스프링 프레임워크를 파악하고 학습하고자 작성한 블로그 글입니다.

프로젝트 소스코드 및 필요한 파일들은 하단에 작성했습니다.

 

(참고로, 스프링 프레임워크 4.3.16은 2018년 4월에 릴리즈되었습니다.)

 

빈(Bean) 개념은 아래 링크를 참조하시면 됩니다.

https://lafortune.tistory.com/74

스프링 프레임워크의 빈(Bean)이란

 

---

 

Java는 익숙하지만 스프링 프레임워크는 처음인 개발자라면, 초기 설정부터 막막할 수 있습니다.

이 글에서는 Spring Framework 4.3.16을 Maven 프로젝트로 구성하고, 옛 방식인 XML 기반 설정을 활용하여 간단한 웹 애플리케이션을 만들어보겠습니다.

스프링의 전반적인 구조를 이해하기 쉽게 설명하면서, 실제로 동작하는 예제 코드와 실행 방법까지 다룹니다.

 

프로젝트 설정 개요

먼저 프로젝트의 전반적인 구조를 살펴보겠습니다. 이번 예제는 Maven으로 관리되는 웹 애플리케이션으로, WAR 파일 형태로 배포됩니다. 주요 폴더 구조는 아래와 같습니다.

 

spring-4.3.16-demo/  (Maven 프로젝트 루트)
├── pom.xml                      (Maven 설정 파일)
├── src/main/java
│   └── com/controller
│       └── HomeController.java  (스프링 MVC 컨트롤러 예제)
└── src/main/webapp
    ├── WEB-INF
    │   ├── web.xml              (웹 애플리케이션 배치 descriptor)
    │   ├── spring-servlet.xml   (스프링 MVC 설정 파일, XML 기반)
    │   └── views
    │       └── home.jsp         (JSP 뷰 페이지 예제)
    └── index.jsp (필요시)

 

위 구조에서 pom.xml은 Maven이 프로젝트를 빌드하고 필요한 라이브러리를 관리하는 설정 파일입니다.

 

web.xml은 웹 어플리케이션의 배치를 정의하며, 스프링의 DispatcherServlet을 등록합니다.

 

spring-servlet.xml은 스프링 MVC 관련 설정을 담은 스프링 설정 파일입니다.

HomeController.java는 사용자의 요청을 처리하는 컨트롤러 클래스이고, home.jsp는 화면에 표시될 뷰입니다.

 

 

Maven pom.xml 설정

Spring 4.3.16 프로젝트를 위해 Maven pom.xml에 어떤 설정이 필요한지 하나씩 살펴보겠습니다.

기본적으로 Spring MVC와 JSP를 사용하기 때문에 Spring MVC 라이브러리, JSP 렌더링을 위한 JSTL, 그리고 서블릿 API 등이 필요합니다.

또한 애플리케이션 서버(Tomcat)에서 실행하기 위해 패키징을 WAR로 지정합니다.

 

아래는 이 예제의 pom.xml 주요 부분입니다.

<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
    <!-- 생략: 모델 버전, 이름 등의 기본 설정 -->
    <groupId>com.example</groupId>
    <artifactId>spring-4.3.16-demo</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-framework-bom</artifactId>
                <version>4.3.16.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- Spring Core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <!-- Spring Web MVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <!-- Spring Core (Bean 어노테이션 지원) -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <!-- JSP Support (JSTL 라이브러리) -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- Servlet API (컨테이너 제공) -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- Logback (로깅 프레임워크) -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.6</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 자바 컴파일러 플러그인: Java 1.8 사용 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- Tomcat Maven 플러그인: 내장 Tomcat으로 실행 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

pom.xml 설명

• <groupId>, <artifactId>, <version>은 Maven 좌표로, 프로젝트의 그룹, 이름, 버전을 정의합니다.
  • 여기서는 예제로 com.example 그룹에 spring-4.3.16-demo라는 artifactId를 주고 버전 1.0.0으로 설정했습니다.
• <packaging>war</packaging>
  • 이 프로젝트의 빌드 산출물이 WAR(Web Application Archive)임을 지정합니다. WAR로 패키징하면 Tomcat 같은 서블릿 컨테이너에 배포하여 실행할 수 있습니다 (일반 자바 실행 파일인 jar와 구분).
• 스프링 BOM(Bill of Materials)
  • dependencyManagement 섹션에 spring-framework-bom을 import하고 버전을 4.3.16.RELEASE로 지정했습니다. BOM은 해당 버전에 맞는 스프링 관련 라이브러리들의 버전을 일괄 관리해주는 Maven 기능입니다. 이를 통해 개별 Spring 라이브러리 의존성에서 <version> 태그를 생략해도 모두 4.3.16 버전으로 맞춰집니다. 즉, Spring 관련 의존성들의 호환성을 BOM이 보장해줍니다.
• Spring MVC 의존성
  • <dependency>로 spring-webmvc를 추가했습니다. Spring MVC 프레임워크를 사용하기 위한 핵심 라이브러리입니다. 또한 spring-context와 spring-core도 의존성에 포함했는데, 이는 스프링의 기본 기능(Bean 컨테이너 등)을 제공하는 라이브러리들입니다. 사실 spring-webmvc를 추가하면 필요한 다른 스프링 모듈들도 대부분 전이 종속성으로 포함되지만, 예제에서는 명시적으로 core와 context를 나열하여 어떤 모듈이 사용되는지 알기 쉽게 했습니다.
• JSP와 서블릿 API
  • JSP 페이지를 사용하기 위해 Java EE의 JSP 표준 태그 라이브러리인 JSTL (javax.servlet:jstl:1.2)을 추가했습니다. 그리고 javax.servlet-api는 서블릿과 JSP 등의 API를 제공하는 의존성인데, <scope>provided</scope>로 지정했습니다.
  • Provided 스코프는 빌드 시에는 필요하지만 실제 실행 시에는 컨테이너가 제공한다는 의미입니다. 예를 들어 Tomcat 서버는 자체적으로 서블릿 API를 갖고 있으므로, WAR 파일에 서블릿 API를 포함시키지 않고 컨테이너의 것을 사용하도록 지정하는 것입니다.
• 로깅
  • 스프링은 내부적으로 Commons Logging을 사용하지만, 실제로는 Logback이나 Log4j2 같은 구현체로 로그를 출력합니다. 예제에서는 Logback 클래식(ch.qos.logback:logback-classic)을 추가했습니다. 이 라이브러리는 logging을 위해 필수는 아니지만, 콘솔에 깔끔한 로그를 보기 위함입니다. (초기 실습 단계에서는 생략해도 무방합니다.)
• 플러그인 (build/plugins):
  • Maven Compiler Plugin
    • Java 소스 코드를 컴파일할 때 JDK 버전과 인코딩을 설정했습니다. 여기서는 Java 1.8을 사용하고 UTF-8 인코딩을 지정하여 한글이 깨지지 않게 합니다.
  • Tomcat7 Maven Plugin
    • 이 플러그인은 Maven으로 바로 내장 Tomcat 서버를 실행할 수 있게 해줍니다.
    • <port>8080</port>은 Tomcat을 8080 포트로 띄우도록 설정한 것이고, <path>/</path>는 애플리케이션을 컨텍스트 루트(예: http://localhost:8080/)에 배치하도록 한 설정입니다. 이 설정 덕분에 나중에 mvn tomcat7:run 명령만으로 앱을 쉽게 실행해볼 수 있습니다.
      (참고: maven-war-plugin도 명시되어 있으나, 기본 WAR 패키징 용도로 특별한 설정 없이 사용되고 있습니다.)

 

웹 배치 설정 (web.xml)과 DispatcherServlet 등록

 

웹 애플리케이션 배치 서술자(web.xml) 은 전통적인 웹 어플리케이션에서 서블릿들을 등록하고 환경을 설정하는 역할을 합니다. Spring MVC를 사용하려면 DispatcherServlet이라는 스프링의 프론트 컨트롤러 서블릿을 등록해야 합니다.

 

다음은 WEB-INF/web.xml의 내용입니다.

<web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" ...>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 

web.xml 설명

• <servlet> 요소를 통해 DispatcherServlet을 애플리케이션에 등록했습니다. servlet-name은 식별자 역할을 하는데 여기서는 "dispatcher"라고 명명했습니다. (이 이름은 자유롭게 정할 수 있지만 관례상 "dispatcher", "appServlet" 등으로 짓습니다.)
• servlet-class는 서블릿 구현 클래스를 지정합니다.
  • Spring MVC의 DispatcherServlet 클래스 경로인 org.springframework.web.servlet.DispatcherServlet를 넣어주었습니다. 이 서블릿이 바로 모든 요청을 받아서 컨트롤러에 위임하고, 뷰를 반환하는 프론트 컨트롤러입니다.
• <init-param> 내의 contextConfigLocation 파라미터가 중요합니다. DispatcherServlet이 초기화될 때 어떤 스프링 설정 파일을 로드할지 지정하는 부분입니다. 여기서는 /WEB-INF/spring-servlet.xml를 가리키도록 했습니다. 즉, 스프링 MVC 관련 빈(bean) 설정은 이 XML 파일에 작성해두겠다는 뜻입니다.
  • 참고로, contextConfigLocation을 명시하지 않으면 기본값으로 /WEB-INF/<servlet-name>-servlet.xml 파일을 찾습니다.
  • 예를 들어 servlet-name이 "dispatcher"라면 dispatcher-servlet.xml을 자동으로 로드하려고 합니다. 이 예제에서는 설정 파일 이름을 spring-servlet.xml로 짓고 명시적으로 경로를 지정한 것입니다.
• <load-on-startup>1</load-on-startup>
  • 이 설정은 해당 서블릿을 서버 시작과 함께 로딩하라는 의미입니다. 숫자가 0보다 크면 컨테이너는 애플리케이션 초기화 시에 서블릿을 미리 생성하고 init()을 호출합니다. DispatcherServlet을 빨리 로드해두어야 사용자 요청 처리에 바로 대응할 수 있으므로 보통 1로 설정합니다.
• <servlet-mapping>
  • DispatcherServlet이 어떤 URL 패턴을 처리할지 명시합니다. 여기서는 <url-pattern>/</url-pattern>로 설정하여 모든 경로 (/ 하위의 모든 경로)에 대해 이 서블릿이 프론트 컨트롤러로 동작하도록 했습니다. 다시 말해, 애플리케이션으로 들어오는 모든 요청을 DispatcherServlet이 가로채어 처리하게 됩니다. (필터나 다른 서블릿에 매핑된 요청은 제외)

정리하면, 이 web.xml 구성으로 인해 우리의 Spring 애플리케이션이 배포되면, DispatcherServlet이 / 경로에 매핑되어 프론트 컨트롤러 역할을 수행하고, 내부적으로 /WEB-INF/spring-servlet.xml 설정 파일을 로딩하게 됩니다.

 

 

Spring MVC 설정 (spring-servlet.xml)

spring-servlet.xml은 DispatcherServlet이 읽어들이는 스프링 설정 파일입니다.

 

여기에는 스프링 MVC를 동작시키기 위한 각종 빈과 설정을 정의합니다. XML로 설정하기 때문에, Java 애노테이션 기반 설정에서 사용하는 여러 기능들을 대응되는 XML 태그로 활성화해야 합니다.

 

다음은 WEB-INF/spring-servlet.xml의 주요 내용입니다.

 

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="... 생략 ...">

    <!-- @EnableWebMvc와 동일한 역할 -->
    <mvc:annotation-driven />
    
    <!-- @ComponentScan과 동일한 역할 -->
    <context:component-scan base-package="com" />
    
    <!-- ViewResolver 빈 설정 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
    
</beans>

 

spring-servlet.xml 설명

• <mvc:annotation-driven />
  • 이 한 줄은 스프링 MVC의 애노테이션 기반 기능을 활성화합니다. Java 설정에 비유하면 @EnableWebMvc 애노테이션을 붙인 것과 같은 효과를 냅니다. 이 설정을 통해 @Controller, @RequestMapping(또는 @GetMapping 등), @ResponseBody, Validator/Conversion 서비스 등 Spring MVC의 핵심 기능들이 동작하도록 관련 빈들이 등록됩니다. 쉽게 말해 "스프링 MVC의 기본 설정을 켜준다" 라고 이해하면 됩니다.
• <context:component-scan base-package="com" />
  • 이 설정은 주어진 패키지 아래를 스캔하여 스프링 빈으로 등록할 클래스들을 찾습니다. Java 설정의 @ComponentScan(basePackages="...")과 동일합니다. 여기서는 "com" 패키지를 기준으로 하위의 클래스를 모두 뒤지며, @Component 계열 어노테이션이 붙은 클래스를 자동으로 Spring에 등록합니다.
    • 예제에서 HomeController 클래스에 @Controller가 붙어 있는데, @Controller는 @Component의 특수화 어노테이션입니다. 따라서 component-scan 설정 덕분에 HomeController가 빈으로 자동 등록되어 DispatcherServlet이 해당 컨트롤러를 인식할 수 있게 됩니다.
    • 주의: 실제 프로젝트에서는 base-package를 "com"처럼 광범위하게 주기보다는 com.example.project 같이 자신의 프로젝트 패키지로 한정하는 것이 좋습니다. 여기선 간단히 com으로만 적었습니다.
• <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> ... </bean>
  • 뷰 리졸버(ViewResolver) 빈을 설정했습니다. Spring MVC에서 컨트롤러는 논리적인 뷰 이름(String)만 반환하고, 해당 이름을 실제 뷰(JSP 등)로 찾아 연결해주는 역할을 ViewResolver가 합니다.
    • InternalResourceViewResolver는 JSP를 위한 ViewResolver 구현체로, prefix와 suffix를 조합해 JSP 파일 경로를 만들어냅니다. 위 설정에서는 prefix="/WEB-INF/views/"와 suffix=".jsp"를 주었기 때문에, 컨트롤러가 "home"이라는 뷰 이름을 리턴하면 실제 렌더링할 JSP 경로를 /WEB-INF/views/home.jsp로 해석합니다.
    • ViewResolver를 사용하면 컨트롤러에서 JSP 경로를 문자열로 하드코딩하지 않아도 되는 장점이 있습니다. 예를 들어 앞서 보았던 Spring 공식 예제 코드(spring.io)에서는 뷰 이름으로 WEB-INF/views/home.jsp처럼 전체 경로를 리턴했는데, 우리는 ViewResolver 설정 덕분에 "home"과 같이 간단히 리턴할 수 있습니다.
    • 또한 prefix로 /WEB-INF/views/를 사용하는 것은 JSP 파일을 웹 컨텍스트 경로 아래 WEB-INF 폴더에 둠으로써 직접 브라우저에서 접근되지 않게 하기 위함입니다. 사용자는 반드시 컨트롤러를 통해서만 JSP에 접근하게 되어 MVC 패턴을 유지할 수 있습니다.

위 세 가지 설정으로, 스프링 MVC를 XML 설정 방식으로 사용할 준비가 거의 끝났습니다.

 

이 외에 필요에 따라 메시지 리소스나 정적 자원 매핑, Interceptor 설정 등을 추가할 수 있지만, 기본적인 동작에는 위 설정들로 충분합니다.

 

 

컨트롤러 예제 코드 (HomeController.java)

이제 실제 요청을 처리하는 컨트롤러(Controller) 코드를 작성해보겠습니다.

 

스프링 MVC에서 컨트롤러 클래스는 @Controller 어노테이션을 사용하여 정의합니다. 메서드에는 처리할 URL과 HTTP 메서드를 매핑하기 위해 @RequestMapping이나 편의 어노테이션인 @GetMapping/@PostMapping 등을 사용합니다.

 

다음은 예제 컨트롤러인 HomeController.java의 코드입니다.

 

package com.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.ui.Model;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Spring 4.3.16 동작 확인!");
        return "home";
    }
}

 

HomeController 설명

• @Controller 어노테이션을 클래스에 붙여 이 클래스가 스프링 MVC 컨트롤러임을 선언합니다. component-scan 설정 덕분에 스프링이 이 클래스를 자동으로 빈으로 등록하게 됩니다.
• @GetMapping("/") 어노테이션은 HTTP GET 요청에 대해 루트 경로("/")로 들어온 요청을 이 home() 메서드가 처리하도록 매핑합니다. Spring 4.3부터는 @RequestMapping(method = GET, value = "/") 대신 이렇게 더 간단한 @GetMapping("/")을 사용할 수 있습니다.
• home() 메서드는 요청을 처리한 뒤 뷰 이름 "home"을 반환합니다. 내부적으로 DispatcherServlet은 이 반환값을 ViewResolver에게 전달하여 실제 JSP 경로로 매핑할 것입니다 (앞에서 설정한 대로면 /WEB-INF/views/home.jsp가 되겠죠).
• 또한 메서드 파라미터로 Model 객체를 받아서 사용하고 있습니다. 스프링 MVC는 컨트롤러 메서드를 호출할 때 모델 객체를 자동으로 전달해주며, 개발자는 거기에 뷰에 전달할 데이터를 추가할 수 있습니다. 여기서는 model.addAttribute("message", "Spring 4.3.16 동작 확인!") 코드를 통해 "message"라는 키에 환영 메시지 값을 넣었습니다. 이렇게 추가된 데이터는 이후 JSP에서 ${message}와 같이 EL(Expression Language)로 조회하여 표시할 수 있습니다.

요약하면, 이 컨트롤러는 루트 페이지에 접속했을 때 "Spring 4.3.16 동작 확인!"이라는 메시지를 보여주는 역할을 합니다.

 

비즈니스 로직은 없고 단순히 모델에 데이터 담아서 뷰 이름 반환하는 기본 형태입니다.

 

JSP 뷰 예제 (home.jsp)

컨트롤러가 "home"이라는 뷰 이름을 반환하면, 앞서 설정한 InternalResourceViewResolver에 의해 /WEB-INF/views/home.jsp 파일이 렌더링됩니다. 이제 해당 JSP 파일의 내용을 보겠습니다.

 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Home</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

 

home.jsp 설명

• 첫 줄의 <%@ page ... %> 지시자는 JSP 페이지 설정입니다. contentType="text/html;charset=UTF-8"로 지정하여 브라우저에 HTML 문서임을 알리고, UTF-8 인코딩을 사용함을 명시했습니다. (이 설정을 해야 한글 등 멀티바이트 문자가 깨지지 않습니다. 우리의 메시지가 한글이므로 매우 중요합니다!)
• <h1>${message}</h1> 부분이 실제 화면에 표시될 내용을 정의합니다. ${message}는 JSP의 Expression Language (EL)를 사용한 표현입니다. 컨트롤러가 Model에 담아준 "message" 속성 값을 EL로 출력하는 것이지요. 컨트롤러에서 "Spring 4.3.16 동작 확인!"이라는 문자열을 넣었으므로, 브라우저에는 <h1> 태그로 감싼 커다란 글씨로 그 문구가 보일 것입니다.
• 이 JSP에서는 JSTL 태그를 직접 사용하진 않았지만, JSTL 라이브러리를 pom.xml에 포함했으므로 <c:out>이나 <c:set> 같은 JSTL 태그를 사용할 수도 있습니다. 예를 들어, 위 코드는 <c:out value="${message}"/>로도 표현 가능하지만, 간단한 출력이라 EL을 바로 사용했습니다.

JSP 파일은 WEB-INF/views/ 폴더 아래 위치하고 있기 때문에 사용자가 직접 URL로 접근할 수 없습니다. 반드시 컨트롤러를 통해서만 이 JSP가 호출되며, 이는 MVC 패턴을 강제하고 뷰를 보호하는 효과가 있습니다.

 

 

전체 흐름: 요청부터 응답까지

Spring MVC의 동작은 Front Controller(DispatcherServlet) 패턴으로 이해할 수 있습니다.

 

Spring MVC 요청 처리 흐름 (DispatcherServlet이 프론트 컨트롤러로 동작한다).

위 그림과 함께, 흐름을 단계별로 설명하면 다음과 같습니다:

1. 사용자 요청
   • 사용자가 브라우저에서 http://localhost:8080/과 같은 URL로 웹 애플리케이션에 요청을 보냅니다. 이 요청은 웹 서버(Tomcat)의 서블릿 엔진으로 전달됩니다.
2. DispatcherServlet 수신
   •  Front Controller인 DispatcherServlet이 모든 요청을 가로채어 받습니다. (우리가 web.xml에서 /로 매핑했기 때문에 모든 요청이 이 서블릿으로 들어옵니다.) DispatcherServlet은 해당 URL에 맞는 컨트롤러를 찾기 위해 Spring의 Handler Mapping을 이용합니다.
3. 컨트롤러 실행
   •  요청에 매핑된 컨트롤러(HomeController)의 메서드를 호출합니다. 예제에서는 HomeController.home() 메서드가 실행되어 모델에 "message" 데이터를 담고 "home"이라는 뷰 이름을 반환합니다.
4. 모델과 뷰 처리
   •  DispatcherServlet은 컨트롤러로부터 받은 뷰 이름과 모델 데이터를 가지고 ViewResolver를 통해 실제 View를 찾습니다. 우리가 설정한 InternalResourceViewResolver가 "home" 뷰 이름을 /WEB-INF/views/home.jsp로 변환하여 JSP 뷰를 결정합니다. 그 다음 DispatcherServlet은 모델 데이터를 request attribute로 JSP에 넘기고, 해당 JSP를 렌더링하도록 요청합니다.
5. JSP 렌더링 및 응답 반환
   • JSP 엔진은 home.jsp를 실행하며 ${message} 표현을 Model에서 넘긴 값으로 치환하여 HTML을 생성합니다. 그 결과 완성된 HTML이 DispatcherServlet을 통해 HTTP 응답으로 사용자에게 전송됩니다. 브라우저는 HTML을 받아 화면에 "Spring 4.3.16 동작 확인!" 텍스트를 표시합니다.

요약하면, DispatcherServlet(프론트 컨트롤러)이 중심이 되어 요청 -> 컨트롤러 -> 모델/뷰 결정 -> JSP 렌더링 -> 응답의 일련의 흐름을 조율합니다.

이러한 구조 덕분에 컨트롤러와 뷰가 깔끔히 분리되고, 공통 작업(로깅, 국제화 처리 등)을 DispatcherServlet 선에서 일괄 관리할 수 있습니다.

 

 

예제 애플리케이션 실행 방법

스프링 프레임워크 4.3.16은 JDK 8으로 구동되며, maven(3.9.9) 도 설치되어 있어야 합니다.

 

다운로드 링크

- 스프링 프레임워크 4.3.16 : https://github.com/spring-projects/spring-framework/releases/tag/v4.3.16.RELEASE

- openJDK 8 : https://adoptium.net/temurin/releases/?version=8

- maven : https://maven.apache.org/download.cgi

 

 

 

이제 모든 코드와 설정을 작성했으니 직접 실행해볼 차례입니다. Maven과 Tomcat 플러그인을 사용하면 비교적 쉽게 로컬에서 애플리케이션을 구동할 수 있습니다. 다음 순서에 따라 진행해보세요.

 

1. 프로젝트 빌드: 터미널(명령 프롬프트)을 열고 프로젝트 루트 디렉터리로 이동한 후, Maven으로 프로젝트를 빌드합니다.

mvn clean package

 

 

이 명령은 소스 코드를 컴파일하고 spring-4.3.16-demo.war 파일을 target 폴더에 생성합니다. (사전에 Maven과 JDK가 설치되어 있어야 합니다.)

 

2. Tomcat 서버 실행: Maven Tomcat 플러그인을 사용하여 WAR를 바로 실행합니다.

mvn tomcat7:run

 

 

• 명령을 실행하면 Maven이 내장 Tomcat(버전 7 또는 호환)을 띄우고, 우리가 만든 WAR를 배포하여 실행합니다. 콘솔 로그에 Tomcat이 시작되었다는 메시지가 보일 것입니다. 기본적으로 8080 포트에서 애플리케이션이 구동됩니다 (pom.xml에서 설정한 대로입니다).

3. 웹 페이지 접속 확인: 브라우저를 열고 http://localhost:8080/ 에 접속해봅니다. 그러면 흰 배경에 큰 글씨로 "Spring 4.3.16 동작 확인!" 이라고 표시된 웹 페이지를 확인할 수 있습니다. 이것이 우리가 작성한 home.jsp 뷰의 내용입니다.

 

만약 해당 문구가 제대로 보인다면 Spring MVC 애플리케이션이 정상적으로 동작하는 것입니다. 컨트롤러에서 모델로 넘긴 데이터가 JSP까지 전달되어 출력되었음을 의미합니다.

 

Tip: tomcat7:run 방식 대신, 생성된 WAR 파일을 별도의 Tomcat 서버에 배포하거나, Eclipse/IntelliJ 같은 IDE의 서버 연동 기능을 활용해 실행할 수도 있습니다. 하지만 Maven 플러그인을 사용하면 별도 Tomcat 설치 없이도 곧바로 실행해볼 수 있어 편리합니다.

 

 

spring-4.3.16-demo.zip

0.01MB