Memulai dengan Spring Boot: Tutorial Lengkap untuk Pemula

Spring Boot telah merevolusi cara pengembang Java membangun aplikasi. Dengan konfigurasi minimal, penyematan server, dan berbagai fitur hebat, Spring Boot memungkinkan Anda fokus pada logika bisnis Anda. Tutorial ini dirancang untuk membimbing Anda melalui dasar-dasar Spring Boot, dari menyiapkan lingkungan pengembangan hingga membangun aplikasi web sederhana. Baik Anda seorang pengembang Java pemula atau berpengalaman yang ingin mempelajari Spring Boot, panduan ini akan memberi Anda dasar yang kuat.

Daftar Isi

Pendahuluan Spring Boot
Prasyarat
Menyiapkan Lingkungan Pengembangan Anda
Membuat Proyek Spring Boot Pertama Anda
Memahami Struktur Proyek Spring Boot
Menulis Endpoint REST Sederhana
Menggunakan Spring Data JPA untuk Akses Database
Menguji Aplikasi Spring Boot Anda
Menggunakan Spring Boot DevTools untuk Pengembangan Lebih Cepat
Konfigurasi Aplikasi Spring Boot
Keamanan dengan Spring Security
Penyebaran Aplikasi Spring Boot Anda
Kesimpulan dan Langkah Selanjutnya

1. Pendahuluan Spring Boot

Apa itu Spring Boot?

Spring Boot adalah kerangka kerja Java open-source yang membuat pengembangan aplikasi berbasis Spring lebih mudah. Spring Boot menghilangkan banyak boilerplate yang terkait dengan konfigurasi Spring, memungkinkan pengembang untuk dengan cepat membuat aplikasi yang siap produksi.

Manfaat Menggunakan Spring Boot:

Penyederhanaan Konfigurasi: Spring Boot menyediakan konfigurasi default yang cerdas, mengurangi kebutuhan akan konfigurasi XML yang ekstensif.
Penyematan Server: Spring Boot menyematkan server seperti Tomcat, Jetty, atau Undertow, menghilangkan kebutuhan untuk penyebaran ke server aplikasi eksternal.
Auto-Configuration: Spring Boot secara otomatis mengonfigurasi aplikasi Anda berdasarkan dependensi yang ada di classpath Anda.
Starter Dependencies: Spring Boot menyediakan “starter POMs” yang menyederhanakan manajemen dependensi dengan menggabungkan sekumpulan dependensi terkait menjadi satu dependensi.
Fitur Siap Produksi: Spring Boot menyediakan fitur bawaan seperti pemantauan kesehatan, metrik, dan audit.

2. Prasyarat

Sebelum Anda memulai dengan Spring Boot, pastikan Anda memiliki prasyarat berikut yang terinstal:

Java Development Kit (JDK): Spring Boot membutuhkan JDK 8 atau lebih tinggi. Kami merekomendasikan menggunakan JDK 11 atau JDK 17. Anda dapat mengunduhnya dari situs web Oracle atau menggunakan distribusi open-source seperti AdoptOpenJDK (sekarang Adoptium).
Integrated Development Environment (IDE): IDE seperti IntelliJ IDEA, Eclipse, atau Visual Studio Code akan sangat membantu. IntelliJ IDEA Ultimate memiliki dukungan Spring Boot yang sangat baik.
Build Tool: Kami akan menggunakan Maven atau Gradle untuk membangun proyek kami. Unduh dan instal Maven dari situs web Apache Maven atau Gradle dari situs web Gradle.

3. Menyiapkan Lingkungan Pengembangan Anda

Setelah Anda memiliki prasyarat yang terinstal, Anda perlu mengonfigurasi IDE Anda untuk pengembangan Spring Boot.

Konfigurasi IntelliJ IDEA:

Instal IntelliJ IDEA Ultimate (disarankan) atau Community Edition.
Pastikan plugin “Spring Assistant” diaktifkan. Ini menyediakan dukungan yang sangat baik untuk Spring Boot.
Konfigurasikan JDK dan Maven/Gradle di pengaturan IntelliJ IDEA.

Konfigurasi Eclipse:

Instal Eclipse IDE for Enterprise Java Developers.
Instal plugin “Spring Tools 4 (ST4)” dari Eclipse Marketplace.
Konfigurasikan JDK dan Maven/Gradle di pengaturan Eclipse.

Konfigurasi Visual Studio Code:

Instal Visual Studio Code.
Instal ekstensi “Spring Boot Extension Pack” dari Visual Studio Code Marketplace.
Konfigurasikan JDK dan Maven/Gradle di pengaturan Visual Studio Code.

4. Membuat Proyek Spring Boot Pertama Anda

Ada beberapa cara untuk membuat proyek Spring Boot baru:

Menggunakan Spring Initializr (Web):

Buka Spring Initializr di browser web Anda.
Pilih bahasa (Java), Spring Boot versi, dan build tool (Maven atau Gradle).
Masukkan metadata proyek Anda (Group, Artifact, Name, Description, Package Name).
Pilih dependensi yang diperlukan. Untuk aplikasi web sederhana, pilih “Spring Web”. Untuk akses database, pilih “Spring Data JPA” dan driver database Anda (misalnya, “H2 Database”).
Klik “Generate”. Ini akan mengunduh file ZIP yang berisi kerangka proyek Anda.
Ekstrak file ZIP ke direktori pilihan Anda.
Impor proyek ke IDE Anda.

Menggunakan Spring Boot CLI (Command Line Interface):

Unduh dan instal Spring Boot CLI dari situs web Spring Boot.
Buka command prompt atau terminal.
Gunakan perintah spring init untuk membuat proyek baru. Contoh:
```
spring init --dependencies=web,h2 my-first-spring-boot-app
```
Impor proyek ke IDE Anda.

Menggunakan IDE Anda:

Sebagian besar IDE menyediakan wizard untuk membuat proyek Spring Boot baru. Misalnya, di IntelliJ IDEA, Anda dapat memilih “File -> New -> Project -> Spring Initializr”.
Ikuti wizard untuk mengkonfigurasi proyek Anda dan memilih dependensi yang diperlukan.

5. Memahami Struktur Proyek Spring Boot

Proyek Spring Boot yang baru dibuat biasanya memiliki struktur direktori berikut:

  
  my-first-spring-boot-app/
  ├── src/
  │   ├── main/
  │   │   ├── java/
  │   │   │   └── com/example/
  │   │   │       └── myfirstspringbootapp/
  │   │   │           └── MyFirstSpringBootAppApplication.java  (Main application class)
  │   │   └── resources/
  │   │       ├── application.properties (or application.yml)
  │   │       └── static/  (For static content like HTML, CSS, JavaScript)
  │   │       └── templates/ (For Thymeleaf templates)
  │   └── test/
  │       └── java/
  │           └── com/example/
  │               └── myfirstspringbootapp/
  │                   └── MyFirstSpringBootAppApplicationTests.java (Testing class)
  ├── pom.xml (Maven) or build.gradle (Gradle) (Build file)
  └── .gitignore

src/main/java: Direktori ini berisi kode sumber Java Anda.
src/main/resources: Direktori ini berisi file sumber daya seperti file properti, templat, dan konten statis.
src/test/java: Direktori ini berisi kode pengujian Anda.
application.properties (atau application.yml): File ini digunakan untuk mengkonfigurasi aplikasi Spring Boot Anda. Kami akan membahas ini lebih detail nanti.
pom.xml (Maven) atau build.gradle (Gradle): File ini adalah file build Anda. Ini menentukan dependensi, plugin, dan konfigurasi build lainnya.

File terpenting adalah MyFirstSpringBootAppApplication.java. Ini adalah kelas aplikasi utama Anda dan berisi metode main() yang digunakan untuk memulai aplikasi Spring Boot Anda.

6. Menulis Endpoint REST Sederhana

Sekarang, mari kita tulis endpoint REST sederhana yang akan mengembalikan pesan “Hello, World!”.

Buat kelas Java baru di dalam direktori src/main/java Anda. Beri nama HelloController.java.

Tambahkan kode berikut ke HelloController.java:

    
    package com.example.myfirstspringbootapp;

    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, World!";
        }
    }

Penjelasan Kode:

@RestController: Anotasi ini menandai kelas ini sebagai pengontrol REST. Ini adalah kombinasi dari @Controller dan @ResponseBody.
@GetMapping("/hello"): Anotasi ini memetakan permintaan HTTP GET ke endpoint /hello ke metode hello().
hello(): Metode ini mengembalikan string “Hello, World!”. Karena kelas ini diberi anotasi dengan @RestController, Spring Boot secara otomatis akan mengonversi string ini menjadi respons HTTP.

Menjalankan Aplikasi Anda:

Buka kelas MyFirstSpringBootAppApplication.java.
Klik kanan di dalam metode main() dan pilih “Run ‘MyFirstSpringBootAppApplication'”. Atau, gunakan perintah Maven atau Gradle di terminal:
- Maven: mvn spring-boot:run
- Gradle: gradle bootRun
Setelah aplikasi berjalan, buka browser web Anda dan navigasikan ke http://localhost:8080/hello. Anda akan melihat pesan “Hello, World!”.

7. Menggunakan Spring Data JPA untuk Akses Database

Spring Data JPA menyederhanakan akses database di aplikasi Spring Boot. Mari kita lihat cara menggunakan Spring Data JPA untuk membuat entitas, menyimpan data ke database, dan mengambil data dari database.

Tambahkan Dependensi Spring Data JPA dan Driver Database:

Buka file pom.xml (Maven) atau build.gradle (Gradle) Anda dan tambahkan dependensi berikut:

Maven (pom.xml):

    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

Gradle (build.gradle):

    
    dependencies {
        implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
        runtimeOnly 'com.h2database:h2'
    }

Dalam contoh ini, kita menggunakan H2, database dalam memori, untuk tujuan pengembangan. Anda dapat menggantinya dengan database lain seperti MySQL, PostgreSQL, atau Oracle dengan menambahkan dependensi driver yang sesuai.

Buat Entitas:

Buat kelas Java baru bernama Product.java di dalam direktori src/main/java Anda. Tambahkan kode berikut:

    
    package com.example.myfirstspringbootapp;

    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;

    @Entity
    public class Product {

        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Long id;

        private String name;
        private String description;
        private double price;

        public Product() {
        }

        public Product(String name, String description, double price) {
            this.name = name;
            this.description = description;
            this.price = price;
        }

        // Getters and Setters (Generate these using your IDE)

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getDescription() {
            return description;
        }

        public void setDescription(String description) {
            this.description = description;
        }

        public double getPrice() {
            return price;
        }

        public void setPrice(double price) {
            this.price = price;
        }
    }

Penjelasan Kode:

@Entity: Anotasi ini menandai kelas ini sebagai entitas JPA. Entitas mewakili tabel dalam database.
@Id: Anotasi ini menandai bidang id sebagai kunci utama.
@GeneratedValue(strategy = GenerationType.AUTO): Anotasi ini menunjukkan bahwa nilai id harus dihasilkan secara otomatis oleh database.

Buat Repository:
Buat interface Java baru bernama ProductRepository.java di dalam direktori src/main/java Anda. Tambahkan kode berikut:
```
    
    package com.example.myfirstspringbootapp;

    import org.springframework.data.jpa.repository.JpaRepository;

    public interface ProductRepository extends JpaRepository<Product, Long> {
    }
    
    
```
Penjelasan Kode:
- JpaRepository<Product, Long>: Antarmuka ini menyediakan metode untuk melakukan operasi CRUD (Create, Read, Update, Delete) pada entitas Product. Spring Data JPA secara otomatis akan menghasilkan implementasi antarmuka ini.

Gunakan Repository di Controller:

Modifikasi kelas HelloController.java Anda untuk menggunakan ProductRepository:

    
    package com.example.myfirstspringbootapp;

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;

    import java.util.List;

    @RestController
    public class HelloController {

        @Autowired
        private ProductRepository productRepository;

        @GetMapping("/hello")
        public String hello() {
            return "Hello, World!";
        }

        @PostMapping("/products")
        public Product createProduct(@RequestBody Product product) {
            return productRepository.save(product);
        }

        @GetMapping("/products")
        public List<Product> getProducts() {
            return productRepository.findAll();
        }
    }

Penjelasan Kode:

@Autowired: Anotasi ini menyuntikkan instance ProductRepository ke dalam kelas HelloController.
@PostMapping("/products"): Anotasi ini memetakan permintaan HTTP POST ke endpoint /products ke metode createProduct(). Metode ini menyimpan entitas Product yang diterima dalam permintaan ke database.
@GetMapping("/products"): Anotasi ini memetakan permintaan HTTP GET ke endpoint /products ke metode getProducts(). Metode ini mengambil semua entitas Product dari database.
@RequestBody: Anotasi ini menunjukkan bahwa entitas Product harus diambil dari badan permintaan HTTP.

Konfigurasikan Database:
Buka file application.properties (atau application.yml) Anda dan tambahkan konfigurasi database berikut:

application.properties:
```
    
    spring.datasource.url=jdbc:h2:mem:testdb
    spring.datasource.driverClassName=org.h2.Driver
    spring.datasource.username=sa
    spring.datasource.password=
    spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
    spring.jpa.hibernate.ddl-auto=create-drop
    
    
```
application.yml:
```
    
    spring:
      datasource:
        url: jdbc:h2:mem:testdb
        driver-class-name: org.h2.Driver
        username: sa
        password:
      jpa:
        database-platform: org.hibernate.dialect.H2Dialect
        hibernate:
          ddl-auto: create-drop
    
    
```
Penjelasan Konfigurasi:
- spring.datasource.url: URL database. Dalam contoh ini, kita menggunakan database H2 dalam memori bernama “testdb”.
- spring.datasource.driverClassName: Nama kelas driver database.
- spring.datasource.username: Nama pengguna database.
- spring.datasource.password: Kata sandi database.
- spring.jpa.database-platform: Platform database JPA.
- spring.jpa.hibernate.ddl-auto: Properti ini mengontrol bagaimana skema database diperbarui. Nilai create-drop berarti bahwa skema database akan dibuat saat aplikasi dimulai dan dihapus saat aplikasi dihentikan.
Uji Endpoint Anda:
1. Jalankan aplikasi Anda.
2. Gunakan alat seperti Postman atau curl untuk membuat permintaan HTTP POST ke endpoint /products untuk membuat produk baru. Contoh:
  Request (JSON):
```
        
        {
            "name": "Product 1",
            "description": "This is product 1",
            "price": 10.99
        }
        
        
```
3. Gunakan alat seperti Postman atau curl untuk membuat permintaan HTTP GET ke endpoint /products untuk mengambil semua produk. Anda akan melihat daftar produk yang telah Anda buat.

8. Menguji Aplikasi Spring Boot Anda

Pengujian adalah bagian penting dari pengembangan perangkat lunak. Spring Boot menyediakan dukungan yang sangat baik untuk pengujian. Mari kita lihat cara menulis pengujian unit dan pengujian integrasi untuk aplikasi Spring Boot Anda.

Pengujian Unit:
Pengujian unit menguji masing-masing komponen aplikasi Anda secara terpisah. Untuk menguji HelloController, Anda dapat membuat kelas pengujian baru bernama HelloControllerTest.java di dalam direktori src/test/java Anda. Tambahkan kode berikut:
```
    
    package com.example.myfirstspringbootapp;

    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
    import org.springframework.test.web.servlet.MockMvc;
    import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
    import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

    @WebMvcTest(HelloController.class)
    public class HelloControllerTest {

        @Autowired
        private MockMvc mockMvc;

        @Test
        public void testHelloEndpoint() throws Exception {
            mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
                    .andExpect(MockMvcResultMatchers.status().isOk())
                    .andExpect(MockMvcResultMatchers.content().string("Hello, World!"));
        }
    }
    
    
```
Penjelasan Kode:
- @WebMvcTest(HelloController.class): Anotasi ini mengonfigurasi lingkungan pengujian untuk pengujian unit pengontrol Spring MVC. Hanya HelloController yang akan dimuat, dan semua dependensi lainnya akan di-mock.
- @Autowired private MockMvc mockMvc: Objek MockMvc digunakan untuk membuat permintaan HTTP ke pengontrol.
- mockMvc.perform(MockMvcRequestBuilders.get("/hello")): Kode ini membuat permintaan HTTP GET ke endpoint /hello.
- .andExpect(MockMvcResultMatchers.status().isOk()): Kode ini menegaskan bahwa status respons HTTP adalah 200 OK.
- .andExpect(MockMvcResultMatchers.content().string("Hello, World!")): Kode ini menegaskan bahwa isi respons HTTP adalah “Hello, World!”.
Pengujian Integrasi:
Pengujian integrasi menguji interaksi antara beberapa komponen aplikasi Anda. Untuk menguji interaksi antara HelloController dan ProductRepository, Anda dapat menggunakan @SpringBootTest.
```
    
    package com.example.myfirstspringbootapp;

    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;

    import static org.assertj.core.api.Assertions.assertThat;

    @SpringBootTest
    public class MyFirstSpringBootAppApplicationTests {

        @Autowired
        private HelloController helloController;

        @Test
        void contextLoads() {
            assertThat(helloController).isNotNull();
        }
    }
    
    
```
Penjelasan Kode:
- @SpringBootTest: Anotasi ini memuat seluruh konteks aplikasi Spring Boot.
- @Autowired private HelloController helloController: Kode ini menyuntikkan instance HelloController ke dalam kelas pengujian.
- assertThat(helloController).isNotNull(): Kode ini menegaskan bahwa helloController tidak null, yang berarti bahwa konteks aplikasi dimuat dengan benar.
Anda dapat menambahkan lebih banyak pengujian untuk memverifikasi interaksi antara HelloController dan ProductRepository, seperti membuat produk, mengambil produk, dan memverifikasi bahwa data disimpan dengan benar ke database.
Menjalankan Pengujian:
Anda dapat menjalankan pengujian Anda menggunakan IDE Anda atau menggunakan perintah Maven atau Gradle di terminal:
- Maven: mvn test
- Gradle: gradle test

9. Menggunakan Spring Boot DevTools untuk Pengembangan Lebih Cepat

Spring Boot DevTools menyediakan fitur yang meningkatkan pengalaman pengembangan. Ini secara otomatis memulai ulang aplikasi Anda ketika perubahan kode terdeteksi, memungkinkan Anda untuk melihat perubahan Anda dengan cepat tanpa harus secara manual memulai ulang aplikasi Anda.

Tambahkan Dependensi Spring Boot DevTools:

Buka file pom.xml (Maven) atau build.gradle (Gradle) Anda dan tambahkan dependensi berikut:

Maven (pom.xml):

    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>

Gradle (build.gradle):

    
    dependencies {
        developmentOnly 'org.springframework.boot:spring-boot-devtools'
    }

Konfigurasi IntelliJ IDEA:
Jika Anda menggunakan IntelliJ IDEA, Anda perlu mengaktifkan “Compiler auto-make”. Buka “Settings -> Compiler” dan centang “Build project automatically”. Anda juga perlu mendaftarkan hotkey “Ctrl+Shift+A -> Registry” dan aktifkan “compiler.automake.allow.when.app.running”.
Mulai Ulang Otomatis:
Setelah Anda menambahkan dependensi DevTools, Spring Boot akan secara otomatis memulai ulang aplikasi Anda setiap kali Anda membuat perubahan pada kode Anda. Anda dapat memodifikasi properti spring.devtools.restart.enabled di file application.properties (atau application.yml) untuk mengaktifkan atau menonaktifkan fitur ini.
LiveReload:
Spring Boot DevTools juga menyertakan server LiveReload yang secara otomatis me-refresh browser web Anda saat Anda membuat perubahan pada konten statis (seperti file HTML, CSS, dan JavaScript). Untuk menggunakan LiveReload, Anda perlu menginstal ekstensi LiveReload di browser web Anda.

10. Konfigurasi Aplikasi Spring Boot

Spring Boot memungkinkan Anda mengonfigurasi aplikasi Anda menggunakan berbagai sumber, termasuk file properti, file YAML, variabel lingkungan, dan argumen baris perintah.

File Properti:
File application.properties adalah cara paling umum untuk mengonfigurasi aplikasi Spring Boot Anda. Anda dapat menentukan properti dengan menggunakan sintaks key=value.
```
    
    server.port=8081
    spring.application.name=my-spring-boot-app
    
    
```
File YAML:
File YAML (application.yml) adalah format alternatif untuk mengonfigurasi aplikasi Spring Boot Anda. YAML lebih mudah dibaca dan memungkinkan Anda untuk menyusun konfigurasi Anda secara hierarkis.
```
    
    server:
      port: 8081
    spring:
      application:
        name: my-spring-boot-app
    
    
```
Variabel Lingkungan:
Spring Boot juga dapat membaca konfigurasi dari variabel lingkungan. Nama variabel lingkungan harus sesuai dengan nama properti, tetapi dengan garis bawah (_) menggantikan titik (.) dan diubah menjadi huruf besar.

Contoh:
- Properti: server.port
- Variabel Lingkungan: SERVER_PORT
Argumen Baris Perintah:
Anda juga dapat menentukan properti konfigurasi sebagai argumen baris perintah saat Anda menjalankan aplikasi Anda.
```
    
    java -jar my-spring-boot-app.jar --server.port=8082
    
    
```
Profil:
Spring Boot memungkinkan Anda untuk mendefinisikan profil yang berbeda untuk lingkungan yang berbeda (misalnya, pengembangan, pengujian, dan produksi). Anda dapat membuat file konfigurasi terpisah untuk setiap profil (misalnya, application-dev.properties, application-test.properties, dan application-prod.properties).

Untuk mengaktifkan profil tertentu, Anda dapat mengatur properti spring.profiles.active.
```
    
    spring.profiles.active=dev
    
    
```

11. Keamanan dengan Spring Security

Spring Security menyediakan otentikasi dan otorisasi yang komprehensif untuk aplikasi Spring Boot Anda.

Tambahkan Dependensi Spring Security:

Buka file pom.xml (Maven) atau build.gradle (Gradle) Anda dan tambahkan dependensi berikut:

Maven (pom.xml):

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

Gradle (build.gradle):

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

Konfigurasi Keamanan:

Buat kelas Java baru bernama SecurityConfig.java di dalam direktori src/main/java Anda. Tambahkan kode berikut:

    
    package com.example.myfirstspringbootapp;

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.provisioning.InMemoryUserDetailsManager;
    import org.springframework.security.web.SecurityFilterChain;

    import static org.springframework.security.config.Customizer.withDefaults;

    @Configuration
    @EnableWebSecurity
    public class SecurityConfig {

        @Bean
        public InMemoryUserDetailsManager userDetailsService() {
            UserDetails user = User.withDefaultPasswordEncoder()
                    .username("user")
                    .password("password")
                    .roles("USER")
                    .build();
            return new InMemoryUserDetailsManager(user);
        }

        @Bean
        public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
            http
                    .authorizeHttpRequests((authz) -> authz
                            .anyRequest().authenticated()
                    )
                    .httpBasic(withDefaults())
                    .formLogin(withDefaults());
            return http.build();
        }
    }

Penjelasan Kode:

@Configuration: Anotasi ini menandai kelas ini sebagai kelas konfigurasi Spring.
@EnableWebSecurity: Anotasi ini mengaktifkan Spring Security.
userDetailsService(): Metode ini mendefinisikan pengguna dalam memori dengan nama pengguna “user” dan kata sandi “password”. Dalam aplikasi nyata, Anda akan mengambil pengguna dari database atau sumber lain.
filterChain(HttpSecurity http): Metode ini mengonfigurasi filter keamanan. Dalam contoh ini, kita mengonfigurasi semua permintaan untuk mengharuskan otentikasi dan menggunakan otentikasi HTTP Basic dan formulir login.

Uji Keamanan:
Jalankan aplikasi Anda. Saat Anda mencoba mengakses endpoint apa pun, Anda akan diminta untuk memberikan nama pengguna dan kata sandi. Gunakan nama pengguna “user” dan kata sandi “password” untuk masuk.

12. Penyebaran Aplikasi Spring Boot Anda

Ada beberapa cara untuk menyebarkan aplikasi Spring Boot Anda:

Penyebaran JAR:
Cara termudah untuk menyebarkan aplikasi Spring Boot Anda adalah dengan membangun file JAR yang dapat dieksekusi dan menjalankannya menggunakan perintah java -jar.
1. Bangun file JAR yang dapat dieksekusi menggunakan Maven atau Gradle:
  - Maven: mvn clean package
  - Gradle: gradle clean build
2. Salin file JAR ke server tempat Anda ingin menyebarkan aplikasi Anda.
3. Jalankan aplikasi menggunakan perintah java -jar:
```
java -jar my-spring-boot-app.jar
```
Penyebaran WAR:
Anda juga dapat menyebarkan aplikasi Spring Boot Anda sebagai file WAR ke server aplikasi seperti Tomcat atau Jetty.
1. Ubah tipe package di file pom.xml (Maven) atau build.gradle (Gradle) Anda menjadi war.
2. Buat kelas yang memperluas SpringBootServletInitializer dan menimpa metode configure.
3. Bangun file WAR menggunakan Maven atau Gradle:
  - Maven: mvn clean package

M	T	W	T	F	S	S
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30

Thursday

Getting Started with Spring Boot: Complete Beginner’s Tutorial

Memulai dengan Spring Boot: Tutorial Lengkap untuk Pemula

Daftar Isi

1. Pendahuluan Spring Boot

2. Prasyarat

3. Menyiapkan Lingkungan Pengembangan Anda

4. Membuat Proyek Spring Boot Pertama Anda

5. Memahami Struktur Proyek Spring Boot

6. Menulis Endpoint REST Sederhana

7. Menggunakan Spring Data JPA untuk Akses Database

8. Menguji Aplikasi Spring Boot Anda

9. Menggunakan Spring Boot DevTools untuk Pengembangan Lebih Cepat

10. Konfigurasi Aplikasi Spring Boot

11. Keamanan dengan Spring Security

12. Penyebaran Aplikasi Spring Boot Anda

WhatsApp Perluas Fitur Voice Chat, Kini Bisa Dipakai di Semua Grup

You Don’t Need to Build a Big Project to Learn

omcoding

Leave a Reply Cancel reply

OmCoding

Getting Started with Spring Boot: Complete Beginner’s Tutorial

Memulai dengan Spring Boot: Tutorial Lengkap untuk Pemula

Daftar Isi

1. Pendahuluan Spring Boot

2. Prasyarat

3. Menyiapkan Lingkungan Pengembangan Anda

4. Membuat Proyek Spring Boot Pertama Anda

5. Memahami Struktur Proyek Spring Boot

6. Menulis Endpoint REST Sederhana

7. Menggunakan Spring Data JPA untuk Akses Database

8. Menguji Aplikasi Spring Boot Anda

9. Menggunakan Spring Boot DevTools untuk Pengembangan Lebih Cepat

10. Konfigurasi Aplikasi Spring Boot

11. Keamanan dengan Spring Security

12. Penyebaran Aplikasi Spring Boot Anda

WhatsApp Perluas Fitur Voice Chat, Kini Bisa Dipakai di Semua Grup

You Don’t Need to Build a Big Project to Learn

omcoding

Related Posts

Leave a Reply Cancel reply

OmCoding