Java 25와 Spring Boot
Spring Initializr로 게시판 프로젝트를 만들어 bootRun으로 띄우고, 컨트롤러 하나를 추가해 응답과 실행 중인 Java·Spring Boot 버전을 확인합니다.
웹 서버를 처음 만들 때 가장 막막한 것은 "어디서부터 시작해야 화면에 무엇이라도 뜨는가"입니다. 라이브러리를 고르고, 빌드 도구를 설정하고, 서버를 띄우는 코드를 직접 쓰다 보면 정작 만들려던 기능에는 손도 대지 못합니다. Spring Boot는 이 준비를 대신해 줍니다. 이 글에서는 프로젝트를 내려받아 서버를 띄우고, 직접 쓴 코드 몇 줄이 응답으로 돌아오는 것까지 확인합니다.
이 글을 읽고 나면 다음을 할 수 있습니다.
- Spring Initializr로 프로젝트를 만들고
bootRun으로 서버를 띄웁니다. - 컨트롤러 하나를 추가해
curl과 브라우저로 응답을 확인합니다. - 실행 중인 Java와 Spring Boot, Spring Framework의 버전을 응답과 테스트로 확인합니다.
이 장은 빈 폴더에서 시작합니다. 미리 만들어 둔 프로젝트나 파일은 필요 없고, JDK 25가 설치된 컴퓨터와 인터넷 연결, 터미널, 코드 편집기(IntelliJ IDEA나 VS Code)만 있으면 됩니다. 응답을 확인할 때 쓰는 curl은 macOS와 Linux, Windows 10 이상에 들어 있습니다. Windows PowerShell에서는 curl 대신 curl.exe라고 입력합니다. 이 장의 일곱 글은 여기서 만드는 board 프로젝트 하나에 파일을 더해 가며, 마지막 글에서 회원가입과 게시글 등록을 연결합니다.
Spring과 Spring Boot, JDK와 Gradle
Spring은 Java 객체를 만들고 서로 연결하며, 웹 요청을 처리하는 데 필요한 기반을 제공하는 프레임워크(framework)입니다. Spring Boot는 Spring을 대신하는 별도 기술이 아니라, 자주 쓰는 라이브러리와 설정을 알맞은 기본값으로 묶어 첫 실행을 쉽게 해 주는 도구입니다. 그래서 "Spring Boot 프로젝트"는 Spring으로 만든 애플리케이션을 Spring Boot의 기본값으로 시작한 것을 뜻합니다.
도구도 두 가지가 나옵니다. JDK(Java Development Kit)는 Java 코드를 컴파일하고 실행하는 도구 묶음이고, Gradle은 필요한 라이브러리를 내려받아 컴파일과 실행을 대신 반복해 주는 빌드 도구입니다. Gradle은 따로 설치하지 않습니다. 프로젝트 안에 들어 있는 Gradle Wrapper라는 스크립트가 프로젝트에 맞는 버전의 Gradle을 내려받아 실행해 줍니다.
이 교재는 Java 25, Spring Boot 4.1.2와 그것이 고른 Spring Framework 7.0.10, Gradle 9.8.2를 기준으로 합니다.
Initializr로 프로젝트 만들기
Spring Initializr는 선택한 조건에 맞는 프로젝트를 압축 파일로 만들어 주는 사이트입니다. 다음과 같이 고르고 입력합니다.
| 항목 | 값 |
|---|---|
| Project | Gradle - Groovy |
| Language | Java |
| Spring Boot | 4.1.2 |
| Group | dev.andongmin |
| Artifact, Name | board |
| Package name | board |
| Packaging | Jar |
| Java | 25 |
| Dependencies | Spring Web, Thymeleaf |
Package name은 Group과 Artifact를 이어 붙인 값으로 자동으로 채워지므로, board로 직접 고쳐 적습니다. 이 교재의 모든 코드가 board 패키지 아래에 놓이기 때문입니다. GENERATE를 눌러 받은 board.zip을 풀고, 그 폴더를 편집기로 엽니다. 안에는 다음 파일이 들어 있습니다.
| 파일 | 하는 일 |
|---|---|
gradlew, gradlew.bat, gradle/wrapper/ | Gradle Wrapper. 2026년 11월에 받은 프로젝트는 Gradle 9.8.2를 가리킵니다 |
settings.gradle | 프로젝트 이름 board를 정합니다 |
build.gradle | 플러그인과 라이브러리, Java 버전을 정합니다 |
src/main/java/board/BoardApplication.java | 애플리케이션을 시작하는 클래스 |
src/main/resources/application.properties | 설정 파일 |
src/test/java/board/BoardApplicationTests.java | 애플리케이션이 뜨는지 확인하는 테스트 |
이 글에서는 내려받은 파일을 고치지 않고 그대로 씁니다. build.gradle만 열어 내용을 읽어 봅니다.
plugins {
id 'java'
id 'org.springframework.boot' version '4.1.2'
id 'io.spring.dependency-management' version '1.1.7'
}
group = 'dev.andongmin'
version = '0.0.1-SNAPSHOT'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(25)
}
}
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'org.springframework.boot:spring-boot-starter-webmvc'
testImplementation 'org.springframework.boot:spring-boot-starter-thymeleaf-test'
testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
tasks.named('test') {
useJUnitPlatform()
}내려받은 파일이 위와 같은지 확인합니다. 지금 알아 둘 것은 세 군데입니다.
plugins의org.springframework.boot가 Spring Boot의 버전을 정합니다. 그 아래io.spring.dependency-management는 Spring Boot 4.1.2와 함께 쓰도록 검증된 라이브러리 버전의 목록을 가져옵니다. 그래서dependencies의 각 줄에는 버전을 적지 않습니다.java의toolchain은 이 프로젝트를 Java 25로 컴파일하고 실행하라는 뜻입니다. 컴퓨터에 JDK 25가 없으면 빌드가 바로 실패합니다. 예전 JDK로 조용히 컴파일되는 것보다 이편이 안전합니다.dependencies의spring-boot-starter-webmvc가 Initializr에서 고른 Spring Web입니다. 이렇게 이름이starter로 시작하는 묶음을 스타터라고 부르며, 이 스타터는 Spring MVC와 내장 웹 서버 Tomcat을 함께 가져옵니다.-test로 끝나는 두 줄과junit-platform-launcher는 테스트를 작성하고 실행하는 데 씁니다.
서버 띄우기
Initializr가 만든 시작 클래스는 다음과 같습니다. 직접 입력할 필요 없이 파일이 있는지만 확인합니다.
package board;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BoardApplication {
public static void main(String[] args) {
SpringApplication.run(BoardApplication.class, args);
}
}SpringApplication.run()은 이 클래스를 출발점으로 삼아 애플리케이션을 구성하고, 웹 스타터가 있으므로 내장 Tomcat까지 시작합니다. 터미널에서 build.gradle이 있는 프로젝트 폴더로 이동해 다음 명령을 실행합니다.
./gradlew bootRun.\gradlew.bat bootRun앞으로 이 교재는 명령을 ./gradlew 형태로만 적습니다. Windows PowerShell에서는 .\gradlew.bat으로 바꿔 입력합니다. 처음 실행할 때는 Wrapper가 Gradle을, Gradle이 라이브러리를 내려받으므로 몇 분이 걸릴 수 있습니다. 로그가 멈추면 그 안에서 다음 세 가지를 찾습니다.
| 로그에서 찾을 글자 | 뜻 |
|---|---|
:: Spring Boot :: 옆의 (v4.1.2) | Spring Boot 4.1.2로 시작했습니다 |
Tomcat started on port 8080 (http) | 내장 서버가 8080 포트에서 요청을 기다립니다 |
Started BoardApplication | 애플리케이션이 다 떴습니다 |
세 줄이 모두 보이면 성공입니다. 명령이 끝나지 않고 터미널이 입력을 받지 않는 것은 정상입니다. Tomcat이 요청을 기다리는 동안 프로세스가 계속 살아 있기 때문입니다. 서버를 멈출 때는 그 터미널에서 Ctrl+C를 누릅니다.
서버가 떠 있는 지금 브라우저에서 http://localhost:8080/을 열면 무엇이 보일까요? 먼저 예상해 보세요.
결과 확인하기
Whitelabel Error Page라는 제목의 오류 화면이 보이고, 그 안에 상태 404가 적혀 있습니다. 서버는 떠 있지만 /라는 주소를 처리할 코드나 파일을 아직 하나도 만들지 않았기 때문입니다. 오류 화면이 보인다는 것 자체가 서버가 응답하고 있다는 뜻이므로, 지금은 이것이 정상입니다.
컨트롤러 하나로 응답 보기
이제 요청을 처리할 코드를 만듭니다. Spring에서 HTTP 요청을 받는 클래스를 컨트롤러(controller)라고 부릅니다. src/main/java/board 아래에 web 폴더를 만들고 다음 파일을 저장합니다.
package board.web;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "hello, board";
}
}@RestController는 이 클래스가 요청을 받고, 메서드가 돌려준 값을 그대로 응답 본문으로 쓴다는 표시입니다. @GetMapping("/hello")는 GET /hello 요청이 오면 이 메서드를 호출하라는 뜻입니다. 이 클래스를 어디에도 등록하지 않았다는 점을 눈여겨봅니다. BoardApplication에 붙은 @SpringBootApplication이 자기 패키지인 board와 그 아래 패키지에서 이런 표시가 붙은 클래스를 찾아 주기 때문입니다.
실행 중인 서버는 새 코드를 모릅니다. 서버 터미널에서 Ctrl+C로 멈추고 ./gradlew bootRun을 다시 실행한 뒤, 다른 터미널을 열어 요청을 보냅니다.
curl http://localhost:8080/hellohello, board메서드가 돌려준 문자열이 그대로 돌아오면 성공입니다. 브라우저에서 http://localhost:8080/hello를 열어도 같은 글자가 보입니다. curl -i http://localhost:8080/hello처럼 -i를 붙이면 본문 앞에 상태 줄과 헤더도 함께 나옵니다. 첫 줄이 HTTP/1.1 200이면 서버가 요청을 정상으로 처리했다는 뜻입니다.
실행 중인 버전을 응답에 싣기
빌드가 성공했다는 것만으로는 실제로 어떤 버전이 돌고 있는지 알 수 없습니다. build.gradle에 적은 Java 25와 Spring Boot 4.1.2가 실제 실행에도 쓰였는지를 응답으로 직접 확인해 봅니다. 먼저 세 버전을 읽어 담는 작은 레코드를 만듭니다. src/main/java/board 아래에 support 폴더를 만듭니다.
package board.support;
import static java.util.Objects.requireNonNullElse;
import org.springframework.boot.SpringBootVersion;
import org.springframework.core.SpringVersion;
public record RuntimeVersions(
int javaFeature,
String boot,
String framework
) {
public static RuntimeVersions current() {
return new RuntimeVersions(
Runtime.version().feature(),
requireNonNullElse(SpringBootVersion.getVersion(), "unknown"),
requireNonNullElse(SpringVersion.getVersion(), "unknown"));
}
}Runtime.version().feature()는 지금 실행 중인 JVM의 기능 버전, 곧 Java 25라면 25를 돌려줍니다. SpringBootVersion.getVersion()과 SpringVersion.getVersion()은 각각 Spring Boot와 Spring Framework의 버전 문자열을 돌려줍니다. 버전을 읽지 못해 null이 오면 unknown이라는 글자로 바꿔 담습니다.
이제 컨트롤러가 이 값을 응답에 넣게 고칩니다.
package board.web;
import board.support.RuntimeVersions;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
var versions = RuntimeVersions.current();
return "hello, board (java %d, boot %s, spring %s)".formatted(
versions.javaFeature(),
versions.boot(),
versions.framework());
}
}서버를 다시 시작하고 같은 요청을 보냅니다.
curl http://localhost:8080/hellohello, board (java 25, boot 4.1.2, spring 7.0.10)세 숫자가 이 교재의 기준과 같으면 준비가 끝난 것입니다. 이 값은 설정 파일에 적힌 글자가 아니라, 요청을 처리한 바로 그 프로세스가 읽은 값입니다.
버전을 테스트로 고정하기
눈으로 확인한 것은 다음에 또 확인해야 합니다. 같은 확인을 테스트로 적어 두면 명령 한 번으로 되풀이할 수 있습니다. src/test/java/board 아래에 support 폴더를 만들고 다음 파일을 저장합니다.
package board.support;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
class RuntimeVersionsTest {
@Test
void 교재의_실행_기준과_일치한다() {
var versions = RuntimeVersions.current();
assertThat(versions.javaFeature()).isEqualTo(25);
assertThat(versions.boot()).isEqualTo("4.1.2");
assertThat(versions.framework()).startsWith("7.0.");
}
}@Test가 붙은 메서드 하나가 테스트 하나입니다. assertThat(값).isEqualTo(기대값)은 두 값이 다르면 테스트를 실패로 끝냅니다. Spring Framework의 버전은 7.0.으로 시작하는지만 봅니다. Spring Boot의 패치 버전을 올리면 Framework의 패치 번호도 함께 바뀌기 때문입니다. 서버를 멈출 필요 없이 다른 터미널에서 실행합니다.
./gradlew test --tests board.support.RuntimeVersionsTest마지막에 BUILD SUCCESSFUL이 나오면 통과한 것입니다. Gradle은 성공한 테스트의 이름을 따로 출력하지 않으며, 테스트별 결과는 build/reports/tests/test/index.html을 브라우저로 열면 볼 수 있습니다. --tests를 빼고 ./gradlew test만 실행하면 Initializr가 만든 BoardApplicationTests까지 프로젝트의 모든 테스트가 실행됩니다.
막혔을 때 먼저 볼 곳
| 증상 | 먼저 확인할 곳 |
|---|---|
./gradlew를 찾을 수 없다고 나온다 | 터미널의 현재 폴더가 build.gradle이 있는 프로젝트 폴더인지 확인합니다. Windows PowerShell에서는 .\gradlew.bat으로 입력합니다 |
| Java 25 도구 체인을 찾지 못했다는 오류로 빌드가 멈춘다 | JDK 25가 설치되어 있는지 확인합니다. ./gradlew javaToolchains를 실행하면 Gradle이 찾은 JDK의 목록이 나옵니다 |
Port 8080 was already in use로 시작이 실패한다 | 다른 터미널에 이전 서버가 떠 있는지 확인하고 Ctrl+C로 멈춥니다 |
/hello가 404를 돌려준다 | 파일을 저장한 뒤 서버를 다시 시작했는지, HelloController의 패키지가 board.web인지 확인합니다 |
PowerShell에서 curl의 출력 모양이 본문과 다르다 | curl.exe로 입력합니다 |
| 응답의 버전이 기준과 다르다 | build.gradle의 Spring Boot 버전과 toolchain의 숫자를 위 내용과 비교합니다 |
포트가 이미 쓰이고 있을 때 Spring Boot는 다음과 같이 실패한 이유와 해결 방법을 알려 줍니다.
***************************
APPLICATION FAILED TO START
***************************
Description:
Web server failed to start. Port 8080 was already in use.
Action:
Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.이전 서버를 멈출 수 없는 사정이 있다면 ./gradlew bootRun --args='--server.port=8081'처럼 이번 실행에만 다른 포트를 넘길 수 있습니다.
앞으로 코드가 놓일 자리
지금까지 board.web과 board.support 두 패키지를 만들었습니다. 이 장을 진행하면서 패키지가 네 개 더 생깁니다. 아래 이름은 코드가 맡는 일을 기준으로 나눈 것이며, 실제 폴더는 그 코드를 처음 만들 때 만듭니다.
board/
├─ build.gradle
├─ settings.gradle
└─ src/
├─ main/
│ ├─ java/board/
│ │ ├─ BoardApplication.java
│ │ ├─ application/ # 사용 사례
│ │ ├─ config/ # 객체 조립
│ │ ├─ domain/ # 업무 규칙
│ │ ├─ infrastructure/ # 저장 기술
│ │ ├─ support/ # 실행 지원
│ │ └─ web/ # HTTP 요청과 응답
│ └─ resources/
│ ├─ static/
│ └─ templates/
└─ test/java/board/모든 패키지가 BoardApplication이 있는 board 아래에 있으므로, Spring이 클래스를 찾는 범위 안에 들어갑니다.
PROJECT ROADMAP · PACKAGE BOUNDARIES
스캔 루트 아래에서 역할을 나누고 안쪽 port에 의존합니다
BoardApplication은 board 하위의 기본 스캔 루트입니다. 화살표는 코드 의존 또는 조립 방향이며 실행 순서가 아닙니다. 패키지는 해당 역할의 코드가 생길 때 만듭니다.
BoardApplication · 기본 스캔 루트
board.* 아래에서 컴포넌트를 찾는 Boot 진입점입니다. 빈 패키지를 미리 만들 필요는 없습니다.
web
HTTP 입력·응답
application 사용 사례 호출
application
등록·조회 순서
domain 규칙과 port 사용
domain
업무 규칙·저장 port
안쪽 port
infrastructure
바깥 기술 adapter
domain 또는 application port 구현
config
빈 생성·조립
application과 adapter 선택
support
실행 지원
버전 확인·bootstrap 보조
후속 MemoryPostRepository는 domain의 PostRepository를 구현합니다. application에 port가 생겨도 infrastructure adapter가 그 안쪽 port에 의존하는 원칙은 같습니다.
그림의 화살표는 실행 순서가 아니라 코드가 어느 쪽을 가져다 쓰는지를 나타냅니다. web은 요청을 받아 application을 호출하고, application은 domain의 규칙을 쓰며, infrastructure는 domain이 정한 인터페이스를 구현합니다. 화살표가 모두 안쪽의 domain을 향하므로 저장 기술을 바꾸어도 업무 규칙은 그대로 둘 수 있습니다. 각 패키지에 무엇이 들어가는지는 뒤의 글에서 코드를 만들며 하나씩 확인합니다.
더 깊이: 선언한 Java와 실제로 실행된 Java
한 컴퓨터에서 쓰이는 Java는 하나가 아닐 수 있습니다. 터미널에서 java를 입력했을 때 실행되는 JDK, Gradle Wrapper를 시작하는 런처(launcher) JVM, 빌드를 실제로 수행하는 데몬(daemon) JVM, 그리고 컴파일이나 테스트 같은 작업(task)마다 toolchain 설정으로 고르는 JDK가 모두 다를 수 있습니다. 그래서 java --version이 21을 보여 주는데도 이 프로젝트가 Java 25로 컴파일되는 일이 생깁니다. 반대로 invalid source release 같은 오류가 났을 때 JAVA_HOME만 바꾸면 해결된다고 단정할 수도 없습니다.
SPRING · JAVA RUNTIME VERSION
선언한 버전은 실제 선택과 실행 결과로 확인합니다
Gradle 자체의 JVM, 작업의 JDK, 테스트 프로세스는 각각 확인합니다. 앞 단계부터 대조해 처음 기대와 달라진 단계를 고친 뒤 다시 실행합니다.
선언과 실행 후보
- 빌드 기준
build.gradle에서 Java 기능 수준 25와 Boot 4.1.2 BOM을 선언합니다. JDK vendor나 patch까지 고정한 선언은 아닙니다. - Gradle의 JVM
./gradlew --version에서 Wrapper의 Launcher JVM과 빌드를 수행하는 Daemon JVM을 구분합니다. - Toolchain 후보
./gradlew javaToolchains는 발견한 JDK 목록입니다. 특정 작업이 선택한 실행 파일을 알려 주지는 않습니다.
실제 선택과 실행
- 작업의 실제 JDK
./gradlew clean test --info의 compile/test 실행 경로를 확인합니다. compiler와 test launcher는 구분합니다. - 테스트 프로세스
RuntimeVersionsTest가 실제 Java 25와 테스트 classpath의 Boot 4.1.2·Spring 7.0.x metadata를 읽습니다. metadata가 없으면 unknown입니다. - 첫 불일치 단계
선언 → Gradle JVM → 후보 → 작업 선택 → 테스트 프로세스를 대조합니다. 달라진 단계부터 수정하고 같은 검사를 반복합니다.
셸 Java 확인의 범위
java --version은 셸 기본 Java의 단서입니다. Gradle JVM과 작업 compiler를 확정하지 않습니다.
애플리케이션 실행은 따로 확인
테스트 프로세스의 버전이 실제 bootRun 애플리케이션 JVM까지 증명하지 않습니다. 연습의 VersionReport처럼 애플리케이션 시작 경로에서 다시 읽습니다.
Java toolchain 기능 수준과 vendor·patch는 다른 조건입니다. Wrapper 호환 범위와 JDK 설치를 먼저 확인한 뒤 실제 선택과 실행을 확인합니다.
그림은 build.gradle에 적은 버전이 실제 실행에 쓰였는지를 앞 단계부터 차례로 확인하는 순서를 보여 줍니다. 테스트를 실행하는 프로세스와 bootRun으로 띄운 애플리케이션은 서로 다른 프로세스이므로 각각 확인하며, 이 글에서는 RuntimeVersionsTest와 /hello 응답이 그 역할을 했습니다. 그림의 VersionReport는 연습 문제 3에서 만듭니다.
버전이 기대와 다를 때는 다음 명령을 위에서부터 실행해, 어느 단계에서 처음으로 달라졌는지 찾습니다.
| 명령 | 알려 주는 것 |
|---|---|
java --version | 터미널의 기본 Java. Gradle이 쓸 Java를 정하지는 않습니다 |
./gradlew --version | Gradle 버전과 Launcher JVM, Daemon JVM |
./gradlew javaToolchains | Gradle이 찾은 JDK 후보의 목록 |
./gradlew clean test --info | 작업 로그에서 컴파일과 테스트에 실제로 쓴 JDK |
도구 사이의 버전 조건도 따로 있습니다. Spring Boot 4.1.2는 Gradle 8.14 이상의 8.x 또는 9.x를 요구하고, Gradle의 Java 호환 표에 따르면 Java 25는 Gradle 9.1.0부터 지원됩니다. Initializr가 만든 Wrapper는 두 조건을 모두 만족하므로 그대로 쓰면 됩니다. Wrapper의 버전은 gradle/wrapper/gradle-wrapper.properties의 distributionUrl에서 볼 수 있습니다. toolchain의 languageVersion = 25는 Java의 기능 수준만 정할 뿐 JDK 공급사(vendor)나 패치 버전까지 정하지는 않습니다.
라이브러리 버전을 관리하는 방법도 하나가 아닙니다. Initializr는 io.spring.dependency-management 플러그인을 넣어 주지만, 이 플러그인을 지우고 dependencies에 implementation platform('org.springframework.boot:spring-boot-dependencies:4.1.2') 한 줄을 넣어 Gradle이 기본으로 제공하는 방식으로 같은 버전 목록을 가져올 수도 있습니다. 이런 버전 목록을 BOM(Bill of Materials)이라고 부릅니다. 둘 중 무엇을 써도 이 교재의 예제는 똑같이 동작하며, 두 방식을 함께 적용하지는 않습니다. 차이는 14장에서 다시 다룹니다. 스타터의 이름도 알아 둘 만합니다. Spring Boot 4에서는 예전 이름인 spring-boot-starter-web도 아직 쓸 수 있지만 spring-boot-starter-webmvc로 대체되어 사용 중단 예정이며, spring-boot-starter-webmvc-test는 공통 테스트 스타터인 spring-boot-starter-test를 함께 가져옵니다.
정리
- Spring Boot는 Spring을 대신하는 기술이 아니라, Spring 애플리케이션의 라이브러리와 설정을 기본값으로 묶어 주는 도구입니다.
- Initializr가 만든 프로젝트는 고치지 않아도
./gradlew bootRun으로 뜨며, 시작 로그의Started BoardApplication으로 성공을 확인합니다. @RestController와@GetMapping을 붙인 클래스는 시작 클래스의 패키지 아래에 두기만 하면 Spring이 찾아 요청에 연결합니다.- 코드를 고친 뒤에는 서버를 다시 시작해야 반영됩니다.
- 실행 중인 버전은 응답과 테스트로 직접 확인하며, 이 교재의 기준은 Java 25, Spring Boot 4.1.2, Spring Framework 7.0.10입니다.
연습 문제
1. 터미널의 Java는 21인데
java --version은 Java 21을 보여 주는데 RuntimeVersionsTest는 통과했습니다. 무엇이 일어났는지 설명하세요.
해설 보기
터미널의 기본 Java와 테스트를 실행한 JDK가 다른 것입니다. build.gradle의 toolchain이 Java 25를 요구하므로 Gradle은 자신이 찾은 JDK 후보 가운데 Java 25를 골라 컴파일과 테스트에 썼고, 그래서 테스트 안의 Runtime.version().feature()가 25를 돌려주었습니다. ./gradlew javaToolchains에 Java 25 후보가 보이는지 확인하면 이 설명을 직접 확인할 수 있습니다.
2. 404가 나오는 컨트롤러 고치기
동료가 다음 파일을 추가하고 서버를 다시 시작했는데, curl http://localhost:8080/ping이 404를 돌려줍니다. 컴파일 오류는 없습니다. 원인을 찾아 고치세요.
package web;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class PingController {
@GetMapping("/ping")
public String ping() {
return "pong";
}
}해설 보기
패키지가 web이어서 board 패키지 바깥에 있기 때문입니다. @SpringBootApplication은 시작 클래스 BoardApplication이 있는 board 패키지와 그 아래에서만 컨트롤러를 찾습니다. 찾지 못한 클래스는 없는 것과 같으므로 /ping을 처리할 코드가 없어 404가 나옵니다.
파일을 src/main/java/board/web/PingController.java로 옮기고 첫 줄을 package board.web;으로 고칩니다. 서버를 다시 시작한 뒤 curl http://localhost:8080/ping이 pong을 출력하면 고쳐진 것입니다.
3. 시작할 때 버전 출력하기
요청을 보내지 않아도 버전을 알 수 있도록, 애플리케이션이 시작할 때 세 버전을 한 줄로 출력하는 VersionReport 클래스를 board.support 패키지에 만드세요.
- Spring Boot의
CommandLineRunner인터페이스를 구현합니다. 이 인터페이스의run메서드는 애플리케이션이 다 뜬 뒤 한 번 호출됩니다. - Spring이 이 클래스를 찾아 객체로 만들도록 클래스에
@Component를 붙입니다. - 출력 형식은
runtime java=25 boot=4.1.2 framework=7.0.10입니다.
해설 보기
package board.support;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public final class VersionReport implements CommandLineRunner {
@Override
public void run(String... args) {
var value = RuntimeVersions.current();
System.out.printf(
"runtime java=%d boot=%s framework=%s%n",
value.javaFeature(), value.boot(), value.framework());
}
}서버를 다시 시작하면 시작 로그의 Started BoardApplication 줄 뒤에 runtime java=25 boot=4.1.2 framework=7.0.10이 한 줄 나옵니다. @Component는 @RestController처럼 Spring이 찾아 주는 클래스라는 표시이고, board.support가 board 아래에 있으므로 따로 등록하지 않아도 됩니다. 버전이 맞는지 검사하는 일은 여전히 RuntimeVersionsTest가 맡습니다. 출력된 글자를 테스트에서 비교하지 않는 것은 출력 형식은 쉽게 바뀌지만 검사할 값은 그대로이기 때문입니다.
이제 서버가 뜨고, 직접 쓴 코드가 응답으로 돌아옵니다. 다음 글 정적 콘텐츠·MVC·JSON 응답에서는 같은 서버에서 HTML 파일과 템플릿으로 만든 화면, JSON 응답을 각각 만들어 보고, 컨트롤러의 반환값이 어떻게 서로 다른 응답이 되는지 비교합니다.