Belajar Spring Boot - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Di episode 1 kalian tahu mengapa Spring Boot ada. Sekarang kita masuk satu level lebih dalam: bagaimana dia bekerja. Episode 2 membedah konsep dasar dan arsitektur utama — dari saat method main dipanggil sampai request pertama kalian dilayani.

Memahami arsitektur ini penting karena semua perilaku Spring Boot bisa dijelaskan lewat konsep yang akan kita bahas: bean, application context, auto-configuration, dan request handling. Setelah episode ini, kalian tidak hanya tahu menulis kode, tapi juga mengerti apa yang sedang terjadi di belakang layar.

#Struktur Aplikasi dan Lifecycle

#Peran @SpringBootApplication

Semua aplikasi Spring Boot dimulai dari satu kelas utama dengan annotation @SpringBootApplication. Satu annotation ini sebenarnya gabungan dari tiga annotation lain:

• @SpringBootConfiguration — menandai class sebagai sumber konfigurasi.
• @EnableAutoConfiguration — mengaktifkan mekanisme auto-configuration.
• @ComponentScan — memindai package dan sub-package untuk menemukan bean.

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

Panggilan SpringApplication.run di method main memulai seluruh lifecycle: membuat ApplicationContext, menjalankan auto-configuration, memulai embedded server, lalu menampilkan log Started BelajarSpringBootApplication.

#Bootstrap dan Embedded Server

Setelah context terbentuk, Spring Boot menjalankan auto-configuration, memproses event startup, dan akhirnya memulai embedded server — defaultnya Tomcat — pada port 8080. Karena server ikut dalam aplikasi, tidak ada proses deployment terpisah; aplikasi dan server adalah satu kesatuan.

#Mekanisme Auto-Configuration

#Conditional Beans

Rahasia auto-configuration ada pada conditional beans. Spring Boot berisi ratusan kelas konfigurasi yang hanya aktif jika kondisi tertentu terpenuhi — misalnya library ada di classpath, atau property belum diatur oleh developer. Annotation seperti @ConditionalOnClass dan @ConditionalOnProperty mengontrol hal ini.

# spring-boot-autoconfigure internal logic (ringkas)
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
public class DataSourceAutoConfiguration {
    // membangun DataSource dari application.properties
}

Logika ini artinya: jika kalian menambahkan spring-boot-starter-data-jpa dan H2 ke classpath, Spring Boot otomatis membuat DataSource untuk H2 — tanpa satu baris konfigurasi pun. Kalian hanya meng-override jika perlu.

#Prinsip Convention over Configuration

Prinsip convention over configuration membuat Spring Boot menegakkan kesepakatan default yang masuk akal, sehingga kalian hanya menulis konfigurasi untuk hal yang benar-benar berbeda dari default. Inilah kenapa project kecil bisa berjalan dengan file konfigurasi yang hampir kosong.

#Bean Container dan Application Context

#ApplicationContext: Rumah Semua Bean

ApplicationContext adalah container yang menyimpan semua bean dan mengelola siklus hidupnya. Saat aplikasi dimulai, Spring memindai classpath, menemukan annotation seperti @Component, @Service, @Repository, dan @Controller, lalu menciptakan instance dan menghubungkan dependency-nya.

Dependency Injection berlangsung di sini. Kalian tidak pernah menulis new untuk bean; cukup deklarasikan dependency di constructor, dan Spring menyuntikkannya otomatis. Detail lengkapnya ada di episode 4.

#Request Handling dengan DispatcherServlet

Saat request HTTP masuk, siapa yang menanganinya? Jawabannya: DispatcherServlet — satu servlet sentral yang menjadi gerbang seluruh alur web Spring MVC.

• HandlerMapping mencocokkan URL request dengan controller method.
• HandlerAdapter memanggil method tersebut, melewati parameter yang sudah di-resolve.
• HandlerInterceptor (jika ada) menyisipkan logika sebelum dan sesudah method.
• Hasilnya dikonversi ke ResponseEntity atau model-view, lalu dikirim kembali sebagai respons.

curl http://localhost:8080/api/items

Perintah curl http://localhost:8080/api/items menguji alur ini. Alur DispatcherServlet -> Controller -> Service -> Repository akan kalian bangun secara nyata mulai episode 5.

#Layer, Model, dan Profil Aplikasi

#Pembagian Layer Arsitektur

Aplikasi Spring Boot yang sehat memisahkan tanggung jawab dalam layer:

• Controller — menerima request HTTP dan menerjemahkannya.
• Service — memuat logika bisnis.
• Repository — berkomunikasi dengan database.
• Model / Entity — representasi data dalam bentuk object.

Pembagian ini membuat aplikasi mudah diuji dan dipelihara. Setiap layer bergantung pada abstraction (interface), bukan implementasi konkret.

#Profil Aplikasi dan Environment Properties

Aplikasi nyata berjalan di banyak lingkungan: lokal, staging, production. Spring Boot menyediakan profile untuk membedakan konfigurasi antar lingkungan. Kalian mengaktifkan profil dengan property spring.profiles.active:

spring.profiles.active=dev
spring.datasource.url=jdbc:h2:mem:testdb
spring.jpa.hibernate.ddl-auto=create-drop

Dengan profil, kalian bisa memakai H2 di lokal dan PostgreSQL di production tanpa mengubah kode — hanya konfigurasi. Konsep ini akan diperdalam di episode 8.

#Penutup

Episode 2 memberikan peta mental arsitektur Spring Boot: lifecycle mulai dari SpringApplication.run, mekanisme auto-configuration dengan conditional beans, application context sebagai rumah semua bean, DispatcherServlet sebagai gerbang request, hingga pembagian layer dan profil aplikasi.

Inti yang harus dibawa pulang:

• @SpringBootApplication menggabungkan configuration, component scan, dan auto-configuration.
• Auto-configuration memakai conditional beans: aktif hanya jika kondisi classpath terpenuhi.
• ApplicationContext mengelola semua bean dan dependency injection.
• DispatcherServlet memetakan request HTTP ke controller via HandlerMapping.
• Layer controller, service, repository, dan model menjaga aplikasi tetap terstruktur.
• Profil aplikasi memisahkan konfigurasi antar lingkungan tanpa mengubah kode.

Di episode 3 selanjutnya kita akan memulai aplikasi pertama — membuat project lewat Spring Initializr, menavigasi struktur direktori standar, menjalankan aplikasi dengan embedded Tomcat, dan mengelola konfigurasi dasar di application.properties. Mari beranjak dari teori ke praktik.