Kenapa penting

Sampai M06 kamu merakit semuanya sendiri: membuat object, membuka koneksi JDBC, menulis main class yang memanggil service. Untuk aplikasi kecil itu cukup, tetapi API sungguhan butuh web server, serialisasi JSON, konfigurasi per environment, logging, koneksi database, dan test — semuanya harus saling tersambung dengan benar. Hampir semua lowongan backend Java menyebut Spring Boot, karena ia menyediakan semua itu dengan default yang masuk akal, sehingga kamu bisa fokus pada logika bisnis. Bab ini membangun fondasi: dari mana project berasal, apa isinya, apa yang terjadi saat aplikasi start, dan bagaimana mengecek bahwa endpoint pertamamu benar-benar jalan.

Konsep inti

Spring Framework vs Spring Boot

Spring Framework adalah fondasi: IoC container (pengelola object, dibahas di bab berikutnya), Spring MVC untuk web, dukungan transaksi, akses data, dan banyak lagi. Spring Framework sangat fleksibel, tetapi dulu menyiapkannya berarti menulis banyak konfigurasi: memilih versi library yang cocok satu sama lain, mendaftarkan servlet, memasang server, dan menyambungkan semuanya.

Spring Boot adalah lapisan di atas Spring Framework yang mengambil keputusan default untukmu:

Spring Boot menyediakan	Artinya
Starter	satu dependency yang membawa sekumpulan library yang sudah cocok versi
Auto-configuration	bean default dibuat otomatis berdasarkan library yang ada di classpath
Embedded server	Tomcat ikut di dalam aplikasi — tidak perlu install server terpisah
Jar executable	aplikasi dijalankan dengan java -jar
Externalized configuration	application.properties/application.yml, environment variable
Dependency management (BOM)	versi ratusan library diatur parent, kamu cukup tulis artifactId

Acuan materi ini: Spring Boot 4.1.x yang berjalan di atas Spring Framework 7, Jakarta EE 11, dan Java 17+ (kita memakai Java 25). Jadi saat kamu "memakai Spring Boot", sebenarnya kamu tetap memakai Spring Framework — Boot hanya menyiapkannya.

Membuat project dengan Spring Initializr

Buka start.spring.io (IntelliJ IDEA dan VS Code juga punya wizard yang memanggil layanan yang sama), lalu pilih:

• Project: Maven · Language: Java · Spring Boot: versi 4.1.x stabil terbaru (bukan SNAPSHOT/M/RC)
• Group: id.jalurjava · Artifact: katalog · Packaging: Jar · Java: 25
• Dependencies: Spring Web (Spring MVC) dan Spring Boot DevTools

Klik Generate, ekstrak zip-nya, buka di IDE. Strukturnya:

katalog/
├── .mvn/wrapper/                     # konfigurasi Maven Wrapper
├── mvnw, mvnw.cmd                    # Maven Wrapper (Linux/macOS, Windows)
├── pom.xml
└── src/
    ├── main/
    │   ├── java/id/jalurjava/katalog/
    │   │   └── KatalogApplication.java
    │   └── resources/
    │       ├── application.properties
    │       ├── static/               # file statis (jarang dipakai untuk REST API)
    │       └── templates/
    └── test/java/id/jalurjava/katalog/
        └── KatalogApplicationTests.java

Strukturnya sama dengan layout Maven standar yang kamu kenal di M05. Maven Wrapper (mvnw) mengunduh versi Maven yang dikunci project, sehingga semua orang di tim memakai Maven yang sama.

Starter dan pom.xml

Bagian penting pom.xml hasil Initializr kurang lebih seperti ini:

<!-- Potongan pom.xml -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>4.1.2</version> <!-- ikuti versi stabil yang dipilih di Initializr -->
    <relativePath/>
</parent>

<properties>
    <java.version>25</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

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

Perhatikan: dependency tidak menulis versi. Parent spring-boot-starter-parent membawa BOM yang menetapkan versi Spring Framework, Tomcat, Jackson, JUnit, dan lainnya yang sudah diuji bersama.

Starter adalah dependency "paket": spring-boot-starter-webmvc membawa Spring MVC, Tomcat embedded, Jackson untuk JSON, logging, dan inti Spring Boot. Di Boot 4, nama lama spring-boot-starter-web sudah deprecated — kamu masih akan menemukannya di banyak tutorial dan project lama, tetapi untuk project baru pakai spring-boot-starter-webmvc. Setiap teknologi juga punya pasangan test starter berpola spring-boot-starter-<teknologi>-test, seperti spring-boot-starter-webmvc-test, yang sekaligus membawa JUnit, AssertJ, dan Mockito.

@SpringBootApplication dan main class

package id.jalurjava.katalog;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class KatalogApplication {

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

@SpringBootApplication adalah gabungan tiga annotation:

• @SpringBootConfiguration — class ini adalah sumber konfigurasi.
• @EnableAutoConfiguration — aktifkan auto-configuration.
• @ComponentScan — cari class ber-annotation (controller, service, dsb.) mulai dari package class ini ke bawah.

Karena itu main class sebaiknya ada di root package (id.jalurjava.katalog), dan semua kode lain di sub-package-nya (id.jalurjava.katalog.product, id.jalurjava.katalog.order). SpringApplication.run membuat container Spring, menjalankan auto-configuration, menyalakan Tomcat, lalu aplikasi siap menerima request.

Auto-configuration: cara kerja dan cara mengintipnya

Auto-configuration adalah kumpulan class konfigurasi di dalam Spring Boot yang aktif berdasarkan kondisi: "bila class X ada di classpath", "bila property Y bernilai Z", "bila belum ada bean bertipe W". Contohnya:

• Spring MVC dan Tomcat ada di classpath → Boot menyiapkan web server dan DispatcherServlet (pintu masuk semua request HTTP).
• Jackson ada di classpath → Boot menyiapkan konverter JSON. Di Boot 4 defaultnya Jackson 3 (package tools.jackson), dan yang dikonfigurasi otomatis adalah JsonMapper.
• Driver database belum ada → tidak ada yang dibuat untuk database.

Auto-configuration juga mundur (back off) bila kamu mendefinisikan bean sendiri dengan tipe yang sama — default hanya dipakai saat kamu tidak menentukan pilihan. Kalau perlu mematikan satu auto-configuration secara eksplisit, ada atribut exclude di @SpringBootApplication atau property spring.autoconfigure.exclude.

Untuk tahu apa yang aktif dan kenapa, jalankan aplikasi dengan --debug:

./mvnw spring-boot:run -Dspring-boot.run.arguments=--debug
# atau, setelah dibuild:
java -jar target/katalog-0.0.1-SNAPSHOT.jar --debug

Spring Boot lalu mencetak conditions report di console. Bentuknya kira-kira seperti ini (disingkat; teks persis bisa sedikit berbeda antarversi):

============================
CONDITIONS EVALUATION REPORT
============================

Positive matches:
-----------------
   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet' (OnClassCondition)

Negative matches:
-----------------
   DataSourceAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class '...' (OnClassCondition)

Positive matches = auto-configuration yang aktif; negative matches = yang tidak aktif beserta kondisi yang gagal. Ini alat pertama saat kamu bertanya "kenapa bean ini ada?" atau "kenapa fitur itu tidak jalan?". Alternatif lain: tulis debug=true di application.properties selama investigasi, lalu hapus lagi.

Menjalankan aplikasi

Ada dua cara utama:

# 1. Mode development — compile lalu jalankan langsung
./mvnw spring-boot:run

# 2. Build jar executable, lalu jalankan seperti di server
./mvnw package
java -jar target/katalog-0.0.1-SNAPSHOT.jar

spring-boot-maven-plugin mengemas ulang (repackage) jar hasil build menjadi jar executable yang memuat semua dependency, termasuk Tomcat. Satu file itu cukup untuk dijalankan di server mana pun yang punya Java 25 — inilah yang nanti dimasukkan ke image Docker. Saat start, log akan menampilkan baris yang menyebut Tomcat berjalan di port 8080 dan berapa detik aplikasi butuh untuk start. Hentikan dengan Ctrl+C.

DevTools sekilas

spring-boot-devtools mempercepat siklus kerja: aplikasi restart otomatis setiap kali classpath berubah — misalnya setelah kamu menjalankan Build Project di IntelliJ, menyimpan file di Eclipse, atau ./mvnw compile. Restart ini lebih cepat daripada start dari nol karena library pihak ketiga tidak dimuat ulang.

DevTools otomatis nonaktif saat aplikasi dijalankan sebagai jar penuh (java -jar) dan tidak ikut dikemas ke jar executable secara default. Jangan pernah memaksanya aktif di production — itu risiko keamanan.

Endpoint pertama dan curl

Buat class di sub-package dari main class:

package id.jalurjava.katalog.hello;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    record Ping(String service, String status) {}

    @GetMapping("/hello")
    public String hello() {
        return "Halo dari Jalur Java!";
    }

    @GetMapping("/ping")
    public Ping ping() {
        return new Ping("katalog", "OK");
    }
}

@RestController menandai class sebagai penerima request HTTP yang mengembalikan data (bukan halaman HTML). @GetMapping("/hello") memetakan GET /hello ke method itu. Detail mapping, parameter, dan status code dibahas di bab REST controller — sekarang cukup untuk membuktikan aplikasinya hidup. Jalankan aplikasi, lalu dari terminal lain:

curl -i localhost:8080/hello
curl -s localhost:8080/ping

Request pertama mengembalikan status 200 dengan body teks Halo dari Jalur Java!. Request kedua mengembalikan JSON {"service":"katalog","status":"OK"} — record diserialisasi otomatis oleh Jackson tanpa satu baris konfigurasi pun. Itulah auto-configuration bekerja: karena Jackson ada di classpath, konverter JSON sudah siap.

Contoh di dunia backend

Tim biasanya memulai service baru dengan endpoint status sederhana sebelum menulis fitur. Endpoint ini dipakai untuk cek manual setelah deploy dan untuk smoke test di pipeline CI. (Spring Boot punya modul Actuator untuk health check yang lengkap — dibahas di level berikutnya; contoh ini sengaja minimal.)

package id.jalurjava.katalog.status;

import java.time.Instant;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// Potongan — bagian dari aplikasi katalog
@RestController
public class StatusController {

    record ServiceStatus(String service, String version, Instant startedAt) {}

    private final Instant startedAt = Instant.now();

    @GetMapping("/api/status")
    public ServiceStatus status() {
        return new ServiceStatus("katalog", "0.0.1", startedAt);
    }
}

Smoke test sesudah build:

./mvnw -q package
java -jar target/katalog-0.0.1-SNAPSHOT.jar &
sleep 5
curl -fs localhost:8080/api/status && echo " → service hidup"
kill %1

Flag -f membuat curl keluar dengan kode error bila status HTTP ≥ 400, sehingga skrip CI bisa gagal dengan jelas. Instant diserialisasi Jackson menjadi teks ISO-8601 seperti 2026-10-23T03:15:00.123Z — format yang sama dengan yang kamu pelajari di bab java.time.

Pertanyaan interview

1. Apa beda Spring Framework dan Spring Boot?

Spring Framework adalah fondasinya: IoC container, Spring MVC, transaksi, akses data. Spring Boot adalah lapisan di atasnya yang menyediakan starter, dependency management, auto-configuration, embedded server, dan jar executable, sehingga aplikasi Spring bisa jalan dengan konfigurasi minimal. Boot tidak menggantikan Spring — ia menyiapkannya.

2. Bagaimana auto-configuration bekerja, dan bagaimana menimpanya?

Auto-configuration adalah class konfigurasi bersyarat: aktif bila class tertentu ada di classpath, property tertentu diset, atau bean sejenis belum ada. Untuk menimpa, cukup definisikan bean sendiri — default-nya mundur. Untuk mematikan sepenuhnya, pakai exclude di @SpringBootApplication atau spring.autoconfigure.exclude. Untuk melihat keputusannya, jalankan dengan --debug dan baca conditions report.

3. Kenapa main class sebaiknya diletakkan di root package?

@SpringBootApplication memuat @ComponentScan yang menelusuri package main class dan sub-package-nya. Bila main class di root package, semua controller, service, dan repository di sub-package otomatis ditemukan. Bila ada class di luar jalur itu, class tersebut tidak terdaftar — gejalanya 404 atau error "bean tidak ditemukan" saat start.

Jebakan umum

• Class di luar package main class. Controller tidak ter-scan → 404 tanpa error apa pun di log. Letakkan main class di root package.
• Menulis versi untuk dependency yang sudah dikelola parent. Bisa menarik versi yang tidak cocok dengan Spring Boot-mu. Biarkan BOM yang menentukan, kecuali benar-benar perlu.
• Menyalin tutorial lama secara mentah. Banyak contoh masih memakai spring-boot-starter-web, javax.*, atau Jackson 2 (com.fasterxml.jackson.databind). Di Boot 4: spring-boot-starter-webmvc, jakarta.*, dan Jackson 3 (tools.jackson).
• Memilih versi SNAPSHOT/milestone di Initializr. Untuk belajar dan production, pilih versi stabil.
• Mengira DevTools aktif di jar. DevTools nonaktif saat java -jar; restart otomatis hanya terjadi saat classpath berubah (build/compile), bukan sekadar saat file disimpan di semua IDE.
• Port 8080 sudah dipakai. Aplikasi gagal start dengan pesan port sedang dipakai. Matikan proses lama atau ubah port lewat konfigurasi (bab berikutnya tentang konfigurasi).

Ringkasan

• Spring Framework = fondasi (IoC, MVC, transaksi); Spring Boot = starter, auto-configuration, embedded server, jar executable di atasnya.
• Spring Initializr menghasilkan project Maven standar dengan Maven Wrapper dan main class ber-@SpringBootApplication.
• Di Boot 4, starter Spring MVC adalah spring-boot-starter-webmvc; test starter-nya spring-boot-starter-webmvc-test.
• Auto-configuration aktif berdasarkan kondisi dan mundur bila kamu mendefinisikan bean sendiri; lihat keputusannya dengan --debug.
• Jalankan dengan ./mvnw spring-boot:run saat development, atau ./mvnw package lalu java -jar seperti di server.
• Uji endpoint dengan curl; object yang dikembalikan @RestController otomatis menjadi JSON.

Bacaan lanjutan

• Spring Boot — Developing Your First Application
• Spring Boot — Auto-configuration
• Spring Boot — Developer Tools