4. 시작하기(Getting Started)

스프링 부트 또는 일반 “스프링”을 시작하는 경우 이 장을 읽고 시작하자. 기본적인 “무엇을?”, “어떻게?”, “왜?에 대한 답을 제공한다. 설치 가이드과 함께 스프링 부트에 대한 소개가 포함되어 있다. 그런 다음 첫 번째 스프링 부트 애플리케이션을 구축하는 과정을 안내하고 몇 가지 핵심 원칙을 논의한다.

4.1. Introducing Spring Boot

스프링 부트는 실행할 수 있는 독립 실행형, 프로덕션 등급 스프링 기반 애플리케이션을 생성하는 데 도움이 된다. 우리는 스프링 플랫폼과 서드파티 라이브러리에 대한 견해를 갖고 있으므로 불편 없이 시작할 수 있다. 대부분의 스프링 부트 애플리케이션에는 스프링 구성이 거의 필요하지 않다.

스프링 부트를 사용하면 java -jar 또는 보다 전통적인 war 배포를 사용하여 시작할 수 있는 자바 애플리케이션을 생성할 수 있다.

우리의 주요 목표는 다음과 같다:

• 모든 스프링 개발에 대해 근본적으로 더 빠르고 광범위하게 접근할 수 있는 시작 경험을 제공한다.
• 독선적인 태도를 취하되 요구 사항이 기본값과 달라지기 시작하면 신속하게 변경하자.
• 대규모 프로젝트 클래스에 공통적으로 적용되는 다양한 비기능적 특징(예: 내장형 서버, 보안, 메트릭, 상태 확인, 외부화된 구성)을 제공한다.
• 코드 생성이 전혀 없으며(네이티브 이미지를 대상으로 하지 않는 경우) XML 구성이 필요하지 않다.

4.2. System Requirements

스프링 부트 3.1.1에는 자바 17이 필요하며 자바 20까지 호환된다. 스프링 프레임워크 6.0.10 이상도 필요하다.

다음 빌드 도구는 공식 빌드 지원이 제공된다.

빌드 툴	버전
메이븐(Maven)	3.6.3 or later
그레이들(Gradle)	7.x (7.5 or later) and 8.x

4.2.1. Servlet Containers

이름	서블릿 버전
톰캣 10.0	5.0
제티 11.0	5.1
언더토우 2.2 (자카르타 EE 9)	5.0

또한 스프링 부트 애플리케이션을 서블릿 5.0+ 호환 컨테이너에 배포할 수도 있다.

4.2.2. GraalVM Native Images

그랄VM 22.3 이상을 사용하여 스프링 부트 애플리케이션을 네이티브 이미지로 변환할 수 있다.

이미지는 [네이티브 빌드 툴] 그레이들/메이븐 플러그인 또는 그랄VM에서 제공하는 네이티브 이미지 툴를 사용하여 생성할 수 있다. 네이티브 이미지 Paketo 빌드팩을 사용하여 네이티브 이미지를 생성할 수도 있다.

다음 버전이 지원된다:

이름	버전
GraalVM Community	22.3
Native Build Tools	0.9.23

4.3. Installing Spring Boot

스프링 부트는 “클래식” 자바 개발 툴과 함께 사용하거나 커맨드라인 툴로 설치할 수 있다. 어느 쪽이든 자바 SDK v17 이상이 필요하다. 시작하기 전에 다음 명령을 사용하여 현재 자바 설치를 확인해야 한다:

    $ java -version

자바 개발이 처음이거나 스프링 부트를 실험하고 싶다면, 먼저 스프링 부트 CLI(커맨드라인 인터페이스)를 사용해 볼 수 있다. 그렇지 않은 경우, “클래식” 설치 지침을 읽어 보자.

4.3.1. Installation Instructions for the Java Developer

표준 자바 라이브러리와 동일한 방식으로 스프링 부트를 사용할 수 있다. 그렇게 하려면, 클래스패스에 적절한 spring-boot-*.jar 파일을 포함시키자. 스프링 부트에는 특별한 통합 도구가 필요하지 않으므로 IDE 또는 텍스트 편집기를 사용할 수 있다. 또한 스프링 부트 애플리케이션에는 특별한 것이 없으므로 다른 자바 프로그램과 마찬가지로 스프링 부트 애플리케이션을 실행하고 디버그할 수 있다.

스프링 부트 jar를 복사할 수 있지만, 일반적으로 의존성 관리를 지원하는 빌드 도구(예: 메이븐 또는 그레이들)를 사용하는 것이 좋다.

Maven Installation

스프링 부트는 아파치 메이븐 3.6.3 이상과 호환된다. 아직 메이븐을 설치하지 않은 경우 maven.apache.org의 지침을 따르면 된다.

많은 운영 체제에서 메이븐은 패키지 매니저(package manager)를 사용하여 설치할 수 있다. OSX Homebrew를 사용하는 경우, brew Install maven을 사용해 보자. 우분투 사용자는 sudo apt-get install maven을 실행하면 된다. Chocolatey를 사용하는 윈도우 사용자는 관리자(administrator) 권한 프롬프트에서 choco install maven을 실행할 수 있다.

스프링 부트 의존성은 org.springframework.boot 그룹 ID를 사용한다. 일반적으로 메이븐 POM 파일은 spring-boot-starter-parent 프로젝트에서 상속되며 하나 이상의 “스타터”에 대한 의존성을 선언한다. 스프링 부트는 또한 실행 가능한 jar를 생성하기 위한 옵셔널한 메이븐 플러그인을 제공한다.

스프링 부트 및 메이븐 시작에 대한 자세한 내용은 메이븐 플러그인 레퍼런스 가이드의 시작하기 절에서 확인할 수 있다.

Gradle Installation

스프링 부트는 그레이들 7.x(7.5 이상) 및 8.x와 호환된다. 아직 그레이들을 설치하지 않은 경우 gradle.org의 지침을 따르자.

스프링 부트 의존성은 org.springframework.boot 그룹을 사용하여 선언할 수 있다. 일반적으로 프로젝트는 하나 이상의 “스타터” 의존성을 선언한다. 스프링 부트는 의존성 선언을 단순화하고 실행 가능한 jar를 생성하는 데 사용할 수 있는 유용한 그레이들 플러그인을 제공한다.

Gradle Wrapper

그레이들 래퍼는 프로젝트를 빌드해야 할 때 그레이들을 "다운 받아오는(“obtaining”)" 좋은 방법을 제공한다. 정확히는, 빌드 프로세스를 시작하기(bootstrap) 위해 코드와 함께 커밋하는 작은 스크립트 및 라이브러리이다. 자세한 내용은 [docs.gradle.org/current/userguide/gradle_wrapper.html](https://docs.gradle.org/current/userguide/gradle_wrapper.html)을 참고하자.

스프링 부트 및 그레이들 시작에 대한 자세한 내용은 그레이들 플러그인 레퍼런스 가이드의 시작하기 절에서 확인할 수 있다.

4.3.2. Installing the Spring Boot CLI

스프링 부트 CLI(커맨드 라인 인터페이스)는 스프링으로 빠르게 프로토타입을 만드는 데 사용할 수 있는 커맨드 라인 도구이다.

스프링 부트를 사용하기 위해 CLI를 사용할 필요는 없지만, IDE 없이 스프링 애플리케이션을 시작하는 빠른 방법이다.

Manual Installation

다음 위치 중 하나에서 스프링 CLI 배포판을 다운로드할 수 있다.

• spring-boot-cli-3.1.1-bin.zip
• spring-boot-cli-3.1.1-bin.tar.gz

다운로드한 후, 압축을 푼 압축파일의 INSTALL.txt 지침을 따르자. 요약하면 .zip 파일의 bin/ 디렉토리에 스프링 스크립트(윈도우용 spring.bat)가 있다. 또는 .jar 파일과 함께 java -jar을 사용할 수 있다(스크립트는 클래스패스가 올바르게 설정되었는지 확인하는 데 도움이 된다).

Installation with SDKMAN!

SDKMAN! (소프트웨어 개발 키트 매니저)는 그루비 및 스프링 부트 CLI를 포함한 다양한 바이너리 SDK의 여러 버전을 관리하는 데 사용할 수 있다. SDKMAN을 다운 받자! sdkman.io에서 다음 명령을 사용하여 스프링 부트를 설치한다:

    $ sdk install springboot
    $ spring --version
    Spring CLI v3.1.1

CLI용 기능을 개발하고 구축한 버전에 접근하려면 다음 명령을 사용하자:

    $ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-3.1.1-bin/spring-3.1.1/
    $ sdk default springboot dev
    $ spring --version
    Spring CLI v3.1.1

위 지침서는 dev 인스턴스라는 로컬 스프링 인스턴스를 설치한다. 대상 빌드 위치를 가리키므로 스프링 부트를 다시 빌드할 때마다 스프링이 최신 상태가 된다.

다음 명령을 실행하면 볼 수 있다:

    $ sdk ls springboot
    ================================================================================
    Available Springboot Versions
    ================================================================================
    > + dev
    * 3.1.1
  
    ================================================================================
    + - local version
    * - installed
    > - currently in use
    ================================================================================

OSX Homebrew Installation

맥에서 Homebrew를 사용하는 경우 다음 명령을 사용하여 스프링 부트 CLI를 설치할 수 있다:

    $ brew tap spring-io/tap
    $ brew install spring-boot

Homebrew는 /usr/local/bin에 스프링을 설치한다.

명령이 표시되지 않으면 Brew 설치가 오래된 것일 수 있다. 이런 경우에는 brew update를 실행하고 재시도하자.

MacPorts Installation

맥에서 맥포트(MacPorts)를 사용하는 경우 다음 명령을 사용하여 스프링 부트 CLI를 설치할 수 있다:

    $ sudo port install spring-boot-cli

Command-line Completion

스프링 부트 CLI에는 BASH 및 zsh 셸에 대한 명령 완성을 제공하는 스크립트가 포함되어 있다. 모든 셸에서 스크립트(스프링(spring)이라고도 함)를 실행(source)하거나 개인 또는 시스템 전체 bash 초기화에 넣을 수 있다. 데비안(Debian) 시스템에서 시스템 전체 스크립트는 <installation location>/shell-completion/bash에 있으며 해당 디렉토리의 모든 스크립트는 새 셸이 시작될 때 실행된다. 예를 들어, SDKMAN!을 사용하여 설치한 경우 스크립트를 수동으로 실행하려면 다음 명령을 사용해야한다:

    $ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
    $ spring <HIT TAB HERE>
    grab help jar run test version

Homebrew 또는 MacPorts를 사용하여 스프링 부트 CLI를 설치하면 커맨드라인 자동 완성 스크립트가 셸에 등록된다.

Windows Scoop Installation

윈도우에서 Scoop을 사용하는 경우 다음 명령을 사용하여 스프링 부트 CLI를 설치할 수 있다:

    > scoop bucket add extras
    > scoop install springboot

Scoop은 ~/scoop/apps/springboot/current/bin에 스프링을 설치한다.

앱 매니페스트가 표시되지 않으면, Scoop 설치가 오래된 것일 수 있다. 그런 경우에는 scoop update를 실행하고 재시도하자.

4.4. Developing Your First Spring Boot Application

이 절에서는 간단하게 “Hello World!” 개발 방법을 설명한다. 스프링 부트의 주요 기능 중 일부를 강조하는 웹 애플리케이션이다. 빌드 시스템으로 메이븐 또는 그레이들 중에서 선택할 수 있다.

spring.io 웹사이트에는 스프링 부트의 다양한 “시작하기” 가이드가 포함되어 있다. 특정 문제를 해결해야 하는 경우, 가이드를 먼저 확인하자. start.spring.io로 이동하고 의존성 검색기(Dependencies)에서 “Web” 스타터를 선택하여 아래 단계를 단축할 수 있다. 그러면 바로 코딩을 시작할 수 있도록 새로운 프로젝트 구조가 생성된다. 자세한 내용은 start.spring.io 사용자 가이드를 확인하자.

4.4.1. Prerequisites

시작하기 전에 터미널을 열고 다음 명령을 실행하여 유효한 자바 버전이 설치되어 있는지 확인하자:

$ java -version
openjdk version "17.0.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)

이 샘플은 자체 디렉토리에 생성되어야 한다. 뒤이은 지침에서는 적절한 디렉토리를 만들었고 이것이 현재 디렉토리라고 가정한다.

Maven

메이븐을 사용하려면, 메이븐이 설치되어 있는지 확인하자:

$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime:
/Users/developer/sdkman/candidates/java/17.0.4.1-librca

Gradle

그레이들을 사용하려면 그레이들이 설치되어 있는지 확인하자:

$ gradle --version
------------------------------------------------------------
Gradle 8.1.1
------------------------------------------------------------
Build time: 2023-04-21 12:31:26 UTC
Revision: 1cf537a851c635c364a4214885f8b9798051175b
Kotlin: 1.8.10
Groovy: 3.0.15
Ant: Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM: 17.0.7 (BellSoft 17.0.7+7-LTS)
OS: Linux 6.2.12-200.fc37.aarch64 aarch64

4.4.2. Setting up the project with Maven

메이븐 pom.xml 파일을 생성하는 것부터 시작해야 한다. pom.xml은 프로젝트를 빌드하는 데 사용되는 레시피다. 즐겨 사용하는 텍스트 편집기를 열고 다음을 추가하자:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.example</groupId>
        <artifactId>myproject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>3.1.1</version>
        </parent>
        <!-- 여기에 라인 추가... -->
    </project>

앞의 목록은 작동 중인 빌드를 제공해야 한다. mvn package를 실행하여 테스트할 수 있다 (지금은 “jar will beempt - no content was mark for inclusion!” 경고를 무시하면 된다).

이 시점에서 프로젝트를 IDE로 가져올 수 있다(대부분의 최신 자바 IDE에는 메이븐에 대한 지원이 내장되어 있다). 단순화를 위해 이 예에서는 일반 텍스트 편집기를 계속 사용한다.

4.4.3. Setting up the project with Gradle

그레이들 build.gradle 파일을 생성하는 것부터 시작해야 한다. build.gradle은 프로젝트를 빌드하는 데 사용되는 빌드 스크립트다. 즐겨 사용하는 텍스트 편집기를 열고 다음을 추가해보자:

    plugins {
        id 'java'
        id 'org.springframework.boot' version '3.1.1'
    }

    apply plugin: 'io.spring.dependency-management'
    group = 'com.example'
    version = '0.0.1-SNAPSHOT'
    sourceCompatibility = '17'
    
    repositories {
        mavenCentral()
    }
    
    dependencies {
    }

앞의 목록은 작동 중인 빌드를 제공해야 한다. 그레이들 클래스를 실행하여 테스트할 수 있다.

이 시점에서 프로젝트를 IDE로 가져올 수 있다(대부분의 최신 자바 IDE에는 그레이들에 대한 기본 지원이 포함되어 있다). 단순화를 위해 이 예에서는 일반 텍스트 편집기를 계속 사용한다.

4.4.4. Adding Classpath Dependencies

스프링 부트는 클래스패스에 jar를 추가할 수 있는 다양한 “스타터(Starters)”를 제공한다. “스타터”는 특정 타입의 애플리케이션을 개발할 때 필요할 수 있는 의존성을 제공한다.

Maven

대부분의 스프링 부트 애플리케이션은 POM의 상위(parent) 섹션에 spring-boot-starter-parent를 사용한다. spring-boot-starter-parent는 유용한 메이븐 기본값을 제공하는 특별한 스타터이다. 또한 “축복받은(blessed)” 의존성에 대한 버전 태그를 생략할 수 있도록 [의존성 매니저(dependency-management)] 절을 제공한다.

웹 애플리케이션을 개발 중이므로 spring-boot-starter-web 의존성을 추가한다. 그 전에 다음 명령을 실행하여 현재 가지고 있는 내용을 확인할 수 있다:

  $ mvn dependency:tree

  [INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree 명령은 프로젝트 의존성의 트리를 표현해 보여준다. spring-boot-starter-parent 자체로는 의존성을 제공하지 않는다는 것을 알 수 있다. 필요한 의존성을 추가하려면 pom.xml을 편집하고 상위 섹션 바로 아래에 spring-boot-starter-web 의존성을 추가하자:

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

mvn dependency:tree를 다시 실행하면, 톰캣 웹 서버 및 스프링 부트 자체를 포함하여 여러 추가 의존성이 있음을 알 수 있다.

Gradle

대부분의 스프링 부트 애플리케이션은 org.springframework.boot 그레이들 플러그인을 사용한다. 이 플러그인은 유용한 기본값과 그레이들 태스크(task)를 제공한다. io.spring.dependent-management 그레이들 플러그인은 “축복된” 의존성에 대한 버전 태그를 생략할 수 있도록 의존성 관리를 제공한다.

웹 애플리케이션을 개발 중이므로 spring-boot-starter-web 의존성을 추가한다. 그 전에 다음 명령을 실행하여 현재 가지고 있는 내용을 확인할 수 있다.

    $ gradle dependencies

    > Task :dependencies
    ------------------------------------------------------------
    Root project 'myproject'
    ------------------------------------------------------------

gradle dependencies 명령은 프로젝트 의존성 트리를 표현해 보여준다. 현재 프로젝트에는 의존성이 없다. 필요한 의존성을 추가하려면 build.gradle을 편집하고 의존성 섹션에 spring-boot-starter-web 의존성을 추가하자:

    dependencies {
        implementation 'org.springframework.boot:spring-boot-starter-web'
    }

그레이들 의존성을 다시 실행하면 이제 톰캣 웹 서버 및 스프링 부트 자체를 포함하여 여러 추가 의존성이 있음을 알 수 있다.

4.4.5. Writing the Code

애플리케이션을 완료하려면 싱글 자바 파일을 생성해야 한다. 기본적으로 메이븐과 그레이들은 src/main/java에서 소스를 컴파일하므로 해당 디렉토리 구조를 만든 다음 src/main/java/MyApplication.java라는 파일을 추가하여 다음 코드를 포함하고 있어야 한다:

자바

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    @RestController
    @SpringBootApplication
    public class MyApplication {
        @RequestMapping("/")
        String home() {
            return "Hello World!";
        }

        public static void main(String[] args) {
            SpringApplication.run(MyApplication.class, args);
        } 
    }

코틀린

    import org.springframework.boot.autoconfigure.SpringBootApplication
    import org.springframework.boot.runApplication
    import org.springframework.web.bind.annotation.RequestMapping
    import org.springframework.web.bind.annotation.RestController

    @RestController
    @SpringBootApplication
    class MyApplication {

        @RequestMapping("/")
        fun home() = "Hello World!"
    }

    fun main(args: Array<String>) {
        runApplication<MyApplication>(*args)
    }

여기에 코드가 많지 않지만 꽤 많은 일이 일어나고 있다. 다음 절에서 중요한 부분을 단계별로 살펴보자.

The @RestController and @RequestMapping Annotations

MyApplication 클래스의 첫 번째 어노테이션은 @RestController이다. 이를 스테레오타입 어노테이션이라고 한다. 이는 코드를 읽는 사람들과 클래스에게 특정 역할을 수행하는 스프링에 대한 힌트를 제공하는 것이다. 이 경우 우리의 클래스는 웹 @Controller이므로 스프링은 들어오는 웹 요청을 처리할 때 이것을 고려한다.

@RequestMapping 어노테이션은 “라우팅(“routing”)” 정보를 제공한다. 이는 / 패스가 포함된 모든 HTTP 요청이 home 메소드에 매핑되어야 함을 스프링에게 알려준다. @RestController 어노테이션은 스프링에게 결과 문자열을 호출자(caller)에게 다시 렌더링하도록 지시한다.

@RestController 및 @RequestMapping 어노테이션은 스프링 MVC 어노테이션이다(스프링 부트에만 해당되지 않음). 자세한 내용은 스프링 레퍼런스 문서의 MVC 절을 참고하자.

The @SpringBootApplication Annotation

두 번째 클래스 레벨 어노테이션은 @SpringBootApplication이다. 이 어노테이션은 메타 어노테이션(meta-annotation)으로 알려져 있으며,@SpringBootConfiguration, @EnableAutoConfiguration 및 @ComponentScan과 결합한다.

그중 우리가 여기서 가장 관심을 갖는 어노테이션은 @EnableAutoConfiguration이다. @EnableAutoConfiguration은 추가한 jar 의존성을 기반으로 스프링 구성 방법을 “추측”하도록 스프링 부트에 지시한다. spring-boot-starter-web에는 톰캣과 스프링 MVC가 추가되어 있으므로, 자동 구성(auto-configuration)은 사용자가 웹 애플리케이션을 개발하고 있다고 가정하고 이에 따라 스프링을 설정한다.

Starters and Auto-configuration

자동 구성(Auto-configuration)은 "스타터"와 잘 작동하도록 설계됐지만, 두 개념이 직접적으로 연결되어 있지는 않다. 스타터 외부에서 jar 의존성을 자유롭게 선택하고 선택할 수 있다. 스프링 부트는 애플리케이션을 자동 구성하는 데 최선을 다한다.

The “main” Method

애플리케이션의 마지막 부분은 main 메소드이다. 이는 자바 애플리케이션 진입점 규칙을 따르는 표준 메소드다. main 메소드는 run을 호출하여 스프링 부트의 SpringApplication 클래스에 위임한다. SpringApplication은 애플리케이션을 부트스트랩하여 스프링을 시작하고 자동 구성된 톰캣 웹 서버를 시작한다.

기본 스프링 컴포넌트인 SpringApplication에 알리려면 MyApplication.class를 run 메서드에 대한 아규먼트로 전달해야 한다. 커맨드라인 아규먼트를 노출하기 위해 args 배열도 전달된다.

4.4.6. Running the Example

Maven

이 시점에서, 애플리케이션이 작동해야 한다. spring-boot-starter-parent POM을 사용했기 때문에 애플리케이션을 시작하는 데 사용할 수 있는 유용한 실행 목표가 있다. 루트 프로젝트 디렉토리에서 mvn spring-boot:run을 입력하여 애플리케이션이 시작된다. 다음과 유사한 출력이 표시된다:

    $ mvn spring-boot:run
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/ ___)| |_)| | | | | || (_|  | ) ) ) ) 
      ' |____| .__|_| |_|_| |_\__,  | / / / /
    =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::  (v3.1.1)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started MyApplication in 0.906 seconds (process running for 6.514)

localhost:8080에 대한 웹 브라우저를 열면 다음 출력이 표시된다:

Hello World!

애플리케이션을 정상적으로 종료하려면 ctrl-c를 누르자.

Gradle

이 시점에서, 애플리케이션이 작동해야 한다. org.springframework.boot 그레이들 플러그인을 사용했기 때문에 애플리케이션을 시작하는 데 사용할 수 있는 유용한 bootRun 목표가 있습니다. 루트 프로젝트 디렉토리에서 gradle bootRun을 입력하여 애플리케이션을 시작합니다. 다음과 유사한 출력이 표시된다:

    $ gradle bootRun
      .   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/ ___)| |_)| | | | | || (_|  | ) ) ) ) 
      ' |____| .__|_| |_|_| |_\__,  | / / / /
    =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::  (v3.1.1)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started MyApplication in 0.906 seconds (process running for 6.514)

localhost:8080에 대한 웹 브라우저를 열면 다음 출력이 표시된다:

Hello World!

애플리케이션을 정상적으로 종료하려면 ctrl-c를 누르자.

4.4.7. Creating an Executable Jar

프로덕션 환경에서 실행할 수 있는 완전히 독립적인 실행 가능한 jar 파일을 생성하여 예제를 마무리한다. 실행 가능한 jar(때때로 “fat jar”라고도 함)는 코드를 실행하는 데 필요한 모든 jar 의존성과 함께 컴파일된 클래스를 포함하는 압축파일이다.

Executable jars and Java

자바는 중첩된 jar 파일(jar 내에 자체적으로 포함된 jar 파일)을 로드하는 표준 방법을 제공하지 않는다. 자체 포함된 애플리케이션을 배포하려는 경우 문제가 될 수 있다.

이 문제를 해결하기 위해 많은 개발자는 "uber" jar를 사용한다. uber jar는 모든 애플리케이션 의존성의 모든 클래스를 싱글 압축파일로 패키징한다. 이 접근 방식의 문제점은 애플리케이션에 어떤 라이브러리가 있는지 확인하기가 어렵다는 것이다. 여러 jar에서 동일한 파일 이름이 사용되는 경우(그러나 내용이 다른 경우) 문제가 될 수도 있다.

스프링 부트는 [다른 접근 방식]()을 취하며 실제로 jar를 직접 중첩할 수 있다.

Maven

실행 가능한 jar를 생성하려면, pom.xml에 spring-boot-maven-plugin을 추가해야 한다. 이렇게 하려면 dependencies 섹션 바로 아래에 다음 줄을 입력하자:

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

spring-boot-starter-parent POM에는 리패키지(repackage) 목표를 바인딩하기 위한 <executions> 구성이 포함되어 있다. 상위 POM을 사용하지 않는 경우 이 구성을 직접 선언해야 한다. 자세한 내용은 플러그인 문서를 참고하자.

다음과 같이 pom.xml을 저장하고 커맨드라인에서 mvn package를 실행한다:

$ mvn package
  [INFO] Scanning for projects...
  [INFO]
  [INFO] ------------------------------------------------------------------------
  [INFO] Building myproject 0.0.1-SNAPSHOT
  [INFO] ------------------------------------------------------------------------
  [INFO] .... ..
  [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
  [INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
  [INFO]
  [INFO] --- spring-boot-maven-plugin:3.1.1:repackage (default) @ myproject ---
  [INFO] ------------------------------------------------------------------------
  [INFO] BUILD SUCCESS
  [INFO] ------------------------------------------------------------------------

대상(target) 디렉토리를 보면 myproject-0.0.1-SNAPSHOT.jar이 표시되어야 한다. 파일 크기는 약 18MB여야 한다. 내부를 엿보고 싶다면 다음과 같이 jar tvf를 사용할 수 있다:

    $ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

또한 대상(target) 디렉토리에 myproject-0.0.1-SNAPSHOT.jar.original이라는 훨씬 작은 파일이 표시되어야 한다. 이것은 스프링 부트에 의해 리패키징(repackaged)되기 전에 메이븐이 생성한 원본 jar 파일이다.

해당 애플리케이션을 실행하려면 다음과 같이 java -jar 명령을 사용하자:

    $ java -jar target/myproject-0.0.1-SNAPSHOT.jar
     .   ____          _            __ _ _
    /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
    \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
     '  |____| .__|_| |_|_| |_\__, | / / / /
    =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::  (v3.1.1)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started MyApplication in 0.999 seconds (process running for 1.253)

애플리케이션을 정상적으로 종료하려면 ctrl-c를 누르자.

Gradle

실행 가능한 jar를 생성하려면, 다음과 같이 커맨드라인에서 gradle bootJar를 실행해야 한다:

$ gradle bootJar
  BUILD SUCCESSFUL in 639ms
  3 actionable tasks: 3 executed

build/libs 디렉토리를 보면, myproject-0.0.1-SNAPSHOT.jar이 보일 것이다. 파일 크기는 약 18MB여야 한다. 내부를 엿보고 싶다면 다음과 같이 jar tvf를 사용할 수 있다:

    $ jar tvf build/libs/myproject-0.0.1-SNAPSHOT.jar

해당 애플리케이션을 실행하려면 다음과 같이 java -jar 명령을 사용하자:

    $ java -jar build/libs/myproject-0.0.1-SNAPSHOT.jar
     .   ____          _            __ _ _
    /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
    \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
     '  |____| .__|_| |_|_| |_\__, | / / / /
    =========|_|==============|___/=/_/_/_/
    :: Spring Boot ::  (v3.1.1)
    ....... . . .
    ....... . . . (log output here)
    ....... . . .
    ........ Started MyApplication in 0.999 seconds (process running for 1.253)

애플리케이션을 정상적으로 종료하려면 ctrl-c를 누르자.

4.5. What to Read Next

이 절에서 스프링 부트 기본 사항 중 일부를 제공는데, 자신만의 애플리케이션을 작성하는 데 도움이 되었기를 바란다. 작업 지향적인 타입의 개발자라면 spring.io로 이동하여 “스프링으로 어떻게 해야 합니까?”라는 구체적인 문제를 해결하는 시작 가이드를 따르는 것이 좋다. 또한 스프링 관련 “How-to” 레퍼런스 문서도 있다.

그렇지 않은 경우, 다음 단계는 스프링 부트를 사용하여 개발을 읽는 것이다. 정말 참을성이 없다면, 먼저 스프링 부트 기능에 대해 읽어보자.