본문 바로가기

서블릿·JSP 책임

서블릿은 요청을 처리해 화면용 모델을 만들고 JSP는 그 모델을 이스케이프해 출력하도록 나눈 뒤, 포워드와 303 리다이렉트의 차이를 내장 Tomcat 테스트로 확인합니다.

앞 글에서는 서블릿이 상태와 헤더를 정하고 본문을 직접 썼습니다. 게시글 상세 화면처럼 HTML이 길어지면 사정이 달라집니다. 서블릿 안에서 태그를 문자열로 이어 붙이기 시작하면 화면을 고칠 때마다 Java 코드를 고쳐야 하고, 사용자가 쓴 제목이 그대로 마크업에 섞여 들어갑니다.

이 글을 읽고 나면 다음을 할 수 있습니다.

  • 서블릿이 HTML을 직접 쓸 때 생기는 문제를 재현하고, 서블릿과 JSP가 맡을 일을 나눕니다.
  • 화면에 필요한 값만 담은 모델을 요청 속성에 넣고 /WEB-INF 아래의 JSP로 포워드합니다.
  • 조회와 검증 실패에는 포워드를, 성공한 POST에는 303 리다이렉트를 골라 씁니다.

이 장의 앞 글들과 같은 board 프로젝트를 씁니다. 1장 첫 글에서 만든 프로젝트에 Spring Web과 Thymeleaf, 테스트 스타터가 들어 있어야 하고, ./gradlew bootRun으로 애플리케이션이 뜨는 상태여야 합니다. JSP를 해석하는 라이브러리는 이 글의 중간에서 테스트용으로만 추가합니다. 이 글에서 만드는 게시글 42번의 상세 화면은 이어지는 세 글에서 컨트롤러, 프런트 컨트롤러, 핸들러 어댑터로 차례로 옮겨 갑니다.


서블릿이 HTML을 직접 쓰면 생기는 일

먼저 문제가 되는 구조를 직접 띄워 봅니다. 아래 서블릿은 게시글 제목을 h1 태그 사이에 문자열로 이어 붙여 응답합니다. 제목에는 누군가 게시글을 쓰면서 넣었다고 가정한 스크립트 태그가 들어 있습니다.

src/main/java/board/servlet/RawPostHtmlServlet.java
package board.servlet;

import java.io.IOException;

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

public class RawPostHtmlServlet extends HttpServlet {
    @Override
    protected void doGet(
            HttpServletRequest request,
            HttpServletResponse response) throws IOException {
        String title = "<script>alert('x')</script>";
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html");
        response.getWriter().write(
                "<!doctype html><title>post</title><h1>" + title + "</h1>");
    }
}

이 서블릿을 /raw/post-html 경로에 등록합니다. ServletRegistrationBean은 Spring Boot가 내장 Tomcat에 서블릿을 등록할 때 쓰는 빈입니다.

src/main/java/board/servlet/RawPostHtmlConfig.java
package board.servlet;

import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class RawPostHtmlConfig {
    @Bean
    ServletRegistrationBean<RawPostHtmlServlet> rawPostHtmlServlet() {
        return new ServletRegistrationBean<>(
                new RawPostHtmlServlet(), "/raw/post-html");
    }
}

프로젝트 루트에서 애플리케이션을 띄우고, 다른 터미널에서 요청을 보냅니다.

서버 실행과 요청
./gradlew bootRun
curl http://localhost:8080/raw/post-html

응답 본문은 다음 한 줄입니다.

응답 본문
<!doctype html><title>post</title><h1><script>alert('x')</script></h1>

같은 주소를 브라우저로 열면 제목이 글자로 보이지 않고 x라고 적힌 경고 창이 뜹니다. 브라우저는 응답의 어느 부분이 서버가 쓴 태그이고 어느 부분이 사용자가 쓴 제목인지 구별하지 못하므로, 제목 안의 script 태그를 그대로 실행합니다. 이것이 교차 사이트 스크립팅(XSS)입니다.

이 서블릿에는 문제가 하나 더 있습니다. 요청을 해석하는 일, 게시글을 찾는 일, 화면의 태그를 정하는 일이 doGet 하나에 묶여 있어서, h1을 h2로 바꾸는 화면 수정도 Java 코드를 고쳐 다시 컴파일하고 배포해야 합니다.

반대쪽으로 치우친 구조도 있습니다. JSP(Jakarta Server Pages)는 HTML 안에 동적인 값을 끼워 넣는 서버 쪽 템플릿 기술인데, 템플릿 안에 Java 코드를 적는 스크립틀릿(scriptlet)으로 파라미터를 해석하고 저장소를 조회하고 업무 규칙까지 실행할 수 있습니다. 그렇게 쓰면 이번에는 템플릿이 애플리케이션의 흐름을 떠맡습니다. 조회가 렌더링 도중에 실패하면 응답의 앞부분이 이미 나갔을 수 있고, 화면 하나를 테스트하려 해도 서블릿 컨테이너와 데이터베이스가 필요해집니다. JSP라는 기술이 문제가 아니라, 템플릿에 화면 말고 다른 일을 시키는 것이 문제입니다.

확인이 끝났으면 서버를 멈추고 방금 만든 두 파일을 지웁니다.


서블릿과 JSP가 맡을 일 나누기

두 극단을 피하려면 일을 다음처럼 나눕니다.

구성 요소맡는 일맡지 않는 일
서블릿 컨트롤러HTTP 입력 검증, 사용 사례 호출, 화면용 모델 준비, 정해진 뷰 선택HTML 문자열, SQL, 업무 상태 계산
사용 사례와 도메인조회, 권한, 상태 전이, 추천 자격 같은 업무 의미HTML 태그와 화면에 표시할 문자열
화면용 모델과 매퍼화면에 내보낼 필드 선택, 날짜·숫자·레이블 형식요청 처리와 데이터베이스 접근
JSP나 Thymeleaf 뷰요소 배치와 출력 위치에 맞는 이스케이프저장소 호출, 요청 해석, 복잡한 업무 식

게시글 상세 화면에 이 구분을 적용하면 흐름은 이렇습니다. GET /posts/42를 받은 PostPageServlet이 경로에서 번호를 읽고, 조회를 맡은 PostQuery에서 게시글의 조회 결과(projection)인 PostProjection을 얻습니다. PostPageMapper는 그 가운데 화면에 필요한 값만 골라 PostPageModel을 만듭니다. 서블릿은 이 모델을 요청 속성(request attribute)에 post라는 이름으로 넣고, 미리 정해 둔 /WEB-INF 아래의 JSP로 요청을 넘깁니다. 같은 요청을 서버 안의 다른 자원에 넘기는 이 동작을 포워드(forward)라고 합니다. JSP는 넘겨받은 모델을 읽어 마크업만 만듭니다.

표현과 제어를 분리하고 typed model로만 연결한다

projection 조회·page model·request attribute·고정 WEB-INF view 출력으로 표현 값이 이동한다.

Servlet 문자열 HTML은 제어와 표현을 Java에 섞고, JSP scriptlet은 표현과 업무 규칙과 데이터 접근을 템플릿에 섞습니다. 분리된 구조에서는 GET 요청을 Servlet controller가 받고 PostQuery use case를 호출한 뒤 화면에 필요한 값만 담은 PostPageModel을 request attribute로 저장합니다. 고정된 RequestDispatcher가 WEB-INF 내부 view로 forward하고, view는 repository를 다시 호출하지 않은 채 c:out 또는 Thymeleaf th:text처럼 이스케이프되는 출력 기능으로 markup만 만듭니다.

INPUT → USE CASE → TYPED MODEL → INTERNAL VIEW

표현과 제어를 분리하고 typed model로만 연결합니다

두 혼합 극단을 피합니다. controller는 입력과 use case, model, 고정된 view 선택까지만 소유하고 template는 전달받은 화면 값의 안전한 markup만 소유합니다.

Servlet 조회에서 mapper와 내부 view로 이어지는 typed model 전달PostPageServlet이 PostQuery에서 projection을 조회하고 PostPageMapper가 화면 model을 만듭니다. model은 request attribute로 전달되어 고정된 WEB-INF view가 출력합니다. template은 repository나 입력 파싱을 소유하지 않습니다.
GET /posts/42PostPageServlet
연결 관계GET /posts/42 · PostPageServlet → PostQuery · PostProjection
PostQueryPostProjection
연결 관계PostQuery · PostProjection → PostPageMapper · 표시 값 선택
PostPageMapper표시 값 선택
연결 관계PostPageMapper · 표시 값 선택 → PostPageModel · 공개 화면 값만
PostPageModel공개 화면 값만
연결 관계PostPageModel · 공개 화면 값만 → request attribute · post → model
request attributepost → model
연결 관계request attribute · post → model → fixed forward · /WEB-INF view
fixed forward/WEB-INF view

view: c:out / th:text · markup과 text escaping

Servlet 조회와 typed model의 모바일 흐름GET controller가 query에서 projection을 받고 mapper가 화면 model을 만듭니다. model은 request attribute로 전달되고 고정된 내부 view로 forward합니다. view는 제공된 값의 markup과 escaping을 맡으며 repository를 다시 호출하지 않습니다.GET /posts/42PostPageServletPostQueryPostProjectionPostPageMapper표시 값 선택PostPageModel공개 화면 값만request attributepost → modelfixed forward/WEB-INF view

view는 전달된 model로 markup을 만들고 c:out / th:text로 text를 escape합니다. 이 선은 SQL·권한·추천 정책을 template로 옮기는 경로가 아닙니다.

01 · TWO MIXED EXTREMES

Servlet 문자열 HTML과 JSP scriptlet은 반대 방향으로 역할을 섞습니다

전자는 제어와 markup을 Java에, 후자는 표현과 business·DB를 JSP에 둡니다. escaping·markup 변경 결합과 render 중 예외·테스트 난이도가 생깁니다.

02 · CONTROLLER → USE CASE

controller는 입력을 해석하고 PostQuery use case를 호출합니다

request parameter 파싱과 경로 선택은 controller가 맡고, 조회와 업무 규칙은 application 계층에 위임합니다.

03 · TYPED MODEL CONTRACT

화면에 필요한 값만 PostPageModel과 request attribute로 전달합니다

entity나 repository가 아니라 typed model을 request.setAttribute("post", model)로 전달해 오타와 우연한 내부 필드 노출을 줄입니다.

04 · FIXED INTERNAL VIEW

고정된 /WEB-INF view는 markup과 이스케이프만 소유합니다

request가 view 경로를 고르게 하지 않습니다. JSP는 <c:out>, Thymeleaf는 th:text처럼 이스케이프되는 출력을 사용하고 repository를 다시 호출하지 않습니다.

/WEB-INF는 외부 직접 요청을 막지만 서버 내부 dispatch는 허용합니다. 인증·인가를 대신하지 않으며 controller가 선택한 fixed view와 typed model로 사용합니다.

이 예의 조건

  • 두 박스는 같은 실행의 진행 정보와 자료·결과를 보여 줍니다. 박스의 좌우·위아래 위치를 별도 호출 순서로 해석하지 않습니다.
  • 조건별 종료는 대안입니다. 실패 뒤 정상 후속 단계를 실행하거나 독립 비교 사례를 같은 요청으로 연결하지 않습니다.
  • PostPageServlet이 PostQuery에서 projection을 조회하고 PostPageMapper가 화면 model을 만듭니다. model은 request attribute로 전달되어 고정된 WEB-INF view가 출력합니다. template은 repository나 입력 파싱을 소유하지 않습니다.
  • GET controller가 query에서 projection을 받고 mapper가 화면 model을 만듭니다. model은 request attribute로 전달되고 고정된 내부 view로 forward합니다. view는 제공된 값의 markup과 escaping을 맡으며 repository를 다시 호출하지 않습니다.
관계도의 보충 설명
화면 모델 전달의 흐름과 조건
순번원문 표시
1표현과 제어를 분리하고 typed model로만 연결한다
4두 혼합 극단을 피합니다. controller는 입력과 use case, model, 고정된 view 선택까지만 소유하고 template은 전달받은 화면 값의 안전한 markup만 소유합니다.
5Servlet 조회에서 mapper와 내부 view로 이어지는 화면 모델
24Servlet 문자열 HTML과 JSP scriptlet은 각각 다른 일을 섞는다
27controller는 입력을 해석하고 PostQuery use case를 호출한다
28request parameter 파싱과 경로 선택은 controller가 맡고, 조회와 업무 규칙은 application에 맡깁니다.
30화면에 필요한 값만 PostPageModel과 request attribute로 전달한다
35고정된 /WEB-INF view는 markup과 이스케이프만 소유한다
단계별 상태·값과 전환 이유
장면관찰 값전환 이유
projection 조회

Servlet이 PostQuery에서 projection을 얻습니다.

조회: PostQuery · 산출물: projection화면 자료의 조회가 완료됩니다.
typed 화면 모델

PostPageMapper가 page model을 만들어 request attribute에 둡니다.

자료: typed page model · 전달: request attribute조회 결과를 화면 값으로 바꿉니다.
고정 view 출력

고정 WEB-INF view가 model만 출력합니다.

view: 고정 WEB-INF · repository·파싱: template 몫 아님화면 출력이 데이터 조회와 분리됩니다.

표현과 제어를 분리하고 typed model로만 연결한다

projection 조회·page model·request attribute·고정 WEB-INF view 출력으로 표현 값이 이동한다.

Servlet 문자열 HTML은 제어와 표현을 Java에 섞고, JSP scriptlet은 표현과 업무 규칙과 데이터 접근을 템플릿에 섞습니다. 분리된 구조에서는 GET 요청을 Servlet controller가 받고 PostQuery use case를 호출한 뒤 화면에 필요한 값만 담은 PostPageModel을 request attribute로 저장합니다. 고정된 RequestDispatcher가 WEB-INF 내부 view로 forward하고, view는 repository를 다시 호출하지 않은 채 c:out 또는 Thymeleaf th:text처럼 이스케이프되는 출력 기능으로 markup만 만듭니다.

INPUT → USE CASE → TYPED MODEL → INTERNAL VIEW

표현과 제어를 분리하고 typed model로만 연결합니다

두 혼합 극단을 피합니다. controller는 입력과 use case, model, 고정된 view 선택까지만 소유하고 template는 전달받은 화면 값의 안전한 markup만 소유합니다.

Servlet 조회에서 mapper와 내부 view로 이어지는 typed model 전달PostPageServlet이 PostQuery에서 projection을 조회하고 PostPageMapper가 화면 model을 만듭니다. model은 request attribute로 전달되어 고정된 WEB-INF view가 출력합니다. template은 repository나 입력 파싱을 소유하지 않습니다.
GET /posts/42PostPageServlet
연결 관계GET /posts/42 · PostPageServlet → PostQuery · PostProjection
PostQueryPostProjection
연결 관계PostQuery · PostProjection → PostPageMapper · 표시 값 선택
PostPageMapper표시 값 선택
연결 관계PostPageMapper · 표시 값 선택 → PostPageModel · 공개 화면 값만
PostPageModel공개 화면 값만
연결 관계PostPageModel · 공개 화면 값만 → request attribute · post → model
request attributepost → model
연결 관계request attribute · post → model → fixed forward · /WEB-INF view
fixed forward/WEB-INF view

view: c:out / th:text · markup과 text escaping

Servlet 조회와 typed model의 모바일 흐름GET controller가 query에서 projection을 받고 mapper가 화면 model을 만듭니다. model은 request attribute로 전달되고 고정된 내부 view로 forward합니다. view는 제공된 값의 markup과 escaping을 맡으며 repository를 다시 호출하지 않습니다.GET /posts/42PostPageServletPostQueryPostProjectionPostPageMapper표시 값 선택PostPageModel공개 화면 값만request attributepost → modelfixed forward/WEB-INF view

view는 전달된 model로 markup을 만들고 c:out / th:text로 text를 escape합니다. 이 선은 SQL·권한·추천 정책을 template로 옮기는 경로가 아닙니다.

01 · TWO MIXED EXTREMES

Servlet 문자열 HTML과 JSP scriptlet은 반대 방향으로 역할을 섞습니다

전자는 제어와 markup을 Java에, 후자는 표현과 business·DB를 JSP에 둡니다. escaping·markup 변경 결합과 render 중 예외·테스트 난이도가 생깁니다.

02 · CONTROLLER → USE CASE

controller는 입력을 해석하고 PostQuery use case를 호출합니다

request parameter 파싱과 경로 선택은 controller가 맡고, 조회와 업무 규칙은 application 계층에 위임합니다.

03 · TYPED MODEL CONTRACT

화면에 필요한 값만 PostPageModel과 request attribute로 전달합니다

entity나 repository가 아니라 typed model을 request.setAttribute("post", model)로 전달해 오타와 우연한 내부 필드 노출을 줄입니다.

04 · FIXED INTERNAL VIEW

고정된 /WEB-INF view는 markup과 이스케이프만 소유합니다

request가 view 경로를 고르게 하지 않습니다. JSP는 <c:out>, Thymeleaf는 th:text처럼 이스케이프되는 출력을 사용하고 repository를 다시 호출하지 않습니다.

/WEB-INF는 외부 직접 요청을 막지만 서버 내부 dispatch는 허용합니다. 인증·인가를 대신하지 않으며 controller가 선택한 fixed view와 typed model로 사용합니다.

이 예의 조건

  • 두 박스는 같은 실행의 진행 정보와 자료·결과를 보여 줍니다. 박스의 좌우·위아래 위치를 별도 호출 순서로 해석하지 않습니다.
  • 조건별 종료는 대안입니다. 실패 뒤 정상 후속 단계를 실행하거나 독립 비교 사례를 같은 요청으로 연결하지 않습니다.
  • PostPageServlet이 PostQuery에서 projection을 조회하고 PostPageMapper가 화면 model을 만듭니다. model은 request attribute로 전달되어 고정된 WEB-INF view가 출력합니다. template은 repository나 입력 파싱을 소유하지 않습니다.
  • GET controller가 query에서 projection을 받고 mapper가 화면 model을 만듭니다. model은 request attribute로 전달되고 고정된 내부 view로 forward합니다. view는 제공된 값의 markup과 escaping을 맡으며 repository를 다시 호출하지 않습니다.

관계도의 보충 설명

화면 모델 전달의 흐름과 조건
순번원문 표시
1표현과 제어를 분리하고 typed model로만 연결한다
4두 혼합 극단을 피합니다. controller는 입력과 use case, model, 고정된 view 선택까지만 소유하고 template은 전달받은 화면 값의 안전한 markup만 소유합니다.
5Servlet 조회에서 mapper와 내부 view로 이어지는 화면 모델
24Servlet 문자열 HTML과 JSP scriptlet은 각각 다른 일을 섞는다
27controller는 입력을 해석하고 PostQuery use case를 호출한다
28request parameter 파싱과 경로 선택은 controller가 맡고, 조회와 업무 규칙은 application에 맡깁니다.
30화면에 필요한 값만 PostPageModel과 request attribute로 전달한다
35고정된 /WEB-INF view는 markup과 이스케이프만 소유한다
단계별 상태·값과 전환 이유
장면관찰 값전환 이유
projection 조회

Servlet이 PostQuery에서 projection을 얻습니다.

조회: PostQuery · 산출물: projection화면 자료의 조회가 완료됩니다.
typed 화면 모델

PostPageMapper가 page model을 만들어 request attribute에 둡니다.

자료: typed page model · 전달: request attribute조회 결과를 화면 값으로 바꿉니다.
고정 view 출력

고정 WEB-INF view가 model만 출력합니다.

view: 고정 WEB-INF · repository·파싱: template 몫 아님화면 출력이 데이터 조회와 분리됩니다.

그림은 방금 설명한 순서를 왼쪽에서 오른쪽으로 보여 줍니다. 서블릿이 PostQuery에서 조회 결과를 얻고, 매퍼가 만든 PostPageModel이 요청 속성 post로 전달되어, 고정된 /WEB-INF 뷰가 그 값만 출력합니다. 그림에 적힌 c:out과 th:text는 뷰가 값을 이스케이프해 출력하는 기능으로, 아래에서 실제 코드로 다룹니다.


테스트 파일을 만들고 실행하기

JSP를 실제로 렌더링하려면 JSP 엔진인 Jasper와, c:out 같은 태그를 제공하는 Jakarta Tags 라이브러리가 필요합니다. build.gradle의 dependencies 블록에 다음 세 줄을 추가합니다.

build.gradle (dependencies 블록에 추가)
testRuntimeOnly 'org.apache.tomcat.embed:tomcat-embed-jasper'
testRuntimeOnly 'jakarta.servlet.jsp.jstl:jakarta.servlet.jsp.jstl-api'
testRuntimeOnly 'org.glassfish.web:jakarta.servlet.jsp.jstl'

세 항목의 버전은 Spring Boot 4.1.2의 의존성 버전 묶음(BOM)이 정하므로 따로 적지 않습니다. testRuntimeOnly로 넣었기 때문에 테스트를 실행할 때만 쓰이고, 애플리케이션 본체에는 들어가지 않습니다.

이어서 아래 파일을 만듭니다. 서블릿과 모델, JSP 세 장, 내장 Tomcat을 띄우는 코드와 테스트 일곱 개가 한 파일에 들어 있어 길지만, 지금은 전부 읽지 않아도 됩니다. 접힌 부분을 펼쳐 그대로 저장한 뒤 실행부터 하고, 핵심 부분은 다음 절부터 하나씩 떼어서 읽습니다. JSP는 테스트가 시작할 때 임시 디렉터리에 파일로 만들어 Tomcat의 문서 루트로 연결하므로 src/main/webapp을 만들 필요가 없습니다.

테스트 파일 전체 보기
src/test/java/board/servlet/EmbeddedServletViewBoundaryTest.java
package board.servlet;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.text.NumberFormat;
import java.time.Duration;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.Test;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.tomcat.servlet.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.server.servlet.context
        .ServletWebServerApplicationContext;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.util.FileSystemUtils;
import org.thymeleaf.context.Context;
import org.thymeleaf.spring6.SpringTemplateEngine;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.StringTemplateResolver;

public class EmbeddedServletViewBoundaryTest {
    private static final HttpClient CLIENT = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .followRedirects(HttpClient.Redirect.NEVER)
            .version(HttpClient.Version.HTTP_1_1)
            .build();
    private static final String UNSAFE =
            "<script>alert('x')</script>&게시글";

    @Test
    void GET은_typed_model을_fixed_WEB_INF_view로_forward하고_escape한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var response = get(server, "/posts/42");
            var body = response.body();

            assertAll(
                    () -> assertEquals(200, response.statusCode()),
                    () -> assertTrue(body.contains("&lt;script&gt;")),
                    () -> assertFalse(body.contains("<script>alert")),
                    () -> assertTrue(body.contains("1,200자")),
                    () -> assertTrue(body.contains("긴 글")),
                    () -> assertTrue(body.contains("추천")),
                    () -> assertTrue(body.contains(
                            "<p id=\"forward-uri\">/posts/42</p>")),
                    () -> assertTrue(body.contains(
                            "<p id=\"repository\"></p>")),
                    () -> assertEquals(1, server.store().queryCount.get()),
                    () -> assertEquals(
                            PostPageModel.class,
                            server.probe().lastModelType.get()));
        }
    }

    @Test
    void WEB_INF는_직접_요청하면_404이고_view_parameter로_바뀌지_않는다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var direct = get(server, "/WEB-INF/views/post-detail.jsp");
            var routed = get(
                    server,
                    "/posts/42?view=/WEB-INF/views/escaping-probe.jsp");

            assertAll(
                    () -> assertEquals(404, direct.statusCode()),
                    () -> assertEquals(200, routed.statusCode()),
                    () -> assertTrue(routed.body().contains(
                            "<main id=\"post-detail\">")),
                    () -> assertFalse(routed.body().contains(
                            "<p id=\"raw\">")),
                    () -> assertEquals(1, server.store().queryCount.get()));
        }
    }

    @Test
    void 검증_실패_POST는_같은_request의_입력과_error를_forward한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var title = "<x";
            var response = post(
                    server,
                    "/posts",
                    "title=" + URLEncoder.encode(title, UTF_8));

            assertAll(
                    () -> assertEquals(422, response.statusCode()),
                    () -> assertTrue(response.body().contains(
                            "value=\"&lt;x\"")),
                    () -> assertTrue(response.body().contains(
                            "제목은 3자 이상이어야 합니다")),
                    () -> assertTrue(response.body().contains(
                            "<p id=\"forward-uri\">/posts</p>")),
                    () -> assertTrue(response.body().contains(
                            "<p id=\"marker\">"
                                    + server.probe().lastPostMarker.get()
                                    + "</p>")),
                    () -> assertEquals(0, server.store().commandCount.get()));
        }
    }

    @Test
    void 성공_POST는_303_Location_뒤_new_GET에서_model을_다시_만든다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var created = post(
                    server,
                    "/posts",
                    "title=" + URLEncoder.encode("새 게시글", UTF_8));
            var location = created.headers()
                    .firstValue("Location")
                    .orElseThrow();
            var redirected = get(created.request().uri().resolve(location));

            assertAll(
                    () -> assertEquals(303, created.statusCode()),
                    () -> assertTrue(location.endsWith("/posts/43")),
                    () -> assertEquals(200, redirected.statusCode()),
                    () -> assertTrue(redirected.body().contains("새 게시글")),
                    () -> assertTrue(redirected.body().contains(
                            "<p id=\"post-only\"></p>")),
                    () -> assertEquals("GET", server.probe().lastGetMethod.get()),
                    () -> assertNotEquals(
                            server.probe().lastPostMarker.get(),
                            server.probe().lastGetMarker.get()),
                    () -> assertEquals(1, server.store().commandCount.get()),
                    () -> assertEquals(1, server.store().queryCount.get()));
        }
    }

    @Test
    void forward는_미커밋_buffer를_지우고_commit_뒤에는_거부된다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var beforeCommit = get(
                    server, "/diagnostics/forward-before-commit");
            var afterCommit = get(
                    server, "/diagnostics/forward-after-commit");

            assertAll(
                    () -> assertEquals(200, beforeCommit.statusCode()),
                    () -> assertFalse(beforeCommit.body().contains("STALE")),
                    () -> assertTrue(beforeCommit.body().contains(
                            "<p id=\"escaped\">&lt;script&gt;")),
                    () -> assertEquals(200, afterCommit.statusCode()),
                    () -> assertEquals("PARTIAL", afterCommit.body()),
                    () -> assertTrue(
                            server.probe().committedForwardRejected.get()));
        }
    }

    @Test
    void JSP_raw_EL과_c_out의_escaped_text를_실제_Jasper로_구분한다()
            throws Exception {
        try (var server = RunningServer.start()) {
            var response = get(server, "/diagnostics/jsp-escaping");
            var body = response.body();

            assertAll(
                    () -> assertEquals(200, response.statusCode()),
                    () -> assertTrue(body.contains(
                            "<p id=\"raw\"><script>alert('x')</script>")),
                    () -> assertTrue(body.contains(
                            "<p id=\"escaped\">&lt;script&gt;")),
                    () -> assertTrue(body.contains("&amp;게시글</p>")),
                    () -> assertEquals(3,
                            body.split("id=\"(?:raw|escaped)\"", -1).length));
        }
    }

    @Test
    void Thymeleaf_th_text와_th_utext의_출력을_구분한다() {
        var resolver = new StringTemplateResolver();
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCacheable(false);
        var engine = new SpringTemplateEngine();
        engine.setTemplateResolver(resolver);
        var context = new Context(Locale.KOREA);
        context.setVariable("unsafe", "<em>model</em>&");

        var html = engine.process(
                "<p id=\"escaped\" th:text=\"${unsafe}\"></p>"
                        + "<p id=\"raw\" th:utext=\"${unsafe}\"></p>",
                context);

        assertAll(
                () -> assertTrue(html.contains(
                        "<p id=\"escaped\">&lt;em&gt;model&lt;/em&gt;&amp;</p>")),
                () -> assertTrue(html.contains(
                        "<p id=\"raw\"><em>model</em>&</p>")));
    }

    private static HttpResponse<String> get(
            RunningServer server,
            String path)
            throws IOException, InterruptedException {
        return get(URI.create(server.origin() + path));
    }

    private static HttpResponse<String> get(URI uri)
            throws IOException, InterruptedException {
        return send(uri, "GET", null);
    }

    private static HttpResponse<String> post(
            RunningServer server,
            String path,
            String formBody)
            throws IOException, InterruptedException {
        return send(URI.create(server.origin() + path), "POST", formBody);
    }

    private static HttpResponse<String> send(
            URI uri,
            String method,
            String body)
            throws IOException, InterruptedException {
        var builder = HttpRequest.newBuilder(uri)
                .timeout(Duration.ofSeconds(10));
        if (body == null) {
            builder.method(method, HttpRequest.BodyPublishers.noBody());
        } else {
            builder.header(
                    "Content-Type",
                    "application/x-www-form-urlencoded;charset=UTF-8");
            builder.method(method, HttpRequest.BodyPublishers.ofString(
                    body, UTF_8));
        }
        return CLIENT.send(
                builder.build(),
                HttpResponse.BodyHandlers.ofString(UTF_8));
    }

    public record RunningServer(
            ServletWebServerApplicationContext context,
            String origin,
            BoardStore store,
            ViewProbe probe,
            ViewFiles files)
            implements AutoCloseable {
        static RunningServer start() throws IOException {
            var files = ViewFiles.create();
            var store = new BoardStore();
            var probe = new ViewProbe();
            var mapper = new PostPageMapper();
            var application = new SpringApplication(TestApplication.class);
            application.setWebApplicationType(WebApplicationType.SERVLET);
            application.setRegisterShutdownHook(false);
            application.setDefaultProperties(Map.of(
                    "server.address", "127.0.0.1",
                    "server.port", "0",
                    "server.tomcat.basedir",
                            files.root().resolve("tomcat").toString(),
                    "spring.main.banner-mode", "off",
                    "logging.level.root", "OFF"));
            application.addInitializers(context -> {
                var beans = context.getBeanFactory();
                beans.registerSingleton("viewFiles", files);
                beans.registerSingleton("boardStore", store);
                beans.registerSingleton("viewProbe", probe);
                beans.registerSingleton("postPageMapper", mapper);
            });

            try {
                var context = (ServletWebServerApplicationContext)
                        application.run();
                return new RunningServer(
                        context,
                        "http://127.0.0.1:"
                                + context.getWebServer().getPort(),
                        store,
                        probe,
                        files);
            } catch (RuntimeException failure) {
                files.close();
                throw failure;
            }
        }

        @Override
        public void close() throws IOException {
            context.close();
            files.close();
        }
    }

    @SpringBootConfiguration(proxyBeanMethods = false)
    @EnableAutoConfiguration
    public static class TestApplication {
        @Bean
        WebServerFactoryCustomizer<TomcatServletWebServerFactory>
                documentRoot(ViewFiles files) {
            return factory -> {
                factory.setDocumentRoot(files.root().toFile());
                factory.setRegisterDefaultServlet(true);
            };
        }

        @Bean
        ServletRegistrationBean<PostPageServlet> postPageServlet(
                BoardStore store,
                PostPageMapper mapper,
                ViewProbe probe) {
            var registration = new ServletRegistrationBean<>(
                    new PostPageServlet(store, store, mapper, probe),
                    "/posts",
                    "/posts/*");
            registration.setName("postPageServlet");
            return registration;
        }

        @Bean
        ServletRegistrationBean<DispatchProbeServlet> dispatchProbeServlet(
                ViewProbe probe) {
            var registration = new ServletRegistrationBean<>(
                    new DispatchProbeServlet(probe),
                    "/diagnostics/*");
            registration.setName("dispatchProbeServlet");
            return registration;
        }
    }

    public static final class PostPageServlet extends HttpServlet {
        private static final String DETAIL_VIEW =
                "/WEB-INF/views/post-detail.jsp";
        private static final String FORM_VIEW =
                "/WEB-INF/views/post-form.jsp";
        private final PostQuery query;
        private final PostCommand command;
        private final PostPageMapper mapper;
        private final ViewProbe probe;

        PostPageServlet(
                PostQuery query,
                PostCommand command,
                PostPageMapper mapper,
                ViewProbe probe) {
            this.query = query;
            this.command = command;
            this.mapper = mapper;
            this.probe = probe;
        }

        @Override
        protected void doGet(
                HttpServletRequest request,
                HttpServletResponse response)
                throws ServletException, IOException {
            var path = request.getPathInfo();
            if (path == null || path.length() < 2) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND);
                return;
            }

            final long id;
            try {
                id = Long.parseLong(path.substring(1));
            } catch (NumberFormatException invalidId) {
                response.sendError(HttpServletResponse.SC_BAD_REQUEST);
                return;
            }

            var post = query.find(id);
            if (post.isEmpty()) {
                response.sendError(HttpServletResponse.SC_NOT_FOUND);
                return;
            }
            var model = mapper.toModel(post.orElseThrow());
            var marker = requestMarker("GET", request);
            request.setAttribute("post", model);
            request.setAttribute("requestMarker", marker);
            probe.lastModelType.set(model.getClass());
            probe.lastGetMethod.set(request.getMethod());
            probe.lastGetMarker.set(marker);
            request.getRequestDispatcher(DETAIL_VIEW)
                    .forward(request, response);
        }

        @Override
        protected void doPost(
                HttpServletRequest request,
                HttpServletResponse response)
                throws ServletException, IOException {
            var title = Optional.ofNullable(request.getParameter("title"))
                    .orElse("");
            var marker = requestMarker("POST", request);
            probe.lastPostMarker.set(marker);
            request.setAttribute("requestMarker", marker);

            if (title.strip().length() < 3) {
                response.setStatus(422);
                request.setAttribute(
                        "form",
                        new PostFormModel(
                                title,
                                "제목은 3자 이상이어야 합니다"));
                request.getRequestDispatcher(FORM_VIEW)
                        .forward(request, response);
                return;
            }

            var id = command.create(title.strip());
            request.setAttribute("postRequestOnly", "must-not-cross");
            response.sendRedirect(
                    response.encodeRedirectURL(
                            request.getContextPath() + "/posts/" + id),
                    HttpServletResponse.SC_SEE_OTHER);
        }

        private static String requestMarker(
                String method,
                HttpServletRequest request) {
            return method + ":" + System.identityHashCode(request);
        }
    }

    public static final class DispatchProbeServlet extends HttpServlet {
        private static final String ESCAPING_VIEW =
                "/WEB-INF/views/escaping-probe.jsp";
        private final ViewProbe probe;

        DispatchProbeServlet(ViewProbe probe) {
            this.probe = probe;
        }

        @Override
        protected void doGet(
                HttpServletRequest request,
                HttpServletResponse response)
                throws ServletException, IOException {
            response.setCharacterEncoding(UTF_8.name());
            response.setContentType("text/html");
            switch (request.getPathInfo()) {
                case "/forward-before-commit" -> {
                    response.getWriter().write("STALE");
                    request.setAttribute("unsafe", UNSAFE);
                    request.getRequestDispatcher(ESCAPING_VIEW)
                            .forward(request, response);
                }
                case "/forward-after-commit" -> {
                    response.getWriter().write("PARTIAL");
                    response.flushBuffer();
                    try {
                        request.getRequestDispatcher(ESCAPING_VIEW)
                                .forward(request, response);
                    } catch (IllegalStateException committed) {
                        probe.committedForwardRejected.set(true);
                    }
                }
                case "/jsp-escaping" -> {
                    request.setAttribute("unsafe", UNSAFE);
                    request.getRequestDispatcher(ESCAPING_VIEW)
                            .forward(request, response);
                }
                default -> response.sendError(
                        HttpServletResponse.SC_NOT_FOUND);
            }
        }
    }

    public interface PostQuery {
        Optional<PostProjection> find(long id);
    }

    public interface PostCommand {
        long create(String title);
    }

    public static final class BoardStore implements PostQuery, PostCommand {
        private final Map<Long, StoredPost> posts = new ConcurrentHashMap<>();
        private final AtomicLong nextId = new AtomicLong(43);
        final AtomicInteger queryCount = new AtomicInteger();
        final AtomicInteger commandCount = new AtomicInteger();

        BoardStore() {
            posts.put(42L, new StoredPost(
                    42L,
                    UNSAFE,
                    1_200,
                    true,
                    "server-only-secret"));
        }

        @Override
        public Optional<PostProjection> find(long id) {
            queryCount.incrementAndGet();
            return Optional.ofNullable(posts.get(id))
                    .map(post -> new PostProjection(
                            post.id(),
                            post.title(),
                            post.contentLength(),
                            post.recommended()));
        }

        @Override
        public long create(String title) {
            commandCount.incrementAndGet();
            var id = nextId.getAndIncrement();
            posts.put(id, new StoredPost(
                    id,
                    title,
                    title.length(),
                    false,
                    "created-secret"));
            return id;
        }
    }

    public static final class PostPageMapper {
        PostPageModel toModel(PostProjection post) {
            var formattedLength = NumberFormat
                    .getIntegerInstance(Locale.KOREA)
                    .format(post.contentLength())
                    + "자";
            return new PostPageModel(
                    post.id(),
                    post.title(),
                    formattedLength,
                    post.contentLength() >= 60,
                    post.recommended());
        }
    }

    public record PostPageModel(
            long id,
            String title,
            String displayLength,
            boolean longPost,
            boolean recommended) {
        public long getId() {
            return id;
        }

        public String getTitle() {
            return title;
        }

        public String getDisplayLength() {
            return displayLength;
        }

        public boolean isLongPost() {
            return longPost;
        }

        public boolean isRecommended() {
            return recommended;
        }
    }

    public record PostFormModel(String title, String error) {
        public String getTitle() {
            return title;
        }

        public String getError() {
            return error;
        }
    }

    private record StoredPost(
            long id,
            String title,
            int contentLength,
            boolean recommended,
            String internalSecret) {}

    public record PostProjection(
            long id,
            String title,
            int contentLength,
            boolean recommended) {}

    public static final class ViewProbe {
        final AtomicReference<Class<?>> lastModelType =
                new AtomicReference<>();
        final AtomicReference<String> lastPostMarker =
                new AtomicReference<>();
        final AtomicReference<String> lastGetMarker =
                new AtomicReference<>();
        final AtomicReference<String> lastGetMethod =
                new AtomicReference<>();
        final AtomicBoolean committedForwardRejected =
                new AtomicBoolean(false);
    }

    public record ViewFiles(Path root) implements AutoCloseable {
        private static final String DETAIL_JSP = """
                <%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
                <%@ taglib prefix="c" uri="jakarta.tags.core" %>
                <!doctype html>
                <html lang="ko">
                <head><meta charset="utf-8"><title>게시글 상세</title></head>
                <body>
                  <main id="post-detail">
                    <h1><c:out value="${post.title}" /></h1>
                    <p><c:out value="${post.displayLength}" /></p>
                    <c:if test="${post.longPost}"><strong>긴 글</strong></c:if>
                    <c:if test="${post.recommended}"><strong>추천</strong></c:if>
                    <p id="forward-uri"><c:out value="${requestScope['jakarta.servlet.forward.request_uri']}" /></p>
                    <p id="post-only"><c:out value="${postRequestOnly}" /></p>
                    <p id="repository"><c:out value="${repository}" /></p>
                  </main>
                </body>
                </html>
                """;
        private static final String FORM_JSP = """
                <%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
                <%@ taglib prefix="c" uri="jakarta.tags.core" %>
                <!doctype html>
                <html lang="ko">
                <head><meta charset="utf-8"><title>게시글 등록</title></head>
                <body>
                  <form method="post" action="/posts">
                    <label>제목 <input name="title" value="<c:out value="${form.title}" />"></label>
                    <p role="alert"><c:out value="${form.error}" /></p>
                  </form>
                  <p id="forward-uri"><c:out value="${requestScope['jakarta.servlet.forward.request_uri']}" /></p>
                  <p id="marker"><c:out value="${requestMarker}" /></p>
                </body>
                </html>
                """;
        private static final String ESCAPING_JSP = """
                <%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
                <%@ taglib prefix="c" uri="jakarta.tags.core" %>
                <!doctype html>
                <html lang="ko">
                <head><meta charset="utf-8"><title>escaping probe</title></head>
                <body>
                  <p id="raw">${unsafe}</p>
                  <p id="escaped"><c:out value="${unsafe}" /></p>
                </body>
                </html>
                """;

        static ViewFiles create() throws IOException {
            var root = Files.createTempDirectory("b77-views-")
                    .toRealPath();
            var views = Files.createDirectories(
                    root.resolve("WEB-INF/views"));
            Files.writeString(
                    views.resolve("post-detail.jsp"), DETAIL_JSP, UTF_8);
            Files.writeString(
                    views.resolve("post-form.jsp"), FORM_JSP, UTF_8);
            Files.writeString(
                    views.resolve("escaping-probe.jsp"),
                    ESCAPING_JSP,
                    UTF_8);
            return new ViewFiles(root);
        }

        @Override
        public void close() throws IOException {
            if (!root.getFileName().toString().startsWith("b77-views-")) {
                throw new IOException("unexpected temporary root: " + root);
            }
            FileSystemUtils.deleteRecursively(root);
        }
    }
}

프로젝트 루트에서 이 테스트만 실행합니다.

테스트 실행
./gradlew test --tests board.servlet.EmbeddedServletViewBoundaryTest

Windows의 PowerShell에서는 ./gradlew 대신 .\gradlew.bat을 씁니다. 일곱 테스트가 모두 통과하면 마지막에 BUILD SUCCESSFUL이 나오고, 테스트별 결과는 build/reports/tests/test/index.html에서 볼 수 있습니다. 실패한다면 아래 표에서 먼저 확인할 곳을 찾습니다.

증상먼저 볼 곳
jakarta.servlet이나 org.thymeleaf 타입을 찾지 못해 컴파일이 실패함프로젝트에 Spring Web과 Thymeleaf 스타터가 있는지 확인합니다.
JSP 요청이 200이 아니거나 JSP 소스가 그대로 응답에 나옴build.gradle에 tomcat-embed-jasper 줄이 들어갔는지 확인합니다.
태그 라이브러리를 찾지 못한다는 오류가 남Jakarta Tags의 API와 구현 두 줄, JSP 첫머리의 uri="jakarta.tags.core"를 확인합니다.

서블릿은 모델을 만들고 뷰를 고릅니다

테스트 파일에서 가장 먼저 볼 부분은 PostPageServlet의 doGet입니다. 이 서블릿은 /posts와 /posts/*에 등록되어 있으므로, /posts/42 요청에서 getPathInfo()는 /42를 돌려줍니다.

EmbeddedServletViewBoundaryTest.java (PostPageServlet의 doGet)
@Override
protected void doGet(
        HttpServletRequest request,
        HttpServletResponse response)
        throws ServletException, IOException {
    var path = request.getPathInfo();
    if (path == null || path.length() < 2) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }

    final long id;
    try {
        id = Long.parseLong(path.substring(1));
    } catch (NumberFormatException invalidId) {
        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;
    }

    var post = query.find(id);
    if (post.isEmpty()) {
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }
    var model = mapper.toModel(post.orElseThrow());
    var marker = requestMarker("GET", request);
    request.setAttribute("post", model);
    request.setAttribute("requestMarker", marker);
    probe.lastModelType.set(model.getClass());
    probe.lastGetMethod.set(request.getMethod());
    probe.lastGetMarker.set(marker);
    request.getRequestDispatcher(DETAIL_VIEW)
            .forward(request, response);
}

코드는 위에서 아래로 네 가지 일을 합니다. 경로에서 번호를 읽어 숫자가 아니면 400, 게시글이 없으면 404로 끝냅니다. 게시글이 있으면 매퍼로 PostPageModel을 만들고, 요청 속성 post에 넣습니다. 마지막으로 상수 DETAIL_VIEW, 곧 /WEB-INF/views/post-detail.jsp로 포워드합니다. probe와 requestMarker는 테스트가 값을 비교하려고 남기는 기록입니다. 이 메서드 어디에도 HTML 태그가 없다는 점을 눈여겨봅니다.

저장소가 가진 게시글에는 화면에 내보내면 안 되는 값도 있습니다. 이 예제의 StoredPost에는 internalSecret 필드가 있는데, 조회 결과인 PostProjection에서 먼저 빠지고, 매퍼는 그 조회 결과를 화면에 맞는 값으로 바꿉니다.

EmbeddedServletViewBoundaryTest.java (PostPageMapper)
public static final class PostPageMapper {
    PostPageModel toModel(PostProjection post) {
        var formattedLength = NumberFormat
                .getIntegerInstance(Locale.KOREA)
                .format(post.contentLength())
                + "자";
        return new PostPageModel(
                post.id(),
                post.title(),
                formattedLength,
                post.contentLength() >= 60,
                post.recommended());
    }
}

글자 수 1200을 1,200자라는 표시 문자열로 바꾸는 일과, 60자 이상이면 긴 글이라고 표시할지 정하는 일을 매퍼가 맡습니다. PostPageModel은 레코드이지만 getTitle(), isLongPost() 같은 게터를 따로 가지고 있습니다. JSP의 표현 언어(EL)가 ${post.title}을 getTitle() 호출로 해석하기 때문입니다. Java 쪽의 필드와 생성자는 컴파일러가 타입을 검사하지만, JSP에 적은 post.title이라는 이름은 렌더링할 때 해석되므로 오타가 있는지는 화면을 실제로 렌더링하는 테스트로 확인합니다.

이제 뷰입니다. 테스트 파일의 DETAIL_JSP 문자열이 WEB-INF/views/post-detail.jsp의 내용입니다.

WEB-INF/views/post-detail.jsp
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib prefix="c" uri="jakarta.tags.core" %>
<!doctype html>
<html lang="ko">
<head><meta charset="utf-8"><title>게시글 상세</title></head>
<body>
  <main id="post-detail">
    <h1><c:out value="${post.title}" /></h1>
    <p><c:out value="${post.displayLength}" /></p>
    <c:if test="${post.longPost}"><strong>긴 글</strong></c:if>
    <c:if test="${post.recommended}"><strong>추천</strong></c:if>
    <p id="forward-uri"><c:out value="${requestScope['jakarta.servlet.forward.request_uri']}" /></p>
    <p id="post-only"><c:out value="${postRequestOnly}" /></p>
    <p id="repository"><c:out value="${repository}" /></p>
  </main>
</body>
</html>

JSP가 하는 일은 넘겨받은 post의 값을 태그 사이에 놓는 것뿐입니다. c:if는 조건이 참일 때만 안쪽을 출력하는 태그이고, 값은 모두 c:out 태그로 출력합니다. c:out이 왜 필요한지는 다음 절에서 봅니다. 첫 번째 테스트는 GET /posts/42의 응답에서 다음을 확인합니다.

확인하는 것결과이유
상태 코드200포워드한 JSP가 응답을 끝까지 만들었습니다.
제목&lt;script&gt;로 시작하는 글자로 출력되고, <script>alert는 본문에 없음c:out이 <와 >를 이스케이프했습니다.
글자 수와 표시1,200자, 긴 글, 추천매퍼가 만든 표시 값과 두 참거짓 값입니다.
id="forward-uri" 문단/posts/42포워드된 뒤에도 원래 요청 경로가 jakarta.servlet.forward.request_uri 속성에 남습니다.
조회 횟수1서블릿이 한 번 조회했고, 뷰는 다시 조회하지 않았습니다.

여기서 한 가지를 먼저 예상해 보세요. 브라우저 주소창에 /WEB-INF/views/post-detail.jsp를 직접 입력하면 어떻게 될까요? 또 /posts/42?view=/WEB-INF/views/escaping-probe.jsp처럼 다른 JSP의 경로를 파라미터로 붙이면 화면이 바뀔까요?

결과 확인하기

직접 요청은 404입니다. 서블릿 컨테이너는 /WEB-INF 아래의 자원을 바깥의 요청에 내주지 않고, 서버 안의 포워드나 인클루드 같은 방법으로 접근하게 합니다. ?view=를 붙인 요청은 200이고 화면은 그대로 게시글 상세입니다. doGet이 요청 파라미터를 읽어 뷰를 고르지 않고 상수 DETAIL_VIEW만 쓰기 때문입니다. 두 번째 테스트가 이 두 가지를 확인합니다.

/WEB-INF는 직접 요청을 막아 줄 뿐이며 로그인 여부나 권한을 검사해 주는 장치는 아닙니다. 어떤 뷰를 보여 줄지는 컨트롤러가 상수로 정하고, 요청이 뷰의 경로를 고르지 못하게 하는 것이 여기서 지키는 규칙입니다.


이스케이프는 뷰가 출력할 때 합니다

처음에 본 RawPostHtmlServlet의 문제는 제목을 그대로 내보낸 것이었습니다. JSP로 옮겼다고 해서 이 문제가 저절로 사라지지는 않습니다. ${post.title}이라고만 적으면 EL은 값을 평가해 그대로 출력합니다. 테스트 파일의 escaping-probe.jsp가 두 방식을 나란히 놓고 비교합니다.

WEB-INF/views/escaping-probe.jsp (본문 부분)
<p id="raw">${unsafe}</p>
<p id="escaped"><c:out value="${unsafe}" /></p>

unsafe의 값은 <script>alert('x')</script>&게시글입니다. 여섯 번째 테스트가 이 JSP를 실제 Jasper로 렌더링한 결과는 다음과 같습니다.

출력 방법응답에 나온 내용브라우저의 해석
${unsafe}<script>alert('x')</script>가 그대로스크립트로 실행합니다.
c:out&lt;script&gt;로 시작하고 &amp;게시글로 끝남글자로 보여 줍니다.

Jakarta Tags 3.0의 c:out은 escapeXml 속성의 기본값이 true여서, 따로 지정하지 않아도 <, >, & 같은 문자를 HTML 엔티티로 바꿉니다. 그래서 HTML의 텍스트 위치에 사용자 값을 출력할 때는 c:out을 씁니다.

이 프로젝트의 기본 뷰 기술인 Thymeleaf에도 같은 구분이 있습니다. 일곱 번째 테스트는 서버 없이 템플릿 엔진만 만들어 두 속성을 비교합니다.

EmbeddedServletViewBoundaryTest.java (Thymeleaf 비교 테스트)
@Test
void Thymeleaf_th_text와_th_utext의_출력을_구분한다() {
    var resolver = new StringTemplateResolver();
    resolver.setTemplateMode(TemplateMode.HTML);
    resolver.setCacheable(false);
    var engine = new SpringTemplateEngine();
    engine.setTemplateResolver(resolver);
    var context = new Context(Locale.KOREA);
    context.setVariable("unsafe", "<em>model</em>&");

    var html = engine.process(
            "<p id=\"escaped\" th:text=\"${unsafe}\"></p>"
                    + "<p id=\"raw\" th:utext=\"${unsafe}\"></p>",
            context);

    assertAll(
            () -> assertTrue(html.contains(
                    "<p id=\"escaped\">&lt;em&gt;model&lt;/em&gt;&amp;</p>")),
            () -> assertTrue(html.contains(
                    "<p id=\"raw\"><em>model</em>&</p>")));
}

th:text는 값을 이스케이프해 &lt;em&gt;model&lt;/em&gt;&amp;로 출력하고, th:utext는 <em>model</em>&를 그대로 출력합니다. 사용자가 입력한 값에는 th:text를 씁니다.

이스케이프를 컨트롤러나 매퍼가 아니라 뷰가 맡는 데는 이유가 있습니다. 같은 값이라도 HTML 텍스트, HTML 속성, URL, JavaScript, CSS 가운데 어디에 놓이느냐에 따라 바꿔야 할 문자가 다르고, 값이 어디에 놓이는지는 뷰만 압니다. 그래서 모델에는 이스케이프하지 않은 원래 글자를 넣고, 뷰가 출력 위치에 맞는 방법을 고릅니다. c:out과 th:text는 HTML의 텍스트 위치에 맞는 방법이며, URL이나 JavaScript 안에 값을 넣을 때는 그 위치에 맞는 인코딩을 따로 써야 합니다.


검증에 실패하면 포워드, 성공하면 303

조회 화면은 포워드 하나로 끝났습니다. 글을 등록하는 POST는 결과가 둘로 갈립니다. doPost를 봅니다.

EmbeddedServletViewBoundaryTest.java (PostPageServlet의 doPost)
@Override
protected void doPost(
        HttpServletRequest request,
        HttpServletResponse response)
        throws ServletException, IOException {
    var title = Optional.ofNullable(request.getParameter("title"))
            .orElse("");
    var marker = requestMarker("POST", request);
    probe.lastPostMarker.set(marker);
    request.setAttribute("requestMarker", marker);

    if (title.strip().length() < 3) {
        response.setStatus(422);
        request.setAttribute(
                "form",
                new PostFormModel(
                        title,
                        "제목은 3자 이상이어야 합니다"));
        request.getRequestDispatcher(FORM_VIEW)
                .forward(request, response);
        return;
    }

    var id = command.create(title.strip());
    request.setAttribute("postRequestOnly", "must-not-cross");
    response.sendRedirect(
            response.encodeRedirectURL(
                    request.getContextPath() + "/posts/" + id),
            HttpServletResponse.SC_SEE_OTHER);
}

제목이 앞뒤 공백을 빼고 세 글자보다 짧으면 검증 실패입니다. 이때는 상태를 422로 정하고, 사용자가 입력한 제목과 오류 메시지를 PostFormModel에 담아 요청 속성 form에 넣은 뒤 폼 JSP로 포워드합니다. 포워드는 같은 요청을 넘기는 것이므로 요청 속성이 JSP까지 그대로 전달되고, 사용자는 자기가 입력한 값과 오류 메시지가 채워진 폼을 다시 봅니다.

검증을 통과하면 글을 저장하고 sendRedirect로 303 응답을 보냅니다. 303 See Other는 "결과는 Location이 가리키는 주소를 GET으로 조회해서 보라"는 뜻입니다. 브라우저는 이 응답을 받고 /posts/43으로 새 GET 요청을 보냅니다. 이렇게 POST 뒤에 리다이렉트를 거쳐 GET으로 결과를 보여 주는 방식을 PRG(Post/Redirect/Get)라고 하며, 사용자가 결과 화면을 새로 고쳐도 POST가 다시 전송되지 않습니다. 서블릿 6.1에서 인자가 하나인 sendRedirect(location)은 302를 보내므로, 303을 보내려면 여기처럼 상태 코드를 함께 받는 메서드를 씁니다.

doPost는 리다이렉트 직전에 요청 속성 postRequestOnly에 must-not-cross라는 값을 넣습니다. 상세 JSP에는 이 속성을 출력하는 id="post-only" 문단이 있습니다. 303 뒤에 브라우저가 보낸 GET의 화면에서 이 문단에는 무엇이 들어 있을까요? 먼저 예상해 보세요.

결과 확인하기

비어 있습니다. 303 응답으로 POST 요청은 끝났고, 브라우저가 보낸 GET은 새 요청입니다. 요청 속성은 요청 하나가 처리되는 동안만 살아 있으므로 앞 요청의 postRequestOnly는 새 요청에 없습니다. 새 GET의 doGet은 저장소를 다시 조회해 모델을 처음부터 만듭니다. 네 번째 테스트가 이것을 확인하며, 명령 횟수 1과 조회 횟수 1, 그리고 POST와 GET에 남긴 요청 표식이 서로 다르다는 것도 함께 봅니다.

두 방식의 차이를 정리하면 다음과 같습니다.

포워드303 리다이렉트
대표적인 쓰임GET의 화면, 검증에 실패한 POST의 폼성공한 POST 뒤의 결과 화면
요청같은 요청브라우저가 새 GET 요청을 만듦
요청 속성뷰까지 유지됨전달되지 않음
브라우저 주소원래 주소 그대로Location의 주소로 바뀜
조회와 검증 실패는 같은 request에서 controller가 model 또는 errors를 준비하고 WEB-INF view로 forward하므로 request attributes가 유지되고 브라우저 주소는 바뀌지 않습니다. POST 성공은 303 See Other와 Location을 응답하고 브라우저가 새 GET을 만들어 model을 다시 구성하므로 이전 request attributes는 이어지지 않습니다. 업무 규칙은 service 또는 use case, 화면 포매팅은 typed view-model mapper, markup과 이스케이프는 template가 소유하며 template는 repository, request parsing, 복잡한 업무 계산을 하지 않습니다.

SAME REQUEST FORWARD · NEW REQUEST 303

포워드와 303은 요청 수명을 섞지 않고 계산 소유자를 지킵니다

조회와 검증 실패는 same-request forward, 성공한 POST는 303과 새 GET을 사용합니다. 어느 경로에서도 template가 업무 규칙이나 데이터 접근을 되가져가지 않습니다.

같은 request forward와 별도 요청인 303 후 GET의 비교forward는 커밋 전에 같은 request와 attributes를 view로 전달하고 브라우저 주소를 유지합니다. 성공 POST는 303과 Location을 응답하고 client가 새 GET을 수행해 model을 다시 만듭니다. PRG는 중복 명령 방지를 보장하지 않습니다.GET / invalid POST조회 / 입력 검증 실패request attributesmodel / field errorsfixed forward같은 request주소 유지 · 미커밋 버퍼 제거 · attributes 유지POST 성공이 fixture의 명령 실행303 + LocationPOST 응답 종료새 GETmodel 다시 구성새 주소 · 새 request · 이전 attributes 전달 없음
같은 request forward와 새 request GET의 모바일 비교위 영역은 GET 또는 검증 실패 POST에서 attributes를 만들어 같은 request로 forward하는 경로입니다. 아래 영역은 성공 POST에서 303과 Location을 받은 뒤 client가 별도 GET을 보내 model을 새로 만드는 경로입니다. 영역 간 연결은 없으며 앞 요청의 attributes가 새 요청으로 복사되지 않습니다.같은 request의 경로새 request를 만드는 경로GET 또는검증 실패 POSTrequest attributesmodel / field errorsfixed forward같은 requestPOST 성공이 fixture의 명령 실행303 + LocationPOST 응답 종료새 GETmodel 다시 구성

위쪽은 원래 주소와 attributes를 유지합니다. 아래쪽은 새 주소에서 model을 다시 만듭니다. 두 영역은 별도 경우의 비교이며, 위에서 아래로 계속 실행하는 한 요청이 아닙니다.

01 · SAME-REQUEST FORWARD

조회와 검증 실패는 같은 request의 model·errors로 view를 렌더링합니다

controller가 request attributes를 완성하고 fixed /WEB-INF view로 forward합니다. 같은 request object와 attributes가 유지되고 browser URL도 유지됩니다. forward는 커밋 전에만 가능하며 미커밋 body buffer를 지웁니다.

02 · POST → 303 PRG → NEW GET

POST success는 Location을 보내고 browser가 new request를 만듭니다

303 See Other 뒤 new GET에는 이전 attributes가 없습니다. GET controller가 화면 model을 다시 구성합니다.

03 · BUSINESS + FORMATTING

업무 값은 use case/domain, 화면 포매팅은 presenter/typed view model이 소유합니다

권한·상태 전이 같은 업무 의미와 locale 날짜·숫자·레이블 같은 표현 준비를 서로 다른 변경 이유에 맞춰 분리합니다.

04 · MARKUP BOUNDARY

template는 배치와 이스케이프만 하고 복잡한 expression을 만들지 않습니다

repository 호출, request parsing, business 계산은 금지합니다. raw JSP EL 및 Thymeleaf th:utext는 기본 출력 방식이 아닙니다.

303은 POST 처리 결과를 다른 resource의 retrieval로 안내하는 HTTP 의미입니다. 중복 명령 방지는 서버의 idempotency·transaction 처리와 함께 설계해야 하며, 상태 코드 하나가 자동으로 보장하지 않습니다.

그림의 위쪽은 GET이나 검증에 실패한 POST가 요청 속성을 만들어 같은 요청으로 포워드하는 경로이고, 아래쪽은 성공한 POST가 303과 Location을 보낸 뒤 브라우저의 새 GET이 모델을 다시 만드는 경로입니다. 두 경로는 서로 다른 경우를 나란히 비교한 것이며 한 요청이 위에서 아래로 이어지는 것이 아닙니다. 아래쪽 상자들의 내용은 다음 절에서 다룹니다.

포워드에는 시점의 제약이 있습니다. 서블릿 6.1의 RequestDispatcher.forward는 응답이 커밋되기 전에만 호출할 수 있고, 아직 커밋되지 않은 버퍼의 내용은 지운 뒤 대상에 넘깁니다. 다섯 번째 테스트의 두 요청이 이 규칙을 보여 줍니다.

요청포워드 전에 한 일결과
/diagnostics/forward-before-commit본문에 STALE을 쓰기만 함응답에 STALE이 없고 JSP의 출력만 있습니다.
/diagnostics/forward-after-commitPARTIAL을 쓰고 flushBuffer()로 커밋함forward가 IllegalStateException을 던지고, 응답 본문은 PARTIAL뿐입니다.

계산을 어느 쪽에 둘지 정하는 기준

매퍼는 1,200자라는 표시와 longPost를 계산하지만 recommended는 조회 결과에서 받은 값을 그대로 넘깁니다. 이 차이는 값이 바뀌는 이유에서 나옵니다. 숫자에 쉼표를 넣는 형식이나 "60자 이상이면 긴 글 표시"는 화면을 어떻게 보여 줄지의 문제이므로 화면용 모델을 만드는 매퍼가 맡습니다. 반면 어떤 글을 추천할지는 서비스의 정책이므로 사용 사례나 도메인이 정하고, 화면은 그 결과만 받아 표시합니다.

그래서 요구가 "긴 글은 자동으로 추천한다"로 바뀐다면, JSP의 c:if 조건이나 매퍼를 고치는 것이 아니라 추천 여부를 정하는 업무 쪽 코드를 고칩니다. 참거짓 값이라고 해서 모두 한곳에 모으지 않고, 그 값이 왜 바뀌는지를 보고 둘 곳을 정합니다.


더 깊이: 이 예제가 정해 둔 조건들

내장 서버에서 JSP를 쓸 때의 제약

이 실습이 JSP를 임시 디렉터리에 두고 테스트 안에서만 실행한 데는 이유가 있습니다. Spring Boot의 서블릿 웹 문서는 내장 서블릿 컨테이너를 쓰고 실행 가능한 아카이브로 패키징한 애플리케이션에서 JSP 지원에 몇 가지 제약이 있다고 밝히고, 가능하면 JSP를 피하라고 권합니다. Tomcat과 Jetty에서는 war로 패키징하면 동작하며, 실행 가능한 war는 java -jar로도 실행되고 일반 서블릿 컨테이너에도 배포할 수 있습니다. 반면 실행 가능한 jar에서는 JSP가 지원되지 않습니다.

같은 문서에 따르면 직접 만든 error.jsp는 Boot의 기본 오류 뷰를 대신하지 못합니다. 또 bootRun으로 실행하면서 JSP를 표준 위치인 src/main/webapp이 아닌 곳에 두었다면, Boot가 JSP를 찾도록 WAR_SOURCE_DIRECTORY 환경 변수를 지정해야 할 수 있습니다. 1장부터 쓰는 게시판 프로젝트는 실행 가능한 jar를 만들므로, 화면을 클래스 경로의 Thymeleaf 템플릿으로 만드는 것이 이 제약을 피하는 길이기도 합니다.

PRG가 막아 주는 것과 막지 못하는 것

PRG는 결과 화면을 새로 고칠 때 POST가 다시 전송되는 일을 막습니다. 같은 POST가 재시도로 서버에 두 번 도착하는 일까지 막지는 못합니다. 한 번만 처리되어야 하는 명령에는 멱등성 키나 유일성 제약 조건, 트랜잭션 같은 서버 쪽 장치를 따로 둡니다.

글자 수와 경로의 기준

title.strip().length()는 Java의 UTF-16 코드 단위를 세므로, 보이는 글자가 둘인 A😀도 길이 3으로 이 검증을 통과합니다. 글자 수를 어떤 단위로 셀지는 업무 규칙으로 따로 정합니다.

경로의 기준은 둘입니다. 폼의 action="/posts"는 브라우저가 호스트의 루트를 기준으로 해석하고, 서버의 getRequestDispatcher("/WEB-INF/...")는 애플리케이션의 컨텍스트 경로를 기준으로 해석합니다. 이 테스트는 컨텍스트 경로가 비어 있어 둘이 같아 보이지만, 애플리케이션을 /board 아래에 배포하면 폼의 제출 주소는 /board/posts여야 합니다. doPost의 리다이렉트가 request.getContextPath()를 앞에 붙이는 것도 그 때문입니다.


정리

  • 서블릿이 HTML을 문자열로 조립하면 사용자 값이 마크업에 섞이고 화면 수정이 Java 코드 수정이 됩니다. 반대로 JSP가 조회와 업무 규칙을 실행하면 템플릿이 흐름을 떠맡습니다.
  • 서블릿은 입력을 검증하고 조회를 호출한 뒤, 화면에 필요한 값만 담은 모델을 요청 속성에 넣고 상수로 정한 /WEB-INF 뷰로 포워드합니다.
  • JSP의 ${...}와 Thymeleaf의 th:utext는 값을 그대로 출력합니다. 사용자 값은 c:out이나 th:text로 출력합니다.
  • 조회와 검증 실패는 같은 요청으로 포워드하고, 성공한 POST는 303과 Location으로 새 GET을 하게 해 모델을 다시 만듭니다.
  • 화면의 형식은 매퍼가, 업무의 뜻이 있는 값은 사용 사례가 계산합니다.

연습 문제

1. 검증, 저장, 새 조회의 횟수 세기

새 서버 하나에 다음 요청을 차례로 보냅니다. ① 제목 AB 로 POST합니다. ② 제목 새 글 로 POST하되 리다이렉트는 따라가지 않습니다. ③ ②의 Location으로 GET을 보냅니다. 단계마다 상태 코드와 명령 횟수, 조회 횟수를 적고, ③의 화면에 표시되는 글자 수와 긴 글, 추천 표시 여부를 예상하세요.

해설 보기

① strip()하면 AB 두 글자이므로 검증에 실패합니다. 상태는 422이고 명령과 조회는 모두 0입니다. 폼에는 공백을 뺀 값이 아니라 입력한 AB 가 그대로 남습니다. PostFormModel에 title.strip()이 아니라 title을 넣기 때문입니다.

② strip()하면 공백 하나를 포함한 새 글 세 글자이므로 통과합니다. 저장소의 다음 번호가 43이므로 응답은 303이고 Location은 /posts/43으로 끝납니다. 명령은 1, 조회는 0입니다. 303을 받았다고 조회가 실행되지는 않습니다.

③ 새 GET이 조회를 한 번 실행해 명령 1, 조회 1이 됩니다. create는 저장한 제목의 길이 3을 contentLength로 넣으므로 표시는 3자이고, 60보다 작아 긴 글은 나오지 않습니다. 새로 만든 글의 recommended는 false이므로 추천도 나오지 않습니다.

2. c:out을 지우면 어느 테스트가 실패할까

DETAIL_JSP의 제목 줄을 다음처럼 바꾸고 테스트를 다시 실행합니다. 어느 테스트의 어느 단언이 실패할지 먼저 예상하고, 실행해 확인한 뒤 원래대로 고치세요.

DETAIL_JSP의 제목 줄을 이렇게 바꿉니다
<h1>${post.title}</h1>
해설 보기

첫 번째 테스트만 실패합니다. 제목이 이스케이프되지 않고 <script>alert('x')</script>&게시글 그대로 출력되므로, 본문에 &lt;script&gt;가 있어야 한다는 단언과 <script>alert가 없어야 한다는 단언 두 개가 깨집니다. assertAll은 안쪽 단언을 끝까지 실행하므로 두 실패가 함께 보고됩니다.

다른 테스트는 통과합니다. 두 번째 테스트는 main 태그가 있는지만 보고, 네 번째 테스트의 새 글 제목 새 게시글에는 이스케이프할 문자가 없습니다. 위험한 문자가 든 표본이 없으면 이스케이프 누락은 테스트에 걸리지 않습니다. 줄을 <h1><c:out value="${post.title}" /></h1>로 되돌리면 다시 통과합니다.

3. 303이 302가 되는 실수

누군가 doPost의 리다이렉트를 다음처럼 줄였습니다. 테스트를 실행하면 무엇이 실패하고, 왜 그럴까요? 확인한 뒤 원래대로 고치세요.

doPost의 리다이렉트를 이렇게 바꿉니다
response.sendRedirect(
        response.encodeRedirectURL(
                request.getContextPath() + "/posts/" + id));
해설 보기

네 번째 테스트의 assertEquals(303, created.statusCode())가 실패합니다. 인자가 하나인 sendRedirect는 302를 보내기 때문입니다. Location은 그대로이므로 이 테스트의 나머지 단언은 통과합니다. 테스트의 HTTP 클라이언트는 리다이렉트를 자동으로 따라가지 않도록 설정되어 있어서 POST의 응답 상태를 그대로 볼 수 있습니다.

302는 리다이렉트된 요청의 메서드를 어떻게 할지가 303만큼 분명하지 않습니다. "POST의 결과를 GET으로 조회하라"는 뜻을 정확히 전하려면 303을 씁니다. 두 번째 인자 HttpServletResponse.SC_SEE_OTHER를 되돌리면 테스트가 다시 통과합니다.

4. 빈 등록 폼 화면 추가하기

지금은 GET /posts/new를 보내면 new가 숫자가 아니어서 400이 나옵니다. 이 주소가 빈 등록 폼을 보여 주게 만드세요.

  • GET /posts/new는 200으로 post-form.jsp를 렌더링합니다.
  • 제목 입력란은 비어 있고, 저장소의 조회와 명령은 한 번도 호출되지 않습니다.
  • 이 동작을 확인하는 테스트를 하나 추가합니다.

힌트: doGet에서 번호를 해석하기 전에 경로가 /new인지 먼저 확인합니다. 폼 JSP는 요청 속성 form을 읽습니다.

해설 보기

doGet에서 경로가 비었는지 검사한 바로 다음에 분기를 넣습니다.

PostPageServlet의 doGet (path 검사 다음에 추가)
if (path.equals("/new")) {
    request.setAttribute("form", new PostFormModel("", ""));
    request.getRequestDispatcher(FORM_VIEW)
            .forward(request, response);
    return;
}

검증에 실패한 POST와 같은 PostFormModel과 같은 폼 JSP를 다시 씁니다. 제목과 오류 메시지가 모두 빈 문자열이므로 입력란과 오류 문단이 비어 나옵니다. 테스트는 다음처럼 씁니다.

EmbeddedServletViewBoundaryTest.java (테스트 추가)
@Test
void GET_posts_new는_빈_폼을_보여_준다() throws Exception {
    try (var server = RunningServer.start()) {
        var response = get(server, "/posts/new");

        assertAll(
                () -> assertEquals(200, response.statusCode()),
                () -> assertTrue(response.body().contains(
                        "value=\"\"")),
                () -> assertTrue(response.body().contains(
                        "<p id=\"forward-uri\">/posts/new</p>")),
                () -> assertEquals(0, server.store().queryCount.get()),
                () -> assertEquals(0, server.store().commandCount.get()));
    }
}

./gradlew test --tests board.servlet.EmbeddedServletViewBoundaryTest로 여덟 테스트가 모두 통과하면 완성입니다. 분기를 번호 해석보다 뒤에 두면 Long.parseLong("new")가 먼저 실패해 400이 나오므로, 테스트가 200을 기대하는 첫 단언에서 실패합니다.

doGet과 doPost는 이제 HTML을 쓰지 않지만, 경로 해석과 조회, 모델 준비, 뷰 선택이 여전히 서블릿 하나에 들어 있고 테스트하려면 Tomcat과 JSP가 필요합니다. 다음 글 MVC의 역할 나누기에서는 이 가운데 컨트롤러의 판단만 떼어 내, 서블릿 없이 호출하고 테스트할 수 있게 만듭니다.